@cosmneo/onion-lasagna 0.2.0 → 0.2.1

package/dist/{router-definition.type-DORVlLNk.d.ts → router-definition.type-DxG8ncJZ.d.ts}

@@ -125,10 +125,9 @@ declare function buildPath(template: string, params: Record<string, string>): st
 declare function normalizePath(path: string): string;
 
 /**
- * @fileoverview Core route definition types.
+ * @fileoverview Core route definition types (v2 — flat API).
  *
- * This module defines the types for the unified route system. A route
- * definition captures all information needed for:
+ * A route definition captures all information needed for:
  * - Type-safe client generation
  * - Server-side route registration with automatic validation
  * - OpenAPI specification generation
@@ -136,144 +135,6 @@ declare function normalizePath(path: string): string;
  * @module unified/route/types/route-definition
  */
 
-/**
- * Request body configuration.
- */
-interface RequestBodyConfig<T = unknown> {
-    /**
-     * Schema for validating the request body.
-     */
-    readonly schema: SchemaAdapter<T>;
-    /**
-     * Content type of the request body.
-     * @default 'application/json'
-     */
-    readonly contentType?: ContentType;
-    /**
-     * Whether the body is required.
-     * @default true
-     */
-    readonly required?: boolean;
-    /**
-     * Description for OpenAPI documentation.
-     */
-    readonly description?: string;
-}
-/**
- * Query parameters configuration.
- */
-interface QueryParamsConfig<T = unknown> {
-    /**
-     * Schema for validating query parameters.
-     */
-    readonly schema: SchemaAdapter<T>;
-    /**
-     * Description for OpenAPI documentation.
-     */
-    readonly description?: string;
-}
-/**
- * Path parameters configuration (optional override).
- * By default, path params are extracted from the path template.
- */
-interface PathParamsConfig<T = unknown> {
-    /**
-     * Schema for validating path parameters.
-     * If provided, overrides the auto-extracted types from the path.
-     */
-    readonly schema: SchemaAdapter<T>;
-    /**
-     * Description for OpenAPI documentation.
-     */
-    readonly description?: string;
-}
-/**
- * Headers configuration.
- */
-interface HeadersConfig<T = unknown> {
-    /**
-     * Schema for validating headers.
-     */
-    readonly schema: SchemaAdapter<T>;
-    /**
-     * Description for OpenAPI documentation.
-     */
-    readonly description?: string;
-}
-/**
- * Context configuration.
- * Used to validate and type context data from middleware (e.g., JWT payload).
- */
-interface ContextConfig<T = unknown> {
-    /**
-     * Schema for validating context data.
-     * Context is extracted by the framework adapter's contextExtractor.
-     */
-    readonly schema: SchemaAdapter<T>;
-    /**
-     * Description for documentation.
-     */
-    readonly description?: string;
-}
-/**
- * Complete request configuration.
- */
-interface RequestConfig<TBody = undefined, TQuery = undefined, TParams = undefined, THeaders = undefined, TContext = undefined> {
-    /**
-     * Request body schema and configuration.
-     */
-    readonly body?: TBody extends undefined ? undefined : RequestBodyConfig<TBody>;
-    /**
-     * Query parameters schema and configuration.
-     */
-    readonly query?: TQuery extends undefined ? undefined : QueryParamsConfig<TQuery>;
-    /**
-     * Path parameters schema and configuration.
-     * Optional - by default inferred from path template.
-     */
-    readonly params?: TParams extends undefined ? undefined : PathParamsConfig<TParams>;
-    /**
-     * Headers schema and configuration.
-     */
-    readonly headers?: THeaders extends undefined ? undefined : HeadersConfig<THeaders>;
-    /**
-     * Context schema and configuration.
-     * Validates context data extracted from middleware (e.g., JWT payload).
-     * Validation failure throws InternalServerError.
-     */
-    readonly context?: TContext extends undefined ? undefined : ContextConfig<TContext>;
-}
-/**
- * Single response configuration.
- */
-interface ResponseConfig<T = unknown> {
-    /**
-     * Description for OpenAPI documentation.
-     * Required for OpenAPI compliance.
-     */
-    readonly description: string;
-    /**
-     * Schema for the response body.
-     * Optional - some responses (204, 3xx) have no body.
-     */
-    readonly schema?: SchemaAdapter<T>;
-    /**
-     * Content type of the response body.
-     * @default 'application/json'
-     */
-    readonly contentType?: ContentType;
-    /**
-     * Response headers schema.
-     */
-    readonly headers?: SchemaAdapter<Record<string, string>>;
-}
-/**
- * Map of status codes to response configurations.
- * Defined as an interface so IDE hovers show "ResponsesConfig"
- * instead of expanding all ~60 HTTP status code keys.
- */
-interface ResponsesConfig extends Readonly<Partial<Record<HttpStatusCode, ResponseConfig>>> {
-}
 /**
  * Security requirement for OpenAPI.
  */
@@ -305,7 +166,7 @@ interface RouteDocumentation {
     readonly tags?: readonly string[];
     /**
      * Unique operation identifier.
-     * Must be unique across all operations.
+     * If not specified, auto-generated from the router key path.
      */
     readonly operationId?: string;
     /**
@@ -324,47 +185,138 @@ interface RouteDocumentation {
     readonly externalDocs?: ExternalDocs;
 }
 /**
- * Input for defining a route.
- * This is what users provide to `defineRoute()`.
+ * Metadata for a schema field (body, query, params, headers, context).
+ *
+ * Allows passing OpenAPI metadata alongside a schema without nesting.
+ * Each field on `defineRoute` accepts either a bare `SchemaAdapter` or
+ * a `SchemaFieldConfig` object:
+ *
+ * @example Bare schema (common case)
+ * ```typescript
+ * body: zodSchema(z.object({ name: z.string() }))
+ * ```
+ *
+ * @example With metadata
+ * ```typescript
+ * body: {
+ *   schema: zodSchema(z.object({ name: z.string() })),
+ *   description: 'The user to create',
+ *   contentType: 'application/json',
+ * }
+ * ```
+ */
+interface SchemaFieldConfig<T extends SchemaAdapter = SchemaAdapter> {
+    readonly schema: T;
+    /** Description for OpenAPI generation. */
+    readonly description?: string;
+    /** Content type (body only). @default 'application/json' */
+    readonly contentType?: string;
+    /** Whether the field is required (body only). @default true */
+    readonly required?: boolean;
+}
+/**
+ * A schema field accepts either a bare SchemaAdapter or a config with metadata.
  */
-interface RouteDefinitionInput<TMethod extends HttpMethod = HttpMethod, TPath extends string = string, TBody = undefined, TQuery = undefined, TPathParams = PathParams<TPath>, THeaders = undefined, TContext = undefined, TResponses extends ResponsesConfig = ResponsesConfig> {
-    /**
-     * HTTP method for this route.
-     */
-    readonly method: TMethod;
-    /**
-     * URL path pattern with optional parameters.
-     *
-     * @example
-     * '/api/users'
-     * '/api/users/:userId'
-     * '/api/projects/{projectId}/tasks/{taskId}'
-     */
-    readonly path: TPath;
-    /**
-     * Request configuration including body, query, params, headers, and context.
-     */
-    readonly request?: {
-        readonly body?: RequestBodyConfig<TBody>;
-        readonly query?: QueryParamsConfig<TQuery>;
-        readonly params?: PathParamsConfig<TPathParams>;
-        readonly headers?: HeadersConfig<THeaders>;
-        readonly context?: ContextConfig<TContext>;
+type SchemaFieldInput<T extends SchemaAdapter = SchemaAdapter> = T | SchemaFieldConfig<T>;
+/**
+ * Stored metadata for all schema fields on a route.
+ * @internal
+ */
+interface RouteFieldMeta {
+    readonly body?: {
+        readonly description?: string;
+        readonly contentType?: string;
+        readonly required?: boolean;
     };
-    /**
-     * Response configurations by status code.
-     */
-    readonly responses: TResponses;
-    /**
-     * OpenAPI documentation.
-     */
-    readonly docs?: RouteDocumentation;
+    readonly query?: {
+        readonly description?: string;
+    };
+    readonly params?: {
+        readonly description?: string;
+    };
+    readonly headers?: {
+        readonly description?: string;
+    };
+    readonly context?: {
+        readonly description?: string;
+    };
+}
+/**
+ * Configuration for a single response status code.
+ *
+ * Used with the `responses` field on `defineRoute` to specify per-status
+ * schemas, descriptions, and content types for OpenAPI generation.
+ *
+ * @example
+ * ```typescript
+ * responses: {
+ *   201: { schema: zodSchema(userSchema), description: 'Created' },
+ *   400: { description: 'Validation error' },
+ *   409: { description: 'User already exists' },
+ * }
+ * ```
+ */
+interface ResponseFieldConfig {
+    readonly schema?: SchemaAdapter;
+    readonly description?: string;
+    readonly contentType?: string;
+}
+/**
+ * Per-status response definitions keyed by HTTP status code.
+ */
+type ResponsesDefinition = Readonly<Record<number, ResponseFieldConfig>>;
+/**
+ * Extracts the success response SchemaAdapter from a ResponsesDefinition.
+ * Cascades through 200 → 201 → 202 → 204.
+ */
+type ExtractSuccessSchema<T> = T extends {
+    200: {
+        schema: infer S extends SchemaAdapter;
+    };
+} ? S : T extends {
+    201: {
+        schema: infer S extends SchemaAdapter;
+    };
+} ? S : T extends {
+    202: {
+        schema: infer S extends SchemaAdapter;
+    };
+} ? S : T extends {
+    204: {
+        schema: infer S extends SchemaAdapter;
+    };
+} ? S : undefined;
+/**
+ * Grouped request schemas for a route definition.
+ *
+ * Contains all input schemas: body, query, path params, headers, and context.
+ * Each field is either a `SchemaAdapter` or `undefined` if not specified.
+ */
+interface RouteRequestDefinition<TBody = undefined, TQuery = undefined, TPathParams = Record<string, string>, THeaders = undefined, TContext = undefined> {
+    /** Request body schema. */
+    readonly body: SchemaAdapter<TBody> | undefined;
+    /** Query parameters schema. */
+    readonly query: SchemaAdapter<TQuery> | undefined;
+    /**
+     * Path parameters schema.
+     * If not provided, path params are inferred from the path template.
+     */
+    readonly params: SchemaAdapter<TPathParams> | undefined;
+    /** Headers schema. */
+    readonly headers: SchemaAdapter<THeaders> | undefined;
+    /** Context schema (e.g., JWT payload from middleware). */
+    readonly context: SchemaAdapter<TContext> | undefined;
 }
 /**
  * A fully defined route with computed types.
  * This is the output of `defineRoute()`.
+ *
+ * Request schemas are grouped under `request`:
+ * - `request.body`, `request.query`, `request.params`, `request.headers`, `request.context`
+ *
+ * Responses are per-status via the `responses` field.
  */
-interface RouteDefinition<TMethod extends HttpMethod = HttpMethod, TPath extends string = string, TBody = undefined, TQuery = undefined, TPathParams = PathParams<TPath>, THeaders = undefined, TContext = undefined, TResponses extends ResponsesConfig = ResponsesConfig> {
+interface RouteDefinition<TMethod extends HttpMethod = HttpMethod, TPath extends string = string, TBody = undefined, TQuery = undefined, TPathParams = PathParams<TPath>, THeaders = undefined, TContext = undefined, TResponse = undefined> {
     /**
      * HTTP method for this route.
      */
@@ -374,23 +326,24 @@ interface RouteDefinition<TMethod extends HttpMethod = HttpMethod, TPath extends
      */
     readonly path: TPath;
     /**
-     * Request configuration.
+     * Request schemas (body, query, params, headers, context).
      */
-    readonly request: {
-        readonly body: RequestBodyConfig<TBody> | undefined;
-        readonly query: QueryParamsConfig<TQuery> | undefined;
-        readonly params: PathParamsConfig<TPathParams> | undefined;
-        readonly headers: HeadersConfig<THeaders> | undefined;
-        readonly context: ContextConfig<TContext> | undefined;
-    };
+    readonly request: RouteRequestDefinition<TBody, TQuery, TPathParams, THeaders, TContext>;
     /**
-     * Response configurations.
+     * Per-status response configurations.
+     * Each key is an HTTP status code, each value has optional schema, description, and contentType.
      */
-    readonly responses: TResponses;
+    readonly responses: Readonly<Record<string, ResponseFieldConfig>> | undefined;
     /**
      * OpenAPI documentation.
      */
     readonly docs: RouteDocumentation;
+    /**
+     * Schema field metadata for OpenAPI generation.
+     * Populated when fields are passed as `{ schema, description?, contentType?, required? }`.
+     * @internal
+     */
+    readonly _meta: RouteFieldMeta;
     /**
      * Phantom types for TypeScript inference.
      * Never accessed at runtime.
@@ -404,53 +357,41 @@ interface RouteDefinition<TMethod extends HttpMethod = HttpMethod, TPath extends
         readonly pathParams: TPathParams;
         readonly headers: THeaders;
         readonly context: TContext;
-        readonly responses: TResponses;
+        readonly response: TResponse;
     };
 }
 /**
  * Infers the request body type from a route definition.
  */
-type InferRouteBody<T> = T extends RouteDefinition<HttpMethod, string, infer TBody, unknown, unknown, unknown, ResponsesConfig> ? TBody : never;
+type InferRouteBody<T> = T extends RouteDefinition<HttpMethod, string, infer TBody, unknown, unknown, unknown, unknown, unknown> ? TBody : never;
 /**
  * Infers the query params type from a route definition.
  */
-type InferRouteQuery<T> = T extends RouteDefinition<HttpMethod, string, unknown, infer TQuery, unknown, unknown, ResponsesConfig> ? TQuery : never;
+type InferRouteQuery<T> = T extends RouteDefinition<HttpMethod, string, unknown, infer TQuery, unknown, unknown, unknown, unknown> ? TQuery : never;
 /**
  * Infers the path params type from a route definition.
  */
-type InferRoutePathParams<T> = T extends RouteDefinition<HttpMethod, string, unknown, unknown, infer TPathParams, unknown, ResponsesConfig> ? TPathParams : never;
+type InferRoutePathParams<T> = T extends RouteDefinition<HttpMethod, string, unknown, unknown, infer TPathParams, unknown, unknown, unknown> ? TPathParams : never;
 /**
  * Infers the headers type from a route definition.
  */
-type InferRouteHeaders<T> = T extends RouteDefinition<HttpMethod, string, unknown, unknown, unknown, infer THeaders, unknown, ResponsesConfig> ? THeaders : never;
+type InferRouteHeaders<T> = T extends RouteDefinition<HttpMethod, string, unknown, unknown, unknown, infer THeaders, unknown, unknown> ? THeaders : never;
 /**
  * Infers the context type from a route definition.
  */
-type InferRouteContext<T> = T extends RouteDefinition<HttpMethod, string, unknown, unknown, unknown, unknown, infer TContext, ResponsesConfig> ? TContext : never;
-/**
- * Infers the response type for a specific status code.
- */
-type InferRouteResponse<T, TStatus extends HttpStatusCode> = T extends RouteDefinition<HttpMethod, string, unknown, unknown, unknown, unknown, unknown, infer TResponses> ? TStatus extends keyof TResponses ? TResponses[TStatus] extends ResponseConfig<infer TData> ? TData : never : never : never;
+type InferRouteContext<T> = T extends RouteDefinition<HttpMethod, string, unknown, unknown, unknown, unknown, infer TContext, unknown> ? TContext : never;
 /**
- * Infers the successful response type (first 2xx response).
+ * Infers the response type from a route definition.
  */
-type InferRouteSuccessResponse<T> = T extends RouteDefinition<HttpMethod, string, unknown, unknown, unknown, unknown, unknown, infer TResponses> ? TResponses extends {
-    200: ResponseConfig<infer T200>;
-} ? T200 : TResponses extends {
-    201: ResponseConfig<infer T201>;
-} ? T201 : TResponses extends {
-    202: ResponseConfig<infer T202>;
-} ? T202 : TResponses extends {
-    204: ResponseConfig;
-} ? void : unknown : never;
+type InferRouteResponse<T> = T extends RouteDefinition<HttpMethod, string, unknown, unknown, unknown, unknown, unknown, infer TResponse> ? TResponse : never;
 /**
  * Extracts the method from a route definition.
  */
-type InferRouteMethod<T> = T extends RouteDefinition<infer TMethod, string, unknown, unknown, unknown, unknown, unknown, ResponsesConfig> ? TMethod : never;
+type InferRouteMethod<T> = T extends RouteDefinition<infer TMethod, string, unknown, unknown, unknown, unknown, unknown, unknown> ? TMethod : never;
 /**
  * Extracts the path from a route definition.
  */
-type InferRoutePath<T> = T extends RouteDefinition<HttpMethod, infer TPath, unknown, unknown, unknown, unknown, unknown, ResponsesConfig> ? TPath : never;
+type InferRoutePath<T> = T extends RouteDefinition<HttpMethod, infer TPath, unknown, unknown, unknown, unknown, unknown, unknown> ? TPath : never;
 
 /**
  * @fileoverview Router definition types for grouping routes.
@@ -464,16 +405,30 @@ type InferRoutePath<T> = T extends RouteDefinition<HttpMethod, infer TPath, unkn
  */
 
 /**
- * A router entry can be either a route definition or a nested router.
- * Uses permissive types to allow any valid route definition.
+ * A router entry can be a route definition, a nested router config, or a router definition.
  */
-type RouterEntry = RouteDefinition<HttpMethod, string, unknown, unknown, unknown, unknown, unknown, ResponsesConfig> | RouterConfig;
+type RouterEntry = RouteDefinition<HttpMethod, string, unknown, unknown, unknown, unknown, unknown, any> | RouterConfig | RouterDefinition;
 /**
  * Configuration for a router (group of routes).
  */
 interface RouterConfig {
     readonly [key: string]: RouterEntry;
 }
+/**
+ * Router-level defaults applied to all child routes.
+ */
+interface RouterDefaults {
+    /**
+     * Default tags for all routes in this router.
+     * Merged with route-specific tags.
+     */
+    readonly tags?: readonly string[];
+    /**
+     * Default context schema for all routes in this router.
+     * Applied to routes that don't define their own context.
+     */
+    readonly context?: SchemaAdapter;
+}
 /**
  * A fully defined router.
  */
@@ -487,9 +442,9 @@ interface RouterDefinition<T extends RouterConfig = RouterConfig> {
      */
     readonly basePath?: string;
     /**
-     * Default tags for all routes in this router.
+     * Default values applied to all child routes.
      */
-    readonly tags?: readonly string[];
+    readonly defaults?: RouterDefaults;
     /**
      * Marker to identify this as a router.
      * @internal
@@ -506,26 +461,6 @@ declare function isRouteDefinition(value: unknown): value is RouteDefinition;
 declare function isRouterDefinition(value: unknown): value is RouterDefinition;
 /**
  * Flattens a router into a map of path keys to route definitions.
- *
- * @example
- * ```typescript
- * const router = defineRouter({
- *   users: {
- *     list: listUsersRoute,
- *     get: getUserRoute,
- *   },
- *   posts: {
- *     create: createPostRoute,
- *   },
- * });
- *
- * type Flat = FlattenRouter<typeof router>;
- * // {
- * //   'users.list': typeof listUsersRoute,
- * //   'users.get': typeof getUserRoute,
- * //   'posts.create': typeof createPostRoute,
- * // }
- * ```
  */
 type FlattenRouter<T extends RouterConfig, Prefix extends string = ''> = T extends RouterConfig ? {
     [K in keyof T]: T[K] extends RouteDefinition<any, any, any, any, any, any, any, any> ? {
@@ -534,33 +469,16 @@ type FlattenRouter<T extends RouterConfig, Prefix extends string = ''> = T exten
 }[keyof T] extends infer U ? U extends Record<string, RouteDefinition<any, any, any, any, any, any, any, any>> ? U : never : never : never;
 /**
  * Gets all route keys from a router.
- *
- * @example
- * ```typescript
- * type Keys = RouterKeys<typeof router>;
- * // 'users.list' | 'users.get' | 'posts.create'
- * ```
  */
 type RouterKeys<T extends RouterConfig, Prefix extends string = ''> = T extends RouterConfig ? {
     [K in keyof T]: T[K] extends RouteDefinition<any, any, any, any, any, any, any, any> ? `${Prefix}${K & string}` : T[K] extends RouterConfig ? RouterKeys<T[K], `${Prefix}${K & string}.`> : never;
 }[keyof T] : never;
 /**
  * Gets a route by its dotted key path.
- *
- * @example
- * ```typescript
- * type UserGet = GetRoute<typeof router, 'users.get'>;
- * // typeof getUserRoute
- * ```
  */
 type GetRoute<T extends RouterConfig, K extends string> = K extends `${infer Head}.${infer Tail}` ? Head extends keyof T ? T[Head] extends RouterConfig ? GetRoute<T[Head], Tail> : never : never : K extends keyof T ? T[K] extends RouteDefinition<any, any, any, any, any, any, any, any> ? T[K] : never : never;
 /**
  * Deep-merges two router configs at the type level.
- *
- * - If both sides are sub-routers (extend RouterConfig), recurse.
- * - Otherwise last-one-wins (B overrides A).
- * - RouteDefinition does NOT extend RouterConfig (it has `method`, `path`, etc.)
- *   so the conditional correctly distinguishes leaves from sub-routers.
  */
 type DeepMergeTwo<A extends RouterConfig, B extends RouterConfig> = {
     readonly [K in keyof A | keyof B]: K extends keyof A ? K extends keyof B ? A[K] extends RouterConfig ? B[K] extends RouterConfig ? DeepMergeTwo<A[K], B[K]> : B[K] : B[K] : A[K] : K extends keyof B ? B[K] : never;
@@ -577,11 +495,6 @@ type DeepMergeAll<T extends readonly RouterConfig[]> = T extends readonly [
 ] ? DeepMergeAll<[DeepMergeTwo<First, Second>, ...Rest]> : RouterConfig;
 /**
  * Recursively flattens complex types for clean IDE hover display.
- * Applied at return sites (not inside recursion) so DTS emit stays fast —
- * TypeScript only resolves when concrete types are provided.
- *
- * Works with any recursive object type: router configs, client types,
- * React Query hooks, etc. Functions and primitives pass through unchanged.
  */
 type PrettifyDeep<T> = T extends (...args: any[]) => any ? T : T extends object ? {
     readonly [K in keyof T]: PrettifyDeep<T[K]>;
@@ -594,4 +507,4 @@ declare function collectRoutes(config: RouterConfig, basePath?: string): {
     route: RouteDefinition;
 }[];
 
-export { normalizePath as A, pathToRegex as B, type ContentType as C, type DeepMergeTwo as D, type ExtractPathParamNames as E, type FlattenRouter as F, type GetRoute as G, type HttpMethod as H, type InferRouteBody as I, getPathParamNames as J, hasPathParams as K, type ContextConfig as L, type RequestConfig as M, type ExternalDocs as N, type InferRouteContext as O, type PathParams as P, type QueryParamsConfig as Q, type RouteDefinition as R, type SecurityRequirement as S, type HttpStatusCode as a, type HasPathParams as b, type RouteDefinitionInput as c, type RequestBodyConfig as d, type PathParamsConfig as e, type HeadersConfig as f, type ResponseConfig as g, type ResponsesConfig as h, type RouteDocumentation as i, type RouterConfig as j, type RouterDefinition as k, type RouterEntry as l, type RouterKeys as m, type DeepMergeAll as n, type PrettifyDeep as o, type InferRouteQuery as p, type InferRoutePathParams as q, type InferRouteHeaders as r, type InferRouteResponse as s, type InferRouteSuccessResponse as t, type InferRouteMethod as u, type InferRoutePath as v, isRouteDefinition as w, isRouterDefinition as x, collectRoutes as y, buildPath as z };
+export { type RouterDefaults as A, type SchemaFieldConfig as B, type ContentType as C, type DeepMergeTwo as D, type ExtractPathParamNames as E, type FlattenRouter as F, type GetRoute as G, type HttpMethod as H, type InferRouteBody as I, type RouteFieldMeta as J, type ResponseFieldConfig as K, type SecurityRequirement as L, type ExternalDocs as M, type RouteRequestDefinition as N, type PathParams as P, type RouteDefinition as R, type SchemaFieldInput as S, type HttpStatusCode as a, type HasPathParams as b, type RouteDocumentation as c, type RouterConfig as d, type RouterDefinition as e, type RouterEntry as f, type RouterKeys as g, type DeepMergeAll as h, type PrettifyDeep as i, type InferRouteQuery as j, type InferRoutePathParams as k, type InferRouteHeaders as l, type InferRouteContext as m, type InferRouteResponse as n, type InferRouteMethod as o, type InferRoutePath as p, isRouteDefinition as q, isRouterDefinition as r, collectRoutes as s, buildPath as t, normalizePath as u, pathToRegex as v, getPathParamNames as w, hasPathParams as x, type ResponsesDefinition as y, type ExtractSuccessSchema as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmneo/onion-lasagna",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Enterprise-grade TypeScript library for building backend applications with hexagonal/onion architecture",
   "type": "module",
   "license": "MIT",

package/dist/chunk-BZULBF4N.js

@@ -1,82 +0,0 @@
-import {
-  isRouteDefinition,
-  isRouterDefinition
-} from "./chunk-DS7TE6KZ.js";
-
-// src/presentation/http/route/define-route.ts
-function defineRoute(input) {
-  const definition = {
-    method: input.method,
-    path: input.path,
-    request: {
-      body: input.request?.body ?? void 0,
-      query: input.request?.query ?? void 0,
-      params: input.request?.params ?? void 0,
-      headers: input.request?.headers ?? void 0,
-      context: input.request?.context ?? void 0
-    },
-    responses: input.responses,
-    docs: {
-      summary: input.docs?.summary,
-      description: input.docs?.description,
-      tags: input.docs?.tags,
-      operationId: input.docs?.operationId,
-      deprecated: input.docs?.deprecated ?? false,
-      security: input.docs?.security,
-      externalDocs: input.docs?.externalDocs
-    },
-    _types: void 0
-  };
-  return Object.freeze(definition);
-}
-
-// src/presentation/http/route/define-router.ts
-function defineRouter(routes, options) {
-  const definition = {
-    routes,
-    basePath: options?.basePath,
-    tags: options?.tags,
-    _isRouter: true
-  };
-  return deepFreeze(definition);
-}
-function deepFreeze(obj) {
-  const propNames = Object.getOwnPropertyNames(obj);
-  for (const name of propNames) {
-    const value = obj[name];
-    if (value && typeof value === "object" && !Object.isFrozen(value)) {
-      deepFreeze(value);
-    }
-  }
-  return Object.freeze(obj);
-}
-function extractRoutes(input) {
-  return isRouterDefinition(input) ? input.routes : input;
-}
-function isSubRouter(value) {
-  return typeof value === "object" && value !== null && !isRouteDefinition(value) && !isRouterDefinition(value);
-}
-function deepMergeConfigs(a, b) {
-  const result = { ...a };
-  for (const key of Object.keys(b)) {
-    const aVal = result[key];
-    const bVal = b[key];
-    if (isSubRouter(aVal) && isSubRouter(bVal)) {
-      result[key] = deepMergeConfigs(aVal, bVal);
-    } else {
-      result[key] = bVal;
-    }
-  }
-  return result;
-}
-function mergeRouters(...routers) {
-  const merged = routers.map(extractRoutes).reduce(deepMergeConfigs);
-  return defineRouter(merged);
-}
-
-export {
-  defineRoute,
-  defineRouter,
-  mergeRouters
-};
-//# sourceMappingURL=chunk-BZULBF4N.js.map