@tatara/cli 0.0.0-stage → 0.1.0

package/templates/features/better-auth/files/tests/helpers/auth.ts

@@ -0,0 +1,40 @@
+import { auth } from "#core/auth/auth";
+import { newId } from "#core/db/id";
+// tatara:slot imports
+
+export interface AsUserOptions {
+	email?: string;
+	name?: string;
+	/** user roles (admin plugin); ignored without organizations + roles */
+	roles?: string[];
+	// tatara:slot options
+}
+
+/** Creates a verified user and returns their id. */
+export async function createTestUser(options: AsUserOptions = {}): Promise<string> {
+	const ctx = await auth.$context;
+	const user = await ctx.internalAdapter.createUser({
+		email: options.email ?? `user-${newId()}@example.com`,
+		name: options.name ?? "Test User",
+		emailVerified: true,
+		// tatara:slot user-fields
+	}, { method: "admin" });
+	return user.id;
+}
+
+/** A new user with a real session; the token is sent as a bearer token. */
+export async function authenticate(
+	options: AsUserOptions = {},
+): Promise<{ userId: string; headers: Record<string, string> }> {
+	const userId = await createTestUser(options);
+	const ctx = await auth.$context;
+	const session = await ctx.internalAdapter.createSession(userId);
+	return { userId, headers: { authorization: `Bearer ${session.token}` } };
+}
+
+/** Headers that authenticate as a new user. */
+export async function asUser(options: AsUserOptions = {}): Promise<Record<string, string>> {
+	const user = await authenticate(options);
+	// tatara:slot as-user
+	return user.headers;
+}

package/templates/features/better-auth/files+drizzle+mysql/src/core/auth/adapter.ts

@@ -0,0 +1,15 @@
+import { drizzleAdapter } from "better-auth/adapters/drizzle";
+import * as authSchema from "#core/auth/db/auth.schema";
+import { db } from "#core/db/client";
+// tatara:slot imports
+
+export const database = drizzleAdapter(db, {
+	provider: "mysql",
+	schema: {
+		user: authSchema.users,
+		session: authSchema.sessions,
+		account: authSchema.accounts,
+		verification: authSchema.verifications,
+		// tatara:slot adapter-schema
+	},
+});

package/templates/features/better-auth/files+drizzle+mysql/src/core/auth/db/auth.schema.ts

@@ -0,0 +1,57 @@
+import { boolean, mysqlTable, text, timestamp, varchar } from "drizzle-orm/mysql-core";
+
+const id = () => varchar({ length: 36 });
+const createdAt = () => timestamp({ fsp: 3, mode: "date" }).notNull().defaultNow();
+const updatedAt = () => timestamp({ fsp: 3, mode: "date" }).notNull().defaultNow();
+
+export const users = mysqlTable("users", {
+	id: id().primaryKey(),
+	name: varchar({ length: 255 }).notNull(),
+	email: varchar({ length: 255 }).notNull().unique(),
+	emailVerified: boolean().notNull().default(false),
+	image: text(),
+	// tatara:slot user-fields
+	createdAt: createdAt(),
+	updatedAt: updatedAt(),
+});
+
+export const sessions = mysqlTable("sessions", {
+	id: id().primaryKey(),
+	expiresAt: timestamp({ fsp: 3, mode: "date" }).notNull(),
+	token: varchar({ length: 255 }).notNull().unique(),
+	ipAddress: varchar({ length: 64 }),
+	userAgent: text(),
+	userId: id()
+		.notNull()
+		.references(() => users.id, { onDelete: "cascade" }),
+	// tatara:slot session-fields
+	createdAt: createdAt(),
+	updatedAt: updatedAt(),
+});
+
+export const accounts = mysqlTable("accounts", {
+	id: id().primaryKey(),
+	accountId: varchar({ length: 255 }).notNull(),
+	providerId: varchar({ length: 64 }).notNull(),
+	userId: id()
+		.notNull()
+		.references(() => users.id, { onDelete: "cascade" }),
+	accessToken: text(),
+	refreshToken: text(),
+	idToken: text(),
+	accessTokenExpiresAt: timestamp({ fsp: 3, mode: "date" }),
+	refreshTokenExpiresAt: timestamp({ fsp: 3, mode: "date" }),
+	scope: text(),
+	password: text(),
+	createdAt: createdAt(),
+	updatedAt: updatedAt(),
+});
+
+export const verifications = mysqlTable("verifications", {
+	id: id().primaryKey(),
+	identifier: varchar({ length: 255 }).notNull(),
+	value: text().notNull(),
+	expiresAt: timestamp({ fsp: 3, mode: "date" }).notNull(),
+	createdAt: createdAt(),
+	updatedAt: updatedAt(),
+});

