@fuzdev/fuz_app 0.1.0

package/dist/http/route_spec.js

@@ -0,0 +1,243 @@
+/**
+ * Introspectable route spec system for Hono apps.
+ *
+ * Routes are defined as data (method, path, auth, input/output schemas, handler),
+ * then applied to Hono. The attack surface is generated from the specs —
+ * always accurate, always complete.
+ *
+ * Input/output schemas align with SAES `ActionSpec` conventions:
+ * - `input`: Zod schema for the request body (`z.null()` for no body)
+ * - `output`: Zod schema for the success response body
+ * - `z.strictObject()` for inputs (reject unknown keys)
+ *
+ * @module
+ */
+import { DEV } from 'esm-env';
+import { ERROR_INVALID_JSON_BODY, ERROR_INVALID_REQUEST_BODY, ERROR_INVALID_ROUTE_PARAMS, ERROR_INVALID_QUERY_PARAMS, } from './error_schemas.js';
+import { is_null_schema, merge_error_schemas } from './schema_helpers.js';
+/**
+ * Get validated input from the Hono context.
+ *
+ * Call this in route handlers after the input validation middleware has run.
+ * The type parameter should match the route's `input` schema.
+ *
+ * @returns the validated request body
+ */
+export const get_route_input = (c) => {
+    return c.get('validated_input');
+};
+/**
+ * Get validated URL path params from the Hono context.
+ *
+ * Call this in route handlers after the params validation middleware has run.
+ * The type parameter should match the route's `params` schema.
+ *
+ * TODO @action-system-review Make typesafe — derive `T` from the `params` schema on the
+ * route spec so the type parameter isn't manually specified.
+ *
+ * @returns the validated path parameters
+ */
+export const get_route_params = (c) => {
+    return c.get('validated_params');
+};
+/**
+ * Get validated URL query params from the Hono context.
+ *
+ * Call this in route handlers after the query validation middleware has run.
+ * The type parameter should match the route's `query` schema.
+ *
+ * @returns the validated query parameters
+ */
+export const get_route_query = (c) => {
+    return c.get('validated_query');
+};
+/**
+ * Create input validation middleware for a route spec.
+ *
+ * Returns an empty array for null-input routes (no body expected).
+ * For routes with input schemas, returns a middleware that parses and validates
+ * the JSON body, storing the result on the context as `validated_input`.
+ */
+const create_input_validation = (input_schema) => {
+    if (is_null_schema(input_schema))
+        return [];
+    const validate = async (c, next) => {
+        let body;
+        try {
+            body = await c.req.json();
+        }
+        catch {
+            return c.json({ error: ERROR_INVALID_JSON_BODY }, 400);
+        }
+        if (typeof body !== 'object' || body === null || Array.isArray(body)) {
+            return c.json({ error: ERROR_INVALID_JSON_BODY }, 400);
+        }
+        const result = input_schema.safeParse(body);
+        if (!result.success) {
+            return c.json({ error: ERROR_INVALID_REQUEST_BODY, issues: result.error.issues }, 400);
+        }
+        c.set('validated_input', result.data);
+        await next();
+    };
+    return [validate];
+};
+/**
+ * Create params validation middleware for a route spec.
+ *
+ * Returns an empty array when no params schema is defined.
+ * For routes with params schemas, returns a middleware that validates
+ * `c.req.param()` against the schema, storing the result on the context as `validated_params`.
+ */
+const create_params_validation = (params_schema) => {
+    if (!params_schema)
+        return [];
+    const validate = async (c, next) => {
+        const raw_params = c.req.param();
+        const result = params_schema.safeParse(raw_params);
+        if (!result.success) {
+            return c.json({ error: ERROR_INVALID_ROUTE_PARAMS, issues: result.error.issues }, 400);
+        }
+        c.set('validated_params', result.data);
+        await next();
+    };
+    return [validate];
+};
+/**
+ * Create query params validation middleware for a route spec.
+ *
+ * Returns an empty array when no query schema is defined.
+ * For routes with query schemas, returns a middleware that validates
+ * `c.req.query()` against the schema, storing the result on the context as `validated_query`.
+ */
+const create_query_validation = (query_schema) => {
+    if (!query_schema)
+        return [];
+    const validate = async (c, next) => {
+        const raw_query = c.req.query();
+        const result = query_schema.safeParse(raw_query);
+        if (!result.success) {
+            return c.json({ error: ERROR_INVALID_QUERY_PARAMS, issues: result.error.issues }, 400);
+        }
+        c.set('validated_query', result.data);
+        await next();
+    };
+    return [validate];
+};
+/**
+ * Wrap a handler with DEV-only output and error validation.
+ *
+ * In development, validates 2xx JSON responses against the output schema
+ * and non-2xx responses against declared error schemas.
+ * Logs warnings for mismatches. In production, returns the handler unchanged.
+ */
+const wrap_output_validation = (handler, output_schema, error_schemas, log) => {
+    if (!DEV)
+        return handler;
+    if (is_null_schema(output_schema) && !error_schemas)
+        return handler;
+    return async (c, next) => {
+        const response = await handler(c, next);
+        // Only validate JSON responses — streaming responses (SSE) would hang on .json().
+        const content_type = response.headers.get('Content-Type');
+        if (!content_type?.includes('application/json'))
+            return response;
+        if (response.ok) {
+            try {
+                const cloned = response.clone();
+                const body = await cloned.json();
+                const result = output_schema.safeParse(body);
+                if (!result.success) {
+                    log.warn(`Output schema mismatch: ${c.req.method} ${c.req.path}`, result.error.issues);
+                }
+            }
+            catch {
+                // clone() or json() failed on a response claiming application/json
+            }
+        }
+        else if (error_schemas) {
+            const status_schema = error_schemas[response.status];
+            if (status_schema) {
+                try {
+                    const cloned = response.clone();
+                    const body = await cloned.json();
+                    const result = status_schema.safeParse(body);
+                    if (!result.success) {
+                        log.warn(`Error schema mismatch (${response.status}): ${c.req.method} ${c.req.path}`, result.error.issues);
+                    }
+                }
+                catch {
+                    // clone() or json() failed on a response claiming application/json
+                }
+            }
+        }
+        return response;
+    };
+};
+/**
+ * Apply named middleware specs to a Hono app.
+ *
+ * @param app - the Hono app
+ * @param specs - middleware specs to apply
+ * @mutates `app`
+ */
+export const apply_middleware_specs = (app, specs) => {
+    for (const spec of specs) {
+        app.use(spec.path, spec.handler);
+    }
+};
+/**
+ * Apply route specs to a Hono app.
+ *
+ * For each spec: resolves auth to guards via the provided resolver,
+ * adds input validation middleware (for routes with non-null input schemas),
+ * wraps handler with DEV-only output and error validation, and registers the route.
+ *
+ * Each handler receives a `RouteContext` with:
+ * - `db`: transaction-scoped (for non-GET) or pool-level (for GET)
+ * - `background_db`: always pool-level
+ * - `pending_effects`: fire-and-forget effect queue
+ *
+ * @param app - the Hono app
+ * @param specs - route specs to apply
+ * @param resolve_auth_guards - maps `RouteAuth` to middleware — use `fuz_auth_guard_resolver` from `auth/route_guards.ts`
+ * @param log - the logger instance
+ * @param db - database instance for transaction wrapping and `RouteContext`
+ * @mutates `app`
+ */
+export const apply_route_specs = (app, specs, resolve_auth_guards, log, db) => {
+    const registered = new Set();
+    for (const spec of specs) {
+        const route_key = `${spec.method} ${spec.path}`;
+        if (registered.has(route_key)) {
+            throw new Error(`Duplicate route: ${route_key} — each method+path combination must be unique`);
+        }
+        registered.add(route_key);
+        const guards = resolve_auth_guards(spec.auth);
+        const params_validation = create_params_validation(spec.params);
+        const query_validation = create_query_validation(spec.query);
+        const validation = create_input_validation(spec.input);
+        const merged_errors = merge_error_schemas(spec);
+        // Step 1: adapt RouteHandler → Handler (construct RouteContext, call spec.handler)
+        const use_transaction = spec.transaction ?? spec.method !== 'GET';
+        const inner = spec.handler;
+        let handler = use_transaction
+            ? (c) => db.transaction(async (tx) => inner(c, { db: tx, background_db: db, pending_effects: c.var.pending_effects }))
+            : (c) => inner(c, { db, background_db: db, pending_effects: c.var.pending_effects });
+        // Step 2: output validation
+        handler = wrap_output_validation(handler, spec.output, merged_errors, log);
+        app.on(spec.method, [spec.path], ...guards, ...params_validation, ...query_validation, ...validation, handler);
+    }
+};
+/**
+ * Prepend a prefix to all route spec paths.
+ *
+ * @param prefix - the path prefix (e.g. `/api/account`)
+ * @param specs - route specs to prefix
+ * @returns new array of specs with prefixed paths
+ */
+export const prefix_route_specs = (prefix, specs) => {
+    return specs.map((spec) => ({
+        ...spec,
+        path: `${prefix}${spec.path}`,
+    }));
+};

