forgeos 0.1.0-alpha.7 → 0.1.0-alpha.71

package/src/forge/cli/db.ts

@@ -7,6 +7,9 @@ import { buildAppGraph } from "../compiler/app-graph/build.ts";
 import { createDiagnostic } from "../compiler/diagnostics/create.ts";
 import {
   FORGE_RLS_APPLY_FAILED,
+  FORGE_DB_ADAPTER_UNAVAILABLE,
+  FORGE_PGLITE_STORE_ABORTED,
+  FORGE_PGLITE_STORE_ACTIVE,
   FORGE_RUNTIME_NOT_FOUND,
 } from "../compiler/diagnostics/codes.ts";
 import { GENERATED_DIR } from "../compiler/emitter/constants.ts";
@@ -23,14 +26,20 @@ import {
   resetDatabase,
 } from "../runtime/db/migrate.ts";
 import type { DbAdapterKind } from "../runtime/db/adapter.ts";
+import {
+  DEFAULT_PGLITE_DIR,
+  repairLocalPgliteStore,
+} from "../runtime/db/pglite-adapter.ts";
+import { normalizeForgeCliCommandsInValue } from "../workspace/forge-cli.ts";
 
-export type DbSubcommand = "diff" | "migrate" | "reset" | "status" | "rls-check";
+export type DbSubcommand = "diff" | "migrate" | "reset" | "status" | "doctor" | "repair" | "rls-check";
 
 export interface DbCommandOptions {
   subcommand: DbSubcommand;
   workspaceRoot: string;
   db: DbAdapterKind;
   databaseUrl?: string;
+  local?: boolean;
   json: boolean;
 }
 
@@ -171,7 +180,200 @@ function sqlPlanDiagnostics(plan: SqlPlan): Diagnostic[] {
   return Array.isArray(plan.diagnostics) ? plan.diagnostics : [];
 }
 
