app: add catalog commands/queries (RegisterAsset, UpdateMetadata, GetTimeline, GetAsset)

crates/application/src/catalog/commands/mod.rs

@@ -0,0 +1,2 @@
+pub mod register_asset;
+pub mod update_metadata;

crates/application/src/catalog/commands/register_asset.rs

@@ -0,0 +1,66 @@
+use std::sync::Arc;
+use domain::{
+    catalog::entities::{Asset, AssetType, DuplicateGroup, SourceReference},
+    errors::DomainError,
+    events::DomainEvent,
+    ports::{AssetRepository, DuplicateRepository, EventPublisher},
+    value_objects::{Checksum, DateTimeStamp, SystemId},
+};
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub struct RegisterAssetCommand {
+    pub volume_id: SystemId,
+    pub relative_path: String,
+    pub checksum: String,
+    pub asset_type: AssetType,
+    pub mime_type: String,
+    pub file_size: u64,
+    pub owner_id: SystemId,
+}
+
+pub struct RegisterAssetHandler {
+    asset_repo: Arc<dyn AssetRepository>,
+    duplicate_repo: Arc<dyn DuplicateRepository>,
+    event_pub: Arc<dyn EventPublisher>,
+}
+
+impl RegisterAssetHandler {
+    pub fn new(
+        asset_repo: Arc<dyn AssetRepository>,
+        duplicate_repo: Arc<dyn DuplicateRepository>,
+        event_pub: Arc<dyn EventPublisher>,
+    ) -> Self {
+        Self { asset_repo, duplicate_repo, event_pub }
+    }
+
+    pub async fn execute(&self, cmd: RegisterAssetCommand) -> Result<(Asset, Option<DuplicateGroup>), DomainError> {
+        let checksum = Checksum::new(&cmd.checksum)?;
+
+        let existing = self.asset_repo.find_by_checksum(&checksum).await?;
+
+        let source_ref = SourceReference {
+            volume_id: cmd.volume_id,
+            relative_path: cmd.relative_path,
+            checksum,
+        };
+
+        let asset = Asset::new(source_ref, cmd.asset_type, cmd.mime_type, cmd.file_size, cmd.owner_id);
+        self.asset_repo.save(&asset).await?;
+
+        let dup_group = if let Some(first) = existing.first() {
+            let group = DuplicateGroup::new_exact(first.asset_id, asset.asset_id);
+            self.duplicate_repo.save(&group).await?;
+            Some(group)
+        } else {
+            None
+        };
+
+        self.event_pub.publish(DomainEvent::AssetIngested {
+            asset_id: asset.asset_id,
+            owner_user_id: asset.owner_user_id,
+            timestamp: DateTimeStamp::now(),
+        }).await?;
+
+        Ok((asset, dup_group))
+    }
+}

crates/application/src/catalog/commands/update_metadata.rs

@@ -0,0 +1,47 @@
+use std::sync::Arc;
+use domain::{
+    catalog::entities::{AssetMetadata, MetadataSource},
+    errors::DomainError,
+    events::DomainEvent,
+    ports::{AssetRepository, AssetMetadataRepository, EventPublisher},
+    value_objects::{DateTimeStamp, StructuredData, SystemId},
+};
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub struct UpdateMetadataCommand {
+    pub asset_id: SystemId,
+    pub user_id: SystemId,
+    pub data: StructuredData,
+}
+
+pub struct UpdateMetadataHandler {
+    asset_repo: Arc<dyn AssetRepository>,
+    metadata_repo: Arc<dyn AssetMetadataRepository>,
+    event_pub: Arc<dyn EventPublisher>,
+}
+
+impl UpdateMetadataHandler {
+    pub fn new(
+        asset_repo: Arc<dyn AssetRepository>,
+        metadata_repo: Arc<dyn AssetMetadataRepository>,
+        event_pub: Arc<dyn EventPublisher>,
+    ) -> Self {
+        Self { asset_repo, metadata_repo, event_pub }
+    }
+
+    pub async fn execute(&self, cmd: UpdateMetadataCommand) -> Result<AssetMetadata, DomainError> {
+        self.asset_repo.find_by_id(&cmd.asset_id).await?
+            .ok_or_else(|| DomainError::NotFound(format!("Asset {} not found", cmd.asset_id)))?;
+
+        let metadata = AssetMetadata::new(cmd.asset_id, MetadataSource::UserEdited, cmd.data);
+        self.metadata_repo.save(&metadata).await?;
+
+        self.event_pub.publish(DomainEvent::MetadataUpdated {
+            asset_id: cmd.asset_id,
+            updated_by: cmd.user_id,
+            timestamp: DateTimeStamp::now(),
+        }).await?;
+
+        Ok(metadata)
+    }
+}

