snap-on-openapi 1.0.12 → 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,15 +47,11 @@ 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>;
-    }>;
-    protected handleError(e: unknown, req: Request): {
+    processRootRoute(originalReq: Request): Promise<RouteResponse>;
+    protected handleError(e: unknown, req: Request): Promise<{
         status: number;
         body: z.TypeOf<import("./index.js").OpenApiErrorConfigMap<TErrorCodes>[TErrorCodes]["responseValidator"]>;
         headers: {};
-    };
+    }>;
     protected static getBuilder(): ConfigBuilder<SampleRouteType, ErrorCode, DefaultErrorMap, DefaultRouteParamsMap, DefaultRouteContextMap, DefaultRouteMap, DefaultConfig>;
 }

package/dist/OpenApi.js

@@ -129,6 +129,9 @@ export class OpenApi {
     }
     async processRootRoute(originalReq) {
         try {
+            if (this.config.onRequest) {
+                await this.config.onRequest({ request: originalReq, logger: this.logger });
+            }
             const url = new URL(originalReq.url);
             const basePath = this.getBasePath() === '/' ? '' : this.getBasePath();
             const urlPath = url.pathname.replace(basePath, '');
@@ -176,12 +179,19 @@ export class OpenApi {
                 query: reqQuery,
                 body: body,
             };
-            this.logger.info(`Calling route ${route.path}`);
-            this.logger.info(`${req.method}: ${req.path}`, {
-                path: req.params,
-                query: req.query,
-                body: req.body,
-            });
+            const onRoute = {
+                request: originalReq,
+                logger: this.logger,
+                path: urlPath,
+                method: originalReq.method,
+                params: pathParams,
+                query: reqQuery,
+                body: body,
+                route: route,
+            };
+            if (this.config.onRoute) {
+                await this.config.onRoute(onRoute);
+            }
             const queryValidator = route.validators.query?.strict() ?? z.object({});
             const query = queryValidator.safeParse(req.query);
             if (!query.success) {
@@ -192,80 +202,96 @@ export class OpenApi {
             if (!path.success) {
                 throw new ValidationError(path.error, ValidationLocation.Path, req.params);
             }
-            let response;
             const containsBody = route.method !== Method.GET;
+            let bodyData = {};
             if (containsBody && route.validators.body) {
-                const body = route.validators.body.safeParse(req.body);
-                if (!body.success) {
-                    throw new ValidationError(body.error, ValidationLocation.Body, req.body);
+                const bodyResult = route.validators.body.safeParse(req.body);
+                if (!bodyResult.success) {
+                    throw new ValidationError(bodyResult.error, ValidationLocation.Body, req.body);
                 }
-                const context = await this.config.routes[route.type].contextFactory({
-                    route: route,
-                    request: originalReq,
-                    params: {
-                        query: query.data,
-                        path: path.data,
-                        body: body.data,
-                    },
-                });
-                response = await route.handler({
-                    ...context,
-                    params: {
-                        query: query.data,
-                        path: path.data,
-                        body: body.data,
-                    },
-                });
+                bodyData = bodyResult.data;
             }
-            else {
-                const context = await this.config.routes[route.type].contextFactory({
-                    route: route,
-                    request: originalReq,
-                    params: {
-                        query: query.data,
-                        path: path.data,
-                        body: {},
-                    },
-                });
-                response = await route.handler({
+            const context = await this.config.routes[route.type].contextFactory({
+                route: route,
+                request: originalReq,
+                logger: this.logger,
+                params: {
+                    query: query.data,
+                    path: path.data,
+                    body: bodyData,
+                },
+            });
+            const onHandler = {
+                ...onRoute,
+                validated: {
+                    query: query.data,
+                    path: path.data,
+                    body: bodyData,
+                },
+            };
+            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: {},
-                    }
+                        body: bodyData,
+                    },
                 });
-            }
-            const finalResponse = route.validators.responseHeaders ? response : { body: response, headers: {} };
+                return response;
+            };
+            const response = await wrapper(handler, {
+                route: route,
+                request: originalReq,
+                logger: this.logger,
+                params: {
+                    query: query.data,
+                    path: path.data,
+                    body: bodyData,
+                },
+            }, 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,
+            };
             if (this.config.disableResponseValidation) {
-                this.logger.info('Response: 200', finalResponse);
-                return { status: 200, body: finalResponse.body, headers: finalResponse.headers };
+                if (this.config.onResponse) {
+                    await this.config.onResponse(onResponse);
+                }
+                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);
             }
-            this.logger.info('Response: 200', validated.data);
-            return { status: 200, body: validated.data.body, headers: validated.data.headers };
+            if (this.config.onResponse) {
+                await this.config.onResponse(onResponse);
+            }
+            return response;
         }
         catch (e) {
-            return this.handleError(e, originalReq);
+            return await this.handleError(e, originalReq);
         }
     }
