feat(prime-domain): added canonical impl

Cargo.toml

@@ -23,7 +23,6 @@ db =     { git = "https://github.com/rambit-systems/rambit" }
 dvf =    { git = "https://github.com/rambit-systems/rambit" }
 hex =    { git = "https://github.com/rambit-systems/rambit" }
 model =  { git = "https://github.com/rambit-systems/rambit" }
-repos =  { git = "https://github.com/rambit-systems/rambit" }
 
 # async
 tokio = { version = "1", features = ["full"] }

crates/models/src/artifact.rs

@@ -53,3 +53,21 @@ impl Model for Artifact {
 
   fn id(&self) -> ArtifactRecordId { self.id }
 }
+
+/// A request to create a new [`Artifact`].
+pub struct ArtifactCreateRequest {
+  /// The artifact's path.
+  pub path: ArtifactPath,
+  /// The artifact's compression status.
+  pub size: dvf::CompressionStatus,
+}
+
+impl From<ArtifactCreateRequest> for Artifact {
+  fn from(input: ArtifactCreateRequest) -> Self {
+    Self {
+      id:   ArtifactRecordId::default(),
+      path: input.path,
+      size: input.size,
+    }
+  }
+}

crates/models/src/photo.rs

@@ -36,3 +36,18 @@ impl Model for Photo {
 
   fn id(&self) -> PhotoRecordId { self.id }
 }
+
+/// A request to create a new [`Photo`].
+pub struct PhotoCreateRequest {
+  /// The photo's artifacts.
+  pub artifacts: PhotoArtifacts,
+}
+
+impl From<PhotoCreateRequest> for Photo {
+  fn from(input: PhotoCreateRequest) -> Self {
+    Self {
+      id:        PhotoRecordId::default(),
+      artifacts: input.artifacts,
+    }
+  }
+}

crates/prime-domain/Cargo.toml

@@ -5,10 +5,10 @@ edition = "2021"
 
 [dependencies]
 models = { path = "../models" }
+repos = { path = "../repos" }
 
 crunch.workspace = true
 hex.workspace = true
-repos.workspace = true
 
 tracing.workspace = true
 

crates/prime-domain/src/canonical.rs

@@ -0,0 +1,65 @@
+use hex::health;
+use models::{Photo, PhotoCreateRequest, PhotoRecordId};
+use repos::FetchModelError;
+
+use crate::PrimeDomainService;
+
+/// The canonical implementation of [`PrimeDomainService`].
+pub struct PrimeDomainServiceCanonical<
+  PR: repos::ModelRepository<
+    Model = Photo,
+    ModelCreateRequest = PhotoCreateRequest,
+    CreateError = repos::CreateModelError,
+  >,
+> {
+  photo_repo: PR,
+}
+
+impl<PR> PrimeDomainServiceCanonical<PR>
+where
+  PR: repos::ModelRepository<
+    Model = Photo,
+    ModelCreateRequest = PhotoCreateRequest,
+    CreateError = repos::CreateModelError,
+  >,
+{
+  /// Creates a new [`PrimeDomainServiceCanonical`] with the given photo
+  /// repository.
+  pub fn new(photo_repo: PR) -> Self { Self { photo_repo } }
+}
+
+#[async_trait::async_trait]
+impl<PR> PrimeDomainService for PrimeDomainServiceCanonical<PR>
+where
+  PR: repos::ModelRepository<
+    Model = Photo,
+    ModelCreateRequest = PhotoCreateRequest,
+    CreateError = repos::CreateModelError,
+  >,
+{
+  async fn fetch_photo_by_id(
+    &self,
+    id: PhotoRecordId,
+  ) -> Result<Option<Photo>, FetchModelError> {
+    self.photo_repo.fetch_model_by_id(id).await
+  }
+}
+
+#[async_trait::async_trait]
+impl<PR> health::HealthReporter for PrimeDomainServiceCanonical<PR>
+where
+  PR: repos::ModelRepository<
+    Model = Photo,
+    ModelCreateRequest = PhotoCreateRequest,
+    CreateError = repos::CreateModelError,
+  >,
+{
+  fn name(&self) -> &'static str { stringify!(PrimeDomainServiceCanonical) }
+  async fn health_check(&self) -> health::ComponentHealth {
+    health::AdditiveComponentHealth::from_futures(vec![self
+      .photo_repo
+      .health_report()])
+    .await
+    .into()
+  }
+}

crates/prime-domain/src/lib.rs

@@ -7,20 +7,17 @@ use std::sync::Arc;
 
 pub use hex;
 use hex::Hexagonal;
-use models::{Artifact, ArtifactRecordId, Photo, PhotoRecordId};
-use repos::db::FetchModelError;
+use models::{Photo, PhotoRecordId};
+use repos::FetchModelError;
+
+pub use self::canonical::*;
 
 /// A dynamic [`PrimeDomainService`] trait object.
 pub type DynPrimeDomainService = Arc<Box<dyn PrimeDomainService>>;
 
 /// The prime domain service trait.
 #[async_trait::async_trait]
 pub trait PrimeDomainService: Hexagonal {
-  /// Fetch an [`Artifact`] by its ID.
-  async fn fetch_cache_by_id(
-    &self,
-    id: ArtifactRecordId,
-  ) -> Result<Option<Artifact>, FetchModelError>;
   /// Fetch a [`Photo`] by its ID.
   async fn fetch_photo_by_id(
     &self,

crates/repos/src/lib.rs

@@ -1,6 +1,6 @@
 //! Repositories for use in services.
 
-use db::{FetchModelByIndexError, FetchModelError};
+pub use db::{CreateModelError, FetchModelByIndexError, FetchModelError};
 use hex::Hexagonal;
 use miette::Result;
 use models::EitherSlug;