@tatara/cli 0.3.0 → 0.5.0

package/templates/features/auth-keycloak/files/src/core/auth/keycloak.ts

@@ -1,58 +1,9 @@
-import { createRemoteJWKSet, type JWTPayload, type JWTVerifyGetKey, jwtVerify } from "jose";
+import { keycloakVerifier } from "@tatara/keycloak";
 import { env } from "#core/config/env";
 
-export const issuer = `${env.KEYCLOAK_URL.replace(/\/$/, "")}/realms/${env.KEYCLOAK_REALM}`;
-
-let keySource: JWTVerifyGetKey = createRemoteJWKSet(
-	new URL(`${issuer}/protocol/openid-connect/certs`),
-);
-
-/** Tests replace the realm's key set with a local one. */
-export function setKeySource(source: JWTVerifyGetKey): void {
-	keySource = source;
-}
-
-export interface KeycloakClaims extends JWTPayload {
-	sub: string;
-	email?: string;
-	name?: string;
-	preferred_username?: string;
-	azp?: string;
-	roles?: string[];
-	realm_access?: { roles?: string[] };
-	resource_access?: Record<string, { roles?: string[] }>;
-	organization?: string[] | Record<string, unknown>;
-}
-
-/** Verifies signature, issuer, audience and expiry. Throws when the token is not valid. */
-export async function verifyAccessToken(token: string): Promise<KeycloakClaims> {
-	const { payload } = await jwtVerify(token, keySource, {
-		issuer,
-		audience: env.KEYCLOAK_AUDIENCE,
-	});
-	if (typeof payload.sub !== "string") throw new Error("token has no subject");
-	return payload as KeycloakClaims;
-}
-
-export function rolesOf(claims: KeycloakClaims): string[] {
-	const roles = new Set<string>([
-		...(claims.roles ?? []),
-		...(claims.realm_access?.roles ?? []),
-		...(claims.resource_access?.[env.KEYCLOAK_AUDIENCE]?.roles ?? []),
-	]);
-	return [...roles];
-}
-
-/** Keycloak organizations put memberships in the `organization` claim; the first one wins. */
-export function organizationOf(claims: KeycloakClaims): string | null {
-	const org = claims.organization;
-	if (Array.isArray(org)) return org[0] ?? null;
-	if (org && typeof org === "object") {
-		const [first] = Object.entries(org);
-		if (!first) return null;
-		const [alias, value] = first;
-		const id = (value as { id?: unknown } | undefined)?.id;
-		return typeof id === "string" ? id : alias;
-	}
-	return null;
-}
+/** Verifies access tokens from the realm; `keycloakTokens()` in auth.ts uses it. */
+export const keycloak = keycloakVerifier({
+	url: env.KEYCLOAK_URL,
+	realm: env.KEYCLOAK_REALM,
+	audience: env.KEYCLOAK_AUDIENCE,
+});

package/templates/features/auth-keycloak/files/src/core/auth/tests/keycloak-tokens.test.ts

@@ -1,9 +1,9 @@
 import { generateKeyPair, SignJWT } from "jose";
 import { beforeEach, describe, expect, it } from "vitest";
 import { auth } from "#core/auth/auth";
-import { issuer } from "#core/auth/keycloak";
+import { keycloak } from "#core/auth/keycloak";
 import { env } from "#core/config/env";
-import { newId } from "#core/db/id";
+import { newId } from "@tatara/db";
 import { api } from "#tests/helpers/api";
 import { createTestUser, keycloakToken } from "#tests/helpers/auth";
 import { resetDatabase } from "#tests/helpers/db";