-    handleError(e, req) {
-        this.logger.error('Error during request openAPI route handling', e);
+    async handleError(e, req) {
         try {
-            const response = this.config.handleError ? this.config.handleError(e, { request: req, logger: this.logger }) : this.config.defaultError;
+            const event = {
+                request: req,
+                logger: this.logger,
+                error: e,
+            };
+            const response = this.config.onError ? await this.config.onError(event) : this.config.defaultError;
             const status = this.config.errors[response.code].status;
             const valid = this.config.errors[response.code].responseValidator.safeParse(response.body);
             if (!valid.success) {
                 throw new Error("Error response haven't passed validation");
             }
-            this.logger.info(`Response: '${status}'`, response.body);
             return { status: Number(status), body: response.body, headers: {} };
         }
         catch (e) {

package/dist/services/ConfigBuilder/types/DefaultConfig.d.ts

@@ -2,6 +2,9 @@ import { ErrorCode } from '../../../enums/ErrorCode.js';
 import { SampleRouteType } from '../../../enums/SampleRouteType.js';
 import { Config } from '../../../types/config/Config.js';
 import { ErrorResponse } from '../../../types/config/ErrorResponse.js';
+import { OnErrorEvent } from '../../../types/events/OnErrorEvent.js';
+import { OnResponseEvent } from '../../../types/events/OnResponseEvent.js';
+import { OnRouteEvent } from '../../../types/events/OnRouteEvent.js';
 import { RoutePath } from '../../../types/RoutePath.js';
 import { DefaultErrorMap } from './DefaultErrorMap.js';
 import { DefaultRouteContextMap } from './DefaultRouteContextMap.js';
@@ -17,6 +20,10 @@ export declare class DefaultConfig implements Config<SampleRouteType, ErrorCode,
             readonly error: ErrorCode.UnknownError;
         };
     };
-    handleError?: (e: unknown) => ErrorResponse<ErrorCode, DefaultErrorMap>;
+    onRequest?: () => Promise<void>;
+    onRoute?: (e: OnRouteEvent) => Promise<void>;
+    onHandler?: () => Promise<void>;
+    onResponse?: (e: OnResponseEvent) => Promise<void>;
+    onError?: (e: OnErrorEvent) => Promise<ErrorResponse<ErrorCode, DefaultErrorMap>>;
     skipDescriptionsCheck?: boolean;
 }

package/dist/services/ConfigBuilder/types/DefaultConfig.js

@@ -14,9 +14,23 @@ export class DefaultConfig {
             error: ErrorCode.UnknownError,
         },
     };