package/templates/features/better-auth/files+drizzle+postgres/src/core/auth/adapter.ts

@@ -0,0 +1,15 @@
+import { drizzleAdapter } from "better-auth/adapters/drizzle";
+import * as authSchema from "#core/auth/db/auth.schema";
+import { db } from "#core/db/client";
+// tatara:slot imports
+
+export const database = drizzleAdapter(db, {
+	provider: "pg",
+	schema: {
+		user: authSchema.users,
+		session: authSchema.sessions,
+		account: authSchema.accounts,
+		verification: authSchema.verifications,
+		// tatara:slot adapter-schema
+	},
+});

package/templates/features/better-auth/files+drizzle+postgres/src/core/auth/db/auth.schema.ts

@@ -0,0 +1,56 @@
+import { boolean, pgTable, text, timestamp } from "drizzle-orm/pg-core";
+
+const createdAt = () => timestamp({ withTimezone: true, mode: "date" }).notNull().defaultNow();
+const updatedAt = () => timestamp({ withTimezone: true, mode: "date" }).notNull().defaultNow();
+
+export const users = pgTable("users", {
+	id: text().primaryKey(),
+	name: text().notNull(),
+	email: text().notNull().unique(),
+	emailVerified: boolean().notNull().default(false),
+	image: text(),
+	// tatara:slot user-fields
+	createdAt: createdAt(),
+	updatedAt: updatedAt(),
+});
+
+export const sessions = pgTable("sessions", {
+	id: text().primaryKey(),
+	expiresAt: timestamp({ withTimezone: true, mode: "date" }).notNull(),
+	token: text().notNull().unique(),
+	ipAddress: text(),
+	userAgent: text(),
+	userId: text()
+		.notNull()
+		.references(() => users.id, { onDelete: "cascade" }),
+	// tatara:slot session-fields
+	createdAt: createdAt(),
+	updatedAt: updatedAt(),
+});
+
+export const accounts = pgTable("accounts", {
+	id: text().primaryKey(),
+	accountId: text().notNull(),
+	providerId: text().notNull(),
+	userId: text()
+		.notNull()
+		.references(() => users.id, { onDelete: "cascade" }),
+	accessToken: text(),
+	refreshToken: text(),
+	idToken: text(),
+	accessTokenExpiresAt: timestamp({ withTimezone: true, mode: "date" }),
+	refreshTokenExpiresAt: timestamp({ withTimezone: true, mode: "date" }),
+	scope: text(),
+	password: text(),
+	createdAt: createdAt(),
+	updatedAt: updatedAt(),
+});
+
+export const verifications = pgTable("verifications", {
+	id: text().primaryKey(),
+	identifier: text().notNull(),
+	value: text().notNull(),
+	expiresAt: timestamp({ withTimezone: true, mode: "date" }).notNull(),
+	createdAt: createdAt(),
+	updatedAt: updatedAt(),
+});

package/templates/features/better-auth/files+prisma/prisma/models/auth.prisma