@@ -63,7 +63,7 @@ describe("Keycloak access tokens", () => {
 		const forged = await new SignJWT({ roles: ["admin"] })
 			.setProtectedHeader({ alg: "RS256", kid: "test" })
 			.setSubject(newId())
-			.setIssuer(issuer)
+			.setIssuer(keycloak.issuer)
 			.setAudience(env.KEYCLOAK_AUDIENCE)
 			.setExpirationTime("5m")
 			.sign(privateKey);

package/templates/features/auth-keycloak/files+auth-orgs/src/core/auth/tests/keycloak-organizations.test.ts

@@ -1,6 +1,6 @@
 import { beforeEach, describe, expect, it } from "vitest";
 import { auth } from "#core/auth/auth";
-import { newId } from "#core/db/id";
+import { newId } from "@tatara/db";
 import { api } from "#tests/helpers/api";
 import { keycloakToken } from "#tests/helpers/auth";
 import { resetDatabase } from "#tests/helpers/db";

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

@@ -1,5 +1,5 @@
 import { syncSystemRoles } from "#core/authz/services/sync";
-import { defineSeed } from "#core/db/seed";
+import { defineSeed } from "@tatara/db";
 
 export default defineSeed({
 	name: "authz:system-roles",

package/templates/features/authz/files/src/core/authz/routes/authorization.routes.ts

@@ -1,5 +1,5 @@
 import { createRoute, z } from "@hono/zod-openapi";
-import { currentPrincipal, requireAuth } from "#core/auth/middleware";
+import { currentPrincipal, requireAuth } from "@tatara/auth";
 import { requirePermission } from "#core/authz/middleware";
 import { effectivePermissions, orgOf } from "#core/authz/resolver";
 import { listAudit } from "#core/authz/services/audit";

package/templates/features/authz/files+drizzle/src/core/authz/db/store.ts

@@ -10,7 +10,7 @@ import {
 } from "#core/authz/db/authz.schema";
 import type { AuthzStore, OverlayRow, PermissionGrant, RoleRow } from "#core/authz/types";
 import { db } from "#core/db/client";
-import { newId } from "#core/db/id";
+import { newId } from "@tatara/db";
 
 const toScope = (scope: string): Scope | null => (scope === "" ? null : (scope as Scope));
 

package/templates/features/authz/files+prisma/src/core/authz/db/store.ts

@@ -2,7 +2,7 @@ import type { OverlayEffect, Scope } from "#core/authz/constants";
 import { SYSTEM_ORG_ID } from "#core/authz/constants";
 import type { AuthzStore, OverlayRow, PermissionGrant, RoleRow } from "#core/authz/types";
 import { db } from "#core/db/client";
-import { newId } from "#core/db/id";
+import { newId } from "@tatara/db";
 
 const toScope = (scope: string): Scope | null => (scope === "" ? null : (scope as Scope));
 

package/templates/features/base/files/src/core/http/app.ts

@@ -29,16 +29,10 @@ export function createHttpApp(name: AppName, options: { title: string }) {
 	mountRoutes(app, routes, { app: name, prefix: API_PREFIX });
 	serveOpenApi(app, {
 		title: options.title,
-		async extend(document) {
-			// tatara:slot openapi
-		},
+		// tatara:slot openapi-options
 	});
 	handleErrors(app, {
-		message(err, c) {
-			let message = err.message;
-			// tatara:slot error-message
-			return message;
-		},
+		// tatara:slot error-options
 	});
 	return app;
 }

package/templates/features/base/files/tests/helpers/api.ts

@@ -1,53 +1,9 @@
+import { client } from "@tatara/testing";
 import { app as apiApp } from "#apps/api/app";
 // tatara:slot imports
 
-type HttpApp = { request: (path: string, init?: RequestInit) => Response | Promise<Response> };
-
-export interface ApiResponse<T = unknown> {
-	status: number;
-	headers: Headers;
-	body: T;
-}
-
-export interface RequestOptions {
-	headers?: Record<string, string>;
-}
-
-async function send<T>(
-	target: HttpApp,
-	method: string,
-	path: string,
-	body: unknown,
-	options: RequestOptions = {},
-): Promise<ApiResponse<T>> {
-	const headers: Record<string, string> = { ...options.headers };
-	if (body !== undefined) headers["content-type"] = "application/json";
-	const res = await target.request(path, {
-		method,
-		headers,
-		body: body === undefined ? undefined : JSON.stringify(body),
-	});
-	const text = await res.text();
-	let parsed: unknown = text;
-	try {
-		parsed = text ? JSON.parse(text) : null;
-	} catch {}
-	return { status: res.status, headers: res.headers, body: parsed as T };
-}
-
-export function client(target: HttpApp) {
-	return {
-		get: <T = unknown>(path: string, o?: RequestOptions) => send<T>(target, "GET", path, undefined, o),
-		post: <T = unknown>(path: string, body?: unknown, o?: RequestOptions) =>
-			send<T>(target, "POST", path, body, o),
-		put: <T = unknown>(path: string, body?: unknown, o?: RequestOptions) =>
-			send<T>(target, "PUT", path, body, o),
-		patch: <T = unknown>(path: string, body?: unknown, o?: RequestOptions) =>
-			send<T>(target, "PATCH", path, body, o),
-		delete: <T = unknown>(path: string, o?: RequestOptions) =>
-			send<T>(target, "DELETE", path, undefined, o),
-	};
-}
+export type { ApiResponse, RequestOptions } from "@tatara/testing";
+export { client };
 
 /** Calls the api app in-process (no network). */
 export const api = client(apiApp);

package/templates/features/better-auth/files/src/core/auth/auth.ts

@@ -2,7 +2,7 @@ import { betterAuth } from "better-auth";
 import { bearer, openAPI } from "better-auth/plugins";
 import { database } from "#core/auth/adapter";
 import { env } from "#core/config/env";
-import { newId } from "#core/db/id";
+import { newId } from "@tatara/db";
 // tatara:slot imports
 
 export const auth = betterAuth({

package/templates/features/better-auth/files/src/core/auth/db/seed.ts

@@ -1,6 +1,6 @@
 import { auth } from "#core/auth/auth";
 import { env } from "#core/config/env";
-import { defineSeed } from "#core/db/seed";
+import { defineSeed } from "@tatara/db";
 
 /** Development admin account (never created in production). */
 export default defineSeed({

package/templates/features/better-auth/files/src/core/auth/delivery.ts

@@ -1,36 +1,12 @@
+import { createOutbox } from "@tatara/auth";
 import { smsSender } from "#core/auth/sms";
 import { env } from "#core/config/env";
 // tatara:slot imports
 
-export interface OutboxMessage {
-	channel: "email" | "sms";
-	to: string;
-	subject?: string;
-	text: string;
-	/** one-time code, when the message carries one */
-	code?: string;
-	sentAt: string;
-}
-
-const outbox: OutboxMessage[] = [];
-
 /** Only with DEV_OUTBOX=true in development or test: the outbox exposes sign-in codes. */
-export function outboxEnabled(): boolean {
-	return env.DEV_OUTBOX && (env.NODE_ENV === "development" || env.NODE_ENV === "test");
-}
-
-/** Messages are kept here so tests and local sign-in can read codes. */
-function record(message: Omit<OutboxMessage, "sentAt">) {
-	if (!outboxEnabled()) return;
-	outbox.push({ ...message, sentAt: new Date().toISOString() });
-	if (outbox.length > 200) outbox.shift();
-}
-
-/** Newest first. Empty unless the outbox is enabled. */
-export function readOutbox(to?: string): OutboxMessage[] {
-	if (!outboxEnabled()) return [];
-	return outbox.filter((m) => !to || m.to === to).reverse();
-}
+export const outbox = createOutbox({
+	enabled: env.DEV_OUTBOX && (env.NODE_ENV === "development" || env.NODE_ENV === "test"),
+});
 
 export async function deliverEmail(message: {
 	to: string;
@@ -38,11 +14,11 @@ export async function deliverEmail(message: {
 	text: string;
 	code?: string;
 }): Promise<void> {
-	record({ channel: "email", ...message });
+	outbox.record({ channel: "email", ...message });
 	// tatara:slot email-delivery
 }
 
 export async function deliverSms(message: { to: string; text: string; code?: string }): Promise<void> {
-	record({ channel: "sms", ...message });
+	outbox.record({ channel: "sms", ...message });
 	await smsSender.send(message.to, message.text);
 }

package/templates/features/better-auth/files/src/core/auth/principal.ts

@@ -1,41 +1,10 @@
-import { createMiddleware } from "hono/factory";
+import { principalMiddleware, sessionPrincipal } from "@tatara/auth";
 import { auth } from "#core/auth/auth";
 import type { AppEnv } from "#core/http/context";
+// tatara:slot imports
 
-/**
- * The session's active organization, or null once the user stops being a member of it.
- * better-auth leaves `activeOrganizationId` on the removed member's session.
- */
-async function activeMembership(userId: string, orgId: string | null | undefined) {
-	if (!orgId) return null;
-	const { adapter } = await auth.$context;
-	const member = await adapter.findOne({
-		model: "member",
-		where: [
-			{ field: "organizationId", value: orgId },
-			{ field: "userId", value: userId },
-		],
-	});
-	return member ? orgId : null;
-}
-
-/** Resolves the session (cookie or bearer token) into `c.var.principal`. */
-export const attachPrincipal = createMiddleware<AppEnv>(async (c, next) => {
-	const session = await auth.api.getSession({ headers: c.req.raw.headers });
-	if (session) {
-		const user = session.user as typeof session.user & { role?: string | null };
-		const s = session.session as typeof session.session & { activeOrganizationId?: string | null };
-		c.set("principal", {
-			userId: user.id,
-			orgId: await activeMembership(user.id, s.activeOrganizationId),
-			roles: (user.role ?? "user")
-				.split(",")
-				.map((role) => role.trim())
-				.filter(Boolean),
-			kind: "user",
-			claims: {},
-		});
-	}
-	// tatara:slot no-session
-	await next();
-});
+/** Sets `c.var.principal` from the first resolver that recognises the request's credentials. */
+export const attachPrincipal = principalMiddleware<AppEnv>([
+	(c) => sessionPrincipal(auth, c.req.raw.headers),
+	// tatara:slot resolvers
+]);

package/templates/features/better-auth/files/src/core/auth/sms.ts

@@ -1,14 +1,5 @@
+import { consoleSmsSender, type SmsSender } from "@tatara/auth";
 import { logger } from "#core/logging/logger";
 
-/** Implement this for your SMS provider and return it from `smsSender`. */
-export interface SmsSender {
-	send(to: string, text: string): Promise<void>;
-}
-
-const consoleSender: SmsSender = {
-	async send(to) {
-		logger.info({ to }, "sms not sent: no SMS provider configured (see src/core/auth/sms.ts)");
-	},
-};
-
-export const smsSender: SmsSender = consoleSender;
+/** Logs instead of sending. Replace with an SmsSender for your provider. */
+export const smsSender: SmsSender = consoleSmsSender(logger);

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

@@ -1,5 +1,5 @@
+import { createTestUser as createUser, sessionHeaders } from "@tatara/auth/testing";
 import { auth } from "#core/auth/auth";
-import { newId } from "#core/db/id";
 // tatara:slot imports
 
 export interface AsUserOptions {
@@ -12,14 +12,13 @@ export interface AsUserOptions {
 
 /** 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;
+	return createUser(auth, {
+		email: options.email,
+		name: options.name,
+		fields: {
+			// tatara:slot user-fields
+		},
+	});
 }
 
 /** A new user with a real session; the token is sent as a bearer token. */
@@ -28,9 +27,7 @@ export async function authenticate(
 ): Promise<{ userId: string; headers: Record<string, string> }> {
 	// tatara:slot authenticate
 	const userId = await createTestUser(options);
-	const ctx = await auth.$context;
-	const session = await ctx.internalAdapter.createSession(userId);
-	return { userId, headers: { authorization: `Bearer ${session.token}` } };
+	return { userId, headers: await sessionHeaders(auth, userId) };
 }
 
 /** Headers that authenticate as a new user. */

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

@@ -1,27 +1,15 @@
 import { existsSync, readFileSync } from "node:fs";
 import { parseEnv } from "node:util";
+import { prepareTestDatabases } from "@tatara/testing";
 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)}`,
-		);
-	}
+	const baseUrl = process.env.DATABASE_URL ?? fileEnv.DATABASE_URL;
+	if (!baseUrl) throw new Error("DATABASE_URL is not set for tests (.env.test)");
+	await prepareTestDatabases({ baseUrl, ensureDatabase, migrateDatabase });
 }

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

@@ -1,53 +1,2 @@
-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;`,
-		);
-	});
-}
+// This app uses MySQL through mysql2.
+export { dropAllTables, ensureDatabase, truncateAllTables } from "@tatara/db/mysql2";

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

@@ -1,78 +1,7 @@
-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;`,
-		);
-	});
-}
+// This app uses MySQL through the mariadb driver (Prisma adapter).
+export {
+	connectionConfig,
+	dropAllTables,
+	ensureDatabase,
+	truncateAllTables,
+} from "@tatara/db/mariadb";

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

@@ -1,50 +1,2 @@
-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`,
-			);
-		}
-	});
-}
+// This app uses PostgreSQL through node-postgres.
+export { dropAllTables, ensureDatabase, truncateAllTables } from "@tatara/db/postgres";

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

@@ -1,13 +1 @@
-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();
-	}
-}
+export { migrateDatabase } from "@tatara/db/drizzle-mysql";

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

@@ -1,13 +1 @@
-import { drizzle } from "drizzle-orm/node-postgres";
-import { migrate } from "drizzle-orm/node-postgres/migrator";
-import pg from "pg";
-
-/** Applies ./drizzle migrations to the database at `url`. */
-export async function migrateDatabase(url: string): Promise<void> {
-	const pool = new pg.Pool({ connectionString: url, max: 1 });
-	try {
-		await migrate(drizzle({ client: pool }), { migrationsFolder: "drizzle" });
-	} finally {
-		await pool.end();
-	}
-}
+export { migrateDatabase } from "@tatara/db/drizzle-postgres";