crates/application/src/catalog/mod.rs

@@ -1 +1,7 @@
-// Catalog commands/queries (future: SearchAssets, UpdateMetadata, etc.)
+pub mod commands;
+pub mod queries;
+
+pub use commands::register_asset::{RegisterAssetCommand, RegisterAssetHandler};
+pub use commands::update_metadata::{UpdateMetadataCommand, UpdateMetadataHandler};
+pub use queries::get_timeline::{GetTimelineQuery, GetTimelineHandler};
+pub use queries::get_asset::{GetAssetQuery, GetAssetHandler};

crates/application/src/catalog/queries/get_asset.rs

@@ -0,0 +1,37 @@
+use std::sync::Arc;
+use domain::{
+    catalog::entities::Asset,
+    catalog::services::resolve_metadata,
+    errors::DomainError,
+    ports::{AssetRepository, AssetMetadataRepository},
+    value_objects::{StructuredData, SystemId},
+};
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub struct GetAssetQuery {
+    pub asset_id: SystemId,
+}
+
+pub struct GetAssetHandler {
+    asset_repo: Arc<dyn AssetRepository>,
+    metadata_repo: Arc<dyn AssetMetadataRepository>,
+}
+
+impl GetAssetHandler {
+    pub fn new(
+        asset_repo: Arc<dyn AssetRepository>,
+        metadata_repo: Arc<dyn AssetMetadataRepository>,
+    ) -> Self {
+        Self { asset_repo, metadata_repo }
+    }
+
+    pub async fn execute(&self, query: GetAssetQuery) -> Result<(Asset, StructuredData), DomainError> {
+        let asset = self.asset_repo.find_by_id(&query.asset_id).await?
+            .ok_or_else(|| DomainError::NotFound(format!("Asset {} not found", query.asset_id)))?;
+
+        let layers = self.metadata_repo.find_by_asset(&asset.asset_id).await?;
+        let resolved = resolve_metadata(&layers);
+
+        Ok((asset, resolved))
+    }
+}

crates/application/src/catalog/queries/get_timeline.rs

@@ -0,0 +1,42 @@
+use std::sync::Arc;
+use domain::{
+    catalog::entities::Asset,
+    catalog::services::resolve_metadata,
+    errors::DomainError,
+    ports::{AssetRepository, AssetMetadataRepository},
+    value_objects::{StructuredData, SystemId},
+};
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub struct GetTimelineQuery {
+    pub owner_id: SystemId,
+    pub limit: u32,
+    pub offset: u32,
+}
+
+pub struct GetTimelineHandler {
+    asset_repo: Arc<dyn AssetRepository>,
+    metadata_repo: Arc<dyn AssetMetadataRepository>,
+}
+
+impl GetTimelineHandler {
+    pub fn new(
+        asset_repo: Arc<dyn AssetRepository>,
+        metadata_repo: Arc<dyn AssetMetadataRepository>,
+    ) -> Self {
+        Self { asset_repo, metadata_repo }
+    }
+
+    pub async fn execute(&self, query: GetTimelineQuery) -> Result<Vec<(Asset, StructuredData)>, DomainError> {
+        let assets = self.asset_repo.find_by_owner(&query.owner_id, query.limit, query.offset).await?;
+
+        let mut results = Vec::with_capacity(assets.len());
+        for asset in assets {
+            let layers = self.metadata_repo.find_by_asset(&asset.asset_id).await?;
+            let resolved = resolve_metadata(&layers);
+            results.push((asset, resolved));
+        }
+
+        Ok(results)
+    }
+}

crates/application/src/catalog/queries/mod.rs

@@ -0,0 +1,2 @@
+pub mod get_timeline;
+pub mod get_asset;