feat(api): on-write search reindex after catalogue writes (#17)

Wire best-effort Meilisearch index sync into the admin write paths
(create/update/delete/set_fields/set_visibility). Adds
SearchClient::sync_object (reindex if the object exists, remove if gone —
one uniform path), an optional AppState.search client, and a reindex
helper that logs failures via tracing without failing the committed
write. Server gains MEILI_URL/MEILI_MASTER_KEY/MEILI_INDEX config;
search stays disabled (no-op) when unset. reindex_all remains the
recovery path.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

crates/api/Cargo.toml

@@ -13,12 +13,15 @@ time.workspace = true
 tower-sessions.workspace = true
 tower-sessions-sqlx-store.workspace = true
 sqlx.workspace = true
+tracing.workspace = true
 auth = { path = "../auth" }
 db = { path = "../db" }
 domain = { path = "../domain" }
+search = { path = "../search" }
 
 [dev-dependencies]
 tokio.workspace = true
 tower.workspace = true
 http-body-util.workspace = true
 serde_json.workspace = true
+uuid.workspace = true

crates/api/src/admin.rs

@@ -160,6 +160,8 @@ pub(crate) async fn set_visibility(
                 .await
                 .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
 
+            crate::reindex(&state, object_id).await;
+
             Ok(StatusCode::NO_CONTENT)
         }
         Err(db::catalog::VisibilityError::ObjectNotFound) => Err(StatusCode::NOT_FOUND),

crates/api/src/admin_objects.rs

@@ -234,6 +234,8 @@ pub(crate) async fn create_object(
         .await
         .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
 
+    crate::reindex(&state, id).await;
+
     Ok((
         StatusCode::CREATED,
         Json(CreatedObject { id: id.to_string() }),
@@ -299,6 +301,8 @@ pub(crate) async fn update_object(
         .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
 
     if existed {
+        crate::reindex(&state, object_id).await;
+
         Ok(StatusCode::NO_CONTENT)
     } else {
         Err(StatusCode::NOT_FOUND)
@@ -339,6 +343,8 @@ pub(crate) async fn delete_object(
         .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
 
     if existed {
+        crate::reindex(&state, object_id).await;
+
         Ok(StatusCode::NO_CONTENT)
     } else {
         Err(StatusCode::NOT_FOUND)
@@ -443,6 +449,8 @@ pub(crate) async fn set_fields(
                 .await
                 .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
 
+            crate::reindex(&state, object_id).await;
+
             Ok(StatusCode::NO_CONTENT)
         }
         Err(db::catalog::FieldError::ObjectNotFound) => Err(StatusCode::NOT_FOUND),

crates/api/src/lib.rs

@@ -26,6 +26,23 @@ pub struct AppState {
     /// Whether the session cookie carries the `Secure` attribute (default true;
     /// disable only for plain-HTTP self-hosting).
     pub cookie_secure: bool,
+    /// Search client for on-write index sync. `None` disables indexing (search is a
+    /// best-effort feature; absent when Meilisearch is not configured).
+    pub search: Option<search::SearchClient>,
+}
+
+/// Best-effort: keep the search index in step with a catalogue write that has already
+/// committed. Re-projects and indexes the object, or removes it if it no longer exists.
+/// Never fails the request — a search outage must not undo a committed write, and
+/// `reindex_all` is the recovery path. A no-op when search is not configured.
+pub(crate) async fn reindex(state: &AppState, id: domain::ObjectId) {
+    let Some(search) = &state.search else {
+        return;
+    };
+
+    if let Err(err) = search.sync_object(&state.db, id).await {
+        tracing::error!(?err, object_id = %id, "search reindex after write failed");
+    }
 }
 
 /// Build the application router from shared state.

crates/api/tests/admin.rs

@@ -12,6 +12,7 @@ fn state(pool: PgPool) -> AppState {
         db: db::Db::from_pool(pool),
         app_name: "Test".into(),
         cookie_secure: false,
+        search: None,
     }
 }
 

crates/api/tests/admin_catalog.rs

@@ -12,6 +12,7 @@ fn state(pool: PgPool) -> AppState {
         db: db::Db::from_pool(pool),
         app_name: "Test".into(),
         cookie_secure: false,
+        search: None,
     }
 }
 

crates/api/tests/admin_objects.rs

@@ -15,6 +15,7 @@ fn state(pool: PgPool) -> AppState {
         db: db::Db::from_pool(pool),
         app_name: "Test".into(),
         cookie_secure: false,
+        search: None,
     }
 }
 

crates/api/tests/health.rs

@@ -10,6 +10,7 @@ fn state(pool: PgPool, app_name: &str) -> AppState {
         db: db::Db::from_pool(pool),
         app_name: app_name.to_string(),
         cookie_secure: false,
+        search: None,
     }
 }
 

crates/api/tests/public.rs

@@ -12,6 +12,7 @@ fn state(pool: PgPool) -> AppState {
         db: db::Db::from_pool(pool),
         app_name: "Test".to_string(),
         cookie_secure: false,
+        search: None,
     }
 }
 

crates/api/tests/reindex.rs

@@ -0,0 +1,137 @@
+use api::{AppState, build_app, migrate_sessions};
+use axum::body::Body;
+use axum::http::{Request, StatusCode, header};
+use db::users;
+use domain::{AuditActor, Email, NewUser, ObjectId, Role};
+use http_body_util::BodyExt;
+use search::SearchClient;
+use sqlx::PgPool;
+use tower::ServiceExt;
+
+fn meili() -> (String, String) {
+    (
+        std::env::var("MEILI_URL").expect("MEILI_URL must be set"),
+        std::env::var("MEILI_MASTER_KEY").expect("MEILI_MASTER_KEY must be set"),
+    )
+}
+
+fn unique_index() -> String {
+    format!("api_reindex_test_{}", uuid::Uuid::new_v4().simple())
+}
+
+fn state(pool: PgPool, search: SearchClient) -> AppState {
+    AppState {
+        db: db::Db::from_pool(pool),
+        app_name: "Test".into(),
+        cookie_secure: false,
+        search: Some(search),
+    }
+}
+
+async fn seed_user(pool: &PgPool, email: &str, password: &str, role: Role) {
+    let db = db::Db::from_pool(pool.clone());
+    let mut tx = db.pool().begin().await.unwrap();
+
+    users::create_user(
+        &mut tx,
+        AuditActor::System,
+        &NewUser {
+            email: Email::parse(email).unwrap(),
+            password_hash: auth::hash_password(password).unwrap(),
+            role,
+        },
+    )
+    .await
+    .unwrap();
+
+    tx.commit().await.unwrap();
+}
+
+async fn login(app: &axum::Router, email: &str, password: &str) -> String {
+    let resp = app
+        .clone()
+        .oneshot(
+            Request::builder()
+                .method("POST")
+                .uri("/api/admin/login")
+                .header(header::CONTENT_TYPE, "application/json")
+                .body(Body::from(format!(
+                    r#"{{"email":"{email}","password":"{password}"}}"#
+                )))
+                .unwrap(),
+        )
+        .await
+        .unwrap();
+
+    assert_eq!(resp.status(), StatusCode::NO_CONTENT);
+
+    resp.headers()
+        .get(header::SET_COOKIE)
+        .unwrap()
+        .to_str()
+        .unwrap()
+        .split(';')
+        .next()
+        .unwrap()
+        .to_owned()
+}
+
+#[sqlx::test(migrations = "../db/migrations")]
+async fn admin_writes_sync_the_search_index(pool: PgPool) {
+    migrate_sessions(&db::Db::from_pool(pool.clone()))
+        .await
+        .unwrap();
+
+    seed_user(&pool, "ed@example.com", "pw-editor-123", Role::Editor).await;
+
+    let (url, key) = meili();
+    let search = SearchClient::connect(&url, &key, &unique_index()).unwrap();
+
+    search.ensure_index().await.unwrap();
+
+    // a second handle to the same index, used to observe what the handlers indexed
+    let observer = search.clone();
+
+    let app = build_app(state(pool.clone(), search));
+    let cookie = login(&app, "ed@example.com", "pw-editor-123").await;
+
+    // create via the admin API -> the object is indexed on commit
+    let create = app
+        .clone()
+        .oneshot(
+            Request::builder()
+                .method("POST")
+                .uri("/api/admin/objects")
+                .header(header::COOKIE, &cookie)
+                .header(header::CONTENT_TYPE, "application/json")
+                .body(Body::from(
+                    r#"{"object_number":"R-1","object_name":"astrolabe","number_of_objects":1,"visibility":"internal"}"#,
+                ))
+                .unwrap(),
+        )
+        .await
+        .unwrap();
+    assert_eq!(create.status(), StatusCode::CREATED);
+
+    let created: serde_json::Value =
+        serde_json::from_slice(&create.into_body().collect().await.unwrap().to_bytes()).unwrap();
+    let id: ObjectId = created["id"].as_str().unwrap().parse().unwrap();
+
+    assert_eq!(observer.search("astrolabe").await.unwrap(), vec![id]);
+
+    // delete via the admin API -> the object drops out of the index
+    let delete = app
+        .oneshot(
+            Request::builder()
+                .method("DELETE")
+                .uri(format!("/api/admin/objects/{id}"))
+                .header(header::COOKIE, &cookie)
+                .body(Body::empty())
+                .unwrap(),
+        )
+        .await
+        .unwrap();
+    assert_eq!(delete.status(), StatusCode::NO_CONTENT);
+
+    assert!(observer.search("astrolabe").await.unwrap().is_empty());
+}