snap-on-openapi 1.0.16 → 1.0.18

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 { OnResponseEvent } from './types/events/OnResponseEvent.js';
 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;
@@ -48,7 +49,7 @@ export declare class OpenApi<TRouteTypes extends string, TErrorCodes extends str
     addServer(url: string, description: string): void;
     protected getRouteForPath(path: string, method: string): AnyRoute<TRouteTypes> | null;
     processRootRoute(originalReq: Request): Promise<RouteResponse>;
-    protected handleError(e: unknown, req: Request): Promise<{
+    protected handleError(e: unknown, req: Request, eventPieces?: Partial<OnResponseEvent<TRouteTypes, TConfig['routes'][TRouteTypes]['extraProps']>>): Promise<{
         status: number;
         body: z.TypeOf<import("./index.js").OpenApiErrorConfigMap<TErrorCodes>[TErrorCodes]["responseValidator"]>;
         headers: {};

package/dist/OpenApi.js

@@ -128,9 +128,14 @@ export class OpenApi {
         return null;
     }
     async processRootRoute(originalReq) {
+        let onRequest;
+        let onRoute;
+        let onResponse;
+        let onHandler;
         try {
             if (this.config.onRequest) {
-                await this.config.onRequest({ request: originalReq, logger: this.logger });
+                onRequest = { request: originalReq, logger: this.logger };
+                await this.config.onRequest(onRequest);
             }
             const url = new URL(originalReq.url);
             const basePath = this.getBasePath() === '/' ? '' : this.getBasePath();
@@ -179,7 +184,7 @@ export class OpenApi {
                 query: reqQuery,
                 body: body,
             };
-            const onRoute = {
+            onRoute = {
                 request: originalReq,
                 logger: this.logger,
                 path: urlPath,
@@ -221,7 +226,7 @@ export class OpenApi {
                     body: bodyData,
                 },
             });
-            const onHandler = {
+            onHandler = {
                 ...onRoute,
                 validated: {
                     query: query.data,
@@ -256,7 +261,7 @@ export class OpenApi {
                 headers: route.validators.responseHeaders?.strict() ?? z.object({}),
                 status: z.literal(200),
             });
-            const onResponse = {
+            onResponse = {
                 ...onHandler,
                 response,
             };
@@ -276,12 +281,18 @@ export class OpenApi {
             return response;
         }
         catch (e) {
-            return await this.handleError(e, originalReq);
+            return await this.handleError(e, originalReq, {
+                ...onHandler,
+                ...onRequest,
+                ...onRoute,
+                ...onResponse,
+            });
         }
     }
-    async handleError(e, req) {
+    async handleError(e, req, eventPieces) {
         try {
             const event = {
+                ...eventPieces,
                 request: req,
                 logger: this.logger,
                 error: e,

package/dist/services/ConfigBuilder/ConfigBuilder.js

@@ -45,18 +45,19 @@ export class ConfigBuilder {
         if (conf) {
             return this.construct(conf);
         }
-        const routeMap = this.routeMap ?? undefined;
         const contextMap = this.routeContextMap ?? undefined;
-        if (this.routeContextMap && this.routeMap) {
-            for (const key of Object.keys(routeMap)) {
-                routeMap[key].contextFactory = contextMap[key];
+        if (this.routeMap) {
+            const keys = Object.keys(this.routeMap);
+            for (const key of keys) {
+                const factory = contextMap?.[key] ? contextMap[key] : async () => undefined;
+                this.routeMap[key].contextFactory = factory;
             }
         }
         const def = new DefaultConfig();
         const builtConf = {
             ...def,
             ...this.conf,
-            ...(routeMap ? { routes: routeMap } : {}),
+            ...(this.routeMap ? { routes: this.routeMap } : {}),
             ...(this.errorMap ? { errors: this.errorMap } : {}),
             ...(this.defaultError ? { defaultError: this.defaultError } : {}),
         };

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

@@ -21,9 +21,9 @@ export declare class DefaultConfig implements Config<SampleRouteType, ErrorCode,
         };
     };
     onRequest?: () => Promise<void>;
-    onRoute?: (e: OnRouteEvent) => Promise<void>;
+    onRoute?: (e: OnRouteEvent<SampleRouteType, DefaultRouteParamsMap>) => Promise<void>;
     onHandler?: () => Promise<void>;
-    onResponse?: (e: OnResponseEvent) => Promise<void>;
-    onError?: (e: OnErrorEvent) => Promise<ErrorResponse<ErrorCode, DefaultErrorMap>>;
+    onResponse?: (e: OnResponseEvent<SampleRouteType, DefaultRouteParamsMap>) => Promise<void>;
+    onError?: (e: OnErrorEvent<SampleRouteType, DefaultRouteParamsMap>) => Promise<ErrorResponse<ErrorCode, DefaultErrorMap>>;
     skipDescriptionsCheck?: boolean;
 }

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

@@ -3,4 +3,5 @@ import { RouteContextMap } from '../../../types/config/RouteContextMap.js';
 import { DefaultRouteParamsMap } from './DefaultRouteParamsMap.js';
 export declare class DefaultRouteContextMap implements RouteContextMap<SampleRouteType, DefaultRouteParamsMap> {
     Public: () => Promise<{}>;
+    User: () => Promise<{}>;
 }

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

@@ -1,3 +1,4 @@
 export class DefaultRouteContextMap {
     Public = async () => ({});
+    User = async () => ({});
 }

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

@@ -33,8 +33,8 @@ export type Config<TRouteTypes extends string, TErrorCodes extends string, TErro
     servers?: Server[];
     logLevel?: LogLevel;
     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>>;
+    onRoute?: (e: OnRouteEvent<TRouteTypes, TRouteParamMap>) => Promise<void>;
+    onHandler?: (e: OnHandlerEvent<TRouteTypes, TRouteParamMap>) => Promise<void>;
+    onResponse?: (e: OnResponseEvent<TRouteTypes, TRouteParamMap>) => Promise<void>;
+    onError?: (e: OnErrorEvent<TRouteTypes, TRouteParamMap>) => Promise<ErrorResponse<TErrorCodes, TErrorConfigMap>>;
 };

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

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

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

@@ -1,5 +1,6 @@
+import { RouteExtraPropsMap } from '../config/RouteExtraPropsMap.js';
 import { OnRouteEvent } from './OnRouteEvent.js';
-export interface OnHandlerEvent extends OnRouteEvent {
+export interface OnHandlerEvent<TRouteType extends string, TContextMap extends RouteExtraPropsMap<TRouteType>> extends OnRouteEvent<TRouteType, TContextMap> {
     validated: {
         query: Record<string, unknown>;
         path: Record<string, unknown>;

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

@@ -1,5 +1,6 @@
+import { RouteExtraPropsMap } from '../config/RouteExtraPropsMap.js';
 import { RouteResponse } from '../RouteResponse.js';
 import { OnHandlerEvent } from './OnHandlerEvent.js';
-export interface OnResponseEvent extends OnHandlerEvent {
+export interface OnResponseEvent<TRouteType extends string, TContextMap extends RouteExtraPropsMap<TRouteType>> extends OnHandlerEvent<TRouteType, TContextMap> {
     response: RouteResponse;
 }

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

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

package/package.json

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