@beignet/cli 0.0.47 → 0.0.48

package/src/provider-audit.ts

@@ -18,6 +18,7 @@ export type ProviderPackageJson = {
   dependencies?: Record<string, string>;
   devDependencies?: Record<string, string>;
   peerDependencies?: Record<string, string>;
+  scripts?: Record<string, string>;
 };
 
 export type ProviderDoctorVariantRule = {
@@ -25,6 +26,7 @@ export type ProviderDoctorVariantRule = {
   displayName: string;
   tokens: readonly string[];
   requiredEnv: readonly string[];
+  requiredEnvAlternatives: readonly (readonly string[])[];
   requiredTables: readonly string[];
   registrationSeverity?: "warning" | "hint";
 };
@@ -35,6 +37,7 @@ export type ProviderDoctorRule = {
   tokens: readonly string[];
   appPorts?: readonly { name: string; type: string }[];
   requiredEnv?: readonly string[];
+  requiredEnvAlternatives?: readonly (readonly string[])[];
   requiredTables?: readonly string[];
   watchers?: readonly string[];
   registrationSeverity?: "warning" | "hint";
@@ -94,6 +97,14 @@ export type ProviderRequirementAudit = {
   status: ProviderAuditStatus;
   required: string[];
   missing: string[];
+  alternatives?: string[][];
+  alternativeGroups?: Array<{
+    name: string;
+    displayName: string;
+    status: "present" | "missing";
+    alternatives: string[][];
+    missing: string[];
+  }>;
 };
 
 export type ProviderAppPortsAudit = {
@@ -282,6 +293,36 @@ export async function providerDoctorRulesForInstalledPackages(
   return rules.filter((rule): rule is ProviderDoctorRule => Boolean(rule));
 }
 
+export async function detectedProviderVariantsForRules(
+  targetDir: string,
+  rules: readonly ProviderDoctorRule[],
+): Promise<Map<string, ProviderDoctorVariantRule[]>> {
+  const variantRules = rules.filter(
+    (
+      rule,
+    ): rule is ProviderDoctorRule & {
+      variants: readonly ProviderDoctorVariantRule[];
+    } => rule.variants !== undefined,
+  );
+  if (variantRules.length === 0) return new Map();
+
+  const files = await listFiles(targetDir);
+  const config = await loadBeignetConfig(targetDir, files);
+  const providerEntries = await readProviderListEntries(
+    targetDir,
+    files,
+    config,
+    new Map(),
+  );
+
+  return new Map(
+    variantRules.map((rule) => [
+      rule.packageName,
+      detectedProviderVariants(rule.variants, providerEntries),
+    ]),
+  );
+}
+
 export async function readProviderPackageMetadataSource(
   targetDir: string,
   packageName: string,
@@ -314,6 +355,7 @@ export function providerDoctorRuleFromMetadata(
     tokens: registration?.tokens ?? [],
     appPorts: metadata.appPorts ?? [],
     requiredEnv: metadata.requiredEnv ?? [],
+    requiredEnvAlternatives: metadata.requiredEnvAlternatives ?? [],
     requiredTables: metadata.requiredTables ?? [],
     watchers: metadata.watchers ?? [],
     registrationSeverity: registrationSeverityFromMetadata(registration),
@@ -322,6 +364,7 @@ export function providerDoctorRuleFromMetadata(
       displayName: variant.displayName ?? variant.name,
       tokens: variant.registration?.tokens ?? [],
       requiredEnv: variant.requiredEnv ?? [],
+      requiredEnvAlternatives: variant.requiredEnvAlternatives ?? [],
       requiredTables: variant.requiredTables ?? [],
       registrationSeverity: registrationSeverityFromMetadata(
         variant.registration,
@@ -1061,6 +1104,15 @@ function configuredProviderRequiredEnv(
   return envVars.filter((envVar) => !ignored.has(envVar));
 }
 
+function configuredProviderRequiredEnvAlternatives(
+  alternatives: readonly (readonly string[])[],
+  config: ResolvedBeignetConfig,
+): string[][] {
+  return alternatives.map((alternative) =>
+    configuredProviderRequiredEnv(alternative, config),
+  );
+}
+
 function configuredProviderRequiredTables(
   tableNames: readonly string[],
   config: ResolvedBeignetConfig,
@@ -1187,19 +1239,23 @@ async function providerAuditEntryForRule(options: {
   const requiredEnv =
     options.rule.variants !== undefined
       ? aggregateVariantRequirement(variants, "requiredEnv")
-      : await requirementAudit(
-          configuredProviderRequiredEnv(
+      : await providerEnvRequirementAudit({
+          required: configuredProviderRequiredEnv(
             options.rule.requiredEnv ?? [],
             options.config,
           ),
-          (envVar) =>
+          alternatives: configuredProviderRequiredEnvAlternatives(
+            options.rule.requiredEnvAlternatives ?? [],
+            options.config,
+          ),
+          exists: (envVar) =>
             providerRequiredEnvExists(
               options.targetDir,
               options.configFiles,
               envVar,
               options.sourceCache,
             ),
-        );
+        });
 
   const requiredTables =
     options.rule.variants !== undefined
@@ -1288,12 +1344,19 @@ async function providerVariantAudit(options: {
     options.variant.requiredEnv,
     options.config,
   );
+  const requiredEnvAlternatives = configuredProviderRequiredEnvAlternatives(
+    options.variant.requiredEnvAlternatives,
+    options.config,
+  );
   if (!options.registered) {
     return {
       name: options.variant.name,
       displayName: options.variant.displayName,
       registration: "inactive",
-      requiredEnv: inactiveRequirement(requiredEnv),
+      requiredEnv:
+        requiredEnvAlternatives.length > 0
+          ? inactiveAlternativeRequirement(requiredEnvAlternatives)
+          : inactiveRequirement(requiredEnv),
       requiredTables: inactiveRequirement(options.variant.requiredTables),
     };
   }
@@ -1306,14 +1369,17 @@ async function providerVariantAudit(options: {
       options.variant.registrationSeverity,
       options.providerEntries,
     ),
-    requiredEnv: await requirementAudit(requiredEnv, (envVar) =>
-      providerRequiredEnvExists(
-        options.targetDir,
-        options.configFiles,
-        envVar,
-        options.sourceCache,
-      ),
-    ),
+    requiredEnv: await providerEnvRequirementAudit({
+      required: requiredEnv,
+      alternatives: requiredEnvAlternatives,
+      exists: (envVar) =>
+        providerRequiredEnvExists(
+          options.targetDir,
+          options.configFiles,
+          envVar,
+          options.sourceCache,
+        ),
+    }),
     requiredTables: await requirementAudit(
       configuredProviderRequiredTables(
         options.variant.requiredTables,
@@ -1448,6 +1514,34 @@ async function requirementAudit(
   };
 }
 
+async function providerEnvRequirementAudit(options: {
+  required: readonly string[];
+  alternatives: readonly (readonly string[])[];
+  exists: (requirement: string) => Promise<boolean>;
+}): Promise<ProviderRequirementAudit> {
+  if (options.alternatives.length === 0) {
+    return requirementAudit(options.required, options.exists);
+  }
+
+  const missingAlternatives: string[][] = [];
+  for (const alternative of options.alternatives) {
+    const missing: string[] = [];
+    for (const requirement of alternative) {
+      if (await options.exists(requirement)) continue;
+      missing.push(requirement);
+    }
+    missingAlternatives.push(missing);
+  }
+
+  const present = missingAlternatives.some((missing) => missing.length === 0);
+  return {
+    status: present ? "present" : "missing",
+    required: unique(options.alternatives.flat()),
+    missing: present ? [] : unique(missingAlternatives.flat()),
+    alternatives: options.alternatives.map((alternative) => [...alternative]),
+  };
+}
+
 function inactiveRequirement(
   required: readonly string[],
 ): ProviderRequirementAudit {
@@ -1458,6 +1552,17 @@ function inactiveRequirement(
   };
 }
 
+function inactiveAlternativeRequirement(
+  alternatives: readonly (readonly string[])[],
+): ProviderRequirementAudit {
+  return {
+    status: "inactive",
+    required: unique(alternatives.flat()),
+    missing: [],
+    alternatives: alternatives.map((alternative) => [...alternative]),
+  };
+}
+
 function emptyRequirement(): ProviderRequirementAudit {
   return { status: "none", required: [], missing: [] };
 }
@@ -1467,21 +1572,57 @@ function aggregateVariantRequirement(
   key: "requiredEnv" | "requiredTables",
 ): ProviderRequirementAudit {
   const active = variants
-    .map((variant) => variant[key])
-    .filter((requirement) => requirement.status !== "inactive");
+    .map((variant) => ({ variant, requirement: variant[key] }))
+    .filter(({ requirement }) => requirement.status !== "inactive");
   if (active.length === 0)
     return { status: "inactive", required: [], missing: [] };
 
   const required = unique(
-    active.flatMap((requirement) => requirement.required),
+    active.flatMap(({ requirement }) => requirement.required),
+  );
+  const missing = unique(
+    active.flatMap(({ requirement }) => requirement.missing),
   );
-  const missing = unique(active.flatMap((requirement) => requirement.missing));
   if (required.length === 0) return emptyRequirement();
 
+  const hasAlternativeRequirements = active.some(
+    ({ requirement }) =>
+      requirement.alternatives !== undefined ||
+      requirement.alternativeGroups !== undefined,
+  );
+  const alternativeGroups = hasAlternativeRequirements
+    ? active.flatMap(({ variant, requirement }) => {
+        if (requirement.status === "none") return [];
+        if (
+          requirement.status !== "present" &&
+          requirement.status !== "missing"
+        ) {
+          return [];
+        }
+
+        return [
+          {
+            name: variant.name,
+            displayName: variant.displayName,
+            status: requirement.status,
+            alternatives: (
+              requirement.alternatives ?? [requirement.required]
+            ).map((alternative) => [...alternative]),
+            missing: [...requirement.missing],
+          },
+        ];
+      })
+    : [];
+
   return {
     status: missing.length === 0 ? "present" : "missing",
     required,
     missing,
+    ...(alternativeGroups.length === 1
+      ? { alternatives: alternativeGroups[0]?.alternatives ?? [] }
+      : alternativeGroups.length > 0
+        ? { alternativeGroups }
+        : {}),
   };
 }
 
@@ -1520,7 +1661,17 @@ function providerAuditNotes(input: {
     notes.push("optional provider not registered");
   }
   if (input.requiredEnv.missing.length > 0) {
-    notes.push(`missing env: ${input.requiredEnv.missing.join(", ")}`);
+    notes.push(
+      input.requiredEnv.alternativeGroups
+        ? `missing env configuration groups: ${formatProviderEnvAlternativeGroups(
+            input.requiredEnv.alternativeGroups,
+          )}`
+        : input.requiredEnv.alternatives
+          ? `missing env alternative: ${formatProviderEnvAlternatives(
+              input.requiredEnv.alternatives,
+            )}`
+          : `missing env: ${input.requiredEnv.missing.join(", ")}`,
+    );
   }
   if (input.requiredTables.missing.length > 0) {
     notes.push(`missing tables: ${input.requiredTables.missing.join(", ")}`);
@@ -1863,6 +2014,21 @@ function escapeRegExp(value: string): string {
 function requirementSummary(requirement: ProviderRequirementAudit): string {
   if (requirement.status === "none") return "none";
   if (requirement.status === "inactive") return "inactive";
+  if (requirement.alternativeGroups) {
+    const count = requirement.alternativeGroups.length;
+    const missing = requirement.alternativeGroups.filter(
+      (group) => group.status === "missing",
+    ).length;
+    return requirement.status === "present"
+      ? `${count} variant groups ok`
+      : `${missing}/${count} variant groups incomplete`;
+  }
+  if (requirement.alternatives) {
+    if (requirement.status === "present") {
+      return "alternative ok";
+    }
+    return `${requirement.alternatives.length} alternatives missing`;
+  }
   if (requirement.status === "present") {
     return `${requirement.required.length} ok`;
   }
@@ -1879,6 +2045,32 @@ function unique(values: readonly string[]): string[] {
   return [...new Set(values)];
 }
 
+export function formatProviderEnvAlternatives(
+  alternatives: readonly (readonly string[])[],
+): string {
+  return alternatives
+    .map((alternative) =>
+      alternative.length === 1
+        ? alternative[0]
+        : `(${alternative.join(" + ")})`,
+    )
+    .join(" or ");
+}
+
+function formatProviderEnvAlternativeGroups(
+  groups: NonNullable<ProviderRequirementAudit["alternativeGroups"]>,
+): string {
+  return groups
+    .filter((group) => group.status === "missing")
+    .map(
+      (group) =>
+        `${group.displayName}: ${formatProviderEnvAlternatives(
+          group.alternatives,
+        )}`,
+    )
+    .join(" and ");
+}
+
 function table(rows: string[][]): string {
   const widths = rows[0].map((_, columnIndex) =>
     Math.max(...rows.map((row) => row[columnIndex].length)),

package/src/templates/agents.ts

@@ -79,7 +79,8 @@ array anchors are unambiguous. It also syncs missing default Beignet
 provider-table exports when \`infra/db/schema/beignet.ts\` is missing or still
 matches \`${cli} db schema sync\` output and the schema index has no custom
 named re-export for that file. Run \`${cli} db generate\` and
-\`${cli} db migrate\` after accepting that source repair. Custom or ambiguous
+\`${cli} db migrate\`, then \`${cli} db status\` after accepting that source
+repair. Custom or ambiguous
 code stays diagnostic-only.
 
 ## Prefer generators
@@ -89,10 +90,12 @@ files — prefer it over hand-writing them. See \`${cli} make --help\` for the
 artifact list. Use \`${cli} make feature <name> --recipe full-slice\` when you
 need a richer reference slice with policy, client helpers, workflow artifacts,
 events, listener registration, jobs, and outbox wiring. After changing the Drizzle schema in
-\`infra/db/schema/\`, run \`${cli} db generate\` then \`${cli} db migrate\`.
+\`infra/db/schema/\`, run \`${cli} db generate\`, \`${cli} db migrate\`, then
+\`${cli} db status\`.
 When MCP is available, use \`db_schema_sync\` for Beignet provider table
 re-exports and \`db\` for \`generate\`, \`migrate\`, \`seed\`, or \`reset\`
-instead of falling back to a shell. Use \`task_run\`, \`schedule_run\`,
+instead of falling back to a shell. Use the read-only \`db_status\` tool before
+deploying. Use \`task_run\`, \`schedule_run\`,
 \`outbox_inspect\`, and \`outbox_run\` for registered operational workflows
 and outbox recovery.
 
@@ -175,7 +178,7 @@ skill-loading block.
 \`.mcp.json\` registers the app-local \`@beignet/cli\` bin at
 \`./node_modules/.bin/beignet mcp\`, which exposes app context, validation,
 generation, and operations as structured tools named exactly: \`app_map\`,
-\`explain\`, \`check\`, \`db\`, \`db_schema_sync\`, \`task_run\`,
+\`explain\`, \`check\`, \`db\`, \`db_status\`, \`db_schema_sync\`, \`task_run\`,
 \`schedule_run\`, \`outbox_inspect\`, \`outbox_run\`, \`routes\`, \`doctor\`,
 \`doctor_fix_plan\`, \`doctor_fix\`, \`lint\`, \`make\`, \`provider_add\`.
 It also publishes \`beignet://app/guidance\` and focused
@@ -190,11 +193,14 @@ relationships, conventions, findings, and suggested files for any mapped
 concept or diagnostic; its kinds match the app map. Use \`check\` after edits
 to run the complete validation loop; it returns the same versioned result as
 \`${cli} check --json\`, bounds failure output, and cancels the active package
-script when the MCP request is cancelled. It does not apply Beignet fixes, but
-app-owned scripts retain their normal side effects. Use \`db_schema_sync\` to
+script when the MCP request is cancelled. Pass \`preflightConnect: true\` to
+include migration status and dependency health checks; \`connectTimeoutMs\`
+sets their per-check timeout. It does not apply Beignet fixes, but app-owned
+scripts retain their normal side effects. Use \`db_schema_sync\` to
 preview or apply idempotent provider-table schema re-exports, then call \`db\`
 with \`generate\` and \`migrate\`; database output is bounded, commands time
-out, and cancellation stops the active process tree. Treat \`seed\` and
+out, and cancellation stops the active process tree. Use \`db_status\` for a
+read-only current, pending, or failed migration report. Treat \`seed\` and
 especially \`reset\` as app-owned mutations. Lifecycle \`dryRun\` validates
 and reports the script without executing it; it does not simulate SQL or data
 changes. Use \`task_run\` and \`schedule_run\` for registered operational

package/src/templates/base.ts

@@ -103,6 +103,7 @@ export function packageJson(ctx: TemplateContext): string {
     "db:generate": "drizzle-kit generate",
     "db:migrate": "drizzle-kit migrate",
     "db:reset": currentGeneratedPackageScripts["db:reset"],
+    "db:status": currentGeneratedPackageScripts["db:status"],
   };
 
   return json({
@@ -254,9 +255,10 @@ ${startDatabase}## Prepare the database
 
 \`\`\`bash
 ${cli} db migrate
+${cli} db status
 \`\`\`
 
-The starter ships its initial Drizzle migration in \`drizzle/\`, so the first run only applies it. After you change \`infra/db/schema/\`, run \`${cli} db generate\` and \`${cli} db migrate\` together.
+The starter ships its initial Drizzle migration in \`drizzle/\`, so the first run only applies it. After you change \`infra/db/schema/\`, run \`${cli} db generate\` and \`${cli} db migrate\` together, then verify the target database with \`${cli} db status\`.
 
 ## Start the app
 
@@ -303,10 +305,11 @@ ${start}
 ${cli} make feature projects
 ${cli} db generate
 ${cli} db migrate
+${cli} db status
 ${cli} check
 \`\`\`
 
-\`make feature\` creates a contract-to-test vertical slice with Drizzle schema and repository files, so regenerate and migrate the database before running the app against the new feature.
+\`make feature\` creates a contract-to-test vertical slice with Drizzle schema and repository files, so regenerate, migrate, and verify the database before running the app against the new feature.
 Use \`${cli} make feature projects --recipe full-slice\` when you want a richer reference slice with policy, feature client helpers, workflow artifacts, events, listener registration, jobs, and outbox wiring.
 
 ## App map
@@ -352,7 +355,8 @@ ${optionalAuthRedirects}
           " db migrate` against it before starting the app."
   }
 - Size the process-wide database client for the deployment. Postgres and MySQL use the generated pool-limit environment variable; count web, worker, preview, and task processes against the database connection limit, and keep writable SQLite files on one host.
-- Run \`${cli} db generate\` and \`${cli} db migrate\` after changing the Drizzle schema.
+- Run \`${cli} db generate\`, \`${cli} db migrate\`, and \`${cli} db status\` after changing the Drizzle schema.
+- Run \`${cli} db migrate\` in one serialized migration job per environment, then \`${cli} db status\` and \`${cli} preflight --connect\` before shifting traffic. Do not migrate independently from every web replica.
 - Run \`${cli} db reset\` to rebuild a local ${
     ctx.database === "sqlite"
       ? "SQLite"
@@ -429,6 +433,7 @@ export function providersDoc(ctx: TemplateContext): string {
         "- Peer dependencies: `@upstash/ratelimit` and `@upstash/redis`",
         "- The starter wires `createUpstashRateLimitProvider()` in `server/providers.ts` and adds `rateLimit: RateLimitPort` to `AppPorts`.",
         "- `.env.example` ships dev placeholders so the app boots; set real `UPSTASH_REDIS_REST_URL` and `UPSTASH_REDIS_REST_TOKEN` values before rate limiting requests.",
+        "- Rate-limit decisions time out after 5000ms and fail closed by default. Opt into `UPSTASH_TIMEOUT_POLICY=fail-open` only when availability outweighs enforcement across this provider during an outage.",
         "",
       );
     }
@@ -510,6 +515,8 @@ export function envExample(ctx: TemplateContext): string {
       "UPSTASH_REDIS_REST_URL=https://dev-placeholder.upstash.io",
       "UPSTASH_REDIS_REST_TOKEN=dev-placeholder-change-me",
       "UPSTASH_PREFIX=beignet:ratelimit",
+      "# UPSTASH_TIMEOUT_MS=5000",
+      "# UPSTASH_TIMEOUT_POLICY=fail-closed",
       "",
     );
   }
@@ -518,6 +525,8 @@ export function envExample(ctx: TemplateContext): string {
 }
 
 const files = {
+  gitattributes: `**/drizzle/*.sql text eol=lf
+`,
   gitignore: `.next
 node_modules
 dist

package/src/templates/db/index.ts

@@ -15,6 +15,7 @@ export type DbTemplateFiles = {
   drizzleTodoRepository: string;
   dbRepositories: string;
   databaseReady: string;
+  dbMigrationStatus: string;
   dbProvider: string;
   dbReset: string;
   dbTestDatabase: string;

package/src/templates/db/migration-status.ts

@@ -0,0 +1,126 @@
+type MigrationStatusTemplateOptions = {
+  imports: string;
+  open: string;
+  loadApplied: string;
+  close: string;
+};
+
+export function migrationStatusTemplate(
+  options: MigrationStatusTemplateOptions,
+): string {
+  return `${options.imports}
+import { readFile } from "node:fs/promises";
+import { readMigrationFiles } from "drizzle-orm/migrator";
+
+type AppliedMigration = {
+	hash: string;
+	createdAt: number;
+};
+
+type MigrationJournal = {
+	entries: Array<{ tag: string; when: number }>;
+};
+
+${options.open}
+
+try {
+${indent(options.loadApplied, 1)}
+	process.exitCode = await reportMigrationStatus(applied);
+} finally {
+${indent(options.close, 1)}
+}
+
+async function reportMigrationStatus(
+	applied: AppliedMigration[],
+): Promise<number> {
+	const migrationsFolder = "drizzle";
+	const journal = JSON.parse(
+		await readFile(\`\${migrationsFolder}/meta/_journal.json\`, "utf8"),
+	) as MigrationJournal;
+	const files = readMigrationFiles({ migrationsFolder });
+
+	if (journal.entries.length !== files.length) {
+		console.error(
+			\`Migration history is invalid: journal has \${journal.entries.length} entries but \${files.length} migration files were read.\`,
+		);
+		return 1;
+	}
+
+	const local = files.map((migration, index) => ({
+		tag: journal.entries[index]?.tag ?? \`migration-\${index}\`,
+		createdAt: migration.folderMillis,
+		hash: migration.hash,
+	}));
+	const localByCreatedAt = new Map(
+		local.map((migration) => [migration.createdAt, migration]),
+	);
+	const appliedByCreatedAt = new Map<number, AppliedMigration>();
+
+	for (const migration of applied) {
+		if (appliedByCreatedAt.has(migration.createdAt)) {
+			console.error(
+				\`Migration history has duplicate applied timestamp \${migration.createdAt}.\`,
+			);
+			return 1;
+		}
+		appliedByCreatedAt.set(migration.createdAt, migration);
+
+		const localMigration = localByCreatedAt.get(migration.createdAt);
+		if (!localMigration) {
+			console.error(
+				\`Applied migration \${migration.createdAt} is not present in the checked-in migration journal.\`,
+			);
+			return 1;
+		}
+		if (localMigration.hash !== migration.hash) {
+			console.error(
+				\`Applied migration \${localMigration.tag} no longer matches its checked-in SQL.\`,
+			);
+			return 1;
+		}
+	}
+
+	const latestAppliedAt = applied.reduce(
+		(latest, migration) => Math.max(latest, migration.createdAt),
+		0,
+	);
+	for (const migration of local) {
+		if (
+			migration.createdAt <= latestAppliedAt &&
+			!appliedByCreatedAt.has(migration.createdAt)
+		) {
+			console.error(
+				\`Checked-in migration \${migration.tag} predates the latest applied migration but is absent from database history.\`,
+			);
+			return 1;
+		}
+	}
+
+	const pending = local.filter(
+		(migration) => migration.createdAt > latestAppliedAt,
+	);
+	if (pending.length > 0) {
+		console.error(
+			\`\${pending.length} pending database migration(s):\\n\${pending
+				.map((migration) => \`- \${migration.tag}\`)
+				.join("\\n")}\`,
+		);
+		return 2;
+	}
+
+	console.log(
+		\`Database migrations are current (\${applied.length} applied, 0 pending).\`,
+	);
+	return 0;
+}
+`;
+}
+
+function indent(source: string, depth: number): string {
+  const prefix = "\t".repeat(depth);
+  return source
+    .trim()
+    .split("\n")
+    .map((line) => `${prefix}${line}`)
+    .join("\n");
+}

package/src/templates/db/mysql.ts

@@ -25,6 +25,7 @@
 import { databaseLocalUrl, databaseStartCommand } from "../../choices.js";
 import type { TemplateContext } from "../shared.js";
 import type { DbTemplateFiles } from "./index.js";
+import { migrationStatusTemplate } from "./migration-status.js";
 
 export function mysqlDbFiles(ctx: TemplateContext): DbTemplateFiles {
   return {
@@ -271,6 +272,28 @@ async function prepare(pool: Pool): Promise<void> {
 	await migrate(drizzle(pool), { migrationsFolder: "drizzle" });
 }
 `,
+    dbMigrationStatus: migrationStatusTemplate({
+      imports: `import mysql, { type RowDataPacket } from "mysql2/promise";
+import { env } from "@/lib/env";`,
+      open: `const pool = mysql.createPool({ uri: env.MYSQL_DB_URL });`,
+      loadApplied: `const [tables] = await pool.query<RowDataPacket[]>(
+	"SELECT table_name FROM information_schema.tables WHERE table_schema = DATABASE() AND table_name = '__drizzle_migrations' LIMIT 1",
+);
+const applied: AppliedMigration[] =
+	tables.length === 0
+		? []
+		: (
+				(
+					await pool.query<RowDataPacket[]>(
+						"SELECT hash, created_at FROM __drizzle_migrations ORDER BY created_at",
+					)
+				)[0]
+			).map((row) => ({
+				hash: String(row.hash),
+				createdAt: Number(row.created_at),
+			}));`,
+      close: "await pool.end();",
+    }),
     dbProvider: `import "@beignet/core/server-only";
 import { createProvider } from "@beignet/core/providers";
 import {

package/src/templates/db/postgres.ts

@@ -22,6 +22,7 @@
 import { databaseLocalUrl } from "../../choices.js";
 import type { TemplateContext } from "../shared.js";
 import type { DbTemplateFiles } from "./index.js";
+import { migrationStatusTemplate } from "./migration-status.js";
 
 export function postgresDbFiles(ctx: TemplateContext): DbTemplateFiles {
   return {
@@ -259,6 +260,26 @@ async function prepare(pool: Pool): Promise<void> {
 	await migrate(drizzle(pool), { migrationsFolder: "drizzle" });
 }
 `,
+    dbMigrationStatus: migrationStatusTemplate({
+      imports: `import pg from "pg";
+import { env } from "@/lib/env";`,
+      open: `const pool = new pg.Pool({ connectionString: env.POSTGRES_DB_URL });`,
+      loadApplied: `const table = await pool.query<{ name: string | null }>(
+	"SELECT to_regclass('drizzle.__drizzle_migrations')::text AS name",
+);
+const applied: AppliedMigration[] =
+	table.rows[0]?.name == null
+		? []
+		: (
+				await pool.query<{ hash: string; created_at: string }>(
+					'SELECT hash, created_at FROM "drizzle"."__drizzle_migrations" ORDER BY created_at',
+				)
+			).rows.map((row) => ({
+				hash: row.hash,
+				createdAt: Number(row.created_at),
+			}));`,
+      close: "await pool.end();",
+    }),
     dbProvider: `import "@beignet/core/server-only";
 import { createProvider } from "@beignet/core/providers";
 import {