fix: unmap status mappings instead of deleting, store unmapped provider statuses

- Make mapped_status nullable so unmapping (X button) sets NULL instead of deleting the row — provider statuses never disappear from the UI - normalize_series_status now returns the raw provider status (lowercased) when no mapping exists, so all statuses are stored in series_metadata - Fix series_statuses query crash caused by NULL mapped_status values - Fix metadata batch/refresh server actions crashing page on 400 errors - StatusMappingDto.mapped_status is now string | null in the backoffice Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-03-19 13:22:31 +01:00
parent d4c48de780
commit c44b51d6ef
11 changed files with 109 additions and 68 deletions
--- a/apps/api/src/books.rs
+++ b/apps/api/src/books.rs
@@ -870,7 +870,7 @@ pub async fn series_statuses(
        r#"SELECT DISTINCT s FROM (
            SELECT LOWER(status) AS s FROM series_metadata WHERE status IS NOT NULL
            UNION
-            SELECT mapped_status AS s FROM status_mappings
+            SELECT mapped_status AS s FROM status_mappings WHERE mapped_status IS NOT NULL
        ) t ORDER BY s"#,
    )
    .fetch_all(&state.pool)
--- a/apps/api/src/metadata.rs
+++ b/apps/api/src/metadata.rs
@@ -694,7 +694,7 @@ pub(crate) async fn sync_series_metadata(
        .and_then(|y| y.as_i64())
        .map(|y| y as i32);
    let status = if let Some(raw) = metadata_json.get("status").and_then(|s| s.as_str()) {
-        normalize_series_status(&state.pool, raw).await
+        Some(normalize_series_status(&state.pool, raw).await)
    } else {
        None
    };
@@ -802,7 +802,7 @@ pub(crate) async fn sync_series_metadata(
        FieldDef {
            name: "status",
            old: existing.as_ref().and_then(|r| r.get::<Option<String>, _>("status")).map(serde_json::Value::String),
-            new: status.as_ref().map(|s| serde_json::Value::String(s.clone())),
+            new: status.as_ref().map(|s: &String| serde_json::Value::String(s.clone())),
        },
    ];

@@ -828,33 +828,33 @@ pub(crate) async fn sync_series_metadata(

 /// Normalize provider-specific status strings using the status_mappings table.
 /// Returns None if no mapping is found — unknown statuses are not stored.
-pub(crate) async fn normalize_series_status(pool: &sqlx::PgPool, raw: &str) -> Option<String> {
+pub(crate) async fn normalize_series_status(pool: &sqlx::PgPool, raw: &str) -> String {
    let lower = raw.to_lowercase();

-    // Try exact match first
+    // Try exact match first (only mapped entries)
    if let Ok(Some(row)) = sqlx::query_scalar::<_, String>(
-        "SELECT mapped_status FROM status_mappings WHERE provider_status = $1",
+        "SELECT mapped_status FROM status_mappings WHERE provider_status = $1 AND mapped_status IS NOT NULL",
    )
    .bind(&lower)
    .fetch_optional(pool)
    .await
    {
-        return Some(row);
+        return row;
    }

    // Try substring match (for Bédéthèque-style statuses like "Série finie")
    if let Ok(Some(row)) = sqlx::query_scalar::<_, String>(
-        "SELECT mapped_status FROM status_mappings WHERE $1 LIKE '%' || provider_status || '%' LIMIT 1",
+        "SELECT mapped_status FROM status_mappings WHERE $1 LIKE '%' || provider_status || '%' AND mapped_status IS NOT NULL LIMIT 1",
    )
    .bind(&lower)
    .fetch_optional(pool)
    .await
    {
-        return Some(row);
+        return row;
    }

-    // No mapping found — don't store unknown statuses
-    None
+    // No mapping found — return the provider status as-is (lowercased)
+    lower
 }

 pub(crate) async fn sync_books_metadata(
--- a/apps/api/src/metadata_batch.rs
+++ b/apps/api/src/metadata_batch.rs
@@ -772,7 +772,7 @@ async fn sync_series_from_candidate(
    let start_year = candidate.start_year;
    let total_volumes = candidate.total_volumes;
    let status = if let Some(raw) = candidate.metadata_json.get("status").and_then(|s| s.as_str()) {
-        crate::metadata::normalize_series_status(pool, raw).await
+        Some(crate::metadata::normalize_series_status(pool, raw).await)
    } else {
        None
    };
--- a/apps/api/src/metadata_refresh.rs
+++ b/apps/api/src/metadata_refresh.rs
@@ -575,7 +575,7 @@ async fn sync_series_with_diff(
    let new_start_year = candidate.start_year;
    let new_total_volumes = candidate.total_volumes;
    let new_status = if let Some(raw) = candidate.metadata_json.get("status").and_then(|s| s.as_str()) {
-        crate::metadata::normalize_series_status(pool, raw).await
+        Some(crate::metadata::normalize_series_status(pool, raw).await)
    } else {
        None
    };
--- a/apps/api/src/settings.rs
+++ b/apps/api/src/settings.rs
@@ -342,7 +342,7 @@ pub async fn get_thumbnail_stats(State(_state): State<AppState>) -> Result<Json<
 pub struct StatusMappingDto {
    pub id: String,
    pub provider_status: String,
-    pub mapped_status: String,
+    pub mapped_status: Option<String>,
 }

 #[derive(Debug, Clone, Deserialize, ToSchema)]
@@ -366,7 +366,7 @@ pub async fn list_status_mappings(
    State(state): State<AppState>,
 ) -> Result<Json<Vec<StatusMappingDto>>, ApiError> {
    let rows = sqlx::query(
-        "SELECT id, provider_status, mapped_status FROM status_mappings ORDER BY mapped_status, provider_status",
+        "SELECT id, provider_status, mapped_status FROM status_mappings ORDER BY mapped_status NULLS LAST, provider_status",
    )
    .fetch_all(&state.pool)
    .await?;
@@ -376,7 +376,7 @@ pub async fn list_status_mappings(
        .map(|row| StatusMappingDto {
            id: row.get::<Uuid, _>("id").to_string(),
            provider_status: row.get("provider_status"),
-            mapped_status: row.get("mapped_status"),
+            mapped_status: row.get::<Option<String>, _>("mapped_status"),
        })
        .collect();

@@ -418,18 +418,18 @@ pub async fn upsert_status_mapping(
    Ok(Json(StatusMappingDto {
        id: row.get::<Uuid, _>("id").to_string(),
        provider_status: row.get("provider_status"),
-        mapped_status: row.get("mapped_status"),
+        mapped_status: row.get::<Option<String>, _>("mapped_status"),
    }))
 }

-/// Delete a status mapping
+/// Unmap a status mapping (sets mapped_status to NULL, keeps the provider status known)
 #[utoipa::path(
    delete,
    path = "/settings/status-mappings/{id}",
    tag = "settings",
    params(("id" = String, Path, description = "Mapping UUID")),
    responses(
-        (status = 204, description = "Deleted"),
+        (status = 200, body = StatusMappingDto),
        (status = 401, description = "Unauthorized"),
        (status = 404, description = "Not found"),
    ),
@@ -438,15 +438,20 @@ pub async fn upsert_status_mapping(
 pub async fn delete_status_mapping(
    State(state): State<AppState>,
    AxumPath(id): AxumPath<Uuid>,
-) -> Result<Json<Value>, ApiError> {
-    let result = sqlx::query("DELETE FROM status_mappings WHERE id = $1")
-        .bind(id)
-        .execute(&state.pool)
-        .await?;
+) -> Result<Json<StatusMappingDto>, ApiError> {
+    let row = sqlx::query(
+        "UPDATE status_mappings SET mapped_status = NULL, updated_at = NOW() WHERE id = $1 RETURNING id, provider_status, mapped_status",
+    )
+    .bind(id)
+    .fetch_optional(&state.pool)
+    .await?;

-    if result.rows_affected() == 0 {
-        return Err(ApiError::not_found("status mapping not found"));
+    match row {
+        Some(row) => Ok(Json(StatusMappingDto {
+            id: row.get::<Uuid, _>("id").to_string(),
+            provider_status: row.get("provider_status"),
+            mapped_status: row.get::<Option<String>, _>("mapped_status"),
+        })),
+        None => Err(ApiError::not_found("status mapping not found")),
    }
-
-    Ok(Json(serde_json::json!({"deleted": true})))
 }
--- a/apps/backoffice/app/jobs/page.tsx
+++ b/apps/backoffice/app/jobs/page.tsx
@@ -53,7 +53,13 @@ export default async function JobsPage({ searchParams }: { searchParams: Promise
    "use server";
    const libraryId = formData.get("library_id") as string;
    if (!libraryId) return;
-    const result = await startMetadataBatch(libraryId);
+    let result;
+    try {
+      result = await startMetadataBatch(libraryId);
+    } catch {
+      // Library may have metadata disabled — ignore silently
+      return;
+    }
    revalidatePath("/jobs");
    redirect(`/jobs?highlight=${result.id}`);
  }
@@ -62,7 +68,12 @@ export default async function JobsPage({ searchParams }: { searchParams: Promise
    "use server";
    const libraryId = formData.get("library_id") as string;
    if (!libraryId) return;
-    const result = await startMetadataRefresh(libraryId);
+    let result;
+    try {
+      result = await startMetadataRefresh(libraryId);
+    } catch {
+      return;
+    }
    revalidatePath("/jobs");
    redirect(`/jobs?highlight=${result.id}`);
  }
--- a/apps/backoffice/app/libraries/page.tsx
+++ b/apps/backoffice/app/libraries/page.tsx
@@ -80,7 +80,12 @@ export default async function LibrariesPage() {
  async function batchMetadataAction(formData: FormData) {
    "use server";
    const id = formData.get("id") as string;
-    await startMetadataBatch(id);
+    try {
+      await startMetadataBatch(id);
+    } catch {
+      // Library may have metadata disabled — ignore silently
+      return;
+    }
    revalidatePath("/libraries");
    revalidatePath("/jobs");
  }
--- a/apps/backoffice/app/settings/SettingsPage.tsx
+++ b/apps/backoffice/app/settings/SettingsPage.tsx
@@ -1023,26 +1023,39 @@ function StatusMappingsCard() {

  useEffect(() => { loadData(); }, [loadData]);

-  // Group mappings by target status
+  // Group mappings by target status (only those with a non-null mapped_status)
  const grouped = useMemo(() => {
    const map = new Map<string, StatusMappingDto[]>();
    for (const m of mappings) {
-      const list = map.get(m.mapped_status) || [];
-      list.push(m);
-      map.set(m.mapped_status, list);
+      if (m.mapped_status) {
+        const list = map.get(m.mapped_status) || [];
+        list.push(m);
+        map.set(m.mapped_status, list);
+      }
    }
    return map;
  }, [mappings]);

-  // Provider statuses not yet mapped
-  const mappedProviderStatuses = useMemo(
+  // Unmapped = mappings with null mapped_status + provider statuses not in status_mappings at all
+  const knownProviderStatuses = useMemo(
    () => new Set(mappings.map((m) => m.provider_status)),
    [mappings],
  );
-  const unmappedProviderStatuses = useMemo(
-    () => providerStatuses.filter((ps) => !mappedProviderStatuses.has(ps)),
-    [providerStatuses, mappedProviderStatuses],
+  const unmappedMappings = useMemo(
+    () => mappings.filter((m) => !m.mapped_status),
+    [mappings],
  );
+  const newProviderStatuses = useMemo(
+    () => providerStatuses.filter((ps) => !knownProviderStatuses.has(ps)),
+    [providerStatuses, knownProviderStatuses],
+  );
+
+  // All possible targets = existing statuses from DB + custom ones added locally
+  const [customTargets, setCustomTargets] = useState<string[]>([]);
+  const allTargets = useMemo(() => {
+    const set = new Set([...targetStatuses, ...customTargets]);
+    return [...set].sort();
+  }, [targetStatuses, customTargets]);

  async function handleAssign(providerStatus: string, targetStatus: string) {
    if (!providerStatus || !targetStatus) return;
@@ -1061,27 +1074,12 @@ function StatusMappingsCard() {
    }
  }

-  async function handleDelete(id: string) {
+  async function handleUnmap(id: string) {
    try {
      const res = await fetch(`/api/settings/status-mappings/${id}`, { method: "DELETE" });
-      if (res.ok) {
-        setMappings((prev) => prev.filter((m) => m.id !== id));
-      }
-    } catch {
-      // ignore
-    }
-  }
-
-  async function handleChangeTarget(mapping: StatusMappingDto, newTarget: string) {
-    try {
-      const res = await fetch("/api/settings/status-mappings", {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ provider_status: mapping.provider_status, mapped_status: newTarget }),
-      });
      if (res.ok) {
        const updated: StatusMappingDto = await res.json();
-        setMappings((prev) => prev.map((m) => (m.id === mapping.id ? updated : m)));
+        setMappings((prev) => prev.map((m) => (m.id === id ? updated : m)));
      }
    } catch {
      // ignore
@@ -1090,8 +1088,8 @@ function StatusMappingsCard() {

  function handleCreateTarget() {
    const name = newTargetName.trim().toLowerCase();
-    if (!name || targetStatuses.includes(name)) return;
-    setTargetStatuses((prev) => [...prev, name].sort());
+    if (!name || allTargets.includes(name)) return;
+    setCustomTargets((prev) => [...prev, name]);
    setNewTargetName("");
  }

@@ -1131,7 +1129,7 @@ function StatusMappingsCard() {
            />
            <Button
              onClick={handleCreateTarget}
-              disabled={!newTargetName.trim() || targetStatuses.includes(newTargetName.trim().toLowerCase())}
+              disabled={!newTargetName.trim() || allTargets.includes(newTargetName.trim().toLowerCase())}
            >
              <Icon name="plus" size="sm" />
              {t("settings.createTargetStatus")}
@@ -1139,7 +1137,7 @@ function StatusMappingsCard() {
          </div>

          {/* Grouped by target status */}
-          {targetStatuses.map((target) => {
+          {allTargets.map((target) => {
            const items = grouped.get(target) || [];
            return (
              <div key={target} className="border border-border/50 rounded-lg p-3">
@@ -1158,7 +1156,7 @@ function StatusMappingsCard() {
                      {m.provider_status}
                      <button
                        type="button"
-                        onClick={() => handleDelete(m.id)}
+                        onClick={() => handleUnmap(m.id)}
                        className="ml-1 text-muted-foreground hover:text-destructive transition-colors"
                        title={t("common.delete")}
                      >
@@ -1166,17 +1164,36 @@ function StatusMappingsCard() {
                      </button>
                    </span>
                  ))}
+                  {items.length === 0 && (
+                    <span className="text-xs text-muted-foreground italic">{t("settings.noMappings")}</span>
+                  )}
                </div>
              </div>
            );
          })}

-          {/* Unmapped provider statuses */}
-          {unmappedProviderStatuses.length > 0 && (
+          {/* Unmapped provider statuses (null mapped_status + brand new from providers) */}
+          {(unmappedMappings.length > 0 || newProviderStatuses.length > 0) && (
            <div className="border-t border-border/50 pt-4">
              <h4 className="text-sm font-medium text-foreground mb-3">{t("settings.unmappedSection")}</h4>
              <div className="space-y-2">
-                {unmappedProviderStatuses.map((ps) => (
+                {unmappedMappings.map((m) => (
+                  <div key={m.id} className="flex items-center gap-2">
+                    <span className="text-sm font-mono bg-muted/50 px-2 py-1 rounded-md min-w-[120px]">{m.provider_status}</span>
+                    <Icon name="chevronRight" size="sm" />
+                    <FormSelect
+                      className="w-auto"
+                      value=""
+                      onChange={(e) => { if (e.target.value) handleAssign(m.provider_status, e.target.value); }}
+                    >
+                      <option value="">{t("settings.selectTargetStatus")}</option>
+                      {allTargets.map((s) => (
+                        <option key={s} value={s}>{statusLabel(s)}</option>
+                      ))}
+                    </FormSelect>
+                  </div>
+                ))}
+                {newProviderStatuses.map((ps) => (
                  <div key={ps} className="flex items-center gap-2">
                    <span className="text-sm font-mono bg-muted/50 px-2 py-1 rounded-md min-w-[120px]">{ps}</span>
                    <Icon name="chevronRight" size="sm" />
@@ -1186,7 +1203,7 @@ function StatusMappingsCard() {
                      onChange={(e) => { if (e.target.value) handleAssign(ps, e.target.value); }}
                    >
                      <option value="">{t("settings.selectTargetStatus")}</option>
-                      {targetStatuses.map((s) => (
+                      {allTargets.map((s) => (
                        <option key={s} value={s}>{statusLabel(s)}</option>
                      ))}
                    </FormSelect>
--- a/apps/backoffice/lib/api.ts
+++ b/apps/backoffice/lib/api.ts
@@ -433,7 +433,7 @@ export async function getThumbnailStats() {
 export type StatusMappingDto = {
  id: string;
  provider_status: string;
-  mapped_status: string;
+  mapped_status: string | null;
 };

 export async function fetchStatusMappings(): Promise<StatusMappingDto[]> {
--- a/apps/backoffice/tsconfig.tsbuildinfo
+++ b/apps/backoffice/tsconfig.tsbuildinfo