@mpen/routekit 0.1.0 → 0.1.1

package/dist/routes.d.mts

@@ -0,0 +1,282 @@
+import { C as MiddlewareInput, F as RouteMeta, I as RouteOptions, N as Route, P as RouteMatch, R as RouteSchema, S as MiddlewareEntry, a as MiddlewareResponseDeclaration, f as ContextFromMiddlewareInput, g as HandlerResult, h as HandlerContext, l as AddedContextFromMiddlewareInput, n as DeclaredMiddleware, r as DefineMiddlewareOptions, t as Router, u as AnyContext } from "./router-Cwb7ak0J.mjs";
+import { n as RoutekitResponse } from "./core-CzUCxvGk.mjs";
+import { a as ValibotRouteHandler, c as ValibotSchemaMiddlewareOptions, d as ValibotValidationErrorHandler, f as createValibotRouteBuilder, i as ValibotRouteBuilder, l as ValibotValidationError, m as valibotSchemaMiddleware, n as ValibotHandlerContext, o as ValibotRouteHelperDefaults, p as defineValibotMiddleware, r as ValibotHandlerParams, s as ValibotRouteSchemaInput, t as DefineValibotMiddlewareOptions, u as ValibotValidationErrorBody } from "./valibot-D7liFYyB.mjs";
+import { z } from "zod";
+
+//#region src/router/routes/zod/zod.d.ts
+/**
+ * Validation error component identifiers for Zod-backed routes.
+ */
+declare const enum ValidationError {
+  REQUEST_BODY = 0,
+  URL_PATH = 1,
+  QUERY_PARAMETERS = 2
+}
+type ErrorTree = ReturnType<typeof z.treeifyError>;
+type ZodSchema = z.ZodTypeAny | undefined;
+type AnyZodResponseBodySchemas = Partial<Record<number | 'default', z.ZodTypeAny>>;
+type ZodResponseBodySchemas = AnyZodResponseBodySchemas | undefined;
+type ResponseValidationMode = false | 'strict' | 'parse';
+type ResponseValidationOption = boolean | ResponseValidationMode;
+type ZodRouteContext<Ctx extends object, BuilderMiddleware, RouteMiddleware> = Ctx & AddedContextFromMiddlewareInput<BuilderMiddleware> & AddedContextFromMiddlewareInput<RouteMiddleware>;
+type ZodBuilderMiddlewareInput<Ctx extends object, BuilderMiddleware extends MiddlewareInput<Ctx>, RouteMiddleware extends MiddlewareInput<Ctx>> = [BuilderMiddleware] extends [undefined] ? RouteMiddleware : [RouteMiddleware] extends [undefined] ? BuilderMiddleware : MiddlewareInput<Ctx>;
+/**
+ * Default validation error payload returned by Zod-backed routes.
+ */
+type ZodValidationErrorBody = {
+  component: 'request_body' | 'url_path' | 'query_parameters';
+  errorTree: ErrorTree;
+  message: string;
+};
+/**
+ * Zod schema input that mirrors the core route `schema` shape.
+ */
+type ZodRouteSchemaInput<BodySchema extends ZodSchema = undefined, PathSchema extends ZodSchema = undefined, QuerySchema extends ZodSchema = undefined, ResponseBodySchemas extends ZodResponseBodySchemas = undefined> = {
+  request?: {
+    query?: QuerySchema;
+    path?: PathSchema;
+    body?: BodySchema;
+  };
+  response?: {
+    body?: ResponseBodySchemas;
+  };
+};
+type InferSchema<Schema extends ZodSchema> = Schema extends z.ZodTypeAny ? z.infer<Schema> : unknown;
+type InferResponseBodySchemaUnion<ResponseBodySchemas extends AnyZodResponseBodySchemas> = [keyof ResponseBodySchemas] extends [never] ? unknown : { [Status in keyof ResponseBodySchemas]: NonNullable<ResponseBodySchemas[Status]> extends z.ZodTypeAny ? z.infer<NonNullable<ResponseBodySchemas[Status]>> : never }[keyof ResponseBodySchemas];
+type InferResponseBody<ResponseBodySchemas extends ZodResponseBodySchemas> = ResponseBodySchemas extends AnyZodResponseBodySchemas ? 200 extends keyof ResponseBodySchemas ? InferResponseBodySchemaUnion<ResponseBodySchemas> : 'default' extends keyof ResponseBodySchemas ? InferResponseBodySchemaUnion<ResponseBodySchemas> : unknown : unknown;
+type NormalizeSchema<Schema> = Schema extends ZodRouteSchemaInput<any, any, any, any> ? Schema : ZodRouteSchemaInput<undefined, undefined, undefined, undefined>;
+type ExtractBodySchema<Schema extends ZodRouteSchemaInput<any, any, any, any> | undefined> = NormalizeSchema<Schema> extends ZodRouteSchemaInput<infer BodySchema, any, any, any> ? BodySchema : undefined;
+type ExtractPathSchema<Schema extends ZodRouteSchemaInput<any, any, any, any> | undefined> = NormalizeSchema<Schema> extends ZodRouteSchemaInput<any, infer PathSchema, any, any> ? PathSchema : undefined;
+type ExtractQuerySchema<Schema extends ZodRouteSchemaInput<any, any, any, any> | undefined> = NormalizeSchema<Schema> extends ZodRouteSchemaInput<any, any, infer QuerySchema, any> ? QuerySchema : undefined;
+type ExtractResponseBodySchemas<Schema extends ZodRouteSchemaInput<any, any, any, any> | undefined> = NormalizeSchema<Schema> extends ZodRouteSchemaInput<any, any, any, infer ResponseBodySchemas> ? ResponseBodySchemas : undefined;
+type ZodMiddlewareDeclarations<Schemas extends AnyZodResponseBodySchemas> = { [Status in keyof Schemas]: NonNullable<Schemas[Status]> extends z.ZodTypeAny ? MiddlewareResponseDeclaration<z.infer<NonNullable<Schemas[Status]>>> : never };
+type ZodDeclaredResponse<Schemas extends AnyZodResponseBodySchemas> = { [Status in keyof Schemas]-?: NonNullable<Schemas[Status]> extends z.ZodTypeAny ? RoutekitResponse<z.infer<NonNullable<Schemas[Status]>>, Status extends number ? Status : number> : never }[keyof Schemas];
+type ZodSchemaMiddlewareContext<Schema extends ZodRouteSchemaInput<any, any, any, any> | undefined> = {
+  params: ZodHandlerParams<ExtractBodySchema<Schema>, ExtractPathSchema<Schema>, ExtractQuerySchema<Schema>>;
+};
+/**
+ * Validated request inputs exposed to a Zod-backed handler.
+ */
+type ZodHandlerParams<BodySchema extends ZodSchema, PathSchema extends ZodSchema, QuerySchema extends ZodSchema> = {
+  path: InferSchema<PathSchema>;
+  query: InferSchema<QuerySchema>;
+  body: InferSchema<BodySchema>;
+};
+/**
+ * Context object exposed to a Zod-backed handler.
+ */
+type ZodHandlerContext<BodySchema extends ZodSchema, PathSchema extends ZodSchema, QuerySchema extends ZodSchema, Ctx extends object> = Omit<HandlerContext<Ctx>, 'path'> & {
+  params: ZodHandlerParams<BodySchema, PathSchema, QuerySchema>;
+};
+/**
+ * Validation error handler used when request parsing fails.
+ *
+ * @param component - Request component that failed validation.
+ * @param error - The Zod validation error.
+ * @returns A handler result that should be returned to the client.
+ */
+type ValidationErrorHandler<Responses extends AnyZodResponseBodySchemas = AnyZodResponseBodySchemas> = (component: ValidationError, error: z.ZodError) => ZodDeclaredResponse<Responses>;
+/**
+ * Shared defaults that can be applied to Zod handler helpers.
+ */
+type ZodHandlerDefaults = {
+  /**
+   * Route schema fragments that should be merged into every factory-built route.
+   * Route-level schemas override matching request fields and response status codes.
+   */
+  schema?: ZodRouteSchemaInput<any, any, any, any>;
+  /**
+   * Whether and how to apply `schema.response.body` to handler responses.
+   * `false` disables response validation, `true` and `'strict'` validate without changing the
+   * response body, and `'parse'` returns the parsed response body. Defaults to `'parse'`.
+   */
+  validateResponse?: ResponseValidationOption;
+} & ({
+  onRequestValidationError?: undefined;
+  validationResponses?: undefined;
+} | {
+  /**
+   * Override the default request validation error response.
+   */
+  onRequestValidationError: ValidationErrorHandler;
+  /**
+   * Response schemas returned by `onRequestValidationError`.
+   */
+  validationResponses: AnyZodResponseBodySchemas;
+});
+/**
+ * Shared defaults that can be applied to Zod route helpers.
+ */
+type ZodRouteHelperDefaults<BuilderCtx extends object = AnyContext, BuilderMiddleware extends MiddlewareInput<BuilderCtx> = undefined> = ZodHandlerDefaults & {
+  /**
+   * Middleware applied to every route built by the helper.
+   */
+  middleware?: BuilderMiddleware;
+};
+/**
+ * Handler signature used by Zod schema boundaries and route builders.
+ */
+type ZodRouteHandler<BodySchema extends ZodSchema, PathSchema extends ZodSchema, QuerySchema extends ZodSchema, ResponseBodySchemas extends ZodResponseBodySchemas, Ctx extends object = AnyContext> = (this: Router<any>, ctx: ZodHandlerContext<BodySchema, PathSchema, QuerySchema, Ctx>) => HandlerResult<InferResponseBody<ResponseBodySchemas>>;
+/**
+ * Shared options used by Zod route builders.
+ */
+type ZodHandlerOptions<Schema extends ZodRouteSchemaInput<any, any, any, any> | undefined, Ctx extends object = AnyContext> = ZodHandlerDefaults & {
+  schema?: Schema;
+  handler: ZodRouteHandler<ExtractBodySchema<Schema>, ExtractPathSchema<Schema>, ExtractQuerySchema<Schema>, ExtractResponseBodySchemas<Schema>, Ctx>;
+};
+/**
+ * Full route options used by Zod route builders.
+ */
+type ZodRouteOptions<Schema extends ZodRouteSchemaInput<any, any, any, any> | undefined, Ctx extends object = AnyContext, BuilderMiddleware extends MiddlewareInput<Ctx> = undefined, RouteMiddleware extends MiddlewareInput<Ctx> = undefined> = Omit<Route<Ctx, RouteMiddleware, ZodRouteContext<Ctx, BuilderMiddleware, RouteMiddleware>>, 'handler' | 'schema' | 'middleware'> & ZodHandlerOptions<Schema, ZodRouteContext<Ctx, BuilderMiddleware, RouteMiddleware>> & {
+  middleware?: RouteMiddleware;
+};
+/**
+ * Method-specific route options used by Zod route builders.
+ */
+type WithZodOptions<Schema extends ZodRouteSchemaInput<any, any, any, any> | undefined, Ctx extends object = AnyContext, BuilderMiddleware extends MiddlewareInput<Ctx> = undefined, RouteMiddleware extends MiddlewareInput<Ctx> = undefined> = Omit<RouteOptions<Ctx, RouteMiddleware, ZodRouteContext<Ctx, BuilderMiddleware, RouteMiddleware>>, 'handler' | 'schema' | 'middleware'> & ZodHandlerOptions<Schema, ZodRouteContext<Ctx, BuilderMiddleware, RouteMiddleware>> & {
+  middleware?: RouteMiddleware;
+};
+/**
+ * Zod route builder created by [`createZodRouteBuilder`]{@link createZodRouteBuilder}.
+ *
+ * @example
+ * ```ts
+ * const route = createZodRouteBuilder()
+ *
+ * router.get('/users/:id', route({
+ *   schema: {
+ *     request: {
+ *       path: z.object({id: z.string()}),
+ *     },
+ *   },
+ *   handler: ({params}) => ({id: params.path.id}),
+ * }))
+ *
+ * router.add(route({
+ *   method: HttpMethod.GET,
+ *   path: '/health',
+ *   handler: () => ({ok: true}),
+ * }))
+ * ```
+ */
+type ZodRouteBuilder<BuilderCtx extends object = AnyContext, BuilderMiddleware extends MiddlewareInput<BuilderCtx> = undefined> = {
+  /**
+   * Build a full route definition that includes its own path.
+   *
+   * @param options - Full route options including `path`.
+   * @returns A full route definition compatible with [`Router.add`]{@link Router#add}.
+   */
+  <Schema extends ZodRouteSchemaInput<any, any, any, any> | undefined, RouteMiddleware extends MiddlewareInput<BuilderCtx> = undefined>(options: ZodRouteOptions<Schema, BuilderCtx, BuilderMiddleware, RouteMiddleware>): Route<BuilderCtx, ZodBuilderMiddlewareInput<BuilderCtx, BuilderMiddleware, RouteMiddleware>, ZodRouteContext<BuilderCtx, BuilderMiddleware, RouteMiddleware>>;
+  /**
+   * Build method-specific route options that leave the path to the registering router.
+   *
+   * @param options - Method route options without a route path.
+   * @returns Route options compatible with helpers like [`Router.get`]{@link Router#get}.
+   */
+  <Schema extends ZodRouteSchemaInput<any, any, any, any> | undefined, RouteMiddleware extends MiddlewareInput<BuilderCtx> = undefined>(options: WithZodOptions<Schema, BuilderCtx, BuilderMiddleware, RouteMiddleware>): RouteOptions<BuilderCtx, ZodBuilderMiddlewareInput<BuilderCtx, BuilderMiddleware, RouteMiddleware>, ZodRouteContext<BuilderCtx, BuilderMiddleware, RouteMiddleware>>;
+};
+/**
+ * Options for [`defineZodMiddleware`]{@link defineZodMiddleware}.
+ *
+ * @typeParam AddedCtx - Context made available to downstream handlers.
+ * @typeParam Ctx - Context required by the middleware.
+ * @typeParam Responses - Status-keyed Zod schemas for locally originated responses.
+ */
+type DefineZodMiddlewareOptions<AddedCtx extends object, Ctx extends object, Responses extends AnyZodResponseBodySchemas> = {
+  responses: Responses;
+  run: DefineMiddlewareOptions<AddedCtx, Ctx, ZodMiddlewareDeclarations<Responses>>['run'];
+};
+/**
+ * Create response-declaring middleware backed by Zod response schemas.
+ *
+ * @example
+ * ```ts
+ * const requireAuth = defineZodMiddleware({
+ *     responses: { 401: z.object({ message: z.string() }) },
+ *     run: (_ctx, { respond }) => respond(response({ message: 'Sign in' }, { status: 401 })),
+ * })
+ * ```
+ *
+ * @param options - Locally originated response schemas and middleware implementation.
+ * @returns Declared middleware with inferred, runtime-validated terminal responses.
+ * @typeParam AddedCtx - Context made available to downstream handlers.
+ * @typeParam Ctx - Context required by the middleware.
+ * @typeParam Responses - Status-keyed Zod schemas for locally originated responses.
+ */
+declare function defineZodMiddleware<AddedCtx extends object = {}, Ctx extends object = AnyContext, const Responses extends AnyZodResponseBodySchemas = {}>(options: DefineZodMiddlewareOptions<AddedCtx, Ctx, Responses>): DeclaredMiddleware<AddedCtx, Ctx>;
+/**
+ * Options for [`zodSchemaMiddleware`]{@link zodSchemaMiddleware}.
+ *
+ * @typeParam Schema - Zod request and downstream response schema declaration.
+ */
+type ZodSchemaMiddlewareBaseOptions<Schema extends ZodRouteSchemaInput<any, any, any, any> | undefined> = {
+  schema?: Schema;
+  validateResponse?: ResponseValidationOption;
+};
+/**
+ * Options for a Zod request/response schema boundary.
+ *
+ * A custom request-validation callback must declare the response schemas it can originate.
+ *
+ * @typeParam Schema - Zod request and downstream response schema declaration.
+ * @typeParam ValidationResponses - Schemas owned by a custom validation-error callback.
+ */
+type ZodSchemaMiddlewareOptions<Schema extends ZodRouteSchemaInput<any, any, any, any> | undefined, ValidationResponses extends AnyZodResponseBodySchemas | undefined = undefined> = ZodSchemaMiddlewareBaseOptions<Schema> & ([ValidationResponses] extends [undefined] ? {
+  onRequestValidationError?: undefined;
+  validationResponses?: undefined;
+} : {
+  onRequestValidationError: ValidationErrorHandler<Extract<ValidationResponses, AnyZodResponseBodySchemas>>;
+  validationResponses: ValidationResponses;
+});
+/**
+ * Create Zod middleware that parses request inputs and validates downstream responses.
+ *
+ * @example
+ * ```ts
+ * const parseUserId = zodSchemaMiddleware({
+ *     schema: { request: { path: z.object({ id: z.string() }) } },
+ * })
+ * ```
+ *
+ * @param options - Request, response, and validation-error schema behavior.
+ * @returns Declared middleware exposing parsed request values to downstream handlers.
+ * @typeParam Schema - Zod request and downstream response schema declaration.
+ * @typeParam Ctx - Context required before this middleware executes.
+ */
+declare function zodSchemaMiddleware<Schema extends ZodRouteSchemaInput<any, any, any, any> | undefined, const ValidationResponses extends AnyZodResponseBodySchemas | undefined = undefined, Ctx extends object = AnyContext>(options: ZodSchemaMiddlewareOptions<Schema, ValidationResponses>): DeclaredMiddleware<ZodSchemaMiddlewareContext<Schema>, Ctx>;
+/**
+ * Create a Zod route builder with shared defaults.
+ *
+ * @example
+ * ```ts
+ * const route = createZodRouteBuilder({
+ *   validateResponse: false,
+ *   schema: {
+ *     response: {
+ *       body: {
+ *         400: z.object({message: z.string()}),
+ *       },
+ *     },
+ *   },
+ * })
+ *
+ * router.post('/users/:id', route({
+ *   name: 'user.update',
+ *   schema: {
+ *     request: {
+ *       path: z.object({id: z.string()}),
+ *     },
+ *   },
+ *   handler: ({params}) => ({id: params.path.id}),
+ * }))
+ * ```
+ *
+ * @param defaults - Default schema fragments, response validation, and request validation error handling.
+ * @returns A route builder compatible with method-specific router helpers and full route definitions.
+ */
+declare function createZodRouteBuilder<BuilderMiddleware extends MiddlewareInput<any>, BuilderCtx extends object = ContextFromMiddlewareInput<BuilderMiddleware>>(defaults: ZodRouteHelperDefaults<BuilderCtx, BuilderMiddleware> & {
+  middleware: BuilderMiddleware;
+}): ZodRouteBuilder<BuilderCtx, BuilderMiddleware>;
+declare function createZodRouteBuilder<BuilderCtx extends object = AnyContext, BuilderMiddleware extends MiddlewareInput<BuilderCtx> = undefined>(defaults?: ZodRouteHelperDefaults<BuilderCtx, BuilderMiddleware>): ZodRouteBuilder<BuilderCtx, BuilderMiddleware>;
+//#endregion
+export { type AddedContextFromMiddlewareInput, type ContextFromMiddlewareInput, type DefineValibotMiddlewareOptions, type DefineZodMiddlewareOptions, type MiddlewareEntry, type Route, type RouteMatch, type RouteMeta, type RouteOptions, type RouteSchema, type ValibotHandlerContext, type ValibotHandlerParams, type ValibotRouteBuilder, type ValibotRouteHandler, type ValibotRouteHelperDefaults, type ValibotRouteSchemaInput, type ValibotSchemaMiddlewareOptions, ValibotValidationError, type ValibotValidationErrorBody, type ValibotValidationErrorHandler, ValidationError, type ValidationErrorHandler, type ZodHandlerContext, type ZodHandlerParams, type ZodRouteBuilder, type ZodRouteHandler, type ZodRouteHelperDefaults, type ZodRouteSchemaInput, type ZodSchemaMiddlewareOptions, type ZodValidationErrorBody, createValibotRouteBuilder, createZodRouteBuilder, defineValibotMiddleware, defineZodMiddleware, valibotSchemaMiddleware, zodSchemaMiddleware };

