@beignet/cli 0.0.47 → 0.0.49

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 {

package/src/templates/db/sqlite.ts

@@ -13,6 +13,7 @@
 // lives outside the app schema, so `db generate` never diffs against it.
 
 import type { DbTemplateFiles } from "./index.js";
+import { migrationStatusTemplate } from "./migration-status.js";
 
 const files = {
   drizzleConfig: `export default {
@@ -264,6 +265,58 @@ async function prepare(client: Client): Promise<void> {
 	await migrate(drizzle(client), { migrationsFolder: "drizzle" });
 }
 `,
+  dbMigrationStatus: migrationStatusTemplate({
+    imports: `import { statSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { createClient } from "@libsql/client";
+import { env } from "@/lib/env";`,
+    open: `const databaseFile = sqliteDatabaseFile(env.SQLITE_DB_URL);
+const client =
+	databaseFile !== undefined && !databaseFileExists(databaseFile)
+		? undefined
+		: createClient({
+				url: env.SQLITE_DB_URL,
+				authToken: env.SQLITE_DB_AUTH_TOKEN,
+			});
+
+function sqliteDatabaseFile(url: string): string | undefined {
+	if (!url.startsWith("file:")) return undefined;
+	const rawPath = url.slice("file:".length).split(/[?#]/, 1)[0];
+	if (!rawPath || rawPath === ":memory:") return undefined;
+	return rawPath.startsWith("//")
+		? fileURLToPath(url)
+		: path.resolve(decodeURIComponent(rawPath));
+}
+
+function databaseFileExists(file: string): boolean {
+	try {
+		statSync(file);
+		return true;
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") return false;
+		throw error;
+	}
+}`,
+    loadApplied: `let applied: AppliedMigration[] = [];
+if (client !== undefined) {
+	const table = await client.execute(
+		"SELECT name FROM sqlite_master WHERE type = 'table' AND name = '__drizzle_migrations' LIMIT 1",
+	);
+	applied =
+		table.rows.length === 0
+			? []
+			: (
+					await client.execute(
+						"SELECT hash, created_at FROM __drizzle_migrations ORDER BY created_at",
+					)
+				).rows.map((row) => ({
+					hash: String(row.hash),
+					createdAt: Number(row.created_at),
+				}));
+}`,
+    close: "client?.close();",
+  }),
   dbProvider: `import "@beignet/core/server-only";
 import { createProvider } from "@beignet/core/providers";
 import {

package/src/templates/index.ts

@@ -53,6 +53,7 @@ export function getTemplateFiles(ctx: TemplateContext): TemplateFile[] {
     { path: "AGENTS.md", content: agentsMd(ctx) },
     { path: "CLAUDE.md", content: agentsMd(ctx) },
     { path: ".mcp.json", content: mcpJson(ctx) },
+    { path: ".gitattributes", content: baseFiles.gitattributes },
     { path: ".gitignore", content: baseFiles.gitignore },
     { path: ".env.example", content: envExample(ctx) },
     { path: "next-env.d.ts", content: baseFiles.nextEnv },
@@ -118,6 +119,10 @@ export function getTemplateFiles(ctx: TemplateContext): TemplateFile[] {
     { path: "infra/port-wiring.ts", content: portWiring(ctx) },
     { path: "infra/db/client.ts", content: db.dbClient },
     { path: "infra/db/database-ready.ts", content: db.databaseReady },
+    {
+      path: "infra/db/migration-status.ts",
+      content: db.dbMigrationStatus,
+    },
     { path: "infra/db/provider.ts", content: db.dbProvider },
     { path: "infra/db/repositories.ts", content: db.dbRepositories },
     { path: "infra/db/reset.ts", content: db.dbReset },

package/src/templates/server.ts

@@ -696,6 +696,8 @@ export const { GET, POST } = createDevtoolsRoute(
 	{
 		basePath: "/api/devtools",
 		enabled: env.DEVTOOLS_ENABLED,
+		authorize: async (req) =>
+			Boolean(await (await getServer()).ports.auth.getSession(req)),
 	},
 );
 `,

package/src/templates/shared.ts

@@ -37,7 +37,7 @@ export const externalVersions = {
   reactDom: "^19.2.5",
   tsx: "^4.22.4",
   typescript: "^5.3.0",
-  typesNode: "^20.10.0",
+  typesNode: "^22.0.0",
   typesReact: "^19.0.0",
   typesReactDom: "^19.0.0",
   zod: "^4.0.0",
@@ -62,7 +62,8 @@ export const externalVersions = {
   openFeatureServerSdk: "^1.22.0",
   typesPg: "^8.11.0",
   ioredis: "^5.0.0",
-  awsSdkS3: "^3.955.0",
+  awsSdkS3: "^3.1050.0",
+  awsSdkLibStorage: "3.1050.0",
   upstashRateLimit: "^2.0.0",
   upstashRedis: "^1.0.0",
 };
@@ -77,6 +78,7 @@ export const legacyGeneratedPackageScripts: Record<string, readonly string[]> =
 export const currentGeneratedPackageScripts: Record<string, string> = {
   "db:reset": "tsx infra/db/reset.ts",
   "db:seed": "tsx server/seed.ts",
+  "db:status": "tsx infra/db/migration-status.ts",
   test: "node --import tsx lib/beignet-test-runner.ts",
 };