package/dist/http/schema_helpers.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Shared pure helpers for schema introspection and middleware matching.
+ *
+ * Used by both `route_spec.ts` (input validation) and `surface.ts`
+ * (attack surface generation). Extracted to avoid circular dependencies
+ * between routes and middleware.
+ *
+ * @module
+ */
+import { z } from 'zod';
+import type { RouteAuth } from './route_spec.js';
+import { type RateLimitKey, type RouteErrorSchemas } from './error_schemas.js';
+/**
+ * Check if a schema is exactly `z.null()`.
+ *
+ * Uses Zod 4 type introspection (`_zod.def.type`) rather than runtime parsing
+ * to avoid false positives from `z.nullable(z.string())` or similar schemas
+ * that accept null but also accept other values.
+ */
+export declare const is_null_schema: (schema: z.ZodType) => boolean;
+/**
+ * Check if a schema is a strict object (`z.strictObject()`).
+ *
+ * Strict objects set `catchall` to `ZodNever` to reject unknown keys.
+ * Regular `z.object()` has `catchall: undefined` (strips unknown keys in Zod 4).
+ */
+export declare const is_strict_object_schema: (schema: z.ZodType) => boolean;
+/**
+ * Convert a Zod schema to a JSON-serializable representation for the surface.
+ *
+ * Returns `null` for null schemas, JSON Schema for object schemas.
+ */
+export declare const schema_to_surface: (schema: z.ZodType) => unknown;
+/**
+ * Check if a middleware path pattern applies to a route path.
+ *
+ * Supports Hono-style patterns:
+ * - `/api/*` matches `/api/anything`
+ * - `/api/tx/*` matches `/api/tx/runs` but not `/api/account/login`
+ * - Exact match: `/health` matches `/health`
+ *
+ * @param mw_path - the middleware path pattern
+ * @param route_path - the route path
+ */
+export declare const middleware_applies: (mw_path: string, route_path: string) => boolean;
+/**
+ * Merge auto-derived, middleware, and explicit error schemas for a route spec.
+ *
+ * Merge order: derived -> middleware -> explicit route errors.
+ * Later layers override earlier ones for the same status code.
+ *
+ * @param spec - the route spec (needs `auth`, `input`, `params`, `rate_limit`, `errors`)
+ * @param middleware_errors - optional middleware error schemas
+ * @returns merged error schemas, or `null` if empty
+ */
+export declare const merge_error_schemas: (spec: {
+    auth: RouteAuth;
+    input: z.ZodType;
+    params?: z.ZodObject;
+    query?: z.ZodObject;
+    rate_limit?: RateLimitKey;
+    errors?: RouteErrorSchemas;
+}, middleware_errors?: RouteErrorSchemas | null) => RouteErrorSchemas | null;
+//# sourceMappingURL=schema_helpers.d.ts.map

