@beignet/cli 0.0.9 → 0.0.10

package/src/make.ts

@@ -278,6 +278,78 @@ type GeneratedFile = {
 
 type ResourcePersistence = "memory" | "drizzle";
 
+/**
+ * SQL dialect of the app database. Kept as a local literal union so the
+ * generators do not couple to the create-side option types.
+ */
+export type DatabaseName = "sqlite" | "postgres" | "mysql";
+
+/**
+ * Everything generated Drizzle code needs to target one SQL dialect: the
+ * provider subpath and database type, the drizzle-orm column builders, and
+ * whether mutations can use `.returning(...)`.
+ *
+ * Timestamps (`createdAt`/`updatedAt`/`deletedAt`) stay ISO-8601 strings in
+ * every dialect — deliberate parity with the starter so cursor pagination
+ * compares strings the same way everywhere.
+ */
+type DrizzleDialect = {
+  /** `@beignet/provider-db-drizzle` subpath the repository imports. */
+  subpath: DatabaseName;
+  /** Database type exported by the provider subpath. */
+  dbTypeName: string;
+  /** drizzle-orm column-builder module. */
+  columnModule: string;
+  /** Table factory exported by the column module. */
+  tableFunction: string;
+  /** Named imports pulled from the column module, sorted. */
+  schemaImports: readonly string[];
+  /** Whether insert/update/delete support `.returning(...)`. */
+  supportsReturning: boolean;
+  /** id and foreign-key column builder. */
+  idColumn: (columnName: string) => string;
+  /** ISO-8601 timestamp column builder. */
+  timestampColumn: (columnName: string) => string;
+  /** Integer column builder. */
+  integerColumn: (columnName: string) => string;
+};
+
+const drizzleDialects: Record<DatabaseName, DrizzleDialect> = {
+  sqlite: {
+    subpath: "sqlite",
+    dbTypeName: "DrizzleSqliteDatabase",
+    columnModule: "drizzle-orm/sqlite-core",
+    tableFunction: "sqliteTable",
+    schemaImports: ["integer", "sqliteTable", "text"],
+    supportsReturning: true,
+    idColumn: (columnName) => `text("${columnName}")`,
+    timestampColumn: (columnName) => `text("${columnName}")`,
+    integerColumn: (columnName) => `integer("${columnName}")`,
+  },
+  postgres: {
+    subpath: "postgres",
+    dbTypeName: "DrizzlePostgresDatabase",
+    columnModule: "drizzle-orm/pg-core",
+    tableFunction: "pgTable",
+    schemaImports: ["integer", "pgTable", "text"],
+    supportsReturning: true,
+    idColumn: (columnName) => `text("${columnName}")`,
+    timestampColumn: (columnName) => `text("${columnName}")`,
+    integerColumn: (columnName) => `integer("${columnName}")`,
+  },
+  mysql: {
+    subpath: "mysql",
+    dbTypeName: "DrizzleMysqlDatabase",
+    columnModule: "drizzle-orm/mysql-core",
+    tableFunction: "mysqlTable",
+    schemaImports: ["int", "mysqlTable", "text", "varchar"],
+    supportsReturning: false,
+    idColumn: (columnName) => `varchar("${columnName}", { length: 36 })`,
+    timestampColumn: (columnName) => `varchar("${columnName}", { length: 32 })`,
+    integerColumn: (columnName) => `int("${columnName}")`,
+  },
+};
+
 type IdentifierNames = {
   input: string;
   kebab: string;
@@ -437,6 +509,10 @@ async function makeResourceSlice(
   }
 
   const persistence = await detectResourcePersistence(targetDir, config);
+  const database =
+    persistence === "drizzle"
+      ? await detectResourceDatabase(targetDir, config)
+      : "sqlite";
   const generationOptions = resourceGenerationOptions(options, mode);
   const generatedFiles = resourceFiles(
     names,
@@ -444,6 +520,7 @@ async function makeResourceSlice(
     persistence,
     mode,
     generationOptions,
+    database,
   );
   const plannedFiles = await planGeneratedFiles(targetDir, generatedFiles, {
     force: Boolean(options.force),
@@ -4071,6 +4148,7 @@ function resourceFiles(
     events: false,
     softDelete: false,
   },
+  database: DatabaseName = "sqlite",
 ): GeneratedFile[] {
   const useCaseDir = resourceUseCaseDir(names, config);
   const infraDir = infrastructureDir(config);
@@ -4155,14 +4233,15 @@ function resourceFiles(
   ];
 
   if (persistence === "drizzle") {
+    const dialect = drizzleDialects[database];
     files.push(
       {
         path: drizzleResourceSchemaFilePath(names, config),
-        content: drizzleSchemaFile(names, options),
+        content: drizzleSchemaFile(names, options, dialect),
       },
       {
         path: drizzleResourceRepositoryFilePath(names, config),
-        content: drizzleRepositoryFile(names, config, mode, options),
+        content: drizzleRepositoryFile(names, config, mode, options, dialect),
       },
     );
   }
@@ -4472,6 +4551,51 @@ async function detectResourcePersistence(
     : "memory";
 }
 
+const databaseNames = ["sqlite", "postgres", "mysql"] as const;
+
+/**
+ * Detect the SQL dialect of a Drizzle app from its generated wiring.
+ *
+ * Precedence:
+ * 1. The provider import in the Drizzle repositories file
+ *    (`@beignet/provider-db-drizzle/<dialect>`), resolved through the
+ *    configured infrastructure paths so custom layouts keep working.
+ * 2. The provider registration tokens in `server/providers.ts`
+ *    (`drizzle<Dialect>Provider` / `createDrizzle<Dialect>Provider`).
+ * 3. `"sqlite"`, the starter default.
+ *
+ * Self-healing by design: there is no config field to drift, the detector
+ * reads the same files the app boots from.
+ */
+export async function detectResourceDatabase(
+  targetDir: string,
+  config: ResolvedBeignetConfig,
+): Promise<DatabaseName> {
+  const repositories = await readOptionalFile(
+    path.join(targetDir, drizzleRepositoriesPath(config)),
+  );
+  const providerImport = repositories?.match(
+    /from\s+["']@beignet\/provider-db-drizzle\/(sqlite|postgres|mysql)["']/,
+  );
+  if (providerImport) return providerImport[1] as DatabaseName;
+
+  const providers = await readOptionalFile(
+    path.join(targetDir, providersFilePath(config)),
+  );
+  if (providers !== undefined) {
+    for (const database of databaseNames) {
+      const dialectPascal =
+        database.charAt(0).toUpperCase() + database.slice(1);
+      const tokens = new RegExp(
+        `\\b(?:drizzle${dialectPascal}Provider|createDrizzle${dialectPascal}Provider)\\b`,
+      );
+      if (tokens.test(providers)) return database;
+    }
+  }
+
+  return "sqlite";
+}
+
 function resourceFeatureDir(
   names: ResourceNames,
   config: ResolvedBeignetConfig,
@@ -5826,16 +5950,17 @@ ${mode === "resource" ? `		async findById(id: string${options.tenant ? ", filter
 function drizzleSchemaFile(
   names: ResourceNames,
   options: ResourceGenerationOptions,
+  dialect: DrizzleDialect,
 ): string {
-  return `import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
-
-export const ${names.pluralCamel} = sqliteTable("${names.pluralKebab.replaceAll("-", "_")}", {
-	id: text("id").primaryKey(),
-${options.tenant ? `\ttenantId: text("tenant_id").notNull(),\n` : ""}	name: text("name").notNull(),
-	version: integer("version").notNull(),
-	createdAt: text("created_at").notNull(),
-	updatedAt: text("updated_at").notNull(),
-${options.softDelete ? `\tdeletedAt: text("deleted_at"),\n` : ""}});
+  return `import { ${dialect.schemaImports.join(", ")} } from "${dialect.columnModule}";
+
+export const ${names.pluralCamel} = ${dialect.tableFunction}("${names.pluralKebab.replaceAll("-", "_")}", {
+	id: ${dialect.idColumn("id")}.primaryKey(),
+${options.tenant ? `\ttenantId: ${dialect.idColumn("tenant_id")}.notNull(),\n` : ""}	name: text("name").notNull(),
+	version: ${dialect.integerColumn("version")}.notNull(),
+	createdAt: ${dialect.timestampColumn("created_at")}.notNull(),
+	updatedAt: ${dialect.timestampColumn("updated_at")}.notNull(),
+${options.softDelete ? `\tdeletedAt: ${dialect.timestampColumn("deleted_at")},\n` : ""}});
 `;
 }
 
@@ -5861,6 +5986,7 @@ function drizzleRepositoryFile(
   config: ResolvedBeignetConfig,
   mode: ResourceGenerationMode,
   options: ResourceGenerationOptions,
+  dialect: DrizzleDialect,
 ): string {
   const repositoryPortPath = resourcePortFilePath(names, config);
   const schemaPath = drizzleSchemaIndexPath(config);
@@ -5895,10 +6021,134 @@ function drizzleRepositoryFile(
     "sql",
     "type SQL",
   ].filter((name): name is string => Boolean(name));
+  // After a version-guarded update succeeds, re-select by identity only —
+  // matching what `.returning()` yields on the dialects that support it.
+  const updateReselectWhere = options.tenant
+    ? `and(eq(schema.${names.pluralCamel}.id, input.id), eq(schema.${names.pluralCamel}.tenantId, input.tenantId))`
+    : `eq(schema.${names.pluralCamel}.id, input.id)`;
+  // drizzle-orm/mysql2 has no `.returning(...)`; mutations resolve to a
+  // `[ResultSetHeader, FieldPacket[]]` tuple typed as `unknown` through the
+  // generic database seam, so generated MySQL code reads affectedRows
+  // defensively and re-selects rows it needs back.
+  const affectedRowsHelper =
+    mode === "resource" && !dialect.supportsReturning
+      ? `
+// drizzle-orm/mysql2 mutations resolve to [ResultSetHeader, FieldPacket[]],
+// typed as unknown through the generic database seam, so read affectedRows
+// defensively.
+function affectedRows(result: unknown): number {
+	const head: unknown = Array.isArray(result) ? result[0] : undefined;
+	if (head === null || typeof head !== "object") return 0;
+	return "affectedRows" in head && typeof head.affectedRows === "number"
+		? head.affectedRows
+		: 0;
+}
+`
+      : "";
+  const createMethod = dialect.supportsReturning
+    ? `		async create(input) {
+			const now = new Date().toISOString();
+			const [row] = await db
+				.insert(schema.${names.pluralCamel})
+				.values({
+					id: crypto.randomUUID(),
+${options.tenant ? `\t\t\t\t\ttenantId: input.tenantId,\n` : ""}					name: input.name,
+					version: 1,
+					createdAt: now,
+					updatedAt: now,
+				})
+				.returning();
+
+			if (!row) {
+				throw new Error("Failed to create ${names.singularKebab}.");
+			}
+
+			return to${names.singularPascal}(row);
+		},
+`
+    : `		async create(input) {
+			const now = new Date().toISOString();
+			const ${names.singularCamel}: ${names.singularPascal} = {
+				id: crypto.randomUUID(),
+${options.tenant ? `\t\t\t\ttenantId: input.tenantId,\n` : ""}				name: input.name,
+				version: 1,
+				createdAt: now,
+				updatedAt: now,
+			};
+			await db.insert(schema.${names.pluralCamel}).values(${names.singularCamel});
+
+			return ${names.singularCamel};
+		},
+`;
+  const resourceMethods =
+    mode !== "resource"
+      ? ""
+      : dialect.supportsReturning
+        ? `		async findById(id: string${options.tenant ? ", filter" : ""}) {
+			const [row] = await db
+				.select()
+				.from(schema.${names.pluralCamel})
+				.where(${findWhere})
+				.limit(1);
+
+			return row ? to${names.singularPascal}(row) : null;
+		},
+		async update(input) {
+			const [row] = await db
+				.update(schema.${names.pluralCamel})
+				.set({
+					name: input.name,
+					version: input.version + 1,
+					updatedAt: new Date().toISOString(),
+				})
+				.where(${updateWhere})
+				.returning();
+
+			return row ? to${names.singularPascal}(row) : null;
+		},
+		async delete(id: string${options.tenant ? ", filter" : ""}) {
+${options.softDelete ? `\t\t\tconst now = new Date().toISOString();\n\t\t\tconst rows = await db\n\t\t\t\t.update(schema.${names.pluralCamel})\n\t\t\t\t.set({ deletedAt: now, updatedAt: now })\n\t\t\t\t.where(${deleteWhere})\n\t\t\t\t.returning({ id: schema.${names.pluralCamel}.id });\n` : `\t\t\tconst rows = await db\n\t\t\t\t.delete(schema.${names.pluralCamel})\n\t\t\t\t.where(${deleteWhere})\n\t\t\t\t.returning({ id: schema.${names.pluralCamel}.id });\n`}
+			return rows.length > 0;
+		},
+`
+        : `		async findById(id: string${options.tenant ? ", filter" : ""}) {
+			const [row] = await db
+				.select()
+				.from(schema.${names.pluralCamel})
+				.where(${findWhere})
+				.limit(1);
+
+			return row ? to${names.singularPascal}(row) : null;
+		},
+		async update(input) {
+			const result = await db
+				.update(schema.${names.pluralCamel})
+				.set({
+					name: input.name,
+					version: input.version + 1,
+					updatedAt: new Date().toISOString(),
+				})
+				.where(${updateWhere});
+
+			if (affectedRows(result) === 0) return null;
+
+			const [row] = await db
+				.select()
+				.from(schema.${names.pluralCamel})
+				.where(${updateReselectWhere})
+				.limit(1);
+
+			return row ? to${names.singularPascal}(row) : null;
+		},
+		async delete(id: string${options.tenant ? ", filter" : ""}) {
+${options.softDelete ? `\t\t\tconst now = new Date().toISOString();\n\t\t\tconst result = await db\n\t\t\t\t.update(schema.${names.pluralCamel})\n\t\t\t\t.set({ deletedAt: now, updatedAt: now })\n\t\t\t\t.where(${deleteWhere});\n` : `\t\t\tconst result = await db\n\t\t\t\t.delete(schema.${names.pluralCamel})\n\t\t\t\t.where(${deleteWhere});\n`}
+			return affectedRows(result) > 0;
+		},
+`;
 
   return `import type { beignetServerOnly } from "@beignet/core/server-only";
 import { cursorPageResult } from "@beignet/core/pagination";
-import type { DrizzleSqliteDatabase } from "@beignet/provider-db-drizzle/sqlite";
+import type { ${dialect.dbTypeName} } from "@beignet/provider-db-drizzle/${dialect.subpath}";
 import { ${drizzleImports.join(", ")} } from "drizzle-orm";
 import type { ${names.singularPascal}Repository } from "${aliasModule(repositoryPortPath)}";
 import { encode${names.singularPascal}Cursor } from "${aliasModule(resourceSchemaFilePath(names, config))}";
@@ -5919,7 +6169,7 @@ ${options.tenant ? `\t\ttenantId: row.tenantId,\n` : ""}		name: row.name,
 		updatedAt: row.updatedAt,
 	};
 }
-
+${affectedRowsHelper}
 type List${names.pluralPascal}Query = Parameters<${names.singularPascal}Repository["list"]>[0];
 
 function ${names.singularCamel}SortColumn(query: List${names.pluralPascal}Query) {
@@ -5978,7 +6228,7 @@ function cursorFor${names.singularPascal}(
 }
 
 export function createDrizzle${names.singularPascal}Repository(
-	db: DrizzleSqliteDatabase<typeof schema>,
+	db: ${dialect.dbTypeName}<typeof schema>,
 ): ${names.singularPascal}Repository {
 	return {
 		async list(query) {
@@ -6001,26 +6251,7 @@ export function createDrizzle${names.singularPascal}Repository(
 				nextCursor,
 			);
 		},
-		async create(input) {
-			const now = new Date().toISOString();
-			const [row] = await db
-				.insert(schema.${names.pluralCamel})
-				.values({
-					id: crypto.randomUUID(),
-${options.tenant ? `\t\t\t\t\ttenantId: input.tenantId,\n` : ""}					name: input.name,
-					version: 1,
-					createdAt: now,
-					updatedAt: now,
-				})
-				.returning();
-
-			if (!row) {
-				throw new Error("Failed to create ${names.singularKebab}.");
-			}
-
-			return to${names.singularPascal}(row);
-		},
-${mode === "resource" ? `		async findById(id: string${options.tenant ? ", filter" : ""}) {\n			const [row] = await db\n				.select()\n				.from(schema.${names.pluralCamel})\n				.where(${findWhere})\n				.limit(1);\n\n			return row ? to${names.singularPascal}(row) : null;\n		},\n		async update(input) {\n			const [row] = await db\n				.update(schema.${names.pluralCamel})\n				.set({\n					name: input.name,\n					version: input.version + 1,\n					updatedAt: new Date().toISOString(),\n				})\n				.where(${updateWhere})\n				.returning();\n\n			return row ? to${names.singularPascal}(row) : null;\n		},\n		async delete(id: string${options.tenant ? ", filter" : ""}) {\n${options.softDelete ? `\t\t\tconst now = new Date().toISOString();\n\t\t\tconst rows = await db\n\t\t\t\t.update(schema.${names.pluralCamel})\n\t\t\t\t.set({ deletedAt: now, updatedAt: now })\n\t\t\t\t.where(${deleteWhere})\n\t\t\t\t.returning({ id: schema.${names.pluralCamel}.id });\n` : `\t\t\tconst rows = await db\n\t\t\t\t.delete(schema.${names.pluralCamel})\n\t\t\t\t.where(${deleteWhere})\n\t\t\t\t.returning({ id: schema.${names.pluralCamel}.id });\n`}\n			return rows.length > 0;\n		},\n` : ""}
+${createMethod}${resourceMethods}
 	};
 }
 `;

package/src/templates/base.ts

@@ -1,3 +1,4 @@
+import { databaseLocalUrl, databaseStartCommand } from "../choices.js";
 import { shadcnDependencies, shadcnDevDependencies } from "./shadcn.js";
 import {
   externalVersions,
@@ -17,7 +18,6 @@ export function packageJson(ctx: TemplateContext): string {
     "@beignet/provider-auth-better-auth": ctx.beignetVersion,
     "@beignet/provider-db-drizzle": ctx.beignetVersion,
     "@beignet/provider-logger-pino": ctx.beignetVersion,
-    "@libsql/client": externalVersions.libsqlClient,
     "better-auth": externalVersions.betterAuth,
     "drizzle-orm": externalVersions.drizzleOrm,
     next: externalVersions.next,
@@ -27,6 +27,19 @@ export function packageJson(ctx: TemplateContext): string {
     zod: externalVersions.zod,
   };
 
+  // Ship only the selected database driver.
+  switch (ctx.database) {
+    case "postgres":
+      dependencies.pg = externalVersions.pg;
+      break;
+    case "mysql":
+      dependencies.mysql2 = externalVersions.mysql2;
+      break;
+    default:
+      dependencies["@libsql/client"] = externalVersions.libsqlClient;
+      break;
+  }
+
   if (!ctx.api) {
     dependencies["@beignet/react-query"] = ctx.beignetVersion;
     dependencies["@beignet/react-hook-form"] = ctx.beignetVersion;
@@ -61,6 +74,12 @@ export function packageJson(ctx: TemplateContext): string {
     typescript: externalVersions.typescript,
   };
 
+  if (ctx.database === "postgres") {
+    // PGlite backs infra/db/test-database.ts with in-process Postgres.
+    devDependencies["@electric-sql/pglite"] = externalVersions.pglite;
+    devDependencies["@types/pg"] = externalVersions.typesPg;
+  }
+
   if (!ctx.api) {
     for (const [name, version] of Object.entries(shadcnDevDependencies)) {
       devDependencies[name] = version;
@@ -134,6 +153,30 @@ export function readme(ctx: TemplateContext): string {
 - \`client/\` owns the typed API client, React Query helpers, and the Better Auth client.
 `;
 
+  const startDatabase =
+    ctx.database === "sqlite"
+      ? ""
+      : `## Start the database
+
+\`\`\`bash
+${databaseStartCommand(ctx.database, ctx.name)}
+\`\`\`
+
+The starter's \`.env.example\` points at this local ${ctx.database === "postgres" ? "Postgres" : "MySQL"} container. Point \`${ctx.database === "postgres" ? "POSTGRES_DB_URL" : "MYSQL_DB_URL"}\` at your own server to skip Docker.
+
+`;
+
+  const testingNotes =
+    ctx.database === "postgres"
+      ? `
+\`infra/db/test-database.ts\` runs repository tests against in-process Postgres via PGlite, so \`${test}\` needs no database server.
+`
+      : ctx.database === "mysql"
+        ? `
+The starter's shipped tests use in-memory ports and need no database server. Database-backed tests can use \`createTestDatabase()\` from \`infra/db/test-database.ts\`, which requires \`MYSQL_TEST_URL\` (see the docker one-liner in \`.env.example\`), creates a uniquely named database per call, and drops it on close. Gate such tests with \`test.skipIf(!isMysqlTestDatabaseAvailable())\`.
+`
+        : "";
+
   return `# ${ctx.name}
 
 Beignet app scaffolded with \`@beignet/cli\`.
@@ -145,7 +188,7 @@ ${install}
 cp .env.example .env.local
 \`\`\`
 
-## Prepare the database
+${startDatabase}## Prepare the database
 
 \`\`\`bash
 ${cli} db migrate
@@ -173,7 +216,7 @@ ${typecheck}
 \`\`\`
 
 \`routes\` shows the contracts Beignet can inspect. \`lint\` checks dependency direction. \`doctor\` catches route, OpenAPI, and resource drift.
-
+${testingNotes}
 ## Build for production
 
 \`\`\`bash
@@ -207,16 +250,42 @@ ${cli} doctor
 - \`infra/db/schema/\` contains the Drizzle schema, \`drizzle/\` contains the checked-in migrations, and \`infra/todos/\` contains the durable todo repository adapter.
 - \`server/routes.ts\` keeps the central route registry and OpenAPI contract list.
 - \`server/context.ts\` declares the context blueprint shared by the server and route tests.
-- \`server/providers.ts\` wires devtools, Better Auth, pino, Drizzle/libSQL, and the starter database provider.
+- \`server/providers.ts\` wires devtools, Better Auth, pino, ${
+    ctx.database === "sqlite"
+      ? "Drizzle/libSQL"
+      : ctx.database === "postgres"
+        ? "Drizzle/node-postgres"
+        : "Drizzle/mysql2"
+  }, and the starter database provider.
 - \`lib/env.ts\` validates deployment configuration at startup.
 - \`lib/auth.ts\` exposes \`requireUser(ctx)\` for protected use cases.
 - \`lib/better-auth.ts\` owns Better Auth setup and keeps provider-specific auth details outside use cases.
 ${shellMap}
 ## Before deploying
 
-- Keep \`SQLITE_DB_URL=file:local.db\` for local libSQL development or point it at a hosted libSQL database such as Turso.
+- ${
+    ctx.database === "sqlite"
+      ? "Keep `SQLITE_DB_URL=file:local.db` for local libSQL development or point it at a hosted libSQL database such as Turso."
+      : ctx.database === "postgres"
+        ? "Point `POSTGRES_DB_URL` at your production Postgres 14+ server and run `" +
+          cli +
+          " db migrate` against it before starting the app."
+        : "Point `MYSQL_DB_URL` at your production MySQL 8.0+ server and run `" +
+          cli +
+          " db migrate` against it before starting the app."
+  }
 - Run \`${cli} db generate\` and \`${cli} db migrate\` after changing the Drizzle schema.
-- Run \`${cli} db reset\` to rebuild a local SQLite database from the checked-in migrations.
+- Run \`${cli} db reset\` to rebuild a local ${
+    ctx.database === "sqlite"
+      ? "SQLite"
+      : ctx.database === "postgres"
+        ? "Postgres"
+        : "MySQL"
+  } database from the checked-in migrations${
+    ctx.database === "sqlite"
+      ? ""
+      : "; it refuses non-local hosts unless `BEIGNET_ALLOW_DATABASE_RESET=true`"
+  }.
 - Remove \`DEVTOOLS_ENABLED=true\` in production unless you add authentication and stricter redaction.
 - Set \`APP_URL\`, \`BETTER_AUTH_SECRET\`, \`LOG_LEVEL\`, and service-specific integration variables in your hosting environment.
 - Set \`BETTER_AUTH_TRUSTED_ORIGINS\` before serving auth across multiple origins.
@@ -276,6 +345,25 @@ export function integrationsDoc(ctx: TemplateContext): string {
 }
 
 export function envExample(ctx: TemplateContext): string {
+  const databaseLines =
+    ctx.database === "sqlite"
+      ? [
+          "# Use file:local.db for local libSQL or libsql://... for Turso cloud.",
+          "SQLITE_DB_URL=file:local.db",
+          "# SQLITE_DB_AUTH_TOKEN=",
+        ]
+      : ctx.database === "postgres"
+        ? [
+            "# Local Postgres matching the docker one-liner below; point at your own server in production.",
+            `# ${databaseStartCommand("postgres", ctx.name)}`,
+            `POSTGRES_DB_URL=${databaseLocalUrl("postgres", ctx.name)}`,
+          ]
+        : [
+            "# Local MySQL matching the docker one-liner below; point at your own server in production.",
+            `# ${databaseStartCommand("mysql", ctx.name)}`,
+            `MYSQL_DB_URL=${databaseLocalUrl("mysql", ctx.name)}`,
+          ];
+
   const lines = [
     "# Copy to .env.local and fill in values for your app.",
     "APP_URL=http://localhost:3000",
@@ -287,9 +375,7 @@ export function envExample(ctx: TemplateContext): string {
     "LOG_FORMAT=json",
     `LOG_SERVICE=${ctx.name}`,
     "",
-    "# Use file:local.db for local libSQL or libsql://... for Turso cloud.",
-    "SQLITE_DB_URL=file:local.db",
-    "# SQLITE_DB_AUTH_TOKEN=",
+    ...databaseLines,
     "",
     "BETTER_AUTH_SECRET=local-dev-better-auth-secret-change-me",
     "BETTER_AUTH_URL=http://localhost:3000",

package/src/templates/db/index.ts

@@ -0,0 +1,34 @@
+import type { TemplateContext } from "../shared.js";
+import { mysqlDbFiles } from "./mysql.js";
+import { postgresDbFiles } from "./postgres.js";
+import { sqliteDbFiles } from "./sqlite.js";
+
+/**
+ * Generated database files shared by every dialect. Each dialect module
+ * provides the full set so the scaffold surface stays stable across `--db`
+ * choices.
+ */
+export type DbTemplateFiles = {
+  drizzleConfig: string;
+  dbSchema: string;
+  drizzleTodoRepository: string;
+  dbRepositories: string;
+  databaseReady: string;
+  dbProvider: string;
+  dbReset: string;
+  dbTestDatabase: string;
+  starterMigrationSql: string;
+  starterMigrationJournal: string;
+  starterMigrationSnapshot: string;
+};
+
+export function dbFiles(ctx: TemplateContext): DbTemplateFiles {
+  switch (ctx.database) {
+    case "postgres":
+      return postgresDbFiles(ctx);
+    case "mysql":
+      return mysqlDbFiles(ctx);
+    default:
+      return sqliteDbFiles();
+  }
+}