@@ -0,0 +1,62 @@
+// better-auth tables. Field names are what better-auth expects; columns are snake_case.
+
+model User {
+  id            String    @id @db.VarChar(36)
+  name          String    @db.VarChar(255)
+  email         String    @unique @db.VarChar(255)
+  emailVerified Boolean   @default(false) @map("email_verified")
+  image         String?   @db.Text
+  // tatara:slot user-fields
+  createdAt     DateTime  @default(now()) @map("created_at")
+  updatedAt     DateTime  @default(now()) @updatedAt @map("updated_at")
+  sessions      Session[]
+  accounts      Account[]
+  // tatara:slot user-relations
+
+  @@map("users")
+}
+
+model Session {
+  id        String   @id @db.VarChar(36)
+  expiresAt DateTime @map("expires_at")
+  token     String   @unique @db.VarChar(255)
+  ipAddress String?  @map("ip_address") @db.VarChar(64)
+  userAgent String?  @map("user_agent") @db.Text
+  userId    String   @map("user_id") @db.VarChar(36)
+  user      User     @relation(fields: [userId], references: [id], onDelete: Cascade)
+  // tatara:slot session-fields
+  createdAt DateTime @default(now()) @map("created_at")
+  updatedAt DateTime @default(now()) @updatedAt @map("updated_at")
+
+  @@map("sessions")
+}
+
+model Account {
+  id                    String    @id @db.VarChar(36)
+  accountId             String    @map("account_id") @db.VarChar(255)
+  providerId            String    @map("provider_id") @db.VarChar(64)
+  userId                String    @map("user_id") @db.VarChar(36)
+  user                  User      @relation(fields: [userId], references: [id], onDelete: Cascade)
+  accessToken           String?   @map("access_token") @db.Text
+  refreshToken          String?   @map("refresh_token") @db.Text
+  idToken               String?   @map("id_token") @db.Text
+  accessTokenExpiresAt  DateTime? @map("access_token_expires_at")
+  refreshTokenExpiresAt DateTime? @map("refresh_token_expires_at")
+  scope                 String?   @db.Text
+  password              String?   @db.Text
+  createdAt             DateTime  @default(now()) @map("created_at")
+  updatedAt             DateTime  @default(now()) @updatedAt @map("updated_at")
+
+  @@map("accounts")
+}
+
+model Verification {
+  id         String   @id @db.VarChar(36)
+  identifier String   @db.VarChar(255)
+  value      String   @db.Text
+  expiresAt  DateTime @map("expires_at")
+  createdAt  DateTime @default(now()) @map("created_at")
+  updatedAt  DateTime @default(now()) @updatedAt @map("updated_at")
+
+  @@map("verifications")
+}

package/templates/features/better-auth/files+prisma+mysql/src/core/auth/adapter.ts

@@ -0,0 +1,4 @@
+import { prismaAdapter } from "better-auth/adapters/prisma";
+import { db } from "#core/db/client";
+
+export const database = prismaAdapter(db, { provider: "mysql" });

package/templates/features/better-auth/files+prisma+postgres/src/core/auth/adapter.ts

@@ -0,0 +1,4 @@
+import { prismaAdapter } from "better-auth/adapters/prisma";
+import { db } from "#core/db/client";
+
+export const database = prismaAdapter(db, { provider: "postgresql" });

package/templates/features/db/files/src/core/db/commands/migrate.ts

@@ -0,0 +1,12 @@
+import { defineCommand } from "#core/commands/define";
+import { env } from "#core/config/env";
+import { migrateDatabase } from "#core/db/migrate";
+
+export default defineCommand({
+	name: "db:migrate",
+	description: "Apply pending database migrations",
+	async run(_args, { logger }) {
+		await migrateDatabase(env.DATABASE_URL);
+		logger.info("migrations applied");
+	},
+});

package/templates/features/db/files/src/core/db/commands/reset.ts