package/dist/http/schema_helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema_helpers.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/http/schema_helpers.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAEtB,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAuB,KAAK,YAAY,EAAE,KAAK,iBAAiB,EAAC,MAAM,oBAAoB,CAAC;AAEnG;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,GAAI,QAAQ,CAAC,CAAC,OAAO,KAAG,OAA0C,CAAC;AAE9F;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,GAAI,QAAQ,CAAC,CAAC,OAAO,KAAG,OAI3D,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAAI,QAAQ,CAAC,CAAC,OAAO,KAAG,OAcrD,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,kBAAkB,GAAI,SAAS,MAAM,EAAE,YAAY,MAAM,KAAG,OAQxE,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,mBAAmB,GAC/B,MAAM;IACL,IAAI,EAAE,SAAS,CAAC;IAChB,KAAK,EAAE,CAAC,CAAC,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,CAAC,CAAC,SAAS,CAAC;IACrB,KAAK,CAAC,EAAE,CAAC,CAAC,SAAS,CAAC;IACpB,UAAU,CAAC,EAAE,YAAY,CAAC;IAC1B,MAAM,CAAC,EAAE,iBAAiB,CAAC;CAC3B,EACD,oBAAoB,iBAAiB,GAAG,IAAI,KAC1C,iBAAiB,GAAG,IAUtB,CAAC"}

package/dist/http/schema_helpers.js

