snap-on-openapi 1.0.12 → 1.0.14

package/dist/OpenApi.d.ts

@@ -51,10 +51,10 @@ export declare class OpenApi<TRouteTypes extends string, TErrorCodes extends str
         body: unknown;
         headers: Record<string, string>;
     }>;
-    protected handleError(e: unknown, req: Request): {
+    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,82 @@ 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,
-                    },
-                });
-            }
-            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({
-                    ...context,
-                    params: {
-                        query: query.data,
-                        path: path.data,
-                        body: {},
-                    }
-                });
+                bodyData = bodyResult.data;
             }
+            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 response = await route.handler({
+                ...context,
+                params: {
+                    query: query.data,
+                    path: path.data,
+                    body: bodyData,
+                },
+            });
             const finalResponse = route.validators.responseHeaders ? response : { body: response, headers: {} };
             const finalResponseValidator = z.object({
                 body: route.validators.response ?? z.undefined(),
                 headers: route.validators.responseHeaders?.strict() ?? z.object({}),
             });
+            const onResponse = {
+                ...onHandler,
+                response: { status: 200, body: finalResponse.body, headers: finalResponse.headers },
+            };
             if (this.config.disableResponseValidation) {
-                this.logger.info('Response: 200', finalResponse);
+                if (this.config.onResponse) {
+                    await this.config.onResponse(onResponse);
+                }
                 return { status: 200, body: finalResponse.body, headers: finalResponse.headers };
             }
             const validated = finalResponseValidator.safeParse(finalResponse);
             if (!validated.success) {
                 throw new ValidationError(validated.error, ValidationLocation.Response, finalResponse);
             }
-            this.logger.info('Response: 200', validated.data);
+            if (this.config.onResponse) {
+                await this.config.onResponse(onResponse);
+            }
             return { status: 200, body: validated.data.body, headers: validated.data.headers };
         }
         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/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/config/Config.d.ts

@@ -9,6 +9,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,10 +33,11 @@ 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>;
+    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>>;
     middleware?: <T extends TRouteTypes>(route: AnyRoute<T>, ctx: Awaited<ReturnType<TRouteContextMap[T]>>) => Promise<{
         body?: unknown;
         status?: number;

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/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,8 @@
+import { OnHandlerEvent } from './OnHandlerEvent.js';
+export interface OnResponseEvent extends OnHandlerEvent {
+    response: {
+        status: number;
+        body: unknown;
+        headers: Record<string, string>;
+    };
+}

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.14",
   "description": "Swiftly build type-checked OpenAPI applications with Zod and TypeScript",
   "type": "module",
   "license": "ISC",