prototype actor_store

src/actor_store/db/migrations.rs

···
 //! Database migrations for the actor store.
-use anyhow::Result;
+use anyhow::{Context as _, Result};
+use sqlx::SqlitePool;
 
 use crate::actor_store::db::ActorDb;
 
···
     pub(crate) fn new(db: ActorDb) -> Self {
         Self {
             db,
-            migrations: vec![init_migration],
+            migrations: vec![_001_init],
         }
     }
 
     /// Run all migrations
     pub(crate) async fn migrate_to_latest(&self) -> Result<()> {
-        // We could track which migrations have been run
-        // For simplicity, we just run them all for now
+        let past_migrations = sqlx::query!("SELECT name FROM migration")
+            .fetch_all(&self.db.db)
+            .await?;
+        let mut past_migration_names = past_migrations
+            .iter()
+            .map(|m| m.name.clone())
+            .collect::<Vec<_>>();
+        past_migration_names.sort();
         for migration in &self.migrations {
-            migration(&self.db)?;
+            let name = format!("{:p}", migration);
+            if !past_migration_names.contains(&name) {
+                migration(&self.db)?;
+                sqlx::query("INSERT INTO migration (name, appliedAt) VALUES (?, ?)")
+                    .bind(name)
+                    .bind(chrono::Utc::now().to_rfc3339())
+                    .execute(&self.db.db)
+                    .await?;
+            }
         }
         Ok(())
     }
···
 }
 
 /// Initial migration to create tables
-fn init_migration(db: &ActorDb) -> Result<()> {
+fn _001_init(db: &ActorDb) -> Result<()> {
     tokio::task::block_in_place(|| {
         tokio::runtime::Handle::current()
             .block_on(async { crate::actor_store::db::create_tables(&db.db).await })
     })
 }
+
+/// Create the initial database tables
+pub(crate) async fn create_tables(db: &SqlitePool) -> Result<()> {
+    sqlx::query(
+        "
+        CREATE TABLE IF NOT EXISTS repo_root (
+            did TEXT PRIMARY KEY NOT NULL,
+            cid TEXT NOT NULL,
+            rev TEXT NOT NULL,
+            indexedAt TEXT NOT NULL
+        );
+
+        CREATE TABLE IF NOT EXISTS repo_block (
+            cid TEXT PRIMARY KEY NOT NULL,
+            repoRev TEXT NOT NULL,
+            size INTEGER NOT NULL,
+            content BLOB NOT NULL
+        );
+
+        CREATE TABLE IF NOT EXISTS record (
+            uri TEXT PRIMARY KEY NOT NULL,
+            cid TEXT NOT NULL,
+            collection TEXT NOT NULL,
+            rkey TEXT NOT NULL,
+            repoRev TEXT NOT NULL,
+            indexedAt TEXT NOT NULL,
+            takedownRef TEXT
+        );
+
+        CREATE TABLE IF NOT EXISTS blob (
+            cid TEXT PRIMARY KEY NOT NULL,
+            mimeType TEXT NOT NULL,
+            size INTEGER NOT NULL,
+            tempKey TEXT,
+            width INTEGER,
+            height INTEGER,
+            createdAt TEXT NOT NULL,
+            takedownRef TEXT
+        );
+
+        CREATE TABLE IF NOT EXISTS record_blob (
+            blobCid TEXT NOT NULL,
+            recordUri TEXT NOT NULL,
+            PRIMARY KEY (blobCid, recordUri)
+        );
+
+        CREATE TABLE IF NOT EXISTS backlink (
+            uri TEXT NOT NULL,
+            path TEXT NOT NULL,
+            linkTo TEXT NOT NULL,
+            PRIMARY KEY (uri, path)
+        );
+
+        CREATE TABLE IF NOT EXISTS account_pref (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            name TEXT NOT NULL,
+            valueJson TEXT NOT NULL
+        );
+
+        CREATE TABLE IF NOT EXISTS migration (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            name TEXT NOT NULL,
+            appliedAt TEXT NOT NULL
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_repo_block_repo_rev ON repo_block(repoRev, cid);
+        CREATE INDEX IF NOT EXISTS idx_record_cid ON record(cid);
+        CREATE INDEX IF NOT EXISTS idx_record_collection ON record(collection);
+        CREATE INDEX IF NOT EXISTS idx_record_repo_rev ON record(repoRev);
+        CREATE INDEX IF NOT EXISTS idx_blob_tempkey ON blob(tempKey);
+        CREATE INDEX IF NOT EXISTS idx_backlink_link_to ON backlink(path, linkTo);
+        ",
+    )
+    .execute(db)
+    .await
+    .context("failed to create tables")?;
+
+    Ok(())
+}

src/actor_store/db/mod.rs

···
     Ok(ActorDb::new(pool))
 }
 
-/// Create the initial database tables
-pub(crate) async fn create_tables(db: &SqlitePool) -> Result<()> {
-    sqlx::query(
-        "
-        CREATE TABLE IF NOT EXISTS repo_root (
-            did TEXT PRIMARY KEY NOT NULL,
-            cid TEXT NOT NULL,
-            rev TEXT NOT NULL,
-            indexedAt TEXT NOT NULL
-        );
-
-        CREATE TABLE IF NOT EXISTS repo_block (
-            cid TEXT PRIMARY KEY NOT NULL,
-            repoRev TEXT NOT NULL,
-            size INTEGER NOT NULL,
-            content BLOB NOT NULL
-        );
-
-        CREATE TABLE IF NOT EXISTS record (
-            uri TEXT PRIMARY KEY NOT NULL,
-            cid TEXT NOT NULL,
-            collection TEXT NOT NULL,
-            rkey TEXT NOT NULL,
-            repoRev TEXT NOT NULL,
-            indexedAt TEXT NOT NULL,
-            takedownRef TEXT
-        );
-
-        CREATE TABLE IF NOT EXISTS blob (
-            cid TEXT PRIMARY KEY NOT NULL,
-            mimeType TEXT NOT NULL,
-            size INTEGER NOT NULL,
-            tempKey TEXT,
-            width INTEGER,
-            height INTEGER,
-            createdAt TEXT NOT NULL,
-            takedownRef TEXT
-        );
-
-        CREATE TABLE IF NOT EXISTS record_blob (
-            blobCid TEXT NOT NULL,
-            recordUri TEXT NOT NULL,
-            PRIMARY KEY (blobCid, recordUri)
-        );
-
-        CREATE TABLE IF NOT EXISTS backlink (
-            uri TEXT NOT NULL,
-            path TEXT NOT NULL,
-            linkTo TEXT NOT NULL,
-            PRIMARY KEY (uri, path)
-        );
-
-        CREATE TABLE IF NOT EXISTS account_pref (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            name TEXT NOT NULL,
-            valueJson TEXT NOT NULL
-        );
-
-        CREATE INDEX IF NOT EXISTS idx_repo_block_repo_rev ON repo_block(repoRev, cid);
-        CREATE INDEX IF NOT EXISTS idx_record_cid ON record(cid);
-        CREATE INDEX IF NOT EXISTS idx_record_collection ON record(collection);
-        CREATE INDEX IF NOT EXISTS idx_record_repo_rev ON record(repoRev);
-        CREATE INDEX IF NOT EXISTS idx_blob_tempkey ON blob(tempKey);
-        CREATE INDEX IF NOT EXISTS idx_backlink_link_to ON backlink(path, linkTo);
-        ",
-    )
-    .execute(db)
-    .await
-    .context("failed to create tables")?;
-
-    Ok(())
-}
-
 /// Get a migrator for the database.
 pub(crate) fn get_migrator(db: ActorDb) -> migrations::Migrator {
     migrations::Migrator::new(db)
···
         format!("{} IS NULL", field_ref.into())
     }
 }