@@ -0,0 +1,90 @@
+/**
+ * Shared pure helpers for schema introspection and middleware matching.
+ *
+ * Used by both `route_spec.ts` (input validation) and `surface.ts`
+ * (attack surface generation). Extracted to avoid circular dependencies
+ * between routes and middleware.
+ *
+ * @module
+ */
+import { z } from 'zod';
+import { derive_error_schemas } from './error_schemas.js';
+/**
+ * Check if a schema is exactly `z.null()`.
+ *
+ * Uses Zod 4 type introspection (`_zod.def.type`) rather than runtime parsing
+ * to avoid false positives from `z.nullable(z.string())` or similar schemas
+ * that accept null but also accept other values.
+ */
+export const is_null_schema = (schema) => schema._zod.def.type === 'null';
+/**
+ * Check if a schema is a strict object (`z.strictObject()`).
+ *
+ * Strict objects set `catchall` to `ZodNever` to reject unknown keys.
+ * Regular `z.object()` has `catchall: undefined` (strips unknown keys in Zod 4).
+ */
+export const is_strict_object_schema = (schema) => {
+    if (schema._zod.def.type !== 'object')
+        return false;
+    const catchall = schema._zod.def.catchall;
+    return catchall?._zod.def.type === 'never';
+};
+/**
+ * Convert a Zod schema to a JSON-serializable representation for the surface.
+ *
+ * Returns `null` for null schemas, JSON Schema for object schemas.
+ */
+export const schema_to_surface = (schema) => {
+    if (is_null_schema(schema))
+        return null;
+    try {
+        const json_schema = z.toJSONSchema(schema);
+        // Strip $schema for cleaner snapshots
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        if (typeof json_schema === 'object' && json_schema !== null && '$schema' in json_schema) {
+            const { $schema: _, ...rest } = json_schema;
+            return rest;
+        }
+        return json_schema;
+    }
+    catch {
+        return null;
+    }
+};
+/**
+ * Check if a middleware path pattern applies to a route path.
+ *
+ * Supports Hono-style patterns:
+ * - `/api/*` matches `/api/anything`
+ * - `/api/tx/*` matches `/api/tx/runs` but not `/api/account/login`
+ * - Exact match: `/health` matches `/health`
+ *
+ * @param mw_path - the middleware path pattern
+ * @param route_path - the route path
+ */
+export const middleware_applies = (mw_path, route_path) => {
+    if (mw_path === '*')
+        return true;
+    if (mw_path === route_path)
+        return true;
+    if (mw_path.endsWith('/*')) {
+        const prefix = mw_path.slice(0, -1); // '/api/*' → '/api/'
+        return route_path.startsWith(prefix) || route_path === prefix.slice(0, -1);
+    }
+    return false;
+};
+/**
+ * Merge auto-derived, middleware, and explicit error schemas for a route spec.
+ *
+ * Merge order: derived -> middleware -> explicit route errors.
+ * Later layers override earlier ones for the same status code.
+ *
+ * @param spec - the route spec (needs `auth`, `input`, `params`, `rate_limit`, `errors`)
+ * @param middleware_errors - optional middleware error schemas
+ * @returns merged error schemas, or `null` if empty
+ */
+export const merge_error_schemas = (spec, middleware_errors) => {
+    const derived = derive_error_schemas(spec.auth, !is_null_schema(spec.input), !!spec.params, !!spec.query, spec.rate_limit);
+    const merged = { ...derived, ...middleware_errors, ...spec.errors };
+    return Object.keys(merged).length > 0 ? merged : null;
+};

package/dist/http/surface.d.ts