-    handleError = (e) => {
-        if (e instanceof ValidationError) {
-            const zodError = e.getZodError();
+    onRequest = () => Promise.resolve();
+    onRoute = async (e) => {
+        e.logger.info(`Calling route ${e.route.path}`);
+        e.logger.info(`${e.method}: ${e.request.url}`, {
+            path: e.path,
+            query: e.query,
+            body: e.body,
+        });
+    };
+    onHandler = () => Promise.resolve();
+    onResponse = async (e) => {
+        e.logger.info(`Response: ${e.response.status}`, { body: e.response.body, headers: e.response.headers });
+    };
+    onError = async (e) => {
+        e.logger.error('Error during request openAPI route handling', { url: e.request.url, error: e.error });
+        if (e.error instanceof ValidationError) {
+            const zodError = e.error.getZodError();
             const map = [];
             for (const issue of zodError.issues) {
                 map.push({
@@ -24,18 +38,18 @@ export class DefaultConfig {
                     message: issue.message,
                 });
             }
-            if (e.getLocation() !== ValidationLocation.Response) {
+            if (e.error.getLocation() !== ValidationLocation.Response) {
                 const response = {
                     error: {
                         code: ErrorCode.ValidationFailed,
-                        location: e.getLocation(),
+                        location: e.error.getLocation(),
                         fieldErrors: map,
                     },
                 };
                 return { code: ErrorCode.ValidationFailed, body: response };
             }
         }
-        if (e instanceof BuiltInError && e.getCode() === ErrorCode.NotFound) {
+        if (e.error instanceof BuiltInError && e.error.getCode() === ErrorCode.NotFound) {
             return { code: ErrorCode.NotFound, body: { error: ErrorCode.NotFound } };
         }
         const unknownError = {

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/services/TestUtils/TestUtils.d.ts

@@ -2,6 +2,7 @@ import { OpenApi } from '../../OpenApi.js';
 import { Method } from '../../enums/Methods.js';
 import { SampleRouteType } from '../../enums/SampleRouteType.js';
 import { RoutePath } from '../../types/RoutePath.js';
+import { TestLogger } from './utils/TestLogger.js';
 export declare class TestUtils {
     static createRequest(route: RoutePath, method?: Method, body?: object): Request;
     static sendRequest(api: OpenApi<any, any, any>, route: RoutePath, method?: Method, body?: object): Promise<{
@@ -10,4 +11,5 @@ export declare class TestUtils {
     }>;
     static createOpenApi(): OpenApi<SampleRouteType, import("../../index.js").OpenApiErrorCode, import("../../index.js").OpenApiDefaultConfig>;
     static awaitGeneric<T>(timeoutMs: number, intervalMs: number, callback: () => Promise<T | null>): Promise<T | null>;
+    static getTestLogger(): TestLogger;
 }

package/dist/services/TestUtils/TestUtils.js

@@ -2,6 +2,7 @@ import z from 'zod';
 import { OpenApi } from '../../OpenApi.js';
 import { Method } from '../../enums/Methods.js';
 import { SampleRouteType } from '../../enums/SampleRouteType.js';
+import { TestLogger } from './utils/TestLogger.js';
 export class TestUtils {
     static createRequest(route, method = Method.GET, body) {
         const request = new Request(`http://localhost${route}`, {
@@ -45,4 +46,7 @@ export class TestUtils {
         } while (now < deadline);
         return null;
     }
+    static getTestLogger() {
+        return new TestLogger('TestUtils');
+    }
 }

package/dist/services/TestUtils/utils/TestLogger.d.ts

@@ -0,0 +1,15 @@
+import { Logger } from '../../Logger/Logger.js';
+export declare class TestLogger extends Logger {
+    private messages;
+    popMessage(): {
+        message: string;
+        level: string;
+        data?: object;
+    } | undefined;
+    shiftMessage(): {
+        message: string;
+        level: string;
+        data?: object;
+    } | undefined;
+    protected log(message: string, level: string, data?: object): void;
+}

package/dist/services/TestUtils/utils/TestLogger.js

@@ -0,0 +1,13 @@
+import { Logger } from '../../Logger/Logger.js';
+export class TestLogger extends Logger {
+    messages = [];
+    popMessage() {
+        return this.messages.pop();
+    }
+    shiftMessage() {
+        return this.messages.shift();
+    }
+    log(message, level, data) {
+        this.messages.push({ message, level, data });
+    }
+}

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';
@@ -9,6 +8,11 @@ import { RouteConfigMap } from './RouteConfigMap.js';
 import { RouteContextMap } from './RouteContextMap.js';
 import { RouteExtraPropsMap } from './RouteExtraPropsMap.js';
 import { Server } from './Server.js';
+import { OnErrorEvent } from '../events/OnErrorEvent.js';
+import { OnHandlerEvent } from '../events/OnHandlerEvent.js';
+import { OnRequestEvent } from '../events/OnRequestEvent.js';
+import { OnResponseEvent } from '../events/OnResponseEvent.js';
+import { OnRouteEvent } from '../events/OnRouteEvent.js';
 export type Config<TRouteTypes extends string, TErrorCodes extends string, TErrorConfigMap extends ErrorConfigMap<TErrorCodes>, TRouteParamMap extends RouteExtraPropsMap<TRouteTypes>, TRouteContextMap extends RouteContextMap<TRouteTypes, TRouteParamMap>, TRouteConfigMap extends RouteConfigMap<TRouteTypes, TErrorCodes, TRouteParamMap, TRouteContextMap>> = {
     disableResponseValidation?: boolean;
     logger?: Logger;
@@ -28,13 +32,9 @@ export type Config<TRouteTypes extends string, TErrorCodes extends string, TErro
     apiVersion?: string;
     servers?: Server[];
     logLevel?: LogLevel;
-    handleError?: (e: unknown, context: {
-        request: Request;
-        logger: Logger;
-    }) => ErrorResponse<TErrorCodes, TErrorConfigMap>;
-    middleware?: <T extends TRouteTypes>(route: AnyRoute<T>, ctx: Awaited<ReturnType<TRouteContextMap[T]>>) => Promise<{
-        body?: unknown;
-        status?: number;
-        headers?: Record<string, string>;
-    }>;
+    onRequest?: (e: OnRequestEvent) => Promise<void>;
+    onRoute?: (e: OnRouteEvent) => Promise<void>;
+    onHandler?: (e: OnHandlerEvent) => Promise<void>;
+    onResponse?: (e: OnResponseEvent) => Promise<void>;
+    onError?: (e: OnErrorEvent) => Promise<ErrorResponse<TErrorCodes, TErrorConfigMap>>;
 };

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

@@ -1,9 +1,11 @@
 import { ZodObject, ZodRawShape } from 'zod';
 import { AnyRoute } from '../AnyRoute.js';
 import { RouteExtraProps } from './RouteExtraProps.js';
+import { Logger } from '../../services/Logger/Logger.js';
 export type ContextParams<TRouteType extends string, TExtraProps extends ZodObject<ZodRawShape> | undefined> = {
     route: AnyRoute<TRouteType> & RouteExtraProps<TExtraProps>;
     request: Request;
+    logger: Logger;
     params: {
         body: unknown;
         query: unknown;

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/OnErrorEvent.d.ts

@@ -0,0 +1,7 @@
+import { Logger } from '../../services/Logger/Logger.js';
+import { OnResponseEvent } from './OnResponseEvent.js';
+export interface OnErrorEvent extends Partial<OnResponseEvent> {
+    request: Request;
+    logger: Logger;
+    error: unknown;
+}

package/dist/types/events/OnErrorEvent.js

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

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

@@ -0,0 +1,8 @@
+import { OnRouteEvent } from './OnRouteEvent.js';
+export interface OnHandlerEvent extends OnRouteEvent {
+    validated: {
+        query: Record<string, unknown>;
+        path: Record<string, unknown>;
+        body: unknown;
+    };
+}

package/dist/types/events/OnHandlerEvent.js

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

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

@@ -0,0 +1,5 @@
+import { Logger } from '../../services/Logger/Logger.js';
+export interface OnRequestEvent {
+    request: Request;
+    logger: Logger;
+}

package/dist/types/events/OnRequestEvent.js

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

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

@@ -0,0 +1,5 @@
+import { RouteResponse } from '../RouteResponse.js';
+import { OnHandlerEvent } from './OnHandlerEvent.js';
+export interface OnResponseEvent extends OnHandlerEvent {
+    response: RouteResponse;
+}

package/dist/types/events/OnResponseEvent.js

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

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

@@ -0,0 +1,10 @@
+import { AnyRoute } from '../AnyRoute.js';
+import { OnRequestEvent } from './OnRequestEvent.js';
+export interface OnRouteEvent extends OnRequestEvent {
+    path: string;
+    method: string;
+    params: Record<string, string>;
+    query: Record<string, string | string[]>;
+    body: unknown;
+    route: AnyRoute<string>;
+}

package/dist/types/events/OnRouteEvent.js

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

package/package.json

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