@@ -0,0 +1,19 @@
+import { z } from "zod";
+import { defineCommand } from "#core/commands/define";
+import { env } from "#core/config/env";
+import { dropAllTables } from "#core/db/admin";
+import { migrateDatabase } from "#core/db/migrate";
+
+export default defineCommand({
+	name: "db:reset",
+	description: "Drop every table and re-apply migrations (refuses to run in production)",
+	args: z.object({ force: z.coerce.boolean().default(false) }),
+	async run({ force }, { logger }) {
+		if (env.NODE_ENV === "production" && !force) {
+			throw new Error("db:reset refuses to run with NODE_ENV=production (pass --force to override)");
+		}
+		await dropAllTables(env.DATABASE_URL);
+		await migrateDatabase(env.DATABASE_URL);
+		logger.info("database reset");
+	},
+});

package/templates/features/db/files/src/core/db/commands/seed.ts

@@ -0,0 +1,13 @@
+import { defineCommand } from "#core/commands/define";
+import { seeds } from "#generated/seeds";
+
+export default defineCommand({
+	name: "db:seed",
+	description: "Run every idempotent seed (core first, then modules)",
+	async run(_args, { logger }) {
+		for (const seed of [...seeds].sort((a, b) => (a.order ?? 100) - (b.order ?? 100))) {
+			await seed.run({ logger: logger.child({ seed: seed.name }) });
+			logger.info({ seed: seed.name }, "seeded");
+		}
+	},
+});

package/templates/features/db/files/src/core/db/id.ts

@@ -0,0 +1,13 @@
+import { randomFillSync } from "node:crypto";
+
+/** UUIDv7: random but time-ordered, so sorting by id is sorting by creation time. */
+export function newId(): string {
+	const bytes = new Uint8Array(16);
+	randomFillSync(bytes);
+	const ms = BigInt(Date.now());
+	for (let i = 0; i < 6; i++) bytes[i] = Number((ms >> BigInt(8 * (5 - i))) & 0xffn);
+	bytes[6] = ((bytes[6] ?? 0) & 0x0f) | 0x70;
+	bytes[8] = ((bytes[8] ?? 0) & 0x3f) | 0x80;
+	const hex = [...bytes].map((b) => b.toString(16).padStart(2, "0")).join("");
+	return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}

package/templates/features/db/files/src/core/db/seed.ts

@@ -0,0 +1,14 @@
+import type { Logger } from "#core/logging/logger";
+
+export interface SeedDefinition {
+	name: string;
+	/** lower runs first */
+	order?: number;
+	/** must be idempotent: seeds run on every `tatara dev` */
+	run(ctx: { logger: Logger }): Promise<void>;
+}
+
+/** Default export of every `db/seed.ts`; discovered by `tatara sync`. */
+export function defineSeed(definition: SeedDefinition): SeedDefinition {
+	return definition;
+}

package/templates/features/db/files/tests/global-setup.ts

@@ -0,0 +1,27 @@
+import { existsSync, readFileSync } from "node:fs";
+import { parseEnv } from "node:util";
+import { ensureDatabase } from "#core/db/admin";
+import { migrateDatabase } from "#core/db/migrate";
+import { TEST_WORKERS, workerDatabaseUrl } from "#tests/helpers/database-url";
+
+/** Creates and migrates one database per test worker, once per run. */
+export default async function setup() {
+	const fileEnv = existsSync(".env.test")
+		? (parseEnv(readFileSync(".env.test", "utf8")) as Record<string, string>)
+		: {};
+	const base = process.env.DATABASE_URL ?? fileEnv.DATABASE_URL;
+	if (!base) throw new Error("DATABASE_URL is not set for tests (.env.test)");
+	try {
+		await Promise.all(
+			Array.from({ length: TEST_WORKERS }, async (_, i) => {
+				const url = workerDatabaseUrl(base, i + 1);
+				await ensureDatabase(url);
+				await migrateDatabase(url);
+			}),
+		);
+	} catch (error) {
+		throw new Error(
+			`Could not prepare the test databases. Is the database running? (\`docker compose up -d --wait\`)\n${String(error)}`,
+		);
+	}
+}

package/templates/features/db/files/tests/helpers/database-url.ts