@@ -0,0 +1,132 @@
+/**
+ * App surface generation — JSON-serializable attack surface from route and middleware specs.
+ *
+ * Pure schema helpers (`is_null_schema`, `schema_to_surface`, `middleware_applies`,
+ * `merge_error_schemas`) live in `schema_helpers.ts`.
+ *
+ * @module
+ */
+import { z } from 'zod';
+import type { SseEventSpec } from '../realtime/sse.js';
+import type { MiddlewareSpec } from './middleware_spec.js';
+import type { RouteAuth, RouteSpec } from './route_spec.js';
+import type { RateLimitKey, RouteErrorSchemas } from './error_schemas.js';
+import type { Sensitivity } from '../sensitivity.js';
+/** A route in the generated attack surface (JSON-serializable). */
+export interface AppSurfaceRoute {
+    method: string;
+    path: string;
+    auth: RouteAuth;
+    applicable_middleware: Array<string>;
+    description: string;
+    /** Whether this route mutates state (POST, PUT, DELETE, PATCH). */
+    is_mutation: boolean;
+    /** Whether this route's handler runs inside a database transaction. */
+    transaction: boolean;
+    /** Rate limit key type declared on the route spec. `null` when not rate-limited. */
+    rate_limit_key: RateLimitKey | null;
+    /** JSON Schema representation of the URL path params schema. `null` when no params. */
+    params_schema: unknown;
+    /** JSON Schema representation of the URL query params schema. `null` when no query schema. */
+    query_schema: unknown;
+    /** JSON Schema representation of the request body schema. `null` for no-body routes. */
+    input_schema: unknown;
+    /** JSON Schema representation of the success response schema. */
+    output_schema: unknown;
+    /** JSON Schema representations of error responses, keyed by HTTP status code. `null` when none. */
+    error_schemas: Record<string, unknown> | null;
+}
+/** A middleware in the generated attack surface (JSON-serializable). */
+export interface AppSurfaceMiddleware {
+    name: string;
+    path: string;
+    /** JSON Schema representations of error responses, keyed by HTTP status code. `null` when none. */
+    error_schemas: Record<string, unknown> | null;
+}
+/** An env var in the generated attack surface (JSON-serializable). */
+export interface AppSurfaceEnv {
+    name: string;
+    description: string;
+    /** Sensitivity level from `.meta({sensitivity})`. `null` when not sensitive. */
+    sensitivity: Sensitivity | null;
+    has_default: boolean;
+    optional: boolean;
+}
+/** An SSE event in the generated attack surface (JSON-serializable). */
+export interface AppSurfaceEvent {
+    method: string;
+    description: string;
+    channel: string | null;
+    params_schema: unknown;
+}
+/** Assembly-time diagnostic collected during surface generation or server assembly. */
+export interface AppSurfaceDiagnostic {
+    level: 'warning' | 'info';
+    category: string;
+    message: string;
+    source?: string;
+}
+/** Generated attack surface — JSON-serializable. */
+export interface AppSurface {
+    middleware: Array<AppSurfaceMiddleware>;
+    routes: Array<AppSurfaceRoute>;
+    env: Array<AppSurfaceEnv>;
+    events: Array<AppSurfaceEvent>;
+    diagnostics: Array<AppSurfaceDiagnostic>;
+}
+/**
+ * The surface bundled with the source specs that produced it.
+ *
+ * `AppSurface` is JSON-serializable (snapshots, UI, startup logging).
+ * `AppSurfaceSpec` is runtime-only (tests, introspection, attack surface assertions).
+ */
+export interface AppSurfaceSpec {
+    surface: AppSurface;
+    route_specs: Array<RouteSpec>;
+    middleware_specs: Array<MiddlewareSpec>;
+}
+/** Options for `generate_app_surface`. */
+export interface GenerateAppSurfaceOptions {
+    route_specs: Array<RouteSpec>;
+    middleware_specs: Array<MiddlewareSpec>;
+    env_schema?: z.ZodObject;
+    event_specs?: Array<SseEventSpec>;
+}
+/**
+ * Collect error schemas from all middleware that applies to a route path.
+ *
+ * @param middleware - the middleware specs
+ * @param route_path - the route path to match against
+ * @returns merged middleware error schemas, or `null` if none
+ */
+export declare const collect_middleware_errors: (middleware: Array<MiddlewareSpec>, route_path: string) => RouteErrorSchemas | null;
+/**
+ * Convert env schema to surface entries using `.meta()` metadata.
+ *
+ * @param schema - Zod object schema with `.meta()` on fields
+ * @returns array of env surface entries
+ */
+export declare const env_schema_to_surface: (schema: z.ZodObject) => Array<AppSurfaceEnv>;
+/**
+ * Convert SSE event specs to surface entries.
+ *
+ * @param event_specs - event specs to convert
+ * @returns array of event surface entries
+ */
+export declare const events_to_surface: (event_specs: Array<SseEventSpec>) => Array<AppSurfaceEvent>;
+/**
+ * Generate a JSON-serializable attack surface from middleware, route specs,
+ * and optional env/event metadata.
+ *
+ * @param options - the surface generation options
+ * @returns the attack surface
+ */
+export declare const generate_app_surface: (options: GenerateAppSurfaceOptions) => AppSurface;
+/**
+ * Create an `AppSurfaceSpec` — the surface bundled with its source specs.
+ *
+ * @param options - the surface generation options
+ * @returns the surface spec with surface and raw specs
+ */
+export declare const create_app_surface_spec: (options: GenerateAppSurfaceOptions) => AppSurfaceSpec;
+//# sourceMappingURL=surface.d.ts.map

package/dist/http/surface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"surface.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/http/surface.ts"],"names":[],"mappings":"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"}