@tatara/cli 0.1.3 → 0.3.0

package/templates/features/base/files/src/core/commands/tests/flags.test.ts

@@ -1,16 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { z } from "zod";
-import { flag } from "#core/commands/define";
-import { parseFlags } from "#core/commands/runner";
-
-const args = z.object({ force: flag() });
-const parse = (argv: string[]) => args.parse(parseFlags(argv)).force;
-
-describe("flag()", () => {
-	it("is true for a bare flag", () => expect(parse(["--force"])).toBe(true));
-	it("reads --flag false as false", () => expect(parse(["--force", "false"])).toBe(false));
-	it("reads --flag=0 as false", () => expect(parse(["--force=0"])).toBe(false));
-	it("reads --flag true as true", () => expect(parse(["--force", "true"])).toBe(true));
-	it("defaults to false", () => expect(parse([])).toBe(false));
-	it("rejects anything else", () => expect(() => parse(["--force", "maybe"])).toThrow());
-});

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/health.ts

@@ -1,25 +0,0 @@
-type Check = () => Promise<void>;
-
-const checks = new Map<string, Check>();
-
-/** Registers a dependency checked by GET /ready (database, redis, …). */
-export function registerReadinessCheck(name: string, check: Check): void {
-	checks.set(name, check);
-}
-
-export async function runReadinessChecks() {
-	const results = await Promise.all(
-		[...checks].map(async ([name, check]) => {
-			try {
-				await check();
-				return [name, "ok"] as const;
-			} catch {
-				return [name, "failed"] as const;
-			}
-		}),
-	);
-	return {
-		ready: results.every(([, status]) => status === "ok"),
-		checks: Object.fromEntries(results),
-	};
-}

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 "#core/process/lifecycle";
-
-/** 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();
-	return server;
-}

package/templates/features/base/files/src/core/process/lifecycle.ts

@@ -1,34 +0,0 @@
-import { logger } from "#core/logging/logger";
-
-type Hook = () => Promise<void> | void;
-
-const hooks: { name: string; run: Hook }[] = [];
-let shuttingDown = false;
-
-/** Registers cleanup that runs on SIGTERM/SIGINT or `shutdown()`, last registered first. */
-export function onShutdown(name: string, run: Hook): void {
-	hooks.push({ name, run });
-}
-
-export async function shutdown(code = 0): Promise<never> {
-	if (!shuttingDown) {
-		shuttingDown = true;
-		for (const hook of [...hooks].reverse()) {
-			try {
-				await hook.run();
-			} catch (error) {
-				logger.error({ err: error, hook: hook.name }, "shutdown hook failed");
-			}
-		}
-	}
-	process.exit(code);
-}
-
-export function handleSignals(): void {
-	for (const signal of ["SIGTERM", "SIGINT"] as const) {
-		process.once(signal, () => {
-			logger.info({ signal }, "shutting down");
-			void shutdown(0);
-		});
-	}
-}