@@ -0,0 +1,9 @@
+/** Number of Vitest workers; global setup prepares one database per worker. */
+export const TEST_WORKERS = 4;
+
+/** postgres://…/app_test → postgres://…/app_test_<worker> */
+export function workerDatabaseUrl(baseUrl: string, worker: number | string): string {
+	const url = new URL(baseUrl);
+	url.pathname = `${url.pathname}_${worker}`;
+	return url.toString();
+}

package/templates/features/db/files/tests/helpers/db.ts

@@ -0,0 +1,7 @@
+import { env } from "#core/config/env";
+import { truncateAllTables } from "#core/db/admin";
+
+/** Empties every application table in this worker's test database. Use in beforeEach. */
+export async function resetDatabase(): Promise<void> {
+	await truncateAllTables(env.DATABASE_URL);
+}

package/templates/features/db/files+mysql+drizzle/src/core/db/admin.ts

@@ -0,0 +1,53 @@
+import mysql from "mysql2/promise";
+
+const MIGRATION_TABLES = ["__drizzle_migrations", "_prisma_migrations"];
+
+function databaseName(url: string): string {
+	return decodeURIComponent(new URL(url).pathname.slice(1));
+}
+
+async function withConnection<T>(url: string, fn: (c: mysql.Connection) => Promise<T>): Promise<T> {
+	const connection = await mysql.createConnection({ uri: url, multipleStatements: true });
+	try {
+		return await fn(connection);
+	} finally {
+		await connection.end();
+	}
+}
+
+/** Creates the database named in `url` if it does not exist. */
+export async function ensureDatabase(url: string): Promise<void> {
+	const name = databaseName(url);
+	const server = new URL(url);
+	server.pathname = "/";
+	await withConnection(server.toString(), async (c) => {
+		await c.query(`create database if not exists \`${name.replaceAll("`", "``")}\``);
+	});
+}
+
+async function tables(c: mysql.Connection): Promise<string[]> {
+	const [rows] = await c.query<mysql.RowDataPacket[]>(
+		"select table_name as name from information_schema.tables where table_schema = database() and table_type = 'BASE TABLE'",
+	);
+	return rows.map((r) => String(r.name));
+}
+
+export async function dropAllTables(url: string): Promise<void> {
+	await withConnection(url, async (c) => {
+		const names = await tables(c);
+		if (names.length === 0) return;
+		await c.query(
+			`set foreign_key_checks = 0; drop table ${names.map((t) => `\`${t}\``).join(", ")}; set foreign_key_checks = 1;`,
+		);
+	});
+}
+
+export async function truncateAllTables(url: string): Promise<void> {
+	await withConnection(url, async (c) => {
+		const names = (await tables(c)).filter((t) => !MIGRATION_TABLES.includes(t));
+		if (names.length === 0) return;
+		await c.query(
+			`set foreign_key_checks = 0; ${names.map((t) => `truncate table \`${t}\`;`).join(" ")} set foreign_key_checks = 1;`,
+		);
+	});
+}

package/templates/features/db/files+mysql+prisma/src/core/db/admin.ts

@@ -0,0 +1,78 @@
+import * as mariadb from "mariadb";
+
+const MIGRATION_TABLES = ["__drizzle_migrations", "_prisma_migrations"];
+
+const LOCAL_HOSTS = new Set(["localhost", "127.0.0.1", "::1", "[::1]"]);
+
+/**
+ * mariadb connection options from a mysql:// URL. Public-key retrieval (needed by MySQL's
+ * caching_sha2_password without TLS) is only enabled for local hosts or when the URL asks
+ * for it; use `?ssl=true` for remote databases.
+ */
+export function connectionConfig(url: string): mariadb.ConnectionConfig {
+	const u = new URL(url);
+	const param = (name: string) => u.searchParams.get(name);
+	return {
+		host: u.hostname,
+		port: Number(u.port || 3306),
+		user: decodeURIComponent(u.username),
+		password: decodeURIComponent(u.password),
+		database: decodeURIComponent(u.pathname.slice(1)) || undefined,
+		allowPublicKeyRetrieval:
+			param("allowPublicKeyRetrieval") === "true" || LOCAL_HOSTS.has(u.hostname),
+		...(param("ssl") === "true" ? { ssl: { rejectUnauthorized: true } } : {}),
+	};
+}
+
+const adminConfig = (url: string): mariadb.ConnectionConfig => ({
+	...connectionConfig(url),
+	multipleStatements: true,
+});
+
+async function withConnection<T>(
+	config: mariadb.ConnectionConfig,
+	fn: (c: mariadb.Connection) => Promise<T>,
+): Promise<T> {
+	const connection = await mariadb.createConnection(config);
+	try {
+		return await fn(connection);
+	} finally {
+		await connection.end();
+	}
+}
+
+/** Creates the database named in `url` if it does not exist. */
+export async function ensureDatabase(url: string): Promise<void> {
+	const config = adminConfig(url);
+	const name = String(config.database);
+	await withConnection({ ...config, database: undefined }, async (c) => {
+		await c.query(`create database if not exists \`${name.replaceAll("`", "``")}\``);
+	});
+}
+
+async function tables(c: mariadb.Connection): Promise<string[]> {
+	const rows: { name: string }[] = await c.query(
+		"select table_name as name from information_schema.tables where table_schema = database() and table_type = 'BASE TABLE'",
+	);
+	return rows.map((r) => String(r.name));
+}
+
+export async function dropAllTables(url: string): Promise<void> {
+	await withConnection(adminConfig(url), async (c) => {
+		const names = await tables(c);
+		if (names.length === 0) return;
+		await c.query(
+			`set foreign_key_checks = 0; drop table ${names.map((t) => `\`${t}\``).join(", ")}; set foreign_key_checks = 1;`,
+		);
+	});
+}
+
+export async function truncateAllTables(url: string): Promise<void> {
+	await withConnection(adminConfig(url), async (c) => {
+		const names = (await tables(c)).filter((t) => !MIGRATION_TABLES.includes(t));
+		if (names.length === 0) return;
+		await c.query(
+			`set foreign_key_checks = 0; ${names.map((t) => `truncate table \`${t}\`;`).join(" ")} set foreign_key_checks = 1;`,
+		);
+	});
+}

package/templates/features/db/files+postgres/src/core/db/admin.ts

@@ -0,0 +1,50 @@
+import pg from "pg";
+
+const MIGRATION_TABLES = ["__drizzle_migrations", "_prisma_migrations"];
+
+function databaseName(url: string): string {
+	return decodeURIComponent(new URL(url).pathname.slice(1));
+}
+
+async function withClient<T>(url: string, fn: (client: pg.Client) => Promise<T>): Promise<T> {
+	const client = new pg.Client({ connectionString: url });
+	await client.connect();
+	try {
+		return await fn(client);
+	} finally {
+		await client.end();
+	}
+}
+
+/** Creates the database named in `url` if it does not exist. */
+export async function ensureDatabase(url: string): Promise<void> {
+	const name = databaseName(url);
+	const admin = new URL(url);
+	admin.pathname = "/postgres";
+	await withClient(admin.toString(), async (client) => {
+		const found = await client.query("select 1 from pg_database where datname = $1", [name]);
+		if (found.rowCount === 0) await client.query(`create database "${name.replaceAll('"', '""')}"`);
+	});
+}
+
+export async function dropAllTables(url: string): Promise<void> {
+	await withClient(url, async (client) => {
+		await client.query("drop schema if exists drizzle cascade");
+		await client.query("drop schema public cascade");
+		await client.query("create schema public");
+	});
+}
+
+export async function truncateAllTables(url: string): Promise<void> {
+	await withClient(url, async (client) => {
+		const { rows } = await client.query<{ tablename: string }>(
+			"select tablename from pg_tables where schemaname = 'public'",
+		);
+		const tables = rows.map((r) => r.tablename).filter((t) => !MIGRATION_TABLES.includes(t));
+		if (tables.length > 0) {
+			await client.query(
+				`truncate table ${tables.map((t) => `"${t}"`).join(", ")} restart identity cascade`,
+			);
+		}
+	});
+}

