forgeos 0.1.0-alpha.0

package/src/forge/cli/db.ts

@@ -0,0 +1,316 @@
+import { nodeFileSystem } from "../compiler/fs/index.ts";
+import { join } from "node:path";
+import { buildSqlPlan } from "../compiler/data-graph/sql/ddl.ts";
+import type { SqlPlan } from "../compiler/data-graph/sql/types.ts";
+import { buildDataGraph } from "../compiler/data-graph/build.ts";
+import { buildAppGraph } from "../compiler/app-graph/build.ts";
+import { createDiagnostic } from "../compiler/diagnostics/create.ts";
+import {
+  FORGE_RLS_APPLY_FAILED,
+  FORGE_RUNTIME_NOT_FOUND,
+} from "../compiler/diagnostics/codes.ts";
+import { GENERATED_DIR } from "../compiler/emitter/constants.ts";
+import { discover } from "../compiler/orchestrator/discover.ts";
+import { loadManifest } from "../compiler/orchestrator/manifest.ts";
+import { stripDeterministicHeader } from "../compiler/primitives/header.ts";
+import type { Diagnostic } from "../compiler/types/diagnostic.ts";
+import type { DataGraph } from "../compiler/types/data-graph.ts";
+import { createDbAdapter, type CreateDbAdapterOptions } from "../runtime/db/factory.ts";
+import {
+  applyMigrations,
+  diffSqlPlan,
+  getMigrationStatus,
+  resetDatabase,
+} from "../runtime/db/migrate.ts";
+import type { DbAdapterKind } from "../runtime/db/adapter.ts";
+
+export type DbSubcommand = "diff" | "migrate" | "reset" | "status" | "rls-check";
+
+export interface DbCommandOptions {
+  subcommand: DbSubcommand;
+  workspaceRoot: string;
+  db: DbAdapterKind;
+  databaseUrl?: string;
+  json: boolean;
+}
+
+export interface DbCommandResult {
+  ok: boolean;
+  data?: unknown;
+  diagnostics: Diagnostic[];
+  exitCode: 0 | 1;
+}
+
+function readGeneratedJson<T>(workspaceRoot: string, relative: string): T | null {
+  const absolute = join(workspaceRoot, relative);
+  if (!nodeFileSystem.exists(absolute)) {
+    return null;
+  }
+  const raw = stripDeterministicHeader((nodeFileSystem.readText(absolute) ?? ""));
+  return JSON.parse(raw) as T;
+}
+
+function readGeneratedText(workspaceRoot: string, relative: string): string | null {
+  const absolute = join(workspaceRoot, relative);
+  if (!nodeFileSystem.exists(absolute)) {
+    return null;
+  }
+  return stripDeterministicHeader((nodeFileSystem.readText(absolute) ?? ""));
+}
+
+function splitSqlStatements(sql: string): string[] {
+  const statements: string[] = [];
+  let current = "";
+  let inDollarQuote = false;
+
+  for (let index = 0; index < sql.length; index++) {
+    const char = sql[index];
+    const next = sql[index + 1];
+    if (char === "$" && next === "$") {
+      inDollarQuote = !inDollarQuote;
+      current += "$$";
+      index += 1;
+      continue;
+    }
+    if (char === ";" && !inDollarQuote) {
+      const trimmed = current.trim();
+      if (trimmed) {
+        statements.push(trimmed);
+      }
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+
+  const tail = current.trim();
+  if (tail) {
+    statements.push(tail);
+  }
+  return statements;
+}
+
+async function applyRlsSqlIfPostgres(
+  adapter: Awaited<ReturnType<typeof createDbAdapter>>["adapter"],
+  workspaceRoot: string,
+): Promise<Diagnostic[]> {
+  const diagnostics: Diagnostic[] = [];
+  if (!adapter || adapter.kind !== "postgres") {
+    return diagnostics;
+  }
+
+  const sql = readGeneratedText(workspaceRoot, `${GENERATED_DIR}/rlsPolicies.sql`);
+  if (!sql) {
+    return diagnostics;
+  }
+
+  try {
+    for (const statement of splitSqlStatements(sql)) {
+      await adapter.query(statement);
+    }
+  } catch (error) {
+    diagnostics.push(
+      createDiagnostic({
+        severity: "error",
+        code: FORGE_RLS_APPLY_FAILED,
+        message: error instanceof Error ? error.message : "failed to apply RLS policies",
+      }),
+    );
+  }
+
+  return diagnostics;
+}
+
+async function loadSqlPlan(workspaceRoot: string): Promise<{
+  plan: SqlPlan | null;
+  diagnostics: Diagnostic[];
+}> {
+  const fromDisk = readGeneratedJson<SqlPlan>(
+    workspaceRoot,
+    `${GENERATED_DIR}/sqlPlan.json`,
+  );
+
+  if (fromDisk) {
+    return { plan: fromDisk, diagnostics: [] };
+  }
+
+  const dataGraph = readGeneratedJson<DataGraph>(
+    workspaceRoot,
+    `${GENERATED_DIR}/dataGraph.json`,
+  );
+
+  if (dataGraph) {
+    return { plan: buildSqlPlan(dataGraph), diagnostics: dataGraph.diagnostics ?? [] };
+  }
+
+  const ctx = discover({ workspaceRoot });
+  const manifest = loadManifest(ctx.cacheDir);
+  const appGraph = await buildAppGraph({
+    workspaceRoot: ctx.workspaceRoot,
+    sources: ctx.sources,
+    prior: manifest.priorAppGraph,
+    tsconfigPath: ctx.tsconfigPath ?? undefined,
+  });
+  const built = buildDataGraph(appGraph);
+
+  return {
+    plan: buildSqlPlan(built),
+    diagnostics: built.diagnostics,
+  };
+}
+
+function adapterOptions(options: DbCommandOptions): CreateDbAdapterOptions {
+  return {
+    kind: options.db,
+    workspaceRoot: options.workspaceRoot,
+    databaseUrl: options.databaseUrl,
+  };
+}
+
+function sqlPlanDiagnostics(plan: SqlPlan): Diagnostic[] {
+  return Array.isArray(plan.diagnostics) ? plan.diagnostics : [];
+}
+
+export async function runDbCommand(options: DbCommandOptions): Promise<DbCommandResult> {
+  const { plan, diagnostics: planDiagnostics } = await loadSqlPlan(options.workspaceRoot);
+
+  if (!plan) {
+    return {
+      ok: false,
+      diagnostics: [
+        ...planDiagnostics,
+        createDiagnostic({
+          severity: "error",
+          code: FORGE_RUNTIME_NOT_FOUND,
+          message: `missing ${GENERATED_DIR}/sqlPlan.json; run forge generate first`,
+        }),
+      ],
+      exitCode: 1,
+    };
+  }
+
+  if (options.subcommand === "diff") {
+    const diagnostics = sqlPlanDiagnostics(plan);
+    const { adapter } = await createDbAdapter(adapterOptions(options));
+    let appliedChecksum: string | null = null;
+
+    if (adapter) {
+      try {
+        await applyMigrations(adapter, plan);
+        const status = await getMigrationStatus(adapter);
+        appliedChecksum = status.applied.at(-1)?.checksum ?? null;
+      } finally {
+        await adapter.close();
+      }
+    }
+
+    const diff = diffSqlPlan(plan, appliedChecksum);
+    return {
+      ok: true,
+      data: diff,
+      diagnostics: [...diagnostics, ...planDiagnostics],
+      exitCode: 0,
+    };
+  }
+
+  const diagnostics = sqlPlanDiagnostics(plan);
+  const { adapter, diagnostics: adapterDiagnostics } = await createDbAdapter(
+    adapterOptions(options),
+  );
+
+  if (!adapter) {
+    return {
+      ok: false,
+      diagnostics: [...diagnostics, ...planDiagnostics, ...adapterDiagnostics],
+      exitCode: 1,
+    };
+  }
+
+  try {
+    if (options.subcommand === "migrate") {
+      const migrationDiagnostics = await applyMigrations(adapter, plan);
+      const rlsDiagnostics = await applyRlsSqlIfPostgres(adapter, options.workspaceRoot);
+      const errors = migrationDiagnostics.filter(
+        (diagnostic) => diagnostic.severity === "error",
+      );
+      const rlsErrors = rlsDiagnostics.filter(
+        (diagnostic) => diagnostic.severity === "error",
+      );
+      return {
+        ok: errors.length === 0 && rlsErrors.length === 0,
+        data: { migrationId: plan.migrationId, checksum: plan.checksum },
+        diagnostics: [
+          ...diagnostics,
+          ...planDiagnostics,
+          ...migrationDiagnostics,
+          ...rlsDiagnostics,
+        ],
+        exitCode: errors.length === 0 && rlsErrors.length === 0 ? 0 : 1,
+      };
+    }
+
+    if (options.subcommand === "reset") {
+      const migrationDiagnostics = await resetDatabase(adapter, plan);
+      const errors = migrationDiagnostics.filter(
+        (diagnostic) => diagnostic.severity === "error",
+      );
+      return {
+        ok: errors.length === 0,
+        data: { reset: true, migrationId: plan.migrationId },
+        diagnostics: [...diagnostics, ...planDiagnostics, ...migrationDiagnostics],
+        exitCode: errors.length === 0 ? 0 : 1,
+      };
+    }
+
+    if (options.subcommand === "status") {
+      await applyMigrations(adapter, plan);
+      const status = await getMigrationStatus(adapter);
+      return {
+        ok: true,
+        data: status,
+        diagnostics: [...diagnostics, ...planDiagnostics],
+        exitCode: 0,
+      };
+    }
+
+    return {
+      ok: false,
+      diagnostics: planDiagnostics,
+      exitCode: 1,
+    };
+  } finally {
+    await adapter.close();
+  }
+}
+
+export function formatDbJson(result: DbCommandResult): string {
+  return `${JSON.stringify({
+    ok: result.ok,
+    data: result.data,
+    diagnostics: result.diagnostics,
+    exitCode: result.exitCode,
+  })}\n`;
+}
+
+export function formatDbHuman(subcommand: DbSubcommand, result: DbCommandResult): string {
+  if (!result.ok) {
+    return result.diagnostics
+      .map((diagnostic) => `error ${diagnostic.code}: ${diagnostic.message}`)
+      .join("\n")
+      .concat("\n");
+  }
+
+  if (subcommand === "migrate") {
+    return `migrated ${(result.data as { migrationId: string }).migrationId}\n`;
+  }
+
+  if (subcommand === "reset") {
+    return "database reset complete\n";
+  }
+
+  if (subcommand === "status" || subcommand === "diff") {
+    return `${JSON.stringify(result.data, null, 2)}\n`;
+  }
+
+  return "";
+}

package/src/forge/cli/deps.ts

@@ -0,0 +1,277 @@
+import { nodeFileSystem } from "../compiler/fs/index.ts";
+import { join } from "node:path";
+import { stripDeterministicHeader } from "../compiler/primitives/header.ts";
+import { run } from "../compiler/orchestrator/run.ts";
+import { GENERATED_DIR } from "../compiler/emitter/constants.ts";
+import type { Diagnostic } from "../compiler/types/diagnostic.ts";
+import type { PackageGraph } from "../compiler/types/package-graph.ts";
+import type { ForgeLock } from "../compiler/types/lock.ts";
+import { resolveByPackageName } from "../compiler/recipes/registry.ts";
+import {
+  createUpgradePlan,
+  listOutdatedFromFixture,
+  parseUpgradeTarget,
+} from "../compiler/package-upgrades/planner.ts";
+import {
+  applyUpgradePlan,
+  rollbackUpgradePlan,
+} from "../compiler/package-upgrades/apply.ts";
+
+export type DepsSubcommand =
+  | "outdated"
+  | "inspect"
+  | "diff"
+  | "upgrade-plan"
+  | "upgrade-apply"
+  | "upgrade-check"
+  | "upgrade-rollback"
+  | "risk";
+
+export interface DepsCommandOptions {
+  subcommand: DepsSubcommand;
+  packageName?: string;
+  planPath?: string;
+  target?: string;
+  json: boolean;
+  yes: boolean;
+  allowScripts: boolean;
+  skipTests: boolean;
+  dryRun: boolean;
+  changed: boolean;
+  workspaceRoot: string;
+}
+
+export interface DepsCommandResult {
+  ok: boolean;
+  data?: unknown;
+  diagnostics: Diagnostic[];
+  exitCode: 0 | 1;
+}
+
+function readGeneratedJson<T>(workspaceRoot: string, relative: string): T | null {
+  const absolute = join(workspaceRoot, relative);
+  if (!nodeFileSystem.exists(absolute)) {
+    return null;
+  }
+  const raw = stripDeterministicHeader((nodeFileSystem.readText(absolute) ?? ""));
+  return JSON.parse(raw) as T;
+}
+
+function planPathFor(workspaceRoot: string, planIdOrPath: string): string {
+  if (nodeFileSystem.exists(planIdOrPath)) {
+    return planIdOrPath;
+  }
+  const direct = join(workspaceRoot, planIdOrPath);
+  if (nodeFileSystem.exists(direct)) {
+    return direct;
+  }
+  return join(workspaceRoot, ".forge", "upgrades", planIdOrPath, "plan.json");
+}
+
+function inspectPackage(workspaceRoot: string, packageName: string): DepsCommandResult {
+  const graph = readGeneratedJson<PackageGraph>(workspaceRoot, `${GENERATED_DIR}/packageGraph.json`);
+  const lock = nodeFileSystem.exists(join(workspaceRoot, "forge.lock"))
+    ? (JSON.parse((nodeFileSystem.readText(join(workspaceRoot, "forge.lock")) ?? "")) as ForgeLock)
+    : null;
+  const pkg = graph?.packages.find((candidate) => candidate.name === packageName);
+  const lockEntry = lock?.packages.find((candidate) => candidate.name === packageName);
+  const recipe = resolveByPackageName(packageName);
+
+  if (!pkg) {
+    return {
+      ok: false,
+      diagnostics: [{
+        severity: "error",
+        code: "FORGE_DEPS_PACKAGE_NOT_INSTALLED",
+        message: `package '${packageName}' is not present in generated packageGraph`,
+      }],
+      exitCode: 1,
+    };
+  }
+
+  return {
+    ok: true,
+    data: {
+      package: packageName,
+      version: pkg.version,
+      integrationAlias: recipe?.alias,
+      recipeVersion: recipe?.recipeVersion,
+      runtimeContexts: {
+        allowed: lockEntry?.runtimeContexts ?? [],
+        denied: recipe?.contexts.denied ?? [],
+      },
+      usedBy: {
+        generatedAdapters: (recipe?.adapters ?? []).map(
+          (adapter) => `src/forge/_generated/packages/${adapter}`,
+        ),
+      },
+      secrets: (recipe?.secrets ?? []).map((secret) => secret.envVar),
+    },
+    diagnostics: [],
+    exitCode: 0,
+  };
+}
+
+export async function runDepsCommand(options: DepsCommandOptions): Promise<DepsCommandResult> {
+  if (options.subcommand === "outdated") {
+    return {
+      ok: true,
+      data: { packages: listOutdatedFromFixture(options) },
+      diagnostics: [],
+      exitCode: 0,
+    };
+  }
+
+  if (options.subcommand === "inspect") {
+    if (!options.packageName) {
+      return missingPackage();
+    }
+    return inspectPackage(options.workspaceRoot, options.packageName);
+  }
+
+  if (options.subcommand === "diff" || options.subcommand === "upgrade-plan" || options.subcommand === "risk") {
+    if (!options.packageName) {
+      return missingPackage();
+    }
+    const planned = await createUpgradePlan({
+      workspaceRoot: options.workspaceRoot,
+      packageName: options.packageName,
+      target: parseUpgradeTarget(options.target),
+      writeArtifacts: options.subcommand !== "diff" && options.subcommand !== "risk",
+    });
+
+    if (!planned.plan) {
+      return {
+        ok: false,
+        diagnostics: planned.diagnostics,
+        exitCode: planned.exitCode,
+      };
+    }
+
+    const data =
+      options.subcommand === "diff"
+        ? {
+            package: planned.plan.packageName,
+            from: planned.plan.from.version,
+            to: planned.plan.to.version,
+            apiDiff: planned.plan.apiDiff,
+            fileDiffAvailable: false,
+          }
+        : options.subcommand === "risk"
+          ? planned.plan.risk
+          : {
+              plan: planned.plan,
+              planDir: planned.planDir,
+            };
+
+    return {
+      ok: planned.ok,
+      data,
+      diagnostics: planned.diagnostics,
+      exitCode: planned.exitCode,
+    };
+  }
+
+  if (options.subcommand === "upgrade-apply") {
+    if (!options.planPath) {
+      return missingPlan();
+    }
+    const applied = await applyUpgradePlan({
+      workspaceRoot: options.workspaceRoot,
+      planPath: planPathFor(options.workspaceRoot, options.planPath),
+      yes: options.yes,
+      allowScripts: options.allowScripts,
+      skipTests: options.skipTests,
+      dryRun: options.dryRun,
+    });
+    return {
+      ok: applied.ok,
+      data: {
+        applied: applied.applied,
+        rolledBack: applied.rolledBack,
+        reinstallCommand: applied.plan?.rollback.reinstallCommand,
+      },
+      diagnostics: applied.diagnostics,
+      exitCode: applied.exitCode,
+    };
+  }
+
+  if (options.subcommand === "upgrade-rollback") {
+    if (!options.planPath) {
+      return missingPlan();
+    }
+    const rolledBack = rollbackUpgradePlan({
+      workspaceRoot: options.workspaceRoot,
+      planPath: planPathFor(options.workspaceRoot, options.planPath),
+    });
+    return {
+      ok: rolledBack.ok,
+      data: {
+        rolledBack: rolledBack.rolledBack,
+        reinstallCommand: rolledBack.plan?.rollback.reinstallCommand,
+      },
+      diagnostics: rolledBack.diagnostics,
+      exitCode: rolledBack.exitCode,
+    };
+  }
+
+  const generated = await run({
+    workspaceRoot: options.workspaceRoot,
+    check: true,
+    dryRun: false,
+    json: options.json,
+    concurrency: 4,
+  });
+  return {
+    ok: generated.exitCode === 0,
+    data: {
+      changedOnly: options.changed,
+      changed: generated.changed,
+      unchanged: generated.unchanged,
+    },
+    diagnostics: [...generated.errors, ...generated.warnings],
+    exitCode: generated.exitCode,
+  };
+}
+
+function missingPackage(): DepsCommandResult {
+  return {
+    ok: false,
+    diagnostics: [{
+      severity: "error",
+      code: "FORGE_DEPS_PACKAGE_NOT_INSTALLED",
+      message: "package name is required",
+    }],
+    exitCode: 1,
+  };
+}
+
+function missingPlan(): DepsCommandResult {
+  return {
+    ok: false,
+    diagnostics: [{
+      severity: "error",
+      code: "FORGE_DEPS_TARGET_NOT_FOUND",
+      message: "plan path or plan id is required",
+    }],
+    exitCode: 1,
+  };
+}
+
+export function formatDepsJson(result: DepsCommandResult): string {
+  return `${JSON.stringify(result)}\n`;
+}
+
+export function formatDepsHuman(subcommand: DepsSubcommand, result: DepsCommandResult): string {
+  const diagnostics = result.diagnostics
+    .map((diagnostic) => `${diagnostic.severity} ${diagnostic.code}: ${diagnostic.message}`)
+    .join("\n");
+  if (!result.ok) {
+    return `deps ${subcommand} failed${diagnostics ? `\n${diagnostics}` : ""}\n`;
+  }
+  if (subcommand === "upgrade-plan") {
+    const data = result.data as { planDir?: string; plan?: { risk?: { level?: string } } } | undefined;
+    return `upgrade plan written: ${data?.planDir ?? "not written"}\nrisk: ${data?.plan?.risk?.level ?? "unknown"}\n`;
+  }
+  return `deps ${subcommand} ok${diagnostics ? `\n${diagnostics}` : ""}\n`;
+}