@fishenv/http 0.0.0-stage → 0.0.2

package/dist/contract/builder.d.ts

@@ -0,0 +1,82 @@
+import type { AnySchema, BasePathParams, HttpMethod, InferOutput, InputKind, InputOptions, MergeParam, RouteMeta } from "./types.ts";
+/**
+ * Plain-data snapshot of a contract endpoint.
+ *
+ * This is the runtime shape consumers (the API's `router.contract()`, an
+ * OpenAPI generator, a typed client, ...) read from. It intentionally has no
+ * generic parameters — the compile-time shape lives on `ContractBuilder`
+ * itself and is recovered via `ContractShape<C>`.
+ */
+export interface ContractDefinition {
+    method: HttpMethod;
+    path: string;
+    paramSchemas: Map<string, AnySchema>;
+    inputKind: InputKind;
+    inputOptions: InputOptions<InputKind>;
+    outputSchema?: AnySchema;
+    errorTypes?: (new (...args: unknown[]) => Error)[];
+    meta?: RouteMeta;
+}
+/**
+ * Fluent, immutable contract endpoint builder.
+ *
+ * Mirrors `RouteBuilder` from `@fishenv/http` (method/path/param/input/output)
+ * minus everything server-only (middleware, handlers, DI). A finished
+ * `ContractBuilder` is portable data: it can be handed to
+ * `router.contract(endpoint)` on the API side, or read by an OpenAPI
+ * generator / typed client on the consumer side.
+ */
+export declare class ContractBuilder<M extends HttpMethod, P extends string, K extends InputKind = "none", O extends InputOptions<K> = InputOptions<K>, Params extends Record<string, unknown> = Record<string, unknown>, Output = undefined> {
+    #private;
+    readonly method: M;
+    readonly path: P;
+    constructor(method: M, path: P, paramSchemas?: Map<string, AnySchema>, inputKind?: InputKind, inputOptions?: InputOptions<InputKind>, outputSchema?: AnySchema, errorTypes?: (new (...args: unknown[]) => Error)[], meta?: RouteMeta);
+    /** Set contract metadata (title, tags, etc.) — returns new builder */
+    meta(data: RouteMeta): ContractBuilder<M, P, K, O, Params, Output>;
+    /** Narrow/coerce a path param with a Valibot schema — returns new builder */
+    param<Name extends string & keyof Params, S extends AnySchema>(name: Name, schema: S): ContractBuilder<M, P, K, O, MergeParam<Params, Name, S>, Output>;
+    /** Set input kind and options — returns new builder */
+    input<NK extends InputKind, NO extends InputOptions<NK>>(kind: NK, options?: NO): ContractBuilder<M, P, NK, NO extends InputOptions<NK> ? NO : InputOptions<NK>, Params, Output>;
+    /** Set output schema + optional error types — returns new builder */
+    output<S extends AnySchema>(schema: S, errors?: (new (...args: unknown[]) => Error)[]): ContractBuilder<M, P, K, O, Params, InferOutput<S>>;
+    /**
+     * Runtime snapshot of this endpoint. Used by consumers such as
+     * `router.contract()`, OpenAPI generation, or a typed client — not meant
+     * to be read directly by application code.
+     */
+    get _definition(): ContractDefinition;
+}
+/**
+ * Recovers the compile-time shape (input/output/params) of a `ContractBuilder`.
+ * Used by consumers to derive their own generics from a contract endpoint.
+ */
+export type ContractShape<C> = C extends ContractBuilder<infer M, infer P, infer K, infer O, infer Params, infer Output> ? {
+    method: M;
+    path: P;
+    inputKind: K;
+    inputOptions: O;
+    params: Params;
+    output: Output;
+} : never;
+/** Loosest possible `ContractBuilder` — use as a generic constraint. */
+export type AnyContractBuilder = ContractBuilder<any, any, any, any, any, any>;
+/**
+ * Entry point for defining contract endpoints, e.g.:
+ *
+ * ```ts
+ * export const contract = {
+ *   users: {
+ *     create: c.post("/users").input("json", { body: CreateUserSchema }).output(UserSchema),
+ *     get: c.get("/users/:id").output(UserSchema),
+ *   },
+ * };
+ * ```
+ */
+export declare const c: {
+    get: <P extends string>(path: P) => ContractBuilder<"GET", P, "none", InputOptions<"none">, BasePathParams<P>, undefined>;
+    post: <P extends string>(path: P) => ContractBuilder<"POST", P, "none", InputOptions<"none">, BasePathParams<P>, undefined>;
+    put: <P extends string>(path: P) => ContractBuilder<"PUT", P, "none", InputOptions<"none">, BasePathParams<P>, undefined>;
+    patch: <P extends string>(path: P) => ContractBuilder<"PATCH", P, "none", InputOptions<"none">, BasePathParams<P>, undefined>;
+    delete: <P extends string>(path: P) => ContractBuilder<"DELETE", P, "none", InputOptions<"none">, BasePathParams<P>, undefined>;
+    options: <P extends string>(path: P) => ContractBuilder<"OPTIONS", P, "none", InputOptions<"none">, BasePathParams<P>, undefined>;
+};

