@beignet/cli 0.0.8 → 0.0.10

package/src/templates/server.ts

@@ -1,11 +1,17 @@
-import { hasIntegration, type TemplateContext } from "./shared.js";
+import { databaseLocalUrl } from "../choices.js";
+import {
+  databaseDescriptor,
+  hasIntegration,
+  type TemplateContext,
+} from "./shared.js";
 
 export function serverProviders(ctx: TemplateContext): string {
+  const db = databaseDescriptor(ctx);
   const imports = [
     'import type { beignetServerOnly } from "@beignet/core/server-only";',
     'import { createDevtoolsProvider } from "@beignet/devtools";',
     'import { createAuthBetterAuthProvider } from "@beignet/provider-auth-better-auth";',
-    'import { createDrizzleTursoProvider } from "@beignet/provider-drizzle-turso";',
+    `import { ${db.providerFactory} } from "@beignet/provider-db-drizzle/${db.subpath}";`,
     hasIntegration(ctx, "inngest")
       ? 'import { inngestProvider } from "@beignet/provider-inngest";'
       : undefined,
@@ -26,7 +32,7 @@ export function serverProviders(ctx: TemplateContext): string {
     "\tcreateDevtoolsProvider(),",
     "\tcreateAuthBetterAuthProvider<AuthUser, AuthSessionMetadata>(auth),",
     "\tloggerPinoProvider,",
-    "\tdrizzleTursoProvider,",
+    `\t${db.providerInstance},`,
     "\tstarterDatabaseProvider,",
     hasIntegration(ctx, "inngest") ? "\tinngestProvider," : undefined,
     hasIntegration(ctx, "resend") ? "\tmailResendProvider," : undefined,
@@ -37,7 +43,7 @@ export function serverProviders(ctx: TemplateContext): string {
 
   return `${imports.join("\n")}
 
-const drizzleTursoProvider = createDrizzleTursoProvider({ schema });
+const ${db.providerInstance} = ${db.providerFactory}({ schema });
 
 export const providers = [
 ${entries.join("\n")}
@@ -132,8 +138,16 @@ ${deferred.join("\n")}
 `;
 }
 
-const files = {
-  env: `import { createEnv } from "@beignet/core/config";
+export function env(ctx: TemplateContext): string {
+  const databaseEnvLines =
+    ctx.database === "sqlite"
+      ? `\t\tSQLITE_DB_URL: z.string().default("file:local.db"),
+\t\tSQLITE_DB_AUTH_TOKEN: z.string().optional(),`
+      : `\t\t${databaseDescriptor(ctx).urlEnvVar}: z
+\t\t\t.string()
+\t\t\t.default("${databaseLocalUrl(ctx.database, ctx.name)}"),`;
+
+  return `import { createEnv } from "@beignet/core/config";
 import { z } from "zod";
 
 const BooleanEnv = z.enum(["true", "false"]).transform((value) => value === "true");
@@ -151,8 +165,7 @@ export const env = createEnv({
 			.default("local-dev-better-auth-secret-change-me"),
 		BETTER_AUTH_URL: z.string().url().default("http://localhost:3000"),
 		BETTER_AUTH_TRUSTED_ORIGINS: z.string().optional(),
-		TURSO_DB_URL: z.string().default("file:local.db"),
-		TURSO_DB_AUTH_TOKEN: z.string().optional(),
+${databaseEnvLines}
 		LOG_LEVEL: z
 			.enum(["trace", "debug", "info", "warn", "error", "fatal"])
 			.default("info"),
@@ -166,7 +179,146 @@ export const isProduction = env.NODE_ENV === "production";
 
 export const isDevtoolsEnabled =
 	env.DEVTOOLS_ENABLED ?? process.env.NODE_ENV !== "production";
-`,
+`;
+}
+
+export function betterAuth(ctx: TemplateContext): string {
+  const connectionByDatabase = {
+    sqlite: `import { createClient } from "@libsql/client";
+import { betterAuth } from "better-auth";
+import { drizzleAdapter } from "better-auth/adapters/drizzle";
+import { drizzle } from "drizzle-orm/libsql";
+import { ensureDatabaseReady } from "@/infra/db/database-ready";
+import * as schema from "@/infra/db/schema";
+import { env } from "@/lib/env";
+
+const client = createClient({
+	url: env.SQLITE_DB_URL,
+	authToken: env.SQLITE_DB_AUTH_TOKEN,
+});
+
+// Auth routes can be the first thing to touch the database, before any
+// Beignet provider boots, so readiness is enforced here too.
+await ensureDatabaseReady(client);
+
+const db = drizzle(client, { schema });`,
+    postgres: `import { betterAuth } from "better-auth";
+import { drizzleAdapter } from "better-auth/adapters/drizzle";
+import { drizzle } from "drizzle-orm/node-postgres";
+import pg from "pg";
+import { ensureDatabaseReady } from "@/infra/db/database-ready";
+import * as schema from "@/infra/db/schema";
+import { env } from "@/lib/env";
+
+const pool = new pg.Pool({ connectionString: env.POSTGRES_DB_URL });
+
+// Auth routes can be the first thing to touch the database, before any
+// Beignet provider boots, so readiness is enforced here too.
+await ensureDatabaseReady(pool);
+
+const db = drizzle(pool, { schema });`,
+    mysql: `import { betterAuth } from "better-auth";
+import { drizzleAdapter } from "better-auth/adapters/drizzle";
+import { drizzle } from "drizzle-orm/mysql2";
+import mysql from "mysql2/promise";
+import { ensureDatabaseReady } from "@/infra/db/database-ready";
+import * as schema from "@/infra/db/schema";
+import { env } from "@/lib/env";
+
+const pool = mysql.createPool({ uri: env.MYSQL_DB_URL });
+
+// Auth routes can be the first thing to touch the database, before any
+// Beignet provider boots, so readiness is enforced here too.
+await ensureDatabaseReady(pool);
+
+const db = drizzle(pool, { schema, mode: "default" });`,
+  } as const;
+
+  return `${connectionByDatabase[ctx.database]}
+
+const trustedOrigins = [
+	env.APP_URL,
+	env.BETTER_AUTH_URL,
+	...(env.BETTER_AUTH_TRUSTED_ORIGINS?.split(",")
+		.map((origin) => origin.trim())
+		.filter(Boolean) ?? []),
+];
+
+export const auth = betterAuth({
+	baseURL: env.BETTER_AUTH_URL,
+	secret: env.BETTER_AUTH_SECRET,
+	trustedOrigins: [...new Set(trustedOrigins)],
+	database: drizzleAdapter(db, {
+		provider: "${databaseDescriptor(ctx).betterAuthProvider}",
+		schema,
+	}),
+	emailAndPassword: {
+		enabled: true,
+	},
+	user: {
+		changeEmail: {
+			enabled: true,
+		},
+		deleteUser: {
+			enabled: true,
+		},
+	},
+});
+`;
+}
+
+export function server(ctx: TemplateContext): string {
+  const db = databaseDescriptor(ctx);
+  const providerConfigEntries =
+    ctx.database === "sqlite"
+      ? `\t\t"drizzle-sqlite": {
+\t\t\tDB_URL: env.SQLITE_DB_URL,
+\t\t\tDB_AUTH_TOKEN: env.SQLITE_DB_AUTH_TOKEN,
+\t\t},`
+      : `\t\t"${db.providerName}": {
+\t\t\tDB_URL: env.${db.urlEnvVar},
+\t\t},`;
+
+  return `import type { beignetServerOnly } from "@beignet/core/server-only";
+import { createNextServer } from "@beignet/next";
+import { createIdempotencyHooks } from "@beignet/core/server";
+import type { AppContext } from "@/app-context";
+import { appPorts } from "@/infra/app-ports";
+import { env } from "@/lib/env";
+import { appContext } from "./context";
+import { providers } from "./providers";
+import { routes } from "./routes";
+
+export const server = await createNextServer({
+	ports: appPorts,
+	providers,
+	providerConfig: {
+${providerConfigEntries}
+	},
+	hooks: [createIdempotencyHooks<AppContext>()],
+	context: appContext,
+	routes,
+	mapUnhandledError: ({ err, ctx }) => {
+		ctx?.ports.logger.error("Unhandled API error", {
+			error: err,
+			requestId: ctx?.requestId,
+			environment: env.NODE_ENV,
+		});
+
+		return {
+			status: 500,
+			body: {
+				code: "INTERNAL_SERVER_ERROR",
+				message: "Internal server error",
+				requestId: ctx?.requestId,
+			},
+		};
+	},
+});
+`;
+}
+
+const files = {
   appContext: `import type { ActivityActor, ActivityTenant } from "@beignet/core/ports";
 import type { InferProviderPorts } from "@beignet/core/providers";
 import type { TraceContext } from "@beignet/core/tracing";
@@ -329,46 +481,6 @@ export const appContext = defineServerContext<AppContext, AppRuntimePorts>()({
 		tenant: createTenant(input?.tenantId ?? "tenant_default"),
 	}),
 });
-`,
-  server: `import type { beignetServerOnly } from "@beignet/core/server-only";
-import { createNextServer } from "@beignet/next";
-import { createIdempotencyHooks } from "@beignet/core/server";
-import type { AppContext } from "@/app-context";
-import { appPorts } from "@/infra/app-ports";
-import { env } from "@/lib/env";
-import { appContext } from "./context";
-import { providers } from "./providers";
-import { routes } from "./routes";
-
-export const server = await createNextServer({
-	ports: appPorts,
-	providers,
-	providerConfig: {
-		"drizzle-turso": {
-			DB_URL: env.TURSO_DB_URL,
-			DB_AUTH_TOKEN: env.TURSO_DB_AUTH_TOKEN,
-		},
-	},
-	hooks: [createIdempotencyHooks<AppContext>()],
-	context: appContext,
-	routes,
-	mapUnhandledError: ({ err, ctx }) => {
-		ctx?.ports.logger.error("Unhandled API error", {
-			error: err,
-			requestId: ctx?.requestId,
-			environment: env.NODE_ENV,
-		});
-
-		return {
-			status: 500,
-			body: {
-				code: "INTERNAL_SERVER_ERROR",
-				message: "Internal server error",
-				requestId: ctx?.requestId,
-			},
-		};
-	},
-});
 `,
   apiCatchAllRoute: `import { server } from "@/server";
 
@@ -418,54 +530,6 @@ export const GET = createOpenAPIHandler(server.contracts, {
 import { auth } from "@/lib/better-auth";
 
 export const { GET, POST } = toNextJsHandler(auth);
-`,
-  betterAuth: `import { createClient } from "@libsql/client";
-import { betterAuth } from "better-auth";
-import { drizzleAdapter } from "better-auth/adapters/drizzle";
-import { drizzle } from "drizzle-orm/libsql";
-import { ensureDatabaseReady } from "@/infra/db/database-ready";
-import * as schema from "@/infra/db/schema";
-import { env } from "@/lib/env";
-
-const client = createClient({
-	url: env.TURSO_DB_URL,
-	authToken: env.TURSO_DB_AUTH_TOKEN,
-});
-
-// Auth routes can be the first thing to touch the database, before any
-// Beignet provider boots, so readiness is enforced here too.
-await ensureDatabaseReady(client);
-
-const db = drizzle(client, { schema });
-
-const trustedOrigins = [
-	env.APP_URL,
-	env.BETTER_AUTH_URL,
-	...(env.BETTER_AUTH_TRUSTED_ORIGINS?.split(",")
-		.map((origin) => origin.trim())
-		.filter(Boolean) ?? []),
-];
-
-export const auth = betterAuth({
-	baseURL: env.BETTER_AUTH_URL,
-	secret: env.BETTER_AUTH_SECRET,
-	trustedOrigins: [...new Set(trustedOrigins)],
-	database: drizzleAdapter(db, {
-		provider: "sqlite",
-		schema,
-	}),
-	emailAndPassword: {
-		enabled: true,
-	},
-	user: {
-		changeEmail: {
-			enabled: true,
-		},
-		deleteUser: {
-			enabled: true,
-		},
-	},
-});
 `,
   // API-only scaffold frontend: a minimal layout and landing page that point
   // at the contract-backed API surface, plus a typed client without React

package/src/templates/shared.ts

@@ -1,4 +1,8 @@
-import type { IntegrationName, PackageManager } from "../choices.js";
+import type {
+  DatabaseName,
+  IntegrationName,
+  PackageManager,
+} from "../choices.js";
 
 /**
  * One generated file emitted by the template generator.
@@ -20,6 +24,10 @@ export type TemplateContext = {
    */
   api: boolean;
   integrations: IntegrationName[];
+  /**
+   * Database backing the starter's Drizzle persistence layer.
+   */
+  database: DatabaseName;
 };
 
 export const externalVersions = {
@@ -40,12 +48,93 @@ export const externalVersions = {
   drizzleOrm: "^0.45.2",
   inngest: "^3.0.0",
   libsqlClient: "^0.14.0",
+  mysql2: "^3.12.0",
+  pg: "^8.13.0",
+  pglite: "^0.5.2",
   pino: "^9.7.0",
   resend: "^4.0.1",
+  typesPg: "^8.11.0",
   upstashRateLimit: "^2.0.0",
   upstashRedis: "^1.0.0",
 };
 
+/**
+ * Dialect-specific names used when rendering database-aware templates.
+ */
+export type DatabaseDescriptor = {
+  name: DatabaseName;
+  /** `@beignet/provider-db-drizzle` subpath for this dialect. */
+  subpath: "sqlite" | "postgres" | "mysql";
+  /** Pascal-case dialect token in provider API names, e.g. `createDrizzle${apiToken}UnitOfWork`. */
+  apiToken: "Sqlite" | "Postgres" | "Mysql";
+  /** Drizzle database seam type exported from the provider subpath. */
+  databaseType:
+    | "DrizzleSqliteDatabase"
+    | "DrizzlePostgresDatabase"
+    | "DrizzleMysqlDatabase";
+  /** Provider factory exported from the provider subpath. */
+  providerFactory:
+    | "createDrizzleSqliteProvider"
+    | "createDrizzlePostgresProvider"
+    | "createDrizzleMysqlProvider";
+  /** Provider instance const wired in `server/providers.ts`. */
+  providerInstance:
+    | "drizzleSqliteProvider"
+    | "drizzlePostgresProvider"
+    | "drizzleMysqlProvider";
+  /** Runtime provider name used as the `providerConfig` key. */
+  providerName: "drizzle-sqlite" | "drizzle-postgres" | "drizzle-mysql";
+  /** Connection URL env var read by the provider and app env schema. */
+  urlEnvVar: "SQLITE_DB_URL" | "POSTGRES_DB_URL" | "MYSQL_DB_URL";
+  /** `drizzle.config.ts` dialect string. */
+  drizzleKitDialect: "sqlite" | "postgresql" | "mysql";
+  /** Better Auth drizzle adapter provider string. */
+  betterAuthProvider: "sqlite" | "pg" | "mysql";
+};
+
+const databaseDescriptors: Record<DatabaseName, DatabaseDescriptor> = {
+  sqlite: {
+    name: "sqlite",
+    subpath: "sqlite",
+    apiToken: "Sqlite",
+    databaseType: "DrizzleSqliteDatabase",
+    providerFactory: "createDrizzleSqliteProvider",
+    providerInstance: "drizzleSqliteProvider",
+    providerName: "drizzle-sqlite",
+    urlEnvVar: "SQLITE_DB_URL",
+    drizzleKitDialect: "sqlite",
+    betterAuthProvider: "sqlite",
+  },
+  postgres: {
+    name: "postgres",
+    subpath: "postgres",
+    apiToken: "Postgres",
+    databaseType: "DrizzlePostgresDatabase",
+    providerFactory: "createDrizzlePostgresProvider",
+    providerInstance: "drizzlePostgresProvider",
+    providerName: "drizzle-postgres",
+    urlEnvVar: "POSTGRES_DB_URL",
+    drizzleKitDialect: "postgresql",
+    betterAuthProvider: "pg",
+  },
+  mysql: {
+    name: "mysql",
+    subpath: "mysql",
+    apiToken: "Mysql",
+    databaseType: "DrizzleMysqlDatabase",
+    providerFactory: "createDrizzleMysqlProvider",
+    providerInstance: "drizzleMysqlProvider",
+    providerName: "drizzle-mysql",
+    urlEnvVar: "MYSQL_DB_URL",
+    drizzleKitDialect: "mysql",
+    betterAuthProvider: "mysql",
+  },
+};
+
+export function databaseDescriptor(ctx: TemplateContext): DatabaseDescriptor {
+  return databaseDescriptors[ctx.database];
+}
+
 export function packageRunner(ctx: TemplateContext): string {
   switch (ctx.packageManager) {
     case "npm":