treewide: better cross-device sync capabilities; in-database storage

Signed-off-by: NotAShelf <raf@notashelf.dev>
Change-Id: Id99798df6f7e4470caae8a193c2654aa6a6a6964

crates/pinakes-core/src/model.rs

@@ -44,6 +44,71 @@ impl fmt::Display for ContentHash {
     }
 }
 
+// ===== Managed Storage Types =====
+
+/// Storage mode for media items
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum StorageMode {
+    /// File exists on disk, referenced by path
+    #[default]
+    External,
+    /// File is stored in managed content-addressable storage
+    Managed,
+}
+
+impl fmt::Display for StorageMode {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::External => write!(f, "external"),
+            Self::Managed => write!(f, "managed"),
+        }
+    }
+}
+
+impl std::str::FromStr for StorageMode {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s.to_lowercase().as_str() {
+            "external" => Ok(Self::External),
+            "managed" => Ok(Self::Managed),
+            _ => Err(format!("unknown storage mode: {}", s)),
+        }
+    }
+}
+
+/// A blob stored in managed storage (content-addressable)
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ManagedBlob {
+    pub content_hash: ContentHash,
+    pub file_size: u64,
+    pub mime_type: String,
+    pub reference_count: u32,
+    pub stored_at: DateTime<Utc>,
+    pub last_verified: Option<DateTime<Utc>>,
+}
+
+/// Result of uploading a file to managed storage
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct UploadResult {
+    pub media_id: MediaId,
+    pub content_hash: ContentHash,
+    pub was_duplicate: bool,
+    pub file_size: u64,
+}
+
+/// Statistics about managed storage
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+pub struct ManagedStorageStats {
+    pub total_blobs: u64,
+    pub total_size_bytes: u64,
+    pub unique_size_bytes: u64,
+    pub deduplication_ratio: f64,
+    pub managed_media_count: u64,
+    pub orphaned_blobs: u64,
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct MediaItem {
     pub id: MediaId,
@@ -73,6 +138,17 @@ pub struct MediaItem {
     pub rating: Option<i32>,
     pub perceptual_hash: Option<String>,
 
+    // Managed storage fields
+    /// How the file is stored (external on disk or managed in content-addressable storage)
+    #[serde(default)]
+    pub storage_mode: StorageMode,
+    /// Original filename for uploaded files (preserved separately from file_name)
+    pub original_filename: Option<String>,
+    /// When the file was uploaded to managed storage
+    pub uploaded_at: Option<DateTime<Utc>>,
+    /// Storage key for looking up the blob (usually same as content_hash)
+    pub storage_key: Option<String>,
+
     pub created_at: DateTime<Utc>,
     pub updated_at: DateTime<Utc>,
 }