package/dist/routes.mjs

@@ -0,0 +1,311 @@
+import { M as isJsonContentType, f as defineMiddleware, t as RequestBodyError } from "./request-Dn0zc-xm.mjs";
+import { a as response, i as isRoutekitResponse, r as isRoutekitBody } from "./core-DbmQauwS.mjs";
+import { i as valibotSchemaMiddleware, n as createValibotRouteBuilder, r as defineValibotMiddleware, t as ValibotValidationError } from "./valibot-Du97X-TS.mjs";
+import { HttpStatus } from "@mpen/http";
+import { z } from "zod";
+//#region src/router/routes/zod/zod.ts
+/**
+* Validation error component identifiers for Zod-backed routes.
+*/
+let ValidationError = /* @__PURE__ */ function(ValidationError) {
+	ValidationError[ValidationError["REQUEST_BODY"] = 0] = "REQUEST_BODY";
+	ValidationError[ValidationError["URL_PATH"] = 1] = "URL_PATH";
+	ValidationError[ValidationError["QUERY_PARAMETERS"] = 2] = "QUERY_PARAMETERS";
+	return ValidationError;
+}({});
+const validationErrorComponentName = new Map([
+	[0, "request_body"],
+	[1, "url_path"],
+	[2, "query_parameters"]
+]);
+var ZodResponseValidationError = class extends Error {
+	status;
+	error;
+	constructor(status, error) {
+		super(`Response validation failed for status ${status}: ${z.prettifyError(error)}`);
+		this.name = "ZodResponseValidationError";
+		this.status = status;
+		this.error = error;
+	}
+};
+function createValidationResponse(component, error) {
+	return response({
+		component: validationErrorComponentName.get(component) ?? "request_body",
+		errorTree: z.treeifyError(error),
+		message: z.prettifyError(error)
+	}, { status: HttpStatus.BAD_REQUEST });
+}
+function normalizeResponseValidationMode(option) {
+	if (option === true) return "strict";
+	return option;
+}
+function readQueryParams(searchParams) {
+	const query = {};
+	for (const [key, value] of searchParams.entries()) {
+		const existing = query[key];
+		if (existing === void 0) {
+			query[key] = value;
+			continue;
+		}
+		if (Array.isArray(existing)) existing.push(value);
+		else query[key] = [existing, value];
+	}
+	return query;
+}
+function zodErrorFromThrowable(error) {
+	return new z.ZodError([{
+		code: z.ZodIssueCode.custom,
+		path: [],
+		message: error instanceof Error ? error.message : String(error)
+	}]);
+}
+function sanitizeJsonSchema(schema) {
+	if (Array.isArray(schema)) return schema.map((entry) => sanitizeJsonSchema(entry));
+	if (!schema || typeof schema !== "object") return schema;
+	const sanitizedEntries = Object.entries(schema).filter(([key]) => key !== "$schema" && key !== "~standard").map(([key, value]) => [key, sanitizeJsonSchema(value)]);
+	return Object.fromEntries(sanitizedEntries);
+}
+function toJsonSchema(schema) {
+	return sanitizeJsonSchema(z.toJSONSchema(schema));
+}
+function buildRouteSchema(schema) {
+	if (!schema) return void 0;
+	const request = schema.request ? {
+		...schema.request.query ? { query: toJsonSchema(schema.request.query) } : {},
+		...schema.request.path ? { path: toJsonSchema(schema.request.path) } : {},
+		...schema.request.body ? { body: toJsonSchema(schema.request.body) } : {}
+	} : void 0;
+	const responseBody = schema.response?.body ? Object.fromEntries(Object.entries(schema.response.body).map(([status, responseSchema]) => {
+		return [status === "default" ? status : Number(status), toJsonSchema(responseSchema)];
+	})) : void 0;
+	const response = responseBody && Object.keys(responseBody).length > 0 ? { body: responseBody } : void 0;
+	if ((!request || Object.keys(request).length === 0) && !response) return;
+	return {
+		...request && Object.keys(request).length > 0 ? { request } : {},
+		...response ? { response } : {}
+	};
+}
+function buildZodMiddlewareDeclarations(schemas) {
+	return Object.fromEntries(Object.entries(schemas).flatMap(([status, schema]) => schema ? [[status, {
+		schema: toJsonSchema(schema),
+		parse: (value) => schema.parse(value)
+	}]] : []));
+}
+function defineZodMiddleware(options) {
+	return defineMiddleware({
+		responses: buildZodMiddlewareDeclarations(options.responses),
+		run: options.run
+	});
+}
+function mergeRouteSchema(defaults, schema) {
+	const defaultSchema = defaults.schema;
+	if (!defaultSchema) return schema;
+	if (!schema) return defaultSchema;
+	const request = !defaultSchema.request && !schema.request ? void 0 : {
+		...defaultSchema.request,
+		...schema.request
+	};
+	const defaultBody = defaultSchema.response?.body ?? {};
+	const routeBody = schema.response?.body ?? {};
+	const responseBody = {};
+	const statuses = new Set([...Object.keys(defaultBody), ...Object.keys(routeBody)]);
+	for (const status of statuses) {
+		const s = status === "default" ? status : Number(status);
+		const defaultStatusSchema = defaultBody[s];
+		const routeStatusSchema = routeBody[s];
+		if (defaultStatusSchema && routeStatusSchema) responseBody[s] = z.union([defaultStatusSchema, routeStatusSchema]);
+		else if (defaultStatusSchema) responseBody[s] = defaultStatusSchema;
+		else if (routeStatusSchema) responseBody[s] = routeStatusSchema;
+	}
+	const response = Object.keys(responseBody).length > 0 ? { body: responseBody } : void 0;
+	return {
+		...request ? { request } : {},
+		...response ? { response } : {}
+	};
+}
+function normalizeMiddlewareInput(middleware) {
+	if (!middleware) return [];
+	if (Array.isArray(middleware)) return middleware.filter(Boolean);
+	return [middleware];
+}
+function mergeMiddleware(defaultMiddleware, routeMiddleware) {
+	const list = [...normalizeMiddlewareInput(defaultMiddleware), ...normalizeMiddlewareInput(routeMiddleware)];
+	return list.length ? list : void 0;
+}
+function mergeZodOptions(defaults, options) {
+	const { middleware: defaultMiddleware, ...defaultOptions } = defaults;
+	const schema = mergeRouteSchema(defaults, options.schema);
+	const middleware = mergeMiddleware(defaultMiddleware, options.middleware);
+	return {
+		...defaultOptions,
+		...options,
+		...schema === void 0 ? {} : { schema },
+		...middleware === void 0 ? {} : { middleware }
+	};
+}
+function hasRoutePath(options) {
+	return options.path !== void 0;
+}
+function isSkippableResponseValidationValue(value) {
+	return value instanceof ReadableStream || value instanceof Uint8Array || typeof Buffer !== "undefined" && value instanceof Buffer || !!value && typeof value === "object" && Symbol.asyncIterator in value;
+}
+function jsonValuesEqual(left, right) {
+	if (Object.is(left, right)) return true;
+	if (typeof left !== typeof right) return false;
+	if (!left || !right || typeof left !== "object") return false;
+	if (Array.isArray(left) || Array.isArray(right)) return Array.isArray(left) && Array.isArray(right) && left.length === right.length && left.every((value, index) => jsonValuesEqual(value, right[index]));
+	const leftEntries = Object.entries(left);
+	const rightRecord = right;
+	const rightKeys = new Set(Object.keys(rightRecord));
+	return leftEntries.length === rightKeys.size && leftEntries.every(([key, value]) => rightKeys.has(key) && jsonValuesEqual(value, rightRecord[key]));
+}
+function getResponseSchemaForStatus(schema, status) {
+	return schema?.response?.body?.[status] ?? schema?.response?.body?.default;
+}
+async function readResponseBodyForValidation(response) {
+	if (!response.body) return void 0;
+	const contentType = response.headers.get("content-type") ?? "";
+	const clone = response.clone();
+	if (isJsonContentType(contentType)) return {
+		value: await clone.json(),
+		writableJson: true
+	};
+	return {
+		value: await clone.text(),
+		writableJson: false
+	};
+}
+function responseWithJsonBody(response, value) {
+	const headers = new Headers(response.headers);
+	headers.delete("content-length");
+	if (!headers.has("content-type")) headers.set("content-type", "application/json");
+	return new Response(value === void 0 ? void 0 : JSON.stringify(value), {
+		status: response.status,
+		statusText: response.statusText,
+		headers
+	});
+}
+function parseResponseSchema(schema, status, value, mode) {
+	const responseSchema = getResponseSchemaForStatus(schema, status);
+	if (!responseSchema) return value;
+	const result = responseSchema.safeParse(value);
+	if (!result.success) throw new ZodResponseValidationError(status, result.error);
+	if (mode === "strict" && !jsonValuesEqual(value, result.data)) throw new ZodResponseValidationError(status, new z.ZodError([{
+		code: z.ZodIssueCode.custom,
+		path: [],
+		message: "Response body does not match the parsed schema output."
+	}]));
+	return mode === "parse" ? result.data : value;
+}
+async function validateHandlerResult(schema, result, mode) {
+	if (result instanceof Response) {
+		const body = await readResponseBodyForValidation(result);
+		if (!body) return result;
+		const parsed = parseResponseSchema(schema, result.status, body.value, mode);
+		return mode === "parse" && body.writableJson ? responseWithJsonBody(result, parsed) : result;
+	}
+	if (isRoutekitResponse(result)) {
+		const parsed = parseResponseSchema(schema, result.status, result.body, mode);
+		return mode === "parse" ? response(parsed, {
+			status: result.status,
+			headers: result.headers
+		}) : result;
+	}
+	if (isRoutekitBody(result)) {
+		const parsed = parseResponseSchema(schema, HttpStatus.OK, result.value, mode);
+		return mode === "parse" ? parsed : result;
+	}
+	if (isSkippableResponseValidationValue(result)) return result;
+	return parseResponseSchema(schema, HttpStatus.OK, result, mode);
+}
+const defaultValidationErrorSchema = z.object({
+	component: z.enum([
+		"request_body",
+		"url_path",
+		"query_parameters"
+	]),
+	errorTree: z.unknown(),
+	message: z.string()
+});
+/**
+* Create Zod middleware that parses request inputs and validates downstream responses.
+*
+* @example
+* ```ts
+* const parseUserId = zodSchemaMiddleware({
+*     schema: { request: { path: z.object({ id: z.string() }) } },
+* })
+* ```
+*
+* @param options - Request, response, and validation-error schema behavior.
+* @returns Declared middleware exposing parsed request values to downstream handlers.
+* @typeParam Schema - Zod request and downstream response schema declaration.
+* @typeParam Ctx - Context required before this middleware executes.
+*/
+function zodSchemaMiddleware(options) {
+	const validateResponse = normalizeResponseValidationMode(options.validateResponse) ?? "parse";
+	const parsesRequest = options.schema?.request !== void 0;
+	const declarations = buildZodMiddlewareDeclarations(options.validationResponses ?? (parsesRequest ? { [HttpStatus.BAD_REQUEST]: defaultValidationErrorSchema } : {}));
+	const onRequestValidationError = options.onRequestValidationError ?? createValidationResponse;
+	return defineMiddleware({
+		schema: buildRouteSchema(options.schema),
+		responses: declarations,
+		async run(ctx, { next, forward, respond }) {
+			const bodySchema = options.schema?.request?.body;
+			const pathSchema = options.schema?.request?.path;
+			const querySchema = options.schema?.request?.query;
+			const queryParams = readQueryParams(ctx.url.searchParams);
+			const handlerContext = ctx;
+			const params = {
+				path: ctx.path,
+				query: void 0,
+				body: void 0
+			};
+			handlerContext.params = params;
+			if (querySchema) {
+				const parsed = querySchema.safeParse(queryParams);
+				if (!parsed.success) return respond(onRequestValidationError(2, parsed.error));
+				params.query = parsed.data;
+			}
+			if (pathSchema) {
+				const parsed = pathSchema.safeParse(ctx.path);
+				if (!parsed.success) return respond(onRequestValidationError(1, parsed.error));
+				params.path = parsed.data;
+			}
+			if (bodySchema) {
+				let rawBody;
+				try {
+					rawBody = await ctx.request.body.parse();
+				} catch (err) {
+					if (err instanceof RequestBodyError) throw err;
+					return respond(onRequestValidationError(0, zodErrorFromThrowable(err)));
+				}
+				const parsed = bodySchema.safeParse(rawBody);
+				if (!parsed.success) return respond(onRequestValidationError(0, parsed.error));
+				params.body = parsed.data;
+			}
+			const result = await next();
+			return forward(validateResponse === false ? result : await validateHandlerResult(options.schema, result, validateResponse));
+		}
+	});
+}
+function createZodRouteBuilder(defaults = {}) {
+	return ((options) => {
+		const { schema, handler, onRequestValidationError, validateResponse, validationResponses, middleware, ...routeOptions } = mergeZodOptions(defaults, options);
+		const routeMiddleware = mergeMiddleware(middleware, zodSchemaMiddleware({
+			...schema ? { schema } : {},
+			...onRequestValidationError ? { onRequestValidationError } : {},
+			...validateResponse === void 0 ? {} : { validateResponse },
+			...validationResponses === void 0 ? {} : { validationResponses }
+		}));
+		const built = {
+			...routeOptions,
+			handler,
+			middleware: routeMiddleware
+		};
+		if (hasRoutePath(built)) return built;
+		return built;
+	});
+}
+//#endregion
+export { ValibotValidationError, ValidationError, createValibotRouteBuilder, createZodRouteBuilder, defineValibotMiddleware, defineZodMiddleware, valibotSchemaMiddleware, zodSchemaMiddleware };