package/templates/features/drizzle/files+mysql/drizzle.config.ts

@@ -0,0 +1,12 @@
+import { existsSync } from "node:fs";
+import { defineConfig } from "drizzle-kit";
+
+if (existsSync(".env")) process.loadEnvFile(".env");
+
+export default defineConfig({
+	dialect: "mysql",
+	schema: ["./src/core/*/db/*.schema.ts", "./src/modules/*/db/*.schema.ts"],
+	out: "./drizzle",
+	casing: "snake_case",
+	dbCredentials: { url: process.env.DATABASE_URL ?? "" },
+});

package/templates/features/drizzle/files+mysql/src/core/db/client.ts

@@ -0,0 +1,20 @@
+import { drizzle } from "drizzle-orm/mysql2";
+import mysql from "mysql2/promise";
+import { env } from "#core/config/env";
+import { registerReadinessCheck } from "#core/http/health";
+import { onShutdown } from "#core/process/lifecycle";
+import * as schema from "#generated/schema";
+
+export const pool = mysql.createPool({ uri: env.DATABASE_URL, connectionLimit: env.DATABASE_POOL_MAX });
+
+export const db = drizzle({ client: pool, schema, mode: "default", casing: "snake_case" });
+
+export type Database = typeof db;
+export type Transaction = Parameters<Parameters<Database["transaction"]>[0]>[0];
+/** `db` or an open transaction; services take an Executor so callers can compose them. */
+export type Executor = Database | Transaction;
+
+registerReadinessCheck("database", async () => {
+	await pool.query("select 1");
+});
+onShutdown("database", () => pool.end());