-
-// Re-export commonly used types

src/actor_store/db/schema.rs

···
 //! Database schema definitions for the actor store.
 
 /// Repository root information
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, sqlx::FromRow)]
+#[sqlx(rename_all = "camelCase")]
 pub(crate) struct RepoRoot {
     pub(crate) did: String,
     pub(crate) cid: String,
···
 pub(crate) const REPO_ROOT_TABLE: &str = "repo_root";
 
 /// Repository block (IPLD block)
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, sqlx::FromRow)]
+#[sqlx(rename_all = "camelCase")]
 pub(crate) struct RepoBlock {
     pub(crate) cid: String,
     pub(crate) repo_rev: String,
···
 pub(crate) const REPO_BLOCK_TABLE: &str = "repo_block";
 
 /// Record information
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, sqlx::FromRow)]
+#[sqlx(rename_all = "camelCase")]
 pub(crate) struct Record {
     pub(crate) uri: String,
     pub(crate) cid: String,
···
 pub(crate) const RECORD_TABLE: &str = "record";
 
 /// Blob information
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, sqlx::FromRow)]
+#[sqlx(rename_all = "camelCase")]
 pub(crate) struct Blob {
     pub(crate) cid: String,
     pub(crate) mime_type: String,
···
 pub(crate) const BLOB_TABLE: &str = "blob";
 
 /// Record-blob association
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, sqlx::FromRow)]
+#[sqlx(rename_all = "camelCase")]
 pub(crate) struct RecordBlob {
     pub(crate) blob_cid: String,
     pub(crate) record_uri: String,
···
 pub(crate) const RECORD_BLOB_TABLE: &str = "record_blob";
 
 /// Backlink between records
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, sqlx::FromRow)]
+#[sqlx(rename_all = "camelCase")]
 pub(crate) struct Backlink {
     pub(crate) uri: String,
     pub(crate) path: String,
···
 pub(crate) const BACKLINK_TABLE: &str = "backlink";
 
 /// Account preference
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, sqlx::FromRow)]
+#[sqlx(rename_all = "camelCase")]
 pub(crate) struct AccountPref {
     pub(crate) id: i64,
     pub(crate) name: String,

src/actor_store/preference/reader.rs

···
 pub(crate) struct PreferenceReader {
     /// Database connection.
     pub db: SqlitePool,
-    /// DID of the repository owner.
-    pub did: String,
 }
 
 /// User preference with type information.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Deserialize)]
 pub(crate) struct AccountPreference {
     /// Type of the preference.
     pub r#type: String,
···
 
 impl PreferenceReader {
     /// Create a new preference reader.
-    pub(crate) fn new(db: SqlitePool, did: String) -> Self {
-        Self { db, did }
+    pub(crate) fn new(db: SqlitePool) -> Self {
+        Self { db }
     }
 
     /// Get preferences for a namespace.
     pub(crate) async fn get_preferences(
         &self,
-        namespace: &str,
+        namespace: Option<&str>,
         scope: &str,
     ) -> Result<Vec<AccountPreference>> {
-        // TODO: Implement preference reader
-        // For now, just return an empty list
-        Ok(Vec::new())
+        let prefs_res = sqlx::query!("SELECT * FROM account_pref ORDER BY id")
+            .fetch_all(&self.db)
+            .await?;
+
+        let prefs = prefs_res
+            .into_iter()
+            .filter(|pref| {
+                namespace.map_or(true, |ns| pref_match_namespace(ns, &pref.name))
+                    && pref_in_scope(scope, &pref.name)
+            })
+            .map(|pref| serde_json::from_str(&pref.valueJson).unwrap())
+            .collect();
+
+        Ok(prefs)
     }
 }