@tatara/cli 0.2.0 → 0.4.0

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/tests/helpers/auth.ts

@@ -1,5 +1,5 @@
 import { auth } from "#core/auth/auth";
-import { newId } from "#core/db/id";
+import { newId } from "@tatara/db";
 // tatara:slot imports
 
 export interface AsUserOptions {

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";

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

@@ -1,13 +1 @@
-import { execFile } from "node:child_process";
-import { resolve } from "node:path";
-import { promisify } from "node:util";
-
-const run = promisify(execFile);
-
-/** Applies prisma/migrations to the database at `url` (`prisma migrate deploy`). */
-export async function migrateDatabase(url: string): Promise<void> {
-	await run(resolve("node_modules/.bin/prisma"), ["migrate", "deploy"], {
-		// tatara-check-ignore env-access: the Prisma CLI needs the full environment
-		env: { ...process.env, DATABASE_URL: url },
-	});
-}
+export { migrateDatabase } from "@tatara/db/prisma";

package/templates/generators/module/files/src/modules/__moduleKebab__/routes/__moduleKebab__.routes.ts

@@ -1,5 +1,5 @@
 import { createRoute } from "@hono/zod-openapi";
-import { jsonContent, success, successSchema } from "#core/http/response";
+import { jsonContent, success, successSchema } from "@tatara/http";
 import { createRouter, defineRoutes } from "#core/http/routes";
 import { __moduleCamel__Status } from "#modules/__moduleKebab__/services/__moduleKebab__.service";
 import { __moduleCamel__StatusSchema } from "#modules/__moduleKebab__/validators/__moduleKebab__.validators";

package/templates/generators/resource/files/src/modules/__moduleKebab__/routes/__nameKebab__.routes.ts

@@ -8,7 +8,7 @@ import {
 	paginationQuerySchema,
 	success,
 	successSchema,
-} from "#core/http/response";
+} from "@tatara/http";
 import { createRouter, defineRoutes } from "#core/http/routes";
 // tatara:slot imports
 import {

package/templates/generators/resource/files+drizzle/src/modules/__moduleKebab__/services/__nameKebab__.service.ts

@@ -1,8 +1,8 @@
 import { count, desc, eq } from "drizzle-orm";
 import { db, type Executor } from "#core/db/client";
-import { newId } from "#core/db/id";
-import { NotFoundError } from "#core/http/errors";
-import type { PaginationQuery } from "#core/http/response";
+import { newId } from "@tatara/db";
+import { NotFoundError } from "@tatara/http";
+import type { PaginationQuery } from "@tatara/http";
 import { __namePluralCamel__ } from "#modules/__moduleKebab__/db/__nameKebab__.schema";
 import type {
 	Create__namePascal__Input,

package/templates/generators/resource/files+prisma/src/modules/__moduleKebab__/services/__nameKebab__.service.ts

@@ -1,7 +1,7 @@
 import { db, type Executor } from "#core/db/client";
-import { newId } from "#core/db/id";
-import { NotFoundError } from "#core/http/errors";
-import type { PaginationQuery } from "#core/http/response";
+import { newId } from "@tatara/db";
+import { NotFoundError } from "@tatara/http";
+import type { PaginationQuery } from "@tatara/http";
 import type {
 	Create__namePascal__Input,
 	__namePascal__,

package/templates/generators/route/files/src/modules/__moduleKebab__/routes/__nameKebab__.routes.ts

@@ -1,5 +1,5 @@
 import { createRoute } from "@hono/zod-openapi";
-import { errorResponses, jsonContent, success, successSchema } from "#core/http/response";
+import { errorResponses, jsonContent, success, successSchema } from "@tatara/http";
 import { createRouter, defineRoutes } from "#core/http/routes";
 // tatara:slot imports
 import {

package/templates/versions.json

@@ -31,5 +31,8 @@
   "@aws-sdk/s3-request-presigner": "3.1152.0",
   "nodemailer": "10.1.1",
   "@types/nodemailer": "8.0.2",
-  "@tatara/core": "0.1.0"
+  "@tatara/core": "0.1.0",
+  "@tatara/http": "0.1.0",
+  "@tatara/db": "0.1.0",
+  "@tatara/testing": "0.1.0"
 }

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

@@ -1,79 +0,0 @@
-import type { ContentfulStatusCode } from "hono/utils/http-status";
-
-export class AppError extends Error {
-	readonly status: ContentfulStatusCode;
-	readonly code: string;
-	readonly details?: unknown;
-	/** True when the message is generic, so the response may replace it with `errors.<code>` in the caller's language. */
-	readonly translatable: boolean;
-
-	constructor(
-		status: ContentfulStatusCode,
-		code: string,
-		message: string,
-		details?: unknown,
-		translatable = false,
-	) {
-		super(message);
-		this.name = new.target.name;
-		this.status = status;
-		this.code = code;
-		this.details = details;
-		this.translatable = translatable;
-	}
-}
-
-export class ValidationError extends AppError {
-	constructor(message?: string, details?: unknown) {
-		super(400, "VALIDATION_ERROR", message ?? "Invalid request", details, message === undefined);
-	}
-}
-
-export class BusinessRuleError extends AppError {
-	constructor(code: string, message: string, details?: unknown) {
-		// codes are specific to the rule, so a translation for the code is never less precise
-		super(400, code, message, details, true);
-	}
-}
-
-export class UnauthorizedError extends AppError {
-	constructor(message?: string) {
-		super(
-			401,
-			"UNAUTHORIZED",
-			message ?? "Authentication required",
-			undefined,
-			message === undefined,
-		);
-	}
-}
-
-export class ForbiddenError extends AppError {
-	constructor(message?: string) {
-		super(
-			403,
-			"FORBIDDEN",
-			message ?? "You do not have permission to do this",
-			undefined,
-			message === undefined,
-		);
-	}
-}
-
-export class NotFoundError extends AppError {
-	constructor(resource?: string) {
-		super(
-			404,
-			"NOT_FOUND",
-			`${resource ?? "Resource"} not found`,
-			undefined,
-			resource === undefined,
-		);
-	}
-}
-
-export class ConflictError extends AppError {
-	constructor(message?: string, details?: unknown) {
-		super(409, "CONFLICT", message ?? "Resource already exists", details, message === undefined);
-	}
-}

package/templates/features/base/files/src/core/http/middleware/error-handler.ts

@@ -1,36 +0,0 @@
-import type { Context } from "hono";
-import { HTTPException } from "hono/http-exception";
-import type { AppEnv } from "#core/http/context";
-import { AppError } from "#core/http/errors";
-// tatara:slot imports
-
-export function errorHandler(err: Error, c: Context<AppEnv>) {
-	if (err instanceof AppError) {
-		let message = err.message;
-		// tatara:slot error-message
-		return c.json(
-			{
-				success: false as const,
-				error: message,
-				code: err.code,
-				...(err.details === undefined ? {} : { details: err.details }),
-			},
-			err.status,
-		);
-	}
-	if (err instanceof HTTPException) {
-		return c.json(
-			{ success: false as const, error: err.message || "Request failed", code: "HTTP_ERROR" },
-			err.status,
-		);
-	}
-	c.get("logger").error({ err }, "unhandled error");
-	return c.json(
-		{ success: false as const, error: "Something went wrong", code: "INTERNAL_ERROR" },
-		500,
-	);
-}
-
-export function notFoundHandler(c: Context<AppEnv>) {
-	return c.json({ success: false as const, error: "Route not found", code: "NOT_FOUND" }, 404);
-}

package/templates/features/base/files/src/core/http/middleware/request-context.ts

@@ -1,24 +0,0 @@
-import { createMiddleware } from "hono/factory";
-import type { AppEnv } from "#core/http/context";
-import { logger } from "#core/logging/logger";
-
-const REQUEST_ID = /^[\w-]{8,128}$/;
-
-/** Sets requestId, a request-scoped logger and defaults; logs one line per request. */
-export const requestContext = createMiddleware<AppEnv>(async (c, next) => {
-	const incoming = c.req.header("x-request-id");
-	const requestId = incoming && REQUEST_ID.test(incoming) ? incoming : crypto.randomUUID();
-	const log = logger.child({ requestId });
-	c.set("requestId", requestId);
-	c.set("logger", log);
-	c.set("principal", null);
-	c.set("language", "en");
-	c.header("x-request-id", requestId);
-	const start = performance.now();
-	await next();
-	const ms = Math.round(performance.now() - start);
-	const status = c.res.status;
-	const entry = { method: c.req.method, path: c.req.path, status, ms };
-	if (status >= 500) log.error(entry, "request failed");
-	else log.info(entry, "request");
-});

package/templates/features/base/files/src/core/http/middleware/validation.ts

@@ -1,17 +0,0 @@
-import type { Hook } from "@hono/zod-openapi";
-import type { AppEnv } from "#core/http/context";
-import { ValidationError } from "#core/http/errors";
-
-// biome-ignore lint/suspicious/noExplicitAny: the hook is shared by every route schema
-export const validationHook: Hook<any, AppEnv, any, any> = (result) => {
-	if (!result.success) {
-		throw new ValidationError(
-			undefined,
-			result.error.issues.map((issue) => ({
-				path: issue.path.join("."),
-				message: issue.message,
-				code: issue.code,
-			})),
-		);
-	}
-};

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

@@ -1,72 +0,0 @@
-import { z } from "@hono/zod-openapi";
-
-export const errorSchema = z
-	.object({
-		success: z.literal(false),
-		error: z.string(),
-		code: z.string(),
-		details: z.unknown().optional(),
-	})
-	.openapi("Error");
-
-export const paginationMetaSchema = z
-	.object({
-		page: z.number().int(),
-		pageSize: z.number().int(),
-		total: z.number().int(),
-		totalPages: z.number().int(),
-	})
-	.openapi("PaginationMeta");
-
-export const paginationQuerySchema = z.object({
-	page: z.coerce.number().int().min(1).default(1),
-	pageSize: z.coerce.number().int().min(1).max(100).default(20),
-});
-
-export type PaginationQuery = z.infer<typeof paginationQuerySchema>;
-
-export function successSchema<T extends z.ZodType>(data: T) {
-	return z.object({ success: z.literal(true), data });
-}
-
-export function paginatedSchema<T extends z.ZodType>(item: T) {
-	return z.object({ success: z.literal(true), data: z.array(item), meta: paginationMetaSchema });
-}
-
-export function success<T>(data: T) {
-	return { success: true as const, data };
-}
-
-export function paginated<T>(data: T[], page: number, pageSize: number, total: number) {
-	return {
-		success: true as const,
-		data,
-		meta: { page, pageSize, total, totalPages: Math.max(1, Math.ceil(total / pageSize)) },
-	};
-}
-
-export function jsonContent<T extends z.ZodType>(schema: T, description: string) {
-	return { content: { "application/json": { schema } }, description };
-}
-
-/** A required JSON request body. Without `required`, a request with no body skips validation. */
-export function jsonBody<T extends z.ZodType>(schema: T, description: string) {
-	return { ...jsonContent(schema, description), required: true };
-}
-
-const ERROR_DESCRIPTIONS = {
-	400: "Invalid request",
-	401: "Authentication required",
-	403: "Forbidden",
-	404: "Not found",
-	409: "Conflict",
-} as const;
-
-type ErrorStatus = keyof typeof ERROR_DESCRIPTIONS;
-
-/** OpenAPI error responses for the given statuses, all using the shared error envelope. */
-export function errorResponses<const S extends ErrorStatus[]>(...statuses: S) {
-	return Object.fromEntries(
-		statuses.map((status) => [status, jsonContent(errorSchema, ERROR_DESCRIPTIONS[status])]),
-	) as { [K in S[number]]: ReturnType<typeof jsonContent<typeof errorSchema>> };
-}