package/templates/features/drizzle/files+mysql/src/core/db/migrate.ts

@@ -0,0 +1,13 @@
+import { drizzle } from "drizzle-orm/mysql2";
+import { migrate } from "drizzle-orm/mysql2/migrator";
+import mysql from "mysql2/promise";
+
+/** Applies ./drizzle migrations to the database at `url`. */
+export async function migrateDatabase(url: string): Promise<void> {
+	const connection = await mysql.createConnection({ uri: url });
+	try {
+		await migrate(drizzle({ client: connection }), { migrationsFolder: "drizzle" });
+	} finally {
+		await connection.end();
+	}
+}

package/templates/features/drizzle/files+postgres/drizzle.config.ts

@@ -0,0 +1,12 @@
+import { existsSync } from "node:fs";
+import { defineConfig } from "drizzle-kit";
+
+if (existsSync(".env")) process.loadEnvFile(".env");
+
+export default defineConfig({
+	dialect: "postgresql",
+	schema: ["./src/core/*/db/*.schema.ts", "./src/modules/*/db/*.schema.ts"],
+	out: "./drizzle",
+	casing: "snake_case",
+	dbCredentials: { url: process.env.DATABASE_URL ?? "" },
+});

package/templates/features/drizzle/files+postgres/src/core/db/client.ts

@@ -0,0 +1,20 @@
+import { drizzle } from "drizzle-orm/node-postgres";
+import pg from "pg";
+import { env } from "#core/config/env";
+import { registerReadinessCheck } from "#core/http/health";
+import { onShutdown } from "#core/process/lifecycle";
+import * as schema from "#generated/schema";
+
+export const pool = new pg.Pool({ connectionString: env.DATABASE_URL, max: env.DATABASE_POOL_MAX });
+
+export const db = drizzle({ client: pool, schema, casing: "snake_case" });
+
+export type Database = typeof db;
+export type Transaction = Parameters<Parameters<Database["transaction"]>[0]>[0];
+/** `db` or an open transaction; services take an Executor so callers can compose them. */
+export type Executor = Database | Transaction;
+
+registerReadinessCheck("database", async () => {
+	await pool.query("select 1");
+});
+onShutdown("database", () => pool.end());