package/dist/status-C-8mw-FB.mjs

@@ -0,0 +1,59 @@
+import { a as response } from "./core-DbmQauwS.mjs";
+import { HttpStatus } from "@mpen/http";
+//#region src/router/response/formats/status/responses.ts
+/**
+* Create a `200 OK` logical response.
+*
+* @example
+* ```ts
+* return ok({payload: 'ready'})
+* ```
+*
+* @param responseBody - Logical response body.
+* @param init - Response headers.
+* @returns Routekit logical response.
+*/
+function ok(responseBody, init = {}) {
+	return response(responseBody, {
+		...init,
+		status: HttpStatus.OK
+	});
+}
+/**
+* Create a `400 Bad Request` logical response.
+*
+* @example
+* ```ts
+* return badRequest({message: 'Invalid request'})
+* ```
+*
+* @param responseBody - Logical response body.
+* @param init - Response headers.
+* @returns Routekit logical response.
+*/
+function badRequest(responseBody, init = {}) {
+	return response(responseBody, {
+		...init,
+		status: HttpStatus.BAD_REQUEST
+	});
+}
+/**
+* Create a `422 Unprocessable Content` logical response.
+*
+* @example
+* ```ts
+* return unprocessableContent({message: 'Email is already taken'})
+* ```
+*
+* @param responseBody - Logical response body.
+* @param init - Response headers.
+* @returns Routekit logical response.
+*/
+function unprocessableContent(responseBody, init = {}) {
+	return response(responseBody, {
+		...init,
+		status: HttpStatus.UNPROCESSABLE_ENTITY
+	});
+}
+//#endregion
+export { ok as n, unprocessableContent as r, badRequest as t };