package/dist/contract/builder.js

@@ -0,0 +1,87 @@
+/**
+ * Fluent, immutable contract endpoint builder.
+ *
+ * Mirrors `RouteBuilder` from `@fishenv/http` (method/path/param/input/output)
+ * minus everything server-only (middleware, handlers, DI). A finished
+ * `ContractBuilder` is portable data: it can be handed to
+ * `router.contract(endpoint)` on the API side, or read by an OpenAPI
+ * generator / typed client on the consumer side.
+ */
+export class ContractBuilder {
+    method;
+    path;
+    #paramSchemas;
+    #inputKind;
+    #inputOptions;
+    #outputSchema;
+    #errorTypes;
+    #meta;
+    constructor(method, path, paramSchemas = new Map(), inputKind = "none", inputOptions = {}, outputSchema, errorTypes, meta) {
+        this.method = method;
+        this.path = path;
+        this.#paramSchemas = paramSchemas;
+        this.#inputKind = inputKind;
+        this.#inputOptions = inputOptions;
+        this.#outputSchema = outputSchema;
+        this.#errorTypes = errorTypes;
+        this.#meta = meta;
+    }
+    /** Set contract metadata (title, tags, etc.) — returns new builder */
+    meta(data) {
+        return new ContractBuilder(this.method, this.path, new Map(this.#paramSchemas), this.#inputKind, this.#inputOptions, this.#outputSchema, this.#errorTypes ? [...this.#errorTypes] : undefined, { ...this.#meta, ...data });
+    }
+    /** Narrow/coerce a path param with a Valibot schema — returns new builder */
+    param(name, schema) {
+        const newSchemas = new Map(this.#paramSchemas);
+        newSchemas.set(name, schema);
+        return new ContractBuilder(this.method, this.path, newSchemas, this.#inputKind, this.#inputOptions, this.#outputSchema, this.#errorTypes ? [...this.#errorTypes] : undefined, this.#meta ? { ...this.#meta } : undefined);
+    }
+    /** Set input kind and options — returns new builder */
+    input(kind, options) {
+        return new ContractBuilder(this.method, this.path, new Map(this.#paramSchemas), kind, (options ?? {}), this.#outputSchema, this.#errorTypes ? [...this.#errorTypes] : undefined, this.#meta ? { ...this.#meta } : undefined);
+    }
+    /** Set output schema + optional error types — returns new builder */
+    output(schema, errors) {
+        return new ContractBuilder(this.method, this.path, new Map(this.#paramSchemas), this.#inputKind, this.#inputOptions, schema, errors, this.#meta ? { ...this.#meta } : undefined);
+    }
+    /**
+     * Runtime snapshot of this endpoint. Used by consumers such as
+     * `router.contract()`, OpenAPI generation, or a typed client — not meant
+     * to be read directly by application code.
+     */
+    get _definition() {
+        return {
+            method: this.method,
+            path: this.path,
+            paramSchemas: this.#paramSchemas,
+            inputKind: this.#inputKind,
+            inputOptions: this.#inputOptions,
+            outputSchema: this.#outputSchema,
+            errorTypes: this.#errorTypes,
+            meta: this.#meta,
+        };
+    }
+}
+function endpoint(method) {
+    return (path) => new ContractBuilder(method, path);
+}
+/**
+ * Entry point for defining contract endpoints, e.g.:
+ *
+ * ```ts
+ * export const contract = {
+ *   users: {
+ *     create: c.post("/users").input("json", { body: CreateUserSchema }).output(UserSchema),
+ *     get: c.get("/users/:id").output(UserSchema),
+ *   },
+ * };
+ * ```
+ */
+export const c = {
+    get: endpoint("GET"),
+    post: endpoint("POST"),
+    put: endpoint("PUT"),
+    patch: endpoint("PATCH"),
+    delete: endpoint("DELETE"),
+    options: endpoint("OPTIONS"),
+};

package/dist/contract/index.d.ts

@@ -0,0 +1,2 @@
+export { type AnyContractBuilder, ContractBuilder, type ContractDefinition, type ContractShape, c, } from "./builder.ts";
+export type { AnySchema, BasePathParams, ExtractParams, HttpMethod, InferBody, InferCookies, InferHeaders, InferOutput, InferQuery, InputKind, InputOptions, MergeParam, RouteMeta, ValibotSchema, } from "./types.ts";

package/dist/contract/index.js

@@ -0,0 +1 @@
+export { ContractBuilder, c, } from "./builder.js";

package/dist/contract/types.d.ts

@@ -0,0 +1,39 @@
+import type * as v from "valibot";
+/**
+ * `@fishenv/http-contract` — the "shape" types shared between an API and its
+ * consumers (the API itself, an OpenAPI generator, a typed client, ...).
+ *
+ * This module has zero server-runtime dependencies (no DI, no middleware, no
+ * `Bun.serve`) — it only describes *what* an endpoint looks like: method,
+ * path, input, output. `@fishenv/http` (the `core` package) depends on this
+ * package to build its route registration API; this package must never
+ * depend back on `core`.
+ */
+export type ValibotSchema<O = unknown> = v.BaseSchema<unknown, O, v.BaseIssue<unknown>>;
+export type AnySchema = ValibotSchema<unknown>;
+export type InferOutput<S extends AnySchema> = v.InferOutput<S>;
+export type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS" | "HEAD";
+export type InputKind = "json" | "multipart" | "urlencoded" | "blob" | "text" | "none";
+export interface InputOptions<K extends InputKind> {
+    body?: K extends "blob" | "text" ? never : AnySchema;
+    headers?: AnySchema;
+    query?: AnySchema;
+    cookies?: AnySchema;
+    maxSize?: K extends "blob" | "multipart" ? number : never;
+}
+export type InferBody<K extends InputKind, O extends InputOptions<K>> = K extends "blob" ? Blob : K extends "text" ? string : K extends "none" ? undefined : O["body"] extends AnySchema ? InferOutput<O["body"]> : K extends "multipart" | "urlencoded" ? FormData : unknown;
+export type InferHeaders<O extends InputOptions<InputKind>> = O["headers"] extends AnySchema ? InferOutput<O["headers"]> : Record<string, string>;
+export type InferQuery<O extends InputOptions<InputKind>> = O["query"] extends AnySchema ? InferOutput<O["query"]> : Record<string, string | string[]>;
+export type InferCookies<O extends InputOptions<InputKind>> = O["cookies"] extends AnySchema ? InferOutput<O["cookies"]> : Record<string, string>;
+export type ExtractParams<P extends string> = P extends `${string}:${infer Param}/${infer Rest}` ? (Param extends `${infer Name}?` ? Name : Param) | ExtractParams<`/${Rest}`> : P extends `${string}:${infer Param}` ? Param extends `${infer Name}?` ? Name : Param : never;
+export type BasePathParams<P extends string> = {
+    [K in ExtractParams<P>]: string;
+};
+export type MergeParam<Base extends Record<string, unknown>, Name extends string, Schema extends AnySchema> = Omit<Base, Name> & Record<Name, InferOutput<Schema>>;
+export interface RouteMeta {
+    title?: string;
+    description?: string;
+    tags?: string[];
+    deprecated?: boolean;
+    operationId?: string;
+}

package/dist/core/compose.d.ts

@@ -0,0 +1,22 @@
+import type { DIContainer, ErrorHandlerFn, InterceptorPair, MiddlewareFn, RouteDefinition } from "./types.ts";
+/**
+ * Run the middleware pipeline, accumulating context via object spread.
+ * Each middleware receives the accumulated ctx and returns new fields to merge.
+ */
+export declare function runMiddlewarePipeline(req: Request, middlewares: MiddlewareFn<Record<string, unknown>, Record<string, unknown>>[], container: DIContainer): Promise<Record<string, unknown>>;
+/**
+ * Run before interceptors, the handler, then after interceptors (in reverse).
+ * Before and after share a mutable `state` object created per-request.
+ */
+export declare function runInterceptors(interceptors: InterceptorPair<Record<string, unknown>>[], req: Request, ctx: Record<string, unknown>, handlerFn: () => Promise<Response>): Promise<Response>;
+/**
+ * Coerce a handler's return value into a Response.
+ * - If already a Response, pass through.
+ * - If output schema is defined, serialize as JSON.
+ * - Otherwise throw — handler contract violation.
+ */
+export declare function coerceToResponse(raw: unknown, def: RouteDefinition): Response;
+/**
+ * Full request dispatch: middleware → input parsing → interceptors + handler → error chain.
+ */
+export declare function dispatch(req: Request, definition: RouteDefinition, params: Record<string, string>, container: DIContainer, errorHandlers: ErrorHandlerFn[]): Promise<Response>;

package/dist/core/compose.js

@@ -0,0 +1,82 @@
+import { defaultErrorHandler } from "./error.js";
+import { parseInput } from "./request.js";
+/**
+ * Run the middleware pipeline, accumulating context via object spread.
+ * Each middleware receives the accumulated ctx and returns new fields to merge.
+ */
+export async function runMiddlewarePipeline(req, middlewares, container) {
+    let ctx = { req, container };
+    for (const mw of middlewares) {
+        const additions = await mw({ ...ctx, req });
+        ctx = { ...ctx, ...additions };
+    }
+    return ctx;
+}
+/**
+ * Run before interceptors, the handler, then after interceptors (in reverse).
+ * Before and after share a mutable `state` object created per-request.
+ */
+export async function runInterceptors(interceptors, req, ctx, handlerFn) {
+    const state = {};
+    // Run all before interceptors
+    for (const { before } of interceptors) {
+        if (before)
+            await before({ req, ctx, state });
+    }
+    // Run handler
+    let response = await handlerFn();
+    // Run all after interceptors in reverse order
+    for (const { after } of [...interceptors].reverse()) {
+        if (after)
+            response = await after({ response, ctx, state });
+    }
+    return response;
+}
+/**
+ * Coerce a handler's return value into a Response.
+ * - If already a Response, pass through.
+ * - If output schema is defined, serialize as JSON.
+ * - Otherwise throw — handler contract violation.
+ */
+export function coerceToResponse(raw, def) {
+    if (raw instanceof Response)
+        return raw;
+    if (def.outputSchema != null)
+        return Response.json(raw);
+    throw new TypeError("Handler must return a Response when no output schema is defined");
+}
+/**
+ * Full request dispatch: middleware → input parsing → interceptors + handler → error chain.
+ */
+export async function dispatch(req, definition, params, container, errorHandlers) {
+    try {
+        // 1. Build context via middleware chain
+        const ctx = await runMiddlewarePipeline(req, definition.middlewares, container);
+        // 2. Parse & validate input
+        const input = await parseInput(req, definition, params);
+        // 3. Run interceptors + handler
+        const response = await runInterceptors(definition.interceptors, req, ctx, async () => {
+            const raw = await definition.handler({
+                req,
+                ctx,
+                container,
+                path: input.path,
+                body: input.body,
+                headers: input.headers,
+                query: input.query,
+                cookies: input.cookies,
+            });
+            return coerceToResponse(raw, definition);
+        });
+        return response;
+    }
+    catch (err) {
+        for (const handler of errorHandlers) {
+            const result = await handler(err, { req });
+            if (result != null)
+                return result;
+        }
+        // Built-in fallback always returns
+        return defaultErrorHandler(err, { req });
+    }
+}

package/dist/core/cors.d.ts

@@ -0,0 +1,38 @@
+export interface CorsOptions {
+    /**
+     * Allowed origin(s).
+     * - `'*'`          — allow all origins (when credentials is false)
+     * - `string`       — allow a single explicit origin
+     * - `string[]`     — allow any origin in the list
+     * - `(origin) =>` — dynamic resolver; return the origin to allow or null/undefined to deny
+     */
+    origin: string | string[] | ((origin: string) => string | null | undefined);
+    /** HTTP methods to allow. Default: GET HEAD PUT POST DELETE PATCH */
+    allowMethods?: string[];
+    /**
+     * Headers to allow. Default: [] — when empty the middleware echoes the
+     * request's Access-Control-Request-Headers value (wildcard-like behaviour).
+     */
+    allowHeaders?: string[];
+    /** Headers to expose to the browser. Default: [] */
+    exposeHeaders?: string[];
+    /** Whether to include credentials. Default: false */
+    credentials?: boolean;
+    /** Max-age for preflight cache in seconds. Default: not set */
+    maxAge?: number;
+}
+export interface CompiledCors {
+    /**
+     * Build and return a 204 preflight response.
+     * Always returns a Response — callers decide whether to use it based on the
+     * request method being OPTIONS.
+     */
+    preflight(req: Request): Response;
+    /**
+     * Clone the response (if needed) and inject the CORS response-phase headers:
+     * Access-Control-Allow-Origin, Access-Control-Allow-Credentials,
+     * Access-Control-Expose-Headers, Vary.
+     */
+    applyTo(req: Request, res: Response): Response;
+}
+export declare function buildCors(options: CorsOptions): CompiledCors;

package/dist/core/cors.js

@@ -0,0 +1,96 @@
+// ---------------------------------------------------------------------------
+// CORS types
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// buildCors
+// ---------------------------------------------------------------------------
+const DEFAULT_ALLOW_METHODS = ["GET", "HEAD", "PUT", "POST", "DELETE", "PATCH"];
+export function buildCors(options) {
+    const { origin, allowMethods = DEFAULT_ALLOW_METHODS, allowHeaders = [], exposeHeaders = [], credentials = false, maxAge, } = options;
+    // Build a synchronous origin resolver -----------------------------------
+    function resolveOrigin(requestOrigin) {
+        if (typeof origin === "function") {
+            return origin(requestOrigin) ?? null;
+        }
+        if (origin === "*") {
+            // The spec forbids Access-Control-Allow-Origin: * together with
+            // Access-Control-Allow-Credentials: true — reflect the request origin.
+            return credentials ? requestOrigin || null : "*";
+        }
+        if (Array.isArray(origin)) {
+            return origin.includes(requestOrigin) ? requestOrigin : null;
+        }
+        // Single explicit origin string
+        return origin === requestOrigin ? requestOrigin : null;
+    }
+    // Whether to add Vary: Origin -------------------------------------------
+    function needsVary() {
+        // When the effective origin is always literal '*' (no credentials, no
+        // dynamic/list/single origin), Vary is unnecessary.
+        return credentials || origin !== "*";
+    }
+    // ── preflight -----------------------------------------------------------
+    function preflight(req) {
+        const requestOrigin = req.headers.get("origin") ?? "";
+        const allowed = resolveOrigin(requestOrigin);
+        const headers = new Headers();
+        if (allowed) {
+            headers.set("Access-Control-Allow-Origin", allowed);
+        }
+        if (credentials) {
+            headers.set("Access-Control-Allow-Credentials", "true");
+        }
+        if (needsVary()) {
+            headers.set("Vary", "Origin");
+        }
+        if (maxAge != null) {
+            headers.set("Access-Control-Max-Age", String(maxAge));
+        }
+        if (allowMethods.length) {
+            headers.set("Access-Control-Allow-Methods", allowMethods.join(", "));
+        }
+        // Allowed headers: use configured list or echo the request header
+        let effectiveAllowHeaders = allowHeaders;
+        if (!effectiveAllowHeaders.length) {
+            const requested = req.headers.get("access-control-request-headers");
+            if (requested) {
+                effectiveAllowHeaders = requested.split(/\s*,\s*/);
+            }
+        }
+        if (effectiveAllowHeaders.length) {
+            headers.set("Access-Control-Allow-Headers", effectiveAllowHeaders.join(", "));
+            // Vary on this header when it was echoed from the request
+            if (!allowHeaders.length) {
+                const vary = headers.get("Vary");
+                headers.set("Vary", vary
+                    ? `${vary}, Access-Control-Request-Headers`
+                    : "Access-Control-Request-Headers");
+            }
+        }
+        return new Response(null, { status: 204, headers });
+    }
+    // ── applyTo -------------------------------------------------------------
+    function applyTo(req, res) {
+        const requestOrigin = req.headers.get("origin") ?? "";
+        const allowed = resolveOrigin(requestOrigin);
+        // Nothing to add if origin is not allowed
+        if (!allowed)
+            return res;
+        // Clone response so we can safely mutate headers
+        const next = new Response(res.body, res);
+        next.headers.set("Access-Control-Allow-Origin", allowed);
+        if (credentials) {
+            next.headers.set("Access-Control-Allow-Credentials", "true");
+        }
+        if (exposeHeaders.length) {
+            next.headers.set("Access-Control-Expose-Headers", exposeHeaders.join(", "));
+        }
+        if (needsVary()) {
+            // Append rather than set to preserve any existing Vary value
+            const existing = next.headers.get("Vary");
+            next.headers.set("Vary", existing ? `${existing}, Origin` : "Origin");
+        }
+        return next;
+    }
+    return { preflight, applyTo };
+}

package/dist/core/error.d.ts

@@ -0,0 +1,52 @@
+import type * as v from "valibot";
+import type { HttpMethod } from "./types.ts";
+export declare class HttpError extends Error {
+    readonly status: number;
+    constructor(status: number, message: string, cause?: unknown);
+    toResponse(development?: boolean): Response;
+}
+export declare class BadRequestError extends HttpError {
+    constructor(message?: string, cause?: unknown);
+}
+export declare class UnauthorizedError extends HttpError {
+    constructor(message?: string);
+}
+export declare class ForbiddenError extends HttpError {
+    constructor(message?: string);
+}
+export declare class NotFoundError extends HttpError {
+    constructor(message?: string);
+}
+export declare class MethodNotAllowedError extends HttpError {
+    constructor(message?: string);
+}
+export declare class ConflictError extends HttpError {
+    constructor(message?: string, cause?: unknown);
+}
+export declare class UnprocessableEntityError extends HttpError {
+    constructor(message?: string, cause?: unknown);
+}
+export declare class TooManyRequestsError extends HttpError {
+    constructor(message?: string);
+}
+export declare class InternalServerError extends HttpError {
+    constructor(message?: string, cause?: unknown);
+}
+export type ValidationField = "body" | "headers" | "query" | "cookies" | "path";
+export declare class ValidationError extends HttpError {
+    readonly field: ValidationField;
+    readonly issues: v.BaseIssue<unknown>[];
+    constructor(field: ValidationField, issues: v.BaseIssue<unknown>[]);
+    toResponse(): Response;
+}
+export interface ErrorHandlerOpts {
+    development?: boolean;
+    logger?: {
+        error: (...args: unknown[]) => void;
+    };
+}
+export declare function defaultErrorHandler(err: unknown, _args: {
+    req: Request;
+}, opts?: ErrorHandlerOpts): Response;
+export declare function defaultNotFoundHandler(req: Request): Response;
+export declare function defaultMethodNotAllowedHandler(_req: Request, allowed: HttpMethod[]): Response;

package/dist/core/error.js

@@ -0,0 +1,99 @@
+export class HttpError extends Error {
+    status;
+    constructor(status, message, cause) {
+        super(message, { cause });
+        this.status = status;
+        this.name = "HttpError";
+    }
+    toResponse(development = false) {
+        const body = { error: this.message };
+        if (development && this.stack)
+            body.stack = this.stack;
+        return Response.json(body, { status: this.status });
+    }
+}
+export class BadRequestError extends HttpError {
+    constructor(message = "Bad Request", cause) {
+        super(400, message, cause);
+    }
+}
+export class UnauthorizedError extends HttpError {
+    constructor(message = "Unauthorized") {
+        super(401, message);
+    }
+}
+export class ForbiddenError extends HttpError {
+    constructor(message = "Forbidden") {
+        super(403, message);
+    }
+}
+export class NotFoundError extends HttpError {
+    constructor(message = "Not Found") {
+        super(404, message);
+    }
+}
+export class MethodNotAllowedError extends HttpError {
+    constructor(message = "Method Not Allowed") {
+        super(405, message);
+    }
+}
+export class ConflictError extends HttpError {
+    constructor(message = "Conflict", cause) {
+        super(409, message, cause);
+    }
+}
+export class UnprocessableEntityError extends HttpError {
+    constructor(message = "Unprocessable Entity", cause) {
+        super(422, message, cause);
+    }
+}
+export class TooManyRequestsError extends HttpError {
+    constructor(message = "Too Many Requests") {
+        super(429, message);
+    }
+}
+export class InternalServerError extends HttpError {
+    constructor(message = "Internal Server Error", cause) {
+        super(500, message, cause);
+    }
+}
+export class ValidationError extends HttpError {
+    field;
+    issues;
+    constructor(field, issues) {
+        super(400, "Validation Error");
+        this.name = "ValidationError";
+        this.field = field;
+        this.issues = issues;
+    }
+    toResponse() {
+        return Response.json({
+            error: "ValidationError",
+            field: this.field,
+            issues: this.issues.map((i) => ({
+                message: i.message,
+                path: i.path?.map((p) => p.key) ?? [],
+            })),
+        }, { status: 400 });
+    }
+}
+export function defaultErrorHandler(err, _args, opts = {}) {
+    if (err instanceof HttpError) {
+        return err.toResponse(opts.development);
+    }
+    const logger = opts.logger ?? console;
+    logger.error("[fishenv.http] Unhandled error:", err);
+    const body = { error: "Internal Server Error" };
+    if (opts.development && err instanceof Error)
+        body.stack = err.stack;
+    return Response.json(body, { status: 500 });
+}
+export function defaultNotFoundHandler(req) {
+    return Response.json({ error: "Not Found", path: new URL(req.url).pathname }, { status: 404 });
+}
+export function defaultMethodNotAllowedHandler(_req, allowed) {
+    return new Response(null, {
+        status: 405,
+        headers: { Allow: allowed.join(", ") },
+    });
+}

package/dist/core/index.d.ts

@@ -0,0 +1,16 @@
+export { coerceToResponse, dispatch, runInterceptors, runMiddlewarePipeline, } from "./compose.ts";
+export type { CompiledCors, CorsOptions } from "./cors.ts";
+export { buildCors } from "./cors.ts";
+export type { ValidationField } from "./error.ts";
+export { BadRequestError, ConflictError, defaultErrorHandler, defaultMethodNotAllowedHandler, defaultNotFoundHandler, ForbiddenError, HttpError, InternalServerError, MethodNotAllowedError, NotFoundError, TooManyRequestsError, UnauthorizedError, UnprocessableEntityError, ValidationError, } from "./error.ts";
+export type { MatchedRoute, RouterMatcher } from "./matcher.ts";
+export { Matcher } from "./matcher.ts";
+export type { ParsedInput } from "./request.ts";
+export { extractHeaders, extractQuery, parseBody, parseCookies, parseInput, } from "./request.ts";
+export type { RouterRef } from "./route-builder.ts";
+export { createRouteBuilder, createRouteBuilderFromContract, FinishedRoute, RouteBuilder, } from "./route-builder.ts";
+export type { CtxOf, HttpServer, Logger, ServeOptions } from "./router.ts";
+export { Router, r, router, serve } from "./router.ts";
+export type { AfterInterceptorFn, AnySchema, BasePathParams, BeforeInterceptorFn, DIContainer, ErrorHandlerFn, ExtractParams, HandlerArgs, HandlerFn, HttpMethod, InferBody, InferCookies, InferHeaders, InferOutput, InferQuery, InputKind, InputOptions, InterceptorPair, InterceptorState, MergeCtx, MergeParam, MiddlewareFn, NotFoundHandler, ResolvedInput, RouteDefinition, RouteMeta, ValibotSchema, } from "./types.ts";
+export { buildRouteRegex, extractParamNames, mergePaths } from "./utils/url.ts";
+export { validateField, validatePathParams } from "./validation.ts";

package/dist/core/index.js

@@ -0,0 +1,19 @@
+// Types
+// Compose (pipeline)
+export { coerceToResponse, dispatch, runInterceptors, runMiddlewarePipeline, } from "./compose.js";
+// CORS
+export { buildCors } from "./cors.js";
+// Errors
+export { BadRequestError, ConflictError, defaultErrorHandler, defaultMethodNotAllowedHandler, defaultNotFoundHandler, ForbiddenError, HttpError, InternalServerError, MethodNotAllowedError, NotFoundError, TooManyRequestsError, UnauthorizedError, UnprocessableEntityError, ValidationError, } from "./error.js";
+// Matcher
+export { Matcher } from "./matcher.js";
+// Request parsing
+export { extractHeaders, extractQuery, parseBody, parseCookies, parseInput, } from "./request.js";
+// Route Builder
+export { createRouteBuilder, createRouteBuilderFromContract, FinishedRoute, RouteBuilder, } from "./route-builder.js";
+// Router
+export { Router, r, router, serve } from "./router.js";
+// URL utilities
+export { buildRouteRegex, extractParamNames, mergePaths } from "./utils/url.js";
+// Validation
+export { validateField, validatePathParams } from "./validation.js";