+async function inspectDatabaseColumns(
+  adapter: NonNullable<Awaited<ReturnType<typeof createDbAdapter>>["adapter"]>,
+): Promise<{ tables: Record<string, string[]>; diagnostics: Diagnostic[] }> {
+  try {
+    const result = await adapter.query(
+      `SELECT c.relname AS table_name, a.attname AS column_name
+       FROM pg_catalog.pg_class c
+       JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+       JOIN pg_catalog.pg_attribute a ON a.attrelid = c.oid
+       WHERE n.nspname = 'public'
+         AND c.relkind IN ('r', 'p')
+         AND a.attnum > 0
+         AND NOT a.attisdropped
+       ORDER BY c.relname, a.attnum`,
+    );
+    const tables: Record<string, string[]> = {};
+    for (const row of result.rows) {
+      const table = typeof row.table_name === "string" ? row.table_name : undefined;
+      const column = typeof row.column_name === "string" ? row.column_name : undefined;
+      if (!table || !column) {
+        continue;
+      }
+      tables[table] = [...(tables[table] ?? []), column];
+    }
+    return { tables, diagnostics: [] };
+  } catch (error) {
+    return {
+      tables: {},
+      diagnostics: [
+        createDiagnostic({
+          severity: "error",
+          code: "FORGE_DB_DOCTOR_INSPECT_FAILED",
+          message: error instanceof Error ? error.message : "failed to inspect database columns",
+          fixHint: "Verify the configured database adapter is reachable, then retry the read-only doctor.",
+          suggestedCommands: ["forge db doctor --json", "forge db migrate --json"],
+        }),
+      ],
+    };
+  }
+}
+
+async function runDbDoctor(
+  options: DbCommandOptions,
+  plan: SqlPlan,
+  diagnostics: Diagnostic[],
+  planDiagnostics: Diagnostic[],
+): Promise<DbCommandResult> {
+  const { adapter, diagnostics: adapterDiagnostics } = await createDbAdapter(adapterOptions(options));
+  if (!adapter) {
+    return {
+      ok: false,
+      diagnostics: [...diagnostics, ...planDiagnostics, ...adapterDiagnostics],
+      exitCode: 1,
+    };
+  }
+
+  try {
+    const inspected = await inspectDatabaseColumns(adapter);
+    const expected = Object.fromEntries(
+      plan.tables
+        .filter((table) => table.kind === "create_table" && table.table && table.columns)
+        .map((table) => [table.table!, table.columns!.map((column) => column.name).sort()]),
+    );
+    const missingTables = Object.keys(expected)
+      .filter((table) => !inspected.tables[table])
+      .sort();
+    const missingColumns = Object.entries(expected)
+      .flatMap(([table, columns]) => {
+        const actual = new Set(inspected.tables[table] ?? []);
+        return columns
+          .filter((column) => !actual.has(column))
+          .map((column) => ({ table, column }));
+      })
+      .sort((a, b) => a.table.localeCompare(b.table) || a.column.localeCompare(b.column));
+    const extraTables = Object.keys(inspected.tables)
+      .filter((table) => !expected[table] && !table.startsWith("_forge_"))
+      .sort();
+    const ok = inspected.diagnostics.length === 0 && missingTables.length === 0 && missingColumns.length === 0;
+
+    return normalizeForgeCliCommandsInValue(options.workspaceRoot, {
+      ok,
+      data: {
+        schemaVersion: "0.1.0",
+        summary: {
+          ok,
+          adapter: adapter.kind,
+          expectedTables: Object.keys(expected).length,
+          actualTables: Object.keys(inspected.tables).length,
+          missingTables: missingTables.length,
+          missingColumns: missingColumns.length,
+          extraTables: extraTables.length,
+        },
+        expected,
+        actual: inspected.tables,
+        missingTables,
+        missingColumns,
+        extraTables,
+        nextActions: ok
+          ? ["forge db status --json", "forge check --json"]
+          : ["forge db migrate --json", "forge db doctor --json", "forge generate"],
+      },
+      diagnostics: [
+        ...diagnostics,
+        ...planDiagnostics,
+        ...adapterDiagnostics,
+        ...inspected.diagnostics,
+      ],
+      exitCode: ok ? 0 : 1,
+    });
+  } finally {
+    await adapter.close();
+  }
+}
+
+async function runDbRepair(options: DbCommandOptions): Promise<DbCommandResult> {
+  if (!options.local) {
+    return normalizeForgeCliCommandsInValue(options.workspaceRoot, {
+      ok: false,
+      data: {
+        schemaVersion: "0.1.0",
+        repaired: false,
+        adapter: options.db,
+        local: false,
+        nextActions: ["forge db repair --local --adapter pglite --json"],
+      },
+      diagnostics: [
+        createDiagnostic({
+          severity: "error",
+          code: "FORGE_CLI_USAGE",
+          message: "local database repair requires --local",
+          fixHint: "Pass --local to confirm you want Forge to repair the local development database store.",
+          suggestedCommands: ["forge db repair --local --adapter pglite --json"],
+        }),
+      ],
+      exitCode: 1,
+    });
+  }
+
+  if (options.db !== "pglite") {
+    return normalizeForgeCliCommandsInValue(options.workspaceRoot, {
+      ok: false,
+      data: {
+        schemaVersion: "0.1.0",
+        repaired: false,
+        adapter: options.db,
+        nextActions: ["forge db repair --local --adapter pglite --json"],
+      },
+      diagnostics: [
+        createDiagnostic({
+          severity: "error",
+          code: FORGE_DB_ADAPTER_UNAVAILABLE,
+          message: "local repair currently supports only the pglite adapter",
+          fixHint: "Use --adapter pglite for the local Forge dev database store.",
+          suggestedCommands: ["forge db repair --local --adapter pglite --json"],
+        }),
+      ],
+      exitCode: 1,
+    });
+  }
+
+  const dataDir = join(options.workspaceRoot, DEFAULT_PGLITE_DIR);
+  const result = await repairLocalPgliteStore(dataDir);
+  const diagnostics = result.ok
+    ? []
+    : [
+        createDiagnostic({
+          severity: "error",
+          code: result.before.state === "active" ? FORGE_PGLITE_STORE_ACTIVE : FORGE_PGLITE_STORE_ABORTED,
+          message: result.message,
+          fixHint: result.before.state === "active"
+            ? "Stop the running forge dev process before repairing the PGlite store."
+            : "Archive the local PGlite store and retry forge dev, or use --db memory for non-persistent validation.",
+          suggestedCommands: result.nextActions,
+        }),
+      ];
+
+  return normalizeForgeCliCommandsInValue(options.workspaceRoot, {
+    ok: result.ok,
+    data: {
+      schemaVersion: "0.1.0",
+      adapter: "pglite",
+      local: true,
+      ...result,
+    },
+    diagnostics,
+    exitCode: result.ok ? 0 : 1,
+  });
+}
+
 export async function runDbCommand(options: DbCommandOptions): Promise<DbCommandResult> {
+  if (options.subcommand === "repair") {
+    return runDbRepair(options);
+  }
+
   const { plan, diagnostics: planDiagnostics } = await loadSqlPlan(options.workspaceRoot);
 
   if (!plan) {
@@ -214,6 +416,11 @@ export async function runDbCommand(options: DbCommandOptions): Promise<DbCommand
   }
 
   const diagnostics = sqlPlanDiagnostics(plan);
+
+  if (options.subcommand === "doctor") {
+    return runDbDoctor(options, plan, diagnostics, planDiagnostics);
+  }
+
   const { adapter, diagnostics: adapterDiagnostics } = await createDbAdapter(
     adapterOptions(options),
   );
@@ -308,7 +515,7 @@ export function formatDbHuman(subcommand: DbSubcommand, result: DbCommandResult)
     return "database reset complete\n";
   }
 
-  if (subcommand === "status" || subcommand === "diff") {
+  if (subcommand === "status" || subcommand === "diff" || subcommand === "doctor" || subcommand === "repair") {
     return `${JSON.stringify(result.data, null, 2)}\n`;
   }