snap-on-openapi 1.0.14 → 1.0.15

package/dist/OpenApi.d.ts

@@ -22,6 +22,7 @@ import { InitialBuilder } from './types/InitialBuilder.js';
 import { DefaultRouteContextMap } from './services/ConfigBuilder/types/DefaultRouteContextMap.js';
 import { DefaultRouteParamsMap } from './services/ConfigBuilder/types/DefaultRouteParamsMap.js';
 import z from 'zod';
+import { RouteResponse } from './types/RouteResponse.js';
 export declare class OpenApi<TRouteTypes extends string, TErrorCodes extends string, TConfig extends AnyConfig<TRouteTypes, TErrorCodes>> {
     static readonly builder: InitialBuilder;
     readonly validators: ValidationUtils;
@@ -46,11 +47,7 @@ export declare class OpenApi<TRouteTypes extends string, TErrorCodes extends str
     mergePaths(...paths: RoutePath[]): RoutePath;
     addServer(url: string, description: string): void;
     protected getRouteForPath(path: string, method: string): AnyRoute<TRouteTypes> | null;
-    processRootRoute(originalReq: Request): Promise<{
-        status: number;
-        body: unknown;
-        headers: Record<string, string>;
-    }>;
+    processRootRoute(originalReq: Request): Promise<RouteResponse>;
     protected handleError(e: unknown, req: Request): Promise<{
         status: number;
         body: z.TypeOf<import("./index.js").OpenApiErrorConfigMap<TErrorCodes>[TErrorCodes]["responseValidator"]>;

package/dist/OpenApi.js

@@ -229,37 +229,51 @@ export class OpenApi {
                     body: bodyData,
                 },
             };
-            const response = await route.handler({
-                ...context,
+            const wrapper = this.config.routes[route.type].handlerWrapper ?? (async (handler) => handler());
+            const handler = async () => {
+                const response = await route.handler({
+                    ...context,
+                    params: {
+                        query: query.data,
+                        path: path.data,
+                        body: bodyData,
+                    },
+                });
+                return response;
+            };
+            const response = await wrapper(handler, {
+                route: route,
+                request: originalReq,
+                logger: this.logger,
                 params: {
                     query: query.data,
                     path: path.data,
                     body: bodyData,
                 },
-            });
-            const finalResponse = route.validators.responseHeaders ? response : { body: response, headers: {} };
+            }, context);
             const finalResponseValidator = z.object({
                 body: route.validators.response ?? z.undefined(),
                 headers: route.validators.responseHeaders?.strict() ?? z.object({}),
+                status: z.literal(200),
             });
             const onResponse = {
                 ...onHandler,
-                response: { status: 200, body: finalResponse.body, headers: finalResponse.headers },
+                response,
             };
             if (this.config.disableResponseValidation) {
                 if (this.config.onResponse) {
                     await this.config.onResponse(onResponse);
                 }
-                return { status: 200, body: finalResponse.body, headers: finalResponse.headers };
+                return response;
             }
-            const validated = finalResponseValidator.safeParse(finalResponse);
+            const validated = finalResponseValidator.safeParse(response);
             if (!validated.success) {
-                throw new ValidationError(validated.error, ValidationLocation.Response, finalResponse);
+                throw new ValidationError(validated.error, ValidationLocation.Response, response);
             }
             if (this.config.onResponse) {
                 await this.config.onResponse(onResponse);
             }
-            return { status: 200, body: validated.data.body, headers: validated.data.headers };
+            return response;
         }
         catch (e) {
             return await this.handleError(e, originalReq);

package/dist/services/RoutingFactory/RoutingFactory.d.ts

@@ -3,8 +3,10 @@ import { Method } from '../../enums/Methods.js';
 import { Route } from '../../types/Route.js';
 import { AnyConfig } from '../../types/config/AnyConfig.js';
 import { RouteExtraProps } from '../../types/config/RouteExtraProps.js';
+import { StandardRoute } from './types/StandardRoute.js';
 export declare class RoutingFactory<TRouteTypes extends string, TErrorCodes extends string, TConfig extends AnyConfig<TRouteTypes, TErrorCodes>> {
     protected map: TConfig;
     constructor(map: TConfig);
-    createRoute<TType extends TRouteTypes, TMethod extends Method, TResponseValidator extends ZodFirstPartySchemaTypes | undefined = undefined, TQueryValidator extends ZodObject<ZodRawShape> | undefined = undefined, TPathValidator extends ZodObject<ZodRawShape> | undefined = undefined, TBodyValidator extends ZodFirstPartySchemaTypes | undefined = undefined, TResponseHeadersValidator extends ZodObject<ZodRawShape> | undefined = undefined>(params: Route<TType, Awaited<ReturnType<TConfig['routes'][TType]['contextFactory']>>, TResponseValidator, TPathValidator, TQueryValidator, TBodyValidator, TResponseHeadersValidator, TMethod> & (RouteExtraProps<TConfig['routes'][TType]['extraProps']>)): Route<TType, Awaited<ReturnType<TConfig['routes'][TType]['contextFactory']>>, TResponseValidator, TPathValidator, TQueryValidator, TBodyValidator, TResponseHeadersValidator>;
+    createCustomRoute<TType extends TRouteTypes, TMethod extends Method, TResponseValidator extends ZodFirstPartySchemaTypes | undefined = undefined, TQueryValidator extends ZodObject<ZodRawShape> | undefined = undefined, TPathValidator extends ZodObject<ZodRawShape> | undefined = undefined, TBodyValidator extends ZodFirstPartySchemaTypes | undefined = undefined, TResponseHeadersValidator extends ZodObject<ZodRawShape> | undefined = undefined>(params: Route<TType, Awaited<ReturnType<TConfig['routes'][TType]['contextFactory']>>, TResponseValidator, TPathValidator, TQueryValidator, TBodyValidator, TResponseHeadersValidator, TMethod> & (RouteExtraProps<TConfig['routes'][TType]['extraProps']>)): Route<TType, Awaited<ReturnType<TConfig['routes'][TType]['contextFactory']>>, TResponseValidator, TPathValidator, TQueryValidator, TBodyValidator, TResponseHeadersValidator>;
+    createRoute<TType extends TRouteTypes, TMethod extends Method, TResponseValidator extends ZodFirstPartySchemaTypes | undefined = undefined, TQueryValidator extends ZodObject<ZodRawShape> | undefined = undefined, TPathValidator extends ZodObject<ZodRawShape> | undefined = undefined, TBodyValidator extends ZodFirstPartySchemaTypes | undefined = undefined, TResponseHeadersValidator extends ZodObject<ZodRawShape> | undefined = undefined>(params: StandardRoute<TType, Awaited<ReturnType<TConfig['routes'][TType]['contextFactory']>>, TResponseValidator, TPathValidator, TQueryValidator, TBodyValidator, TMethod> & (RouteExtraProps<TConfig['routes'][TType]['extraProps']>)): Route<TType, Awaited<ReturnType<TConfig['routes'][TType]['contextFactory']>>, TResponseValidator, TPathValidator, TQueryValidator, TBodyValidator, TResponseHeadersValidator>;
 }

package/dist/services/RoutingFactory/RoutingFactory.js

@@ -3,7 +3,7 @@ export class RoutingFactory {
     constructor(map) {
         this.map = map;
     }
-    createRoute(params) {
+    createCustomRoute(params) {
         const result = {
             ...params,
             method: params.method,
@@ -21,4 +21,29 @@ export class RoutingFactory {
         };
         return result;
     }
+    createRoute(params) {
+        const newHandler = async (ctx) => {
+            const body = await params.handler(ctx);
+            return {
+                body: body,
+                status: 200,
+                headers: {},
+            };
+        };
+        const result = {
+            ...params,
+            method: params.method,
+            type: params.type,
+            path: params.path,
+            description: params.description,
+            validators: {
+                query: params.validators.query,
+                path: params.validators.path,
+                response: params.validators.response,
+                body: params.validators.body,
+            },
+            handler: newHandler,
+        };
+        return result;
+    }
 }

package/dist/services/RoutingFactory/types/StandardRoute.d.ts

@@ -0,0 +1,26 @@
+import { z, ZodFirstPartySchemaTypes, ZodObject, ZodRawShape } from 'zod';
+import { Method } from '../../../enums/Methods.js';
+import { RoutePath } from '../../../types/RoutePath.js';
+type BodyHandlerResponse<T extends ZodFirstPartySchemaTypes | undefined = undefined> = Promise<T extends undefined ? void : z.infer<Exclude<T, undefined>>>;
+export interface StandardRoute<TType extends string, TContext extends object, TResponseValidator extends ZodFirstPartySchemaTypes | undefined, TPathValidator extends ZodObject<ZodRawShape> | undefined, TQueryValidator extends ZodObject<ZodRawShape> | undefined, TBodyValidator extends ZodFirstPartySchemaTypes | undefined, TMethod extends Method = Method> {
+    tags?: string[];
+    operationId?: string;
+    type: TType;
+    method: TMethod;
+    path: RoutePath;
+    description: string;
+    validators: {
+        query?: TQueryValidator;
+        path?: TPathValidator;
+        body?: TMethod extends 'GET' ? never : TBodyValidator;
+        response?: TResponseValidator;
+    };
+    handler: (context: {
+        params: {
+            body: TBodyValidator extends ZodFirstPartySchemaTypes ? z.infer<TBodyValidator> : object;
+            query: TQueryValidator extends ZodObject<ZodRawShape> ? z.infer<TQueryValidator> : object;
+            path: TPathValidator extends ZodObject<ZodRawShape> ? z.infer<TPathValidator> : object;
+        };
+    } & TContext) => BodyHandlerResponse<TResponseValidator>;
+}
+export {};

package/dist/services/RoutingFactory/types/StandardRoute.js

@@ -0,0 +1 @@
+export {};

package/dist/types/Route.d.ts

@@ -1,12 +1,7 @@
 import { z, ZodFirstPartySchemaTypes, ZodObject, ZodRawShape } from 'zod';
 import { Method } from '../enums/Methods.js';
 import { RoutePath } from './RoutePath.js';
-type BodyHandlerResponse<T extends ZodFirstPartySchemaTypes | undefined = undefined> = Promise<T extends undefined ? undefined : z.infer<Exclude<T, undefined>>>;
-type FullHandlerRespnse<T extends ZodFirstPartySchemaTypes | undefined, THeaders extends ZodObject<ZodRawShape> | undefined> = Promise<{
-    body: Awaited<BodyHandlerResponse<T>>;
-    headers: z.infer<Exclude<THeaders, undefined>>;
-}>;
-type HandlerResponse<T extends ZodFirstPartySchemaTypes | undefined, TH extends ZodObject<ZodRawShape> | undefined> = TH extends undefined ? BodyHandlerResponse<T> : FullHandlerRespnse<T, Exclude<TH, undefined>>;
+import { RouteResponse } from './RouteResponse.js';
 export interface Route<TType extends string, TContext extends object, TResponseValidator extends ZodFirstPartySchemaTypes | undefined, TPathValidator extends ZodObject<ZodRawShape> | undefined, TQueryValidator extends ZodObject<ZodRawShape> | undefined, TBodyValidator extends ZodFirstPartySchemaTypes | undefined, TResponseHeadersValidator extends ZodObject<ZodRawShape> | undefined, TMethod extends Method = Method> {
     tags?: string[];
     operationId?: string;
@@ -27,6 +22,5 @@ export interface Route<TType extends string, TContext extends object, TResponseV
             query: TQueryValidator extends ZodObject<ZodRawShape> ? z.infer<TQueryValidator> : object;
             path: TPathValidator extends ZodObject<ZodRawShape> ? z.infer<TPathValidator> : object;
         };
-    } & TContext) => HandlerResponse<TResponseValidator, TResponseHeadersValidator>;
+    } & TContext) => Promise<RouteResponse>;
 }
-export {};

package/dist/types/RouteResponse.d.ts

@@ -0,0 +1,5 @@
+export interface RouteResponse {
+    body: unknown;
+    status: number;
+    headers: Record<string, string>;
+}

package/dist/types/RouteResponse.js

@@ -0,0 +1 @@
+export {};

package/dist/types/config/Config.d.ts

@@ -1,7 +1,6 @@
 import { ZodOpenApiVersion } from 'zod-openapi';
 import { Logger } from '../../services/Logger/Logger.js';
 import { LogLevel } from '../../services/Logger/types/LogLevel.js';
-import { AnyRoute } from '../AnyRoute.js';
 import { RoutePath } from '../RoutePath.js';
 import { ErrorConfigMap } from './ErrorConfigMap.js';
 import { ErrorResponse } from './ErrorResponse.js';
@@ -38,9 +37,4 @@ export type Config<TRouteTypes extends string, TErrorCodes extends string, TErro
     onHandler?: (e: OnHandlerEvent) => Promise<void>;
     onResponse?: (e: OnResponseEvent) => Promise<void>;
     onError?: (e: OnErrorEvent) => Promise<ErrorResponse<TErrorCodes, TErrorConfigMap>>;
-    middleware?: <T extends TRouteTypes>(route: AnyRoute<T>, ctx: Awaited<ReturnType<TRouteContextMap[T]>>) => Promise<{
-        body?: unknown;
-        status?: number;
-        headers?: Record<string, string>;
-    }>;
 };

package/dist/types/config/RouteConfig.d.ts

@@ -1,9 +1,11 @@
 import { ZodObject, ZodRawShape } from 'zod';
 import { ContextParams } from './ContextParams.js';
+import { RouteHandlerWrapper } from './RouteHandlerWrapper.js';
 export type RouteConfig<TRouteType extends string, TErrorCodes extends string, TExtraProps extends ZodObject<ZodRawShape> | undefined = ZodObject<ZodRawShape> | undefined, TContext extends object | undefined = object | undefined> = {
     authorization: boolean;
     extraProps: TExtraProps;
     contextFactory: (params: ContextParams<TRouteType, TExtraProps>) => Promise<TContext>;
+    handlerWrapper?: RouteHandlerWrapper<TRouteType, TExtraProps, TContext>;
     errors?: {
         [key in TErrorCodes]?: true;
     };

package/dist/types/config/RouteHandlerWrapper.d.ts

@@ -0,0 +1,4 @@
+import { ZodObject, ZodRawShape } from 'zod';
+import { ContextParams } from './ContextParams.js';
+import { RouteResponse } from '../RouteResponse.js';
+export type RouteHandlerWrapper<TRouteType extends string, TExtraProps extends ZodObject<ZodRawShape> | undefined, TContext extends object | undefined> = (handler: () => Promise<RouteResponse>, params: ContextParams<TRouteType, TExtraProps>, context: TContext) => Promise<RouteResponse>;

package/dist/types/config/RouteHandlerWrapper.js

@@ -0,0 +1 @@
+export {};

package/dist/types/events/OnResponseEvent.d.ts

@@ -1,8 +1,5 @@
+import { RouteResponse } from '../RouteResponse.js';
 import { OnHandlerEvent } from './OnHandlerEvent.js';
 export interface OnResponseEvent extends OnHandlerEvent {
-    response: {
-        status: number;
-        body: unknown;
-        headers: Record<string, string>;
-    };
+    response: RouteResponse;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "snap-on-openapi",
   "author": "Alex Sarychev",
-  "version": "1.0.14",
+  "version": "1.0.15",
   "description": "Swiftly build type-checked OpenAPI applications with Zod and TypeScript",
   "type": "module",
   "license": "ISC",