@beignet/cli 0.0.24 → 0.0.26

package/src/db.ts

@@ -1,5 +1,5 @@
 import { spawn } from "node:child_process";
-import { access, readFile } from "node:fs/promises";
+import { access, mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 
 /**
@@ -33,6 +33,31 @@ export type RunDatabaseCommandResult = {
   exitCode: number;
 };
 
+export type DatabaseSchemaDialect = "sqlite" | "postgres" | "mysql";
+export type DatabaseSchemaTable = "audit" | "idempotency" | "outbox";
+
+export type GenerateDatabaseSchemaOptions = {
+  cwd?: string;
+  dialect?: DatabaseSchemaDialect;
+  tables?: readonly DatabaseSchemaTable[];
+  output?: string;
+  dryRun?: boolean;
+};
+
+export type GenerateDatabaseSchemaResult = {
+  schemaVersion: 1;
+  command: "schema:generate";
+  cwd: string;
+  dialect: DatabaseSchemaDialect;
+  tables: DatabaseSchemaTable[];
+  output: string;
+  indexFile: string;
+  createdFiles: string[];
+  updatedFiles: string[];
+  skippedFiles: string[];
+  dryRun: boolean;
+};
+
 type PackageJson = {
   scripts?: Record<string, string>;
 };
@@ -44,6 +69,12 @@ const databaseScripts: Record<DatabaseCommand, string> = {
   reset: "db:reset",
 };
 
+const allDatabaseSchemaTables = [
+  "audit",
+  "idempotency",
+  "outbox",
+] as const satisfies readonly DatabaseSchemaTable[];
+
 /**
  * Run an app-owned database lifecycle script.
  *
@@ -100,6 +131,67 @@ export async function runDatabaseCommand(
   };
 }
 
+/**
+ * Generate the app-owned Drizzle schema entrypoint for Beignet provider tables.
+ *
+ * This only writes schema source. The app still owns SQL migration generation
+ * through `beignet db generate` and migration application through
+ * `beignet db migrate`.
+ */
+export async function generateDatabaseSchema(
+  options: GenerateDatabaseSchemaOptions = {},
+): Promise<GenerateDatabaseSchemaResult> {
+  const cwd = path.resolve(options.cwd ?? process.cwd());
+  const dialect = await resolveDatabaseSchemaDialect(cwd, options.dialect);
+  const tables = uniqueSchemaTables(options.tables ?? allDatabaseSchemaTables);
+  const output = normalizeAppRelativePath(
+    cwd,
+    options.output ?? "infra/db/schema/beignet.ts",
+    "schema output",
+  );
+  const indexFile = normalizeAppRelativePath(
+    cwd,
+    path.join(path.dirname(output), "index.ts"),
+    "schema index",
+  );
+
+  if (output === indexFile) {
+    throw new Error("Schema output must not be the schema index file.");
+  }
+
+  const result: GenerateDatabaseSchemaResult = {
+    schemaVersion: 1,
+    command: "schema:generate",
+    cwd,
+    dialect,
+    tables,
+    output,
+    indexFile,
+    createdFiles: [],
+    updatedFiles: [],
+    skippedFiles: [],
+    dryRun: Boolean(options.dryRun),
+  };
+
+  const schemaStatus = await writeProjectFile(
+    cwd,
+    output,
+    renderDatabaseSchema(dialect, tables),
+    result.dryRun,
+  );
+  recordFileStatus(result, output, schemaStatus);
+
+  const indexStatus = await updateSchemaIndex(
+    cwd,
+    indexFile,
+    output,
+    result.dryRun,
+  );
+  recordFileStatus(result, indexFile, indexStatus);
+
+  return result;
+}
+
 async function assertDatabaseCommandPreflight(
   cwd: string,
   command: DatabaseCommand,
@@ -135,6 +227,229 @@ async function assertDatabaseCommandPreflight(
   }
 }
 
+async function resolveDatabaseSchemaDialect(
+  cwd: string,
+  explicitDialect: DatabaseSchemaDialect | undefined,
+): Promise<DatabaseSchemaDialect> {
+  if (explicitDialect !== undefined) return explicitDialect;
+
+  const providerDialect = await inferDialectFromProviders(cwd);
+  if (providerDialect !== undefined) return providerDialect;
+
+  const drizzleDialect = await inferDialectFromDrizzleConfig(cwd);
+  if (drizzleDialect !== undefined) return drizzleDialect;
+
+  throw new Error(
+    "Could not infer the Drizzle dialect. Pass --dialect sqlite, --dialect postgres, or --dialect mysql.",
+  );
+}
+
+async function inferDialectFromProviders(
+  cwd: string,
+): Promise<DatabaseSchemaDialect | undefined> {
+  const sources = await Promise.all(
+    ["server/providers.ts", "server/index.ts"].map(async (file) => {
+      try {
+        return await readFile(path.join(cwd, file), "utf8");
+      } catch (error) {
+        if ((error as NodeJS.ErrnoException).code === "ENOENT") return "";
+        throw error;
+      }
+    }),
+  );
+  const source = sources.join("\n");
+  const matches = new Set<DatabaseSchemaDialect>();
+
+  if (
+    /\b(?:drizzleSqliteProvider|createDrizzleSqliteProvider)\b/.test(source)
+  ) {
+    matches.add("sqlite");
+  }
+  if (
+    /\b(?:drizzlePostgresProvider|createDrizzlePostgresProvider)\b/.test(source)
+  ) {
+    matches.add("postgres");
+  }
+  if (/\b(?:drizzleMysqlProvider|createDrizzleMysqlProvider)\b/.test(source)) {
+    matches.add("mysql");
+  }
+
+  return singleInferredDialect(matches, "registered Drizzle providers");
+}
+
+async function inferDialectFromDrizzleConfig(
+  cwd: string,
+): Promise<DatabaseSchemaDialect | undefined> {
+  for (const file of [
+    "drizzle.config.ts",
+    "drizzle.config.mts",
+    "drizzle.config.js",
+    "drizzle.config.mjs",
+  ]) {
+    let source: string;
+    try {
+      source = await readFile(path.join(cwd, file), "utf8");
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === "ENOENT") continue;
+      throw error;
+    }
+
+    const matches = new Set<DatabaseSchemaDialect>();
+    if (/\bdialect\s*:\s*["'](?:sqlite|turso)["']/.test(source)) {
+      matches.add("sqlite");
+    }
+    if (/\bdialect\s*:\s*["']postgresql["']/.test(source)) {
+      matches.add("postgres");
+    }
+    if (/\bdialect\s*:\s*["']mysql["']/.test(source)) {
+      matches.add("mysql");
+    }
+
+    const inferred = singleInferredDialect(matches, file);
+    if (inferred !== undefined) return inferred;
+  }
+
+  return undefined;
+}
+
+function singleInferredDialect(
+  matches: Set<DatabaseSchemaDialect>,
+  source: string,
+): DatabaseSchemaDialect | undefined {
+  if (matches.size === 0) return undefined;
+  if (matches.size === 1) return [...matches][0];
+
+  throw new Error(
+    `Could not infer a single Drizzle dialect from ${source}. Pass --dialect sqlite, --dialect postgres, or --dialect mysql.`,
+  );
+}
+
+function normalizeAppRelativePath(
+  cwd: string,
+  input: string,
+  label: string,
+): string {
+  const absolute = path.resolve(cwd, input);
+  const relative = path.relative(cwd, absolute);
+  if (relative.startsWith("..") || path.isAbsolute(relative)) {
+    throw new Error(`The ${label} path must be inside the app directory.`);
+  }
+  return relative.split(path.sep).join("/");
+}
+
+function renderDatabaseSchema(
+  dialect: DatabaseSchemaDialect,
+  tables: readonly DatabaseSchemaTable[],
+): string {
+  const selectedTables = tables.map((table) => schemaTableDefinitions[table]);
+  const tableNames = selectedTables.map((table) => table.tableName);
+  const exportNames = selectedTables.map((table) => table.exportName).sort();
+
+  return `// Generated by beignet db schema generate.
+// Required tables: ${tableNames.join(", ")}.
+// Re-run this command after upgrading @beignet/provider-db-drizzle.
+
+export {
+${exportNames.map((name) => `  ${name},`).join("\n")}
+} from "@beignet/provider-db-drizzle/${dialect}/schema";
+`;
+}
+
+const schemaTableDefinitions: Record<
+  DatabaseSchemaTable,
+  { exportName: string; tableName: string }
+> = {
+  audit: { exportName: "auditLog", tableName: "audit_log" },
+  idempotency: {
+    exportName: "idempotencyRecords",
+    tableName: "idempotency_records",
+  },
+  outbox: { exportName: "outboxMessages", tableName: "outbox_messages" },
+};
+
+function uniqueSchemaTables(
+  tables: readonly DatabaseSchemaTable[],
+): DatabaseSchemaTable[] {
+  const unique = allDatabaseSchemaTables.filter((table) =>
+    tables.includes(table),
+  );
+  if (unique.length === 0) {
+    throw new Error("At least one schema table must be selected.");
+  }
+  return unique;
+}
+
+type FileWriteStatus = "created" | "updated" | "unchanged";
+
+async function writeProjectFile(
+  cwd: string,
+  relativePath: string,
+  contents: string,
+  dryRun: boolean,
+): Promise<FileWriteStatus> {
+  const absolute = path.join(cwd, relativePath);
+  const existing = await readTextIfExists(absolute);
+  if (existing === contents) return "unchanged";
+
+  if (!dryRun) {
+    await mkdir(path.dirname(absolute), { recursive: true });
+    await writeFile(absolute, contents);
+  }
+
+  return existing === undefined ? "created" : "updated";
+}
+
+async function updateSchemaIndex(
+  cwd: string,
+  indexFile: string,
+  output: string,
+  dryRun: boolean,
+): Promise<FileWriteStatus> {
+  const indexAbsolute = path.join(cwd, indexFile);
+  const existing = await readTextIfExists(indexAbsolute);
+  const exportLine = `export * from "./${schemaIndexSpecifier(indexFile, output)}";`;
+  const contents =
+    existing === undefined
+      ? `${exportLine}\n`
+      : existing.includes(exportLine)
+        ? existing
+        : `${existing.trimEnd()}\n${exportLine}\n`;
+
+  return writeProjectFile(cwd, indexFile, contents, dryRun);
+}
+
+function schemaIndexSpecifier(indexFile: string, output: string): string {
+  const relative = path.relative(path.dirname(indexFile), output);
+  return stripTsExtension(relative).split(path.sep).join("/");
+}
+
+function stripTsExtension(file: string): string {
+  return file.replace(/\.(?:ts|mts|cts)$/, "");
+}
+
+async function readTextIfExists(file: string): Promise<string | undefined> {
+  try {
+    return await readFile(file, "utf8");
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return undefined;
+    throw error;
+  }
+}
+
+function recordFileStatus(
+  result: GenerateDatabaseSchemaResult,
+  file: string,
+  status: FileWriteStatus,
+): void {
+  if (status === "created") {
+    result.createdFiles.push(file);
+  } else if (status === "updated") {
+    result.updatedFiles.push(file);
+  } else {
+    result.skippedFiles.push(file);
+  }
+}
+
 function hasExplicitDrizzleConfigFlag(scriptCommand: string): boolean {
   return /(?:^|\s)--config(?:=|\s)/.test(scriptCommand);
 }

package/src/index.ts

@@ -107,6 +107,27 @@ type DbFlags = {
   dryRun?: boolean;
 };
 
+type DatabaseSchemaDialect = "sqlite" | "postgres" | "mysql";
+type DatabaseSchemaTable = "audit" | "idempotency" | "outbox";
+
+const databaseSchemaDialectChoices = [
+  "sqlite",
+  "postgres",
+  "mysql",
+] as const satisfies readonly DatabaseSchemaDialect[];
+
+const databaseSchemaTableChoices = [
+  "audit",
+  "idempotency",
+  "outbox",
+] as const satisfies readonly DatabaseSchemaTable[];
+
+type DbSchemaGenerateFlags = DbFlags & {
+  dialect?: DatabaseSchemaDialect;
+  tables?: readonly DatabaseSchemaTable[];
+  output?: string;
+};
+
 type TaskRunFlags = {
   json?: boolean;
   input?: string;
@@ -142,6 +163,11 @@ type DoctorFlags = {
   format?: OutputFormat;
 };
 
+type ProviderAuditFlags = {
+  json?: boolean;
+  cwd?: string;
+};
+
 const parseString = (input: string): string => input;
 const parsePositiveInteger = (input: string): number => {
   const value = Number(input);
@@ -209,11 +235,38 @@ const lintFlagParameters = {
   format: formatFlag,
 } satisfies FlagParametersForType<LintFlags, CliContext>;
 
+const providerAuditFlagParameters = {
+  json: jsonFlag,
+  cwd: cwdFlag,
+} satisfies FlagParametersForType<ProviderAuditFlags, CliContext>;
+
 const dbFlagParameters = {
   json: jsonFlag,
   dryRun: dryRunFlag,
 } satisfies FlagParametersForType<DbFlags, CliContext>;
 
+const dbSchemaGenerateFlagParameters = {
+  ...dbFlagParameters,
+  dialect: {
+    kind: "enum",
+    values: databaseSchemaDialectChoices,
+    optional: true,
+    brief:
+      "Drizzle dialect to generate for. Inferred from server/providers.ts when omitted.",
+  },
+  tables: {
+    kind: "enum",
+    values: databaseSchemaTableChoices,
+    optional: true,
+    variadic: ",",
+    brief:
+      "Provider tables to generate as a comma-separated list. Defaults to audit,idempotency,outbox.",
+  },
+  output: parsedStringFlag(
+    "Generated schema file. Defaults to infra/db/schema/beignet.ts.",
+  ),
+} satisfies FlagParametersForType<DbSchemaGenerateFlags, CliContext>;
+
 const taskRunFlagParameters = {
   json: jsonFlag,
   input: parsedStringFlag("JSON input passed to the task schema."),
@@ -557,6 +610,44 @@ const mcpCommand = buildCommand<McpFlags, [], CliContext>({
   },
 });
 
+const providerAuditCommand = buildCommand<ProviderAuditFlags, [], CliContext>({
+  docs: {
+    brief: "Audit installed Beignet provider setup.",
+    fullDescription:
+      "Reports installed provider packages, metadata validity, registration, provider env, required tables, app ports, and variants. This command is report-only; doctor remains the enforcement surface.",
+  },
+  parameters: {
+    flags: providerAuditFlagParameters,
+  },
+  loader: async () => {
+    const { auditProviders, formatProviderAudit } = await import(
+      "./provider-audit.js"
+    );
+
+    return async function runProviderAudit(
+      this: CliContext,
+      flags: ProviderAuditFlags,
+    ) {
+      const result = await auditProviders({ cwd: flags.cwd });
+      writeOutput(
+        this,
+        flags.json
+          ? JSON.stringify(result, null, 2)
+          : formatProviderAudit(result),
+      );
+    };
+  },
+});
+
+const providerRoutes = buildRouteMap({
+  docs: {
+    brief: "Inspect Beignet provider setup.",
+  },
+  routes: {
+    audit: providerAuditCommand,
+  },
+});
+
 type DatabaseCommandName = "generate" | "migrate" | "reset" | "seed";
 
 function databaseCommand(command: DatabaseCommandName) {
@@ -591,6 +682,52 @@ function databaseCommand(command: DatabaseCommandName) {
   });
 }
 
+const dbSchemaGenerateCommand = buildCommand<
+  DbSchemaGenerateFlags,
+  [],
+  CliContext
+>({
+  docs: {
+    brief: "Generate provider-owned Drizzle schema exports.",
+    fullDescription:
+      "Writes an app-owned schema file that re-exports Beignet provider tables, then updates the schema index. Run beignet db generate afterward to let the app's Drizzle Kit script create migrations.",
+  },
+  parameters: {
+    flags: dbSchemaGenerateFlagParameters,
+  },
+  loader: async () => {
+    const { generateDatabaseSchema } = await import("./db.js");
+
+    return async function runDbSchemaGenerate(
+      this: CliContext,
+      flags: DbSchemaGenerateFlags,
+    ) {
+      const result = await generateDatabaseSchema({
+        dialect: flags.dialect,
+        tables: flags.tables,
+        output: flags.output,
+        dryRun: Boolean(flags.dryRun),
+      });
+
+      writeOutput(
+        this,
+        flags.json
+          ? JSON.stringify(result, null, 2)
+          : databaseSchemaGenerateNextSteps(result),
+      );
+    };
+  },
+});
+
+const dbSchemaRoutes = buildRouteMap({
+  docs: {
+    brief: "Generate Beignet database schema helpers.",
+  },
+  routes: {
+    generate: dbSchemaGenerateCommand,
+  },
+});
+
 const dbRoutes = buildRouteMap({
   docs: {
     brief: "Run Beignet database lifecycle commands.",
@@ -599,6 +736,7 @@ const dbRoutes = buildRouteMap({
     generate: databaseCommand("generate"),
     migrate: databaseCommand("migrate"),
     reset: databaseCommand("reset"),
+    schema: dbSchemaRoutes,
     seed: databaseCommand("seed"),
   },
 });
@@ -1214,6 +1352,7 @@ Run npm create beignet@latest (or bun create beignet) to scaffold a new app.`,
     make: makeRoutes,
     mcp: mcpCommand,
     outbox: outboxRoutes,
+    providers: providerRoutes,
     routes: routesCommand,
     schedule: scheduleRoutes,
     task: taskRoutes,
@@ -1278,6 +1417,18 @@ type DatabaseCommandNextStepsResult = {
   dryRun: boolean;
 };
 
+type DatabaseSchemaGenerateNextStepsResult = {
+  cwd: string;
+  dialect: DatabaseSchemaDialect;
+  tables: DatabaseSchemaTable[];
+  output: string;
+  indexFile: string;
+  createdFiles: string[];
+  updatedFiles: string[];
+  skippedFiles: string[];
+  dryRun: boolean;
+};
+
 type AppTaskRunNextStepsResult = {
   name: string;
   durationMs: number;
@@ -1432,7 +1583,12 @@ function isEnvRequiredProviderIntegration(
   );
 }
 
-function changedFileLines(result: MakeNextStepsResult): {
+function changedFileLines(
+  result: Pick<
+    MakeNextStepsResult,
+    "createdFiles" | "updatedFiles" | "skippedFiles"
+  >,
+): {
   changedFiles: string;
   skippedFiles: string;
 } {
@@ -1482,6 +1638,29 @@ Command:
   ${command}`;
 }
 
+function databaseSchemaGenerateNextSteps(
+  result: DatabaseSchemaGenerateNextStepsResult,
+): string {
+  const { changedFiles, skippedFiles } = changedFileLines({
+    createdFiles: result.createdFiles,
+    updatedFiles: result.updatedFiles,
+    skippedFiles: result.skippedFiles,
+  });
+  const prefix = result.dryRun ? "Would generate" : "Generated";
+  const tables = result.tables.join(", ");
+
+  return `${prefix} Beignet ${result.dialect} database schema (${tables}) in ${result.cwd}
+
+Changed files:
+${changedFiles || "  none"}
+${skippedFiles ? `\nSkipped identical files:\n${skippedFiles}` : ""}
+
+Next steps:
+  Run beignet db generate to produce app-owned Drizzle migrations.
+  Run beignet db migrate to apply the migration.
+  Run beignet doctor --strict to check provider setup.`;
+}
+
 function makeFeatureNextSteps(result: MakeNextStepsResult): string {
   return makeNextSteps(result, "feature slice", [
     "Use make feature for product capabilities and workflows. Use make resource when the concept is mostly CRUD-shaped.",