@tatara/cli 0.2.0 → 0.3.0

package/dist/bin.mjs

@@ -1051,12 +1051,12 @@ const i18n = {
 			content: "app.use(detectLanguage);"
 		},
 		{
-			file: "src/core/http/middleware/error-handler.ts",
+			file: "src/core/http/app.ts",
 			slot: "imports",
 			content: "import { t } from \"#core/i18n/index\";"
 		},
 		{
-			file: "src/core/http/middleware/error-handler.ts",
+			file: "src/core/http/app.ts",
 			slot: "error-message",
 			content: "if (err.translatable) message = t(c.get(\"language\"), `errors.${err.code}`, message);"
 		},
@@ -1168,6 +1168,11 @@ const betterAuth = {
 			slot: "imports",
 			content: "import { mergeAuthOpenApi } from \"#core/auth/openapi\";"
 		},
+		{
+			file: "src/core/http/app.ts",
+			slot: "expose-headers",
+			content: "\"set-auth-token\","
+		},
 		{
 			file: "src/core/http/app.ts",
 			slot: "openapi",
@@ -1640,6 +1645,7 @@ const base = {
 	label: "Hono API",
 	dependencies: [
 		"@tatara/core",
+		"@tatara/http",
 		"hono",
 		"@hono/node-server",
 		"@hono/zod-openapi",
@@ -3212,7 +3218,7 @@ function createBaseline(project, deps) {
 //#region src/upgrade/codemods/core-package.ts
 const CORE = "@tatara/core";
 /** Files @tatara/core replaces, with the import specifier apps used for each. */
-const MOVED = {
+const MOVED$1 = {
 	"src/core/commands/define.ts": "#core/commands/define",
 	"src/core/commands/runner.ts": "#core/commands/runner",
 	"src/core/process/lifecycle.ts": "#core/process/lifecycle",
@@ -3247,8 +3253,8 @@ async function rewriteEnv(ctx) {
 }
 /** Only call sites of functions that now come from @tatara/core take the logger argument. */
 async function passLogger(ctx, gone) {
-	const runnerGone = gone.includes(MOVED["src/core/commands/runner.ts"]);
-	const lifecycleGone = gone.includes(MOVED["src/core/process/lifecycle.ts"]);
+	const runnerGone = gone.includes(MOVED$1["src/core/commands/runner.ts"]);
+	const lifecycleGone = gone.includes(MOVED$1["src/core/process/lifecycle.ts"]);
 	const cli = await exists(ctx, CLI_ENTRY);
 	if (cli) {
 		let next = cli;
@@ -3294,17 +3300,14 @@ export const logger = pino(
 export type Logger = typeof logger;
 `);
 }
-//#endregion
-//#region src/upgrade/codemods.ts
-/** Every codemod tatara ships, oldest first. Each step that moves code into a package adds one. */
-const CODEMODS = [{
+const corePackage = {
 	version: "0.2.0",
 	id: "core-package",
 	description: "Use @tatara/core for commands, flags, lifecycle, readiness, logger options and localDefault",
 	async run(ctx) {
 		await ctx.addDependency(CORE, versionOf(CORE));
 		const gone = [];
-		for (const [path, specifier] of Object.entries(MOVED)) if (await ctx.removeIfUnchanged(path) === "kept") ctx.report.notes.push(`${path} is customised; its imports still point at it. Move the change into the app or eject.`);
+		for (const [path, specifier] of Object.entries(MOVED$1)) if (await ctx.removeIfUnchanged(path) === "kept") ctx.report.notes.push(`${path} is customised; its imports still point at it. Move the change into the app or eject.`);
 		else gone.push(specifier);
 		for (const specifier of gone) await ctx.rewriteImports(specifier, CORE);
 		await rewriteEnv(ctx);
@@ -3312,6 +3315,114 @@ const CODEMODS = [{
 		await allowFreshReleases(ctx);
 		await useLoggerOptions(ctx);
 	}
+};
+//#endregion
+//#region src/upgrade/codemods/http-package.ts
+const HTTP = "@tatara/http";
+/** Wiring files the app keeps; replaced by what this CLI generates when the app never changed them. */
+const APP = "src/core/http/app.ts";
+const ROUTES = "src/core/http/routes.ts";
+const SERVERS = ["src/apps/api/server.ts", "src/apps/admin/server.ts"];
+/** Files @tatara/http replaces: import specifier, and the wiring files that import them. */
+const MOVED = [
+	{
+		path: "src/core/http/errors.ts",
+		specifier: "#core/http/errors",
+		usedBy: []
+	},
+	{
+		path: "src/core/http/response.ts",
+		specifier: "#core/http/response",
+		usedBy: []
+	},
+	{
+		path: "src/core/http/middleware/validation.ts",
+		specifier: "#core/http/middleware/validation",
+		usedBy: [APP, ROUTES]
+	},
+	{
+		path: "src/core/http/middleware/error-handler.ts",
+		specifier: "#core/http/middleware/error-handler",
+		usedBy: [APP]
+	},
+	{
+		path: "src/core/http/middleware/request-context.ts",
+		specifier: "#core/http/middleware/request-context",
+		usedBy: [APP]
+	},
+	{
+		path: "src/core/http/server.ts",
+		specifier: "#core/http/server",
+		usedBy: SERVERS
+	}
+];
+async function read(ctx, path) {
+	return ctx.read(path).catch(() => void 0);
+}
+/** Files outside the group that import one of the moved files (they would break). */
+async function outsideImporters(ctx) {
+	const group = /* @__PURE__ */ new Set([
+		APP,
+		ROUTES,
+		...SERVERS,
+		...MOVED.map((m) => m.path)
+	]);
+	const specifiers = MOVED.filter((m) => m.usedBy.length > 0).map((m) => m.specifier);
+	const pattern = new RegExp(`["'](${specifiers.map((s) => s.replace(/[/.]/g, "\\$&")).join("|")})["']`);
+	const out = [];
+	for (const path of await glob(["src/**/*.ts", "tests/**/*.ts"], {
+		cwd: ctx.project.root,
+		ignore: ["src/generated/**"]
+	})) {
+		if (group.has(path)) continue;
+		if (pattern.test(await ctx.read(path))) out.push(path);
+	}
+	return out;
+}
+//#endregion
+//#region src/upgrade/codemods.ts
+/** Every codemod tatara ships, oldest first. Each step that moves code into a package adds one. */
+const CODEMODS = [corePackage, {
+	version: "0.3.0",
+	id: "http-package",
+	description: "Use @tatara/http for app setup, errors, the envelope, OpenAPI docs and the server",
+	async run(ctx) {
+		await ctx.addDependency(HTTP, versionOf(HTTP));
+		const blockers = [];
+		const replace = [];
+		for (const path of [
+			APP,
+			ROUTES,
+			...SERVERS
+		]) {
+			const text = await read(ctx, path);
+			if (text === void 0) continue;
+			if (await ctx.baseline.isUnchanged(path, text)) replace.push(path);
+			else blockers.push(`${path} is customised`);
+		}
+		const present = [];
+		for (const entry of MOVED) {
+			const text = await read(ctx, entry.path);
+			if (text === void 0) continue;
+			present.push(entry);
+			if (!await ctx.baseline.isUnchanged(entry.path, text)) blockers.push(`${entry.path} is customised`);
+		}
+		for (const path of await outsideImporters(ctx)) blockers.push(`${path} imports one of the moved files`);
+		if (blockers.length > 0) {
+			ctx.report.notes.push(`Nothing in src/core/http was changed: ${blockers.join("; ")}. Move these onto @tatara/http (createApp, mountRoutes, serveOpenApi, handleErrors, startServer and its error classes) by hand, then delete the old files.`);
+			return;
+		}
+		for (const path of replace) {
+			const next = await ctx.renderCurrent(path);
+			if (next !== void 0) await ctx.write(path, next);
+		}
+		for (const entry of present) await ctx.removeIfUnchanged(entry.path);
+		for (const specifier of [
+			"#core/http/errors",
+			"#core/http/response",
+			"#core/http/middleware/validation"
+		]) await ctx.rewriteImports(specifier, HTTP);
+	}
 }];
 //#endregion
 //#region src/upgrade/context.ts
@@ -3320,13 +3431,19 @@ function createContext(project, baseline, opts = {}) {
 	const report = {
 		ran: [],
 		written: [],
+		regenerated: [],
 		removed: [],
 		kept: [],
 		notes: []
 	};
 	const abs = (path) => join(project.root, path);
+	let rendered;
 	const write = async (path, text) => {
-		if (!report.written.includes(path)) report.written.push(path);
+		if (!report.written.includes(path)) {
+			report.written.push(path);
+			const before = existsSync(abs(path)) ? await readFile(abs(path), "utf8") : void 0;
+			if (before === void 0 || await baseline.isUnchanged(path, before)) report.regenerated.push(path);
+		}
 		if (opts.dryRun) return;
 		await mkdir(dirname(abs(path)), { recursive: true });
 		await writeFile(abs(path), text);
@@ -3368,6 +3485,19 @@ function createContext(project, baseline, opts = {}) {
 			}
 			return changed;
 		},
+		async renderCurrent(path) {
+			const { name, orm, database, auth, authMethods, addons, packageManager } = project.config;
+			rendered ??= renderApp({
+				name,
+				orm,
+				database,
+				auth,
+				authMethods,
+				addons,
+				packageManager
+			});
+			return (await rendered).get(path);
+		},
 		async addDependency(name, range, { dev = false } = {}) {
 			const pkg = JSON.parse(await readFile(abs("package.json"), "utf8"));
 			const key = dev ? "devDependencies" : "dependencies";
@@ -3401,7 +3531,7 @@ async function nextRecord(project, report) {
 	const record = { ...project.config.generated?.files ?? {} };
 	for (const path of report.removed) delete record[path];
 	const current = await hashTrackedFiles(project.root);
-	for (const path of report.written) {
+	for (const path of report.regenerated) {
 		const hash = current[path];
 		if (hash) record[path] = hash;
 	}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tatara/cli",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Create and grow opinionated Hono backends",
   "type": "module",
   "license": "MIT",

package/templates/features/admin/files/src/apps/admin/server.ts

@@ -1,5 +1,6 @@
+import { startServer } from "@tatara/http";
 import { app } from "#apps/admin/app";
 import { env } from "#core/config/env";
-import { startServer } from "#core/http/server";
+import { logger } from "#core/logging/logger";
 
-startServer(app, env.ADMIN_PORT, "admin");
+startServer(app, { port: env.ADMIN_PORT, name: "admin", logger });

package/templates/features/admin/files/src/modules/example/routes/admin-greeting.routes.ts

@@ -1,6 +1,6 @@
 import { createRoute } from "@hono/zod-openapi";
 import { currentPrincipal } from "#core/auth/middleware";
-import { errorResponses, jsonContent, success, successSchema } from "#core/http/response";
+import { errorResponses, jsonContent, success, successSchema } from "@tatara/http";
 import { createRouter, defineRoutes } from "#core/http/routes";
 import { greetingSchema } from "#modules/example/validators/greeting.validators";
 

package/templates/features/auth/files/src/core/auth/middleware.ts

@@ -1,7 +1,7 @@
 import { createMiddleware } from "hono/factory";
 import type { Context } from "hono";
 import type { AppEnv, Principal } from "#core/http/context";
-import { ForbiddenError, UnauthorizedError } from "#core/http/errors";
+import { ForbiddenError, UnauthorizedError } from "@tatara/http";
 
 /** 401 unless the request carries a valid session or token. */
 export function requireAuth() {

package/templates/features/auth/files/src/core/auth/routes/me.routes.ts

@@ -1,6 +1,6 @@
 import { createRoute, z } from "@hono/zod-openapi";
 import { currentPrincipal, requireAuth } from "#core/auth/middleware";
-import { errorResponses, jsonContent, success, successSchema } from "#core/http/response";
+import { errorResponses, jsonContent, success, successSchema } from "@tatara/http";
 import { createRouter, defineRoutes } from "#core/http/routes";
 
 const principalSchema = z

package/templates/features/authz/files/src/core/authz/middleware.ts

@@ -2,7 +2,7 @@ import { createMiddleware } from "hono/factory";
 import type { Scope } from "#core/authz/constants";
 import { checkPermission } from "#core/authz/resolver";
 import type { AppEnv } from "#core/http/context";
-import { ForbiddenError, UnauthorizedError } from "#core/http/errors";
+import { ForbiddenError, UnauthorizedError } from "@tatara/http";
 import type { PermissionKey } from "#generated/permissions";
 
 /**

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

@@ -19,7 +19,7 @@ import {
 	userParams,
 	userRoleParams,
 } from "#core/authz/validators";
-import { errorResponses, jsonBody, jsonContent, success, successSchema } from "#core/http/response";
+import { errorResponses, jsonBody, jsonContent, success, successSchema } from "@tatara/http";
 import { createRouter, defineRoutes } from "#core/http/routes";
 import { catalog } from "#generated/permissions";
 

package/templates/features/authz/files/src/core/authz/services/grants.ts

@@ -1,7 +1,7 @@
 import { assertGrantValid, InvalidGrantError, META_RESOURCES } from "#core/authz/catalog";
 import type { Scope } from "#core/authz/constants";
 import type { PermissionGrant } from "#core/authz/types";
-import { BusinessRuleError } from "#core/http/errors";
+import { BusinessRuleError } from "@tatara/http";
 import { catalog } from "#generated/permissions";
 
 /** Validates grants against the catalog; custom roles and overlays may not grant meta resources. */

package/templates/features/authz/files/src/core/authz/services/members.ts

@@ -3,7 +3,7 @@ import { type OverlayEffect, type Scope, SYSTEM_ACTOR } from "#core/authz/consta
 import { store } from "#core/authz/db/store";
 import { audit } from "#core/authz/services/audit";
 import { validateGrants } from "#core/authz/services/grants";
-import { NotFoundError } from "#core/http/errors";
+import { NotFoundError } from "@tatara/http";
 
 export async function getMember(orgId: string, userId: string) {
 	const [roles, overlays] = await Promise.all([

package/templates/features/authz/files/src/core/authz/services/roles.ts

@@ -4,7 +4,7 @@ import { audit } from "#core/authz/services/audit";
 import { validateGrants } from "#core/authz/services/grants";
 import { SYSTEM_ROLE_KEYS } from "#core/authz/system-roles";
 import type { RoleRow } from "#core/authz/types";
-import { BusinessRuleError, ConflictError, NotFoundError } from "#core/http/errors";
+import { BusinessRuleError, ConflictError, NotFoundError } from "@tatara/http";
 
 export interface RoleInput {
 	key: string;

package/templates/features/base/files/src/apps/api/server.ts

@@ -1,5 +1,6 @@
+import { startServer } from "@tatara/http";
 import { app } from "#apps/api/app";
 import { env } from "#core/config/env";
-import { startServer } from "#core/http/server";
+import { logger } from "#core/logging/logger";
 
-startServer(app, env.PORT, "api");
+startServer(app, { port: env.PORT, name: "api", logger });

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

@@ -1,57 +1,44 @@
-import { OpenAPIHono } from "@hono/zod-openapi";
-import { Scalar } from "@scalar/hono-api-reference";
-import { bodyLimit } from "hono/body-limit";
-import { cors } from "hono/cors";
-import { secureHeaders } from "hono/secure-headers";
+import { createApp, handleErrors, mountRoutes, serveOpenApi } from "@tatara/http";
 import { env } from "#core/config/env";
 import type { AppEnv } from "#core/http/context";
-import { runReadinessChecks } from "@tatara/core";
-import { errorHandler, notFoundHandler } from "#core/http/middleware/error-handler";
-import { requestContext } from "#core/http/middleware/request-context";
-import { validationHook } from "#core/http/middleware/validation";
 import type { AppName } from "#core/http/routes";
+import { logger } from "#core/logging/logger";
 import { routes } from "#generated/routes";
 // tatara:slot imports
 
 export const API_PREFIX = "/api";
 
+/** The app's HTTP wiring: plain Hono, with tatara's defaults from @tatara/http. */
 export function createHttpApp(name: AppName, options: { title: string }) {
-	const app = new OpenAPIHono<AppEnv>({ defaultHook: validationHook });
-
-	app.use(requestContext);
-	app.use(secureHeaders());
-	app.use(
-		cors({
-			origin: env.CORS_ORIGINS,
-			credentials: true,
-			allowHeaders: ["Content-Type", "Authorization", "X-Request-Id", "Accept-Language"],
-			exposeHeaders: ["X-Request-Id"],
-		}),
-	);
-	app.use(bodyLimit({ maxSize: env.BODY_LIMIT_BYTES }));
-	// tatara:slot middleware
-
-	app.get("/health", (c) => c.json({ status: "ok" }));
-	app.get("/ready", async (c) => {
-		const result = await runReadinessChecks();
-		return c.json(result, result.ready ? 200 : 503);
+	const app = createApp<AppEnv>({
+		logger,
+		cors: {
+			origins: env.CORS_ORIGINS,
+			exposeHeaders: [
+				"X-Request-Id",
+				// tatara:slot expose-headers
+			],
+		},
+		bodyLimitBytes: env.BODY_LIMIT_BYTES,
+		defaults: { principal: null, language: "en" },
 	});
+	// tatara:slot middleware
 
 	// tatara:slot routes
 
-	for (const definition of routes) {
-		if (definition.app === name) app.route(`${API_PREFIX}${definition.basePath}`, definition.router);
-	}
-
-	const openApiConfig = { openapi: "3.1.0", info: { title: options.title, version: "1.0.0" } } as const;
-	app.get("/openapi.json", async (c) => {
-		const document = app.getOpenAPI31Document(openApiConfig);
-		// tatara:slot openapi
-		return c.json(document);
+	mountRoutes(app, routes, { app: name, prefix: API_PREFIX });
+	serveOpenApi(app, {
+		title: options.title,
+		async extend(document) {
+			// tatara:slot openapi
+		},
+	});
+	handleErrors(app, {
+		message(err, c) {
+			let message = err.message;
+			// tatara:slot error-message
+			return message;
+		},
 	});
-	app.get("/docs", Scalar({ url: "/openapi.json", pageTitle: options.title }));
-
-	app.onError(errorHandler);
-	app.notFound(notFoundHandler);
 	return app;
 }

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

@@ -1,6 +1,8 @@
-import { OpenAPIHono } from "@hono/zod-openapi";
+import {
+	createRouter as createTataraRouter,
+	type RouteDefinition as TataraRouteDefinition,
+} from "@tatara/http";
 import type { AppEnv } from "#core/http/context";
-import { validationHook } from "#core/http/middleware/validation";
 
 export const APP_NAMES = [
 	"api",
@@ -9,13 +11,7 @@ export const APP_NAMES = [
 
 export type AppName = (typeof APP_NAMES)[number];
 
-export interface RouteDefinition {
-	/** which HTTP app serves these routes */
-	app: AppName;
-	/** mounted under `/api` + basePath, e.g. "/notes" */
-	basePath: string;
-	router: OpenAPIHono<AppEnv>;
-}
+export type RouteDefinition = TataraRouteDefinition<AppName, AppEnv>;
 
 /** Default export of every `routes/*.routes.ts`; discovered by `tatara sync`. */
 export function defineRoutes(definition: RouteDefinition): RouteDefinition {
@@ -23,6 +19,6 @@ export function defineRoutes(definition: RouteDefinition): RouteDefinition {
 }
 
 /** A router for one routes file. Attach middleware per route or per path, never `use("*")`. */
-export function createRouter(): OpenAPIHono<AppEnv> {
-	return new OpenAPIHono<AppEnv>({ defaultHook: validationHook });
+export function createRouter() {
+	return createTataraRouter<AppEnv>();
 }

package/templates/features/base/files/src/modules/example/routes/greeting.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";
 import { greet } from "#modules/example/services/greeting.service";
 import {

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 { 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 { 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,6 @@
   "@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"
 }

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

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

@@ -1,15 +0,0 @@
-import { serve } from "@hono/node-server";
-import type { OpenAPIHono } from "@hono/zod-openapi";
-import type { AppEnv } from "#core/http/context";
-import { logger } from "#core/logging/logger";
-import { handleSignals, onShutdown } from "@tatara/core";
-
-/** Starts an HTTP app; on shutdown stops accepting connections and drains in-flight requests. */
-export function startServer(app: OpenAPIHono<AppEnv>, port: number, name: string) {
-	const server = serve({ fetch: app.fetch, port }, (info) => {
-		logger.info({ port: info.port, app: name }, `${name} listening on http://localhost:${info.port}`);
-	});
-	onShutdown(`${name}-http`, () => new Promise<void>((resolve) => server.close(() => resolve())));
-	handleSignals(logger);
-	return server;
-}