feat: implement metadata catalog database management

backend/test/catalog-tables-routes.test.ts

@@ -0,0 +1,126 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, expect, test, vi } from "vitest";
+import { buildApp } from "../src/app.js";
+import { loadConfig } from "../src/config.js";
+import { MemoryCatalogRepository } from "../src/catalog/memory-repository.js";
+import { WorkspaceSecretStore } from "../src/workspaces/secret-store.js";
+import type { WorkspaceRegistry, WorkspaceRevision } from "../src/workspaces/registry.js";
+import type { WorkspaceDescriptor } from "../src/workspaces/schema.js";
+
+const roots: string[] = [];
+afterEach(() => { for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true }); });
+
+const workspace: WorkspaceDescriptor = {
+  workspace: { schema_version: 3, id: "psd-clinical", name: "Policlinico San Donato", language: "it" },
+  dwh: {
+    engine: "postgres", database: "warehouse", schema: "datawarehouse", port: 5432,
+    supported_transports: ["postgres_direct", "rest_api"],
+  },
+  semantic_index: {
+    vector_store: { engine: "qdrant", collection: "psd", dimensions: 1024, distance: "cosine" },
+    embedding: { provider: "ollama_internal", model: "qwen3-embedding:0.6b", dimensions: 1024 },
+  },
+  llm_policy: { allowed: ["zai/glm-5.2"] },
+  diagnostics: { dwh_rest: { method: "GET", path: "/health", auth: "bearer", response: { database: "database", schema: "schema" } } },
+};
+const revision: WorkspaceRevision = {
+  id: "psd-clinical", commit: "a".repeat(40), blob: "b".repeat(40), snapshotPath: "/tmp/psd.yaml",
+};
+
+async function setup() {
+  const secretRoot = mkdtempSync(join(tmpdir(), "catalog-table-secret-"));
+  const runtimeRoot = mkdtempSync(join(tmpdir(), "catalog-table-runtime-"));
+  roots.push(secretRoot, runtimeRoot);
+  const repository = new MemoryCatalogRepository();
+  const database = await repository.create({
+    workspaceId: "psd-clinical",
+    engine: "postgres",
+    databaseName: "warehouse",
+    schema: "datawarehouse",
+    binding: { transport: "postgres_direct", host: "db.internal", port: 5432, username: "reader" },
+  });
+  await repository.recordTest(database.id, database.version, {
+    connectionStatus: "reachable",
+    testedVersion: database.version,
+    lastTestedAt: new Date().toISOString(),
+  });
+  const scan = vi.fn(async () => [
+    { name: "patients", sourceComment: "Clinical patients" },
+    { name: "visits", sourceComment: null },
+  ]);
+  const registry = {
+    list: vi.fn(async () => [revision]),
+    listCatalog: vi.fn(async () => [{ id: "psd-clinical", name: "Policlinico San Donato", configurationState: "ready", revision }]),
+    read: vi.fn(async () => ({ workspace, revision })),
+  } as unknown as WorkspaceRegistry;
+  const secretStore = new WorkspaceSecretStore({ root: secretRoot, runtimeRoot, installationId: "test" });
+  const app = buildApp(loadConfig({ THT_HARNESS_DIR: "/missing", NODE_ENV: "test" }), {
+    thtRunner: {} as never,
+    workspaceRegistry: registry,
+    workspaceSecretStore: secretStore,
+    catalogRepository: repository,
+    workspaceDiagnoser: vi.fn(),
+  });
+  return { app, repository, database: (await repository.get(database.id))!, scan };
+}
+
+test("lists physical tables and updates only review metadata", async () => {
+  const { app, repository, database, scan } = await setup();
+  const synchronized = await repository.reconcileTables(database.id, database.version, await scan(), []);
+  expect(synchronized).toMatchObject({ kind: "applied", createdCount: 2, deletedCount: 0 });
+  expect(scan).toHaveBeenCalledOnce();
+
+  const tables = (await app.inject({
+    method: "GET", url: `/catalog/databases/${database.id}/tables`,
+  })).json();
+  expect(tables.map((table: { name: string }) => table.name)).toEqual(["patients", "visits"]);
+  const patients = tables[0];
+  const edited = await app.inject({
+    method: "PATCH",
+    url: `/catalog/databases/${database.id}/tables/${patients.id}`,
+    payload: { version: patients.version, description: "Curated patient registry" },
+  });
+  expect(edited.statusCode).toBe(200);
+  expect(edited.json()).toMatchObject({
+    name: "patients",
+    sourceComment: "Clinical patients",
+    description: "Curated patient registry",
+    version: 2,
+  });
+});
+
+test("requires an exact deletion confirmation before applying the atomic diff", async () => {
+  const { app, repository, database, scan } = await setup();
+  await repository.reconcileTables(database.id, database.version, await scan(), []);
+  scan.mockResolvedValue([{ name: "patients", sourceComment: "Clinical patients" }]);
+
+  const preview = await repository.reconcileTables(database.id, database.version, await scan(), []);
+  expect(preview).toEqual({ kind: "confirmation_required", deletedNames: ["visits"] });
+  expect((await app.inject({ method: "GET", url: `/catalog/databases/${database.id}/tables` })).json()).toHaveLength(2);
+
+  const applied = await repository.reconcileTables(database.id, database.version, await scan(), ["visits"]);
+  expect(applied).toMatchObject({ kind: "applied", deletedCount: 1 });
+  expect((await app.inject({ method: "GET", url: `/catalog/databases/${database.id}/tables` })).json()).toMatchObject([
+    { name: "patients" },
+  ]);
+});
+
+test("refuses synchronization until the current binding has passed its connection test", async () => {
+  const { app, repository, database } = await setup();
+  await repository.update(database.id, database.version, {
+    workspaceId: database.workspaceId,
+    engine: database.engine,
+    databaseName: database.databaseName,
+    schema: database.schema,
+    binding: database.binding,
+  });
+  const response = await app.inject({
+    method: "POST",
+    url: `/catalog/databases/${database.id}/sync-runs`,
+    payload: { version: database.version + 1, scope: "tables", tableIds: [] },
+  });
+  expect(response.statusCode).toBe(409);
+  expect(response.json()).toMatchObject({ code: "schema_sync_conflict" });
+});