snap-on-openapi 1.0.7 → 1.0.9

package/dist/OpenApi.js

@@ -43,7 +43,7 @@ export class OpenApi {
         this.basePath = config.basePath;
         const info = {
             title: config.apiName ?? 'My API',
-            version: '3.1.0',
+            version: config.apiVersion ?? '1.0.0',
         };
         this.schemaGenerator = new SchemaGenerator(this.logger.derrive('SchemaGenerator'), info, this.config, this.routes, this.servers);
         this.wrappers = {
@@ -106,11 +106,11 @@ export class OpenApi {
     }
     getRouteForPath(path, method) {
         const fittingRoutes = [];
+        const pathParts = path.split('/').filter((x) => x !== '');
         outer: for (const route of this.routes) {
             if (route.method === method) {
                 fittingRoutes.push(route);
                 const routeParts = route.path.split('/').filter((x) => x !== '');
-                const pathParts = path.split('/').filter((x) => x !== '');
                 if (routeParts.length !== pathParts.length) {
                     continue;
                 }
@@ -130,7 +130,8 @@ export class OpenApi {
     async processRootRoute(originalReq) {
         try {
             const url = new URL(originalReq.url);
-            const urlPath = url.pathname.replace(this.getBasePath(), '');
+            const basePath = this.getBasePath() === '/' ? '' : this.getBasePath();
+            const urlPath = url.pathname.replace(basePath, '');
             const route = this.getRouteForPath(urlPath, originalReq.method);
             if (!route) {
                 this.logger.info(`Route for ${originalReq.method}:${urlPath} not found`);
@@ -177,7 +178,7 @@ export class OpenApi {
             };
             this.logger.info(`Calling route ${route.path}`);
             this.logger.info(`${req.method}: ${req.path}`, {
-                params: req.params,
+                path: req.params,
                 query: req.query,
                 body: req.body,
             });
@@ -194,7 +195,7 @@ export class OpenApi {
             let response;
             const containsBody = route.method !== Method.GET;
             if (containsBody && route.validators.body) {
-                const body = route.validators.body.strict().safeParse(req.body);
+                const body = route.validators.body.safeParse(req.body);
                 if (!body.success) {
                     throw new ValidationError(body.error, ValidationLocation.Body);
                 }
@@ -237,7 +238,7 @@ export class OpenApi {
             }
             const finalResponse = route.validators.responseHeaders ? response : { body: response, headers: {} };
             const finalResponseValidator = z.object({
-                body: route.validators.response,
+                body: route.validators.response ?? z.undefined(),
                 headers: route.validators.responseHeaders?.strict() ?? z.object({}),
             });
             const validated = finalResponseValidator.safeParse(finalResponse);

package/dist/services/DescriptionChecker/DescriptionChecker.js

@@ -16,7 +16,7 @@ export class DescriptionChecker {
         if (!route.description || route.description.length < minimalLength) {
             throw new Error(`Description for ${route.path} is missing or too small`);
         }
-        this.checkValidatorDescriptions(route, 'responseValidator', 'responseValidator', route.validators.response);
+        this.checkValidatorDescriptions(route, 'responseValidator', 'responseValidator', route.validators.response ?? z.undefined());
         this.checkValidatorDescriptions(route, 'pathValidator', 'pathValidator', route.validators.path ?? z.object({}), false);
         this.checkValidatorDescriptions(route, 'queryValidator', 'queryValidator', route.validators.query ?? z.object({}), false);
         this.checkValidatorDescriptions(route, 'bodyValidator', 'bodyValidator', route.validators.body ?? z.object({}), false);

package/dist/services/ExpressWrapper/ExpressWrapper.d.ts

@@ -9,9 +9,10 @@ export declare class ExpressWrapper<TRouteTypes extends string, TErrorCodes exte
     protected developmentUtils: DevelopmentUtils;
     protected schemaRoute: RoutePath;
     constructor(openApi: OpenApi<TRouteTypes, TErrorCodes, TConfig>);
-    requestBodyToString(req: ExpressRequest): Promise<string | undefined>;
     createStoplightRoute(route: RoutePath, expressApp: ExpressApp): void;
     createSwaggerRoute(route: RoutePath, expressApp: ExpressApp): void;
     createSchemaRoute(route: RoutePath, expressApp: ExpressApp): void;
     createOpenApiRootRoute(expressApp: ExpressApp): void;
+    protected covertExpressRequestToRequest(req: ExpressRequest): Promise<Request>;
+    protected requestBodyToString(req: ExpressRequest): Promise<string | undefined>;
 }

package/dist/services/ExpressWrapper/ExpressWrapper.js

@@ -1,5 +1,5 @@
-import { format } from 'url';
 import { DevelopmentUtils } from '../DevelopmentUtils/DevelopmentUtils.js';
+import { format, parse } from 'url';
 export class ExpressWrapper {
     service;
     developmentUtils;
@@ -8,25 +8,6 @@ export class ExpressWrapper {
         this.service = openApi;
         this.developmentUtils = new DevelopmentUtils();
     }
-    async requestBodyToString(req) {
-        if (!['POST', 'PUT', 'PATCH', 'DELETE'].includes(req.method)) {
-            return undefined;
-        }
-        return new Promise((resolve, reject) => {
-            const chunks = [];
-            req.on('data', (chunk) => {
-                chunks.push(chunk);
-            });
-            req.on('end', () => {
-                const bodyBuffer = Buffer.concat(chunks);
-                const bodyString = bodyBuffer.toString();
-                resolve(bodyString);
-            });
-            req.on('error', (error) => {
-                reject(error);
-            });
-        });
-    }
     createStoplightRoute(route, expressApp) {
         const handler = async (req, res) => {
             const body = this.developmentUtils.getStoplightHtml(this.schemaRoute);
@@ -52,30 +33,9 @@ export class ExpressWrapper {
     }
     createOpenApiRootRoute(expressApp) {
         const route = this.service.getBasePath();
-        const headerToStr = (header) => {
-            if (Array.isArray(header)) {
-                return header.join(',');
-            }
-            return header;
-        };
         const handler = async (req, res) => {
-            const emptyHeaders = {};
-            const headers = Object.entries(req.headers).reduce((acc, val) => ({
-                ...acc,
-                ...(typeof val[1] !== 'undefined' ? { [val[0]]: headerToStr(val[1]) } : {}),
-            }), emptyHeaders);
-            const url = format({
-                protocol: req.protocol,
-                host: req.host,
-                pathname: req.originalUrl,
-            });
-            const body = await this.requestBodyToString(req);
-            const openApiRequest = new Request(url, {
-                headers: headers,
-                method: req.method,
-                body: body,
-            });
-            const result = await this.service.processRootRoute(openApiRequest);
+            const request = await this.covertExpressRequestToRequest(req);
+            const result = await this.service.processRootRoute(request);
             res.status(result.status);
             res.header('Content-Type', 'application/json');
             for (const header of Object.entries(result.headers)) {
@@ -90,4 +50,49 @@ export class ExpressWrapper {
         expressApp.delete(regex, handler);
         expressApp.put(regex, handler);
     }
+    async covertExpressRequestToRequest(req) {
+        const headerToStr = (header) => {
+            if (Array.isArray(header)) {
+                return header.join(',');
+            }
+            return header;
+        };
+        const emptyHeaders = {};
+        const headers = Object.entries(req.headers).reduce((acc, val) => ({
+            ...acc,
+            ...(typeof val[1] !== 'undefined' ? { [val[0]]: headerToStr(val[1]) } : {}),
+        }), emptyHeaders);
+        const body = await this.requestBodyToString(req);
+        const parsedUrl = parse(req.originalUrl, true);
+        const url = format({
+            ...parsedUrl,
+            host: req.host,
+            protocol: req.protocol,
+        });
+        const openApiRequest = new Request(url, {
+            headers: headers,
+            method: req.method,
+            body: body,
+        });
+        return openApiRequest;
+    }
+    async requestBodyToString(req) {
+        if (!['POST', 'PUT', 'PATCH', 'DELETE'].includes(req.method)) {
+            return undefined;
+        }
+        return new Promise((resolve, reject) => {
+            const chunks = [];
+            req.on('data', (chunk) => {
+                chunks.push(chunk);
+            });
+            req.on('end', () => {
+                const bodyBuffer = Buffer.concat(chunks);
+                const bodyString = bodyBuffer.toString();
+                resolve(bodyString);
+            });
+            req.on('error', (error) => {
+                reject(error);
+            });
+        });
+    }
 }

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

@@ -6,5 +6,5 @@ import { RouteExtraProps } from '../../types/config/RouteExtraProps.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, TQueryValidator extends ZodObject<ZodRawShape> | undefined = undefined, TPathValidator extends ZodObject<ZodRawShape> | undefined = undefined, TBodyValidator extends ZodObject<ZodRawShape> | 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: 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>;
 }

package/dist/services/SchemaGenerator/SchemaGenerator.d.ts

@@ -13,6 +13,8 @@ export declare class SchemaGenerator<TRouteTypes extends string, TErrorCodes ext
     protected routeSpec: TConfig;
     constructor(logger: Logger, info: Info, spec: TConfig, routes: AnyRoute<TRouteTypes>[], servers: Server[]);
     getYaml(): string;
+    getJson(): string;
+    saveJson(path: string): void;
     saveYaml(path: string): void;
     protected createDocument(): ReturnType<typeof createDocument>;
     protected createOperation(route: AnyRoute<TRouteTypes>): ZodOpenApiOperationObject;

package/dist/services/SchemaGenerator/SchemaGenerator.js

@@ -19,17 +19,29 @@ export class SchemaGenerator {
     }
     getYaml() {
         const document = this.createDocument();
+        this.logger.info('Generating YAML for Open API');
         const yaml = stringify(document, { aliasDuplicateObjects: false });
         return yaml;
     }
+    getJson() {
+        const document = this.createDocument();
+        this.logger.info('Generating JSON for Open API');
+        const json = JSON.stringify(document, null, 2);
+        return json;
+    }
+    saveJson(path) {
+        const json = this.getJson();
+        this.logger.info(`Saving JSON to ${path}`);
+        writeFileSync(path, json);
+    }
     saveYaml(path) {
-        this.logger.info('Generating YAML for Open API');
         const yaml = this.getYaml();
+        this.logger.info(`Saving YAML to ${path}`);
         writeFileSync(path, yaml);
     }
     createDocument() {
         const openApi = {
-            openapi: '3.1.0',
+            openapi: this.routeSpec.generator?.openApiVersion ?? '3.1.0',
             info: this.info,
             components: {
                 securitySchemes: {
@@ -68,15 +80,20 @@ export class SchemaGenerator {
             query: route.validators.query,
             path: route.validators.path,
         };
+        const mediaTypes = this.routeSpec.generator?.responseMediaTypes ?? ['application/json'];
+        const content = mediaTypes.reduce((acc, mediaType) => ({
+            ...acc,
+            [mediaType]: { schema: route.validators.response },
+        }), {});
         const operation = {
             requestParams: requestParams,
             description: route.description,
+            tags: route.tags,
+            operationId: route.operationId,
             responses: {
                 200: {
-                    description: 'Good Response',
-                    content: {
-                        'application/json': { schema: route.validators.response },
-                    },
+                    description: this.routeSpec.generator?.goodResponseDescription ?? 'Good Response',
+                    content: route.validators.response ? content : undefined,
                 },
             },
         };
@@ -94,22 +111,25 @@ export class SchemaGenerator {
             errors.push(errorConfig);
             httpStatusMap.set(errorConfig.status, errors);
         }
-        for (const [code, errors] of httpStatusMap.entries()) {
-            const error = errors[0];
-            if (!error) {
-                throw new Error(`No errors found for code '${code}'`);
-            }
-            const description = errors.map((x) => x.description).join(' or ');
-            const validators = errors.map((x) => x.responseValidator);
-            const schema = errors.length === 1 ? error.responseValidator : z.union(validators).openapi({ unionOneOf: true });
-            operation.responses[error.status] = {
-                description: description,
-                content: {
-                    'application/json': {
-                        schema: schema,
+        const shouldGenerateErrors = this.routeSpec.generator?.generateErrors ?? true;
+        if (shouldGenerateErrors) {
+            for (const [code, errors] of httpStatusMap.entries()) {
+                const error = errors[0];
+                if (!error) {
+                    throw new Error(`No errors found for code '${code}'`);
+                }
+                const description = errors.map((x) => x.description).join(' or ');
+                const validators = errors.map((x) => x.responseValidator);
+                const schema = errors.length === 1 ? error.responseValidator : z.union(validators).openapi({ unionOneOf: true });
+                operation.responses[error.status] = {
+                    description: description,
+                    content: {
+                        'application/json': {
+                            schema: schema,
+                        },
                     },
-                },
-            };
+                };
+            }
         }
         if (this.routeSpec.routes[route.type].authorization) {
             operation.security = [
@@ -118,11 +138,14 @@ export class SchemaGenerator {
                 },
             ];
         }
-        if (route.method !== Method.GET) {
+        if (route.method !== Method.GET && route.validators.body) {
+            const mediaTypes = this.routeSpec.generator?.requestMediaTypes ?? ['application/json'];
+            const content = mediaTypes.reduce((acc, mediaType) => ({
+                ...acc,
+                [mediaType]: { schema: route.validators.body },
+            }), {});
             operation.requestBody = {
-                content: {
-                    'application/json': { schema: route.validators.body },
-                },
+                content,
             };
         }
         return operation;

package/dist/services/ValidationUtils/ValidationUtils.d.ts

@@ -2,7 +2,8 @@ import 'zod-openapi/extend';
 import { ZodObject, ZodRawShape, ZodType } from 'zod';
 export declare class ValidationUtils {
     readonly strings: {
-        datetime: import("zod").ZodEffects<import("zod").ZodEffects<import("zod").ZodString, string, string>, Date, string>;
+        datetime: import("zod").ZodUnion<[import("zod").ZodDate, import("zod").ZodEffects<import("zod").ZodEffects<import("zod").ZodString, string, string>, Date, string>]>;
+        date: import("zod").ZodUnion<[import("zod").ZodDate, import("zod").ZodEffects<import("zod").ZodEffects<import("zod").ZodString, string, string>, Date, string>]>;
         number: import("zod").ZodEffects<import("zod").ZodEffects<import("zod").ZodString, string, string>, number, string>;
         boolean: import("zod").ZodEffects<import("zod").ZodEnum<["true", "false"]>, boolean, "true" | "false">;
     };
@@ -39,18 +40,18 @@ export declare class ValidationUtils {
             count: number;
         }>;
     }, "strip", import("zod").ZodTypeAny, {
+        items: T["_output"][];
         info: {
             page: number;
             pageSize: number;
             count: number;
         };
-        items: T["_output"][];
     }, {
+        items: T["_input"][];
         info: {
             page: number;
             pageSize: number;
             count: number;
         };
-        items: T["_input"][];
     }>;
 }

package/dist/services/ValidationUtils/ValidationUtils.js

@@ -1,11 +1,13 @@
 import 'zod-openapi/extend';
 import { array, number, object } from 'zod';
-import { stringDateTransformer } from './transformers/stringDateTransformer.js';
 import { stringNumberTransformer } from './transformers/stringNumberTransfromer.js';
 import { stringBooleanTransformer } from './transformers/stringBooleanTransformer.js';
+import { stringDateTimeTransformer } from './transformers/stringDateTimeTransformer.js';
+import { stringDateTransformer } from './transformers/stringDateTransformer.js';
 export class ValidationUtils {
     strings = {
-        datetime: stringDateTransformer,
+        datetime: stringDateTimeTransformer,
+        date: stringDateTransformer,
         number: stringNumberTransformer,
         boolean: stringBooleanTransformer,
     };

package/dist/services/ValidationUtils/transformers/stringDateTimeTransformer.d.ts

@@ -0,0 +1,3 @@
+import 'zod-openapi/extend';
+import z from 'zod';
+export declare const stringDateTimeTransformer: z.ZodUnion<[z.ZodDate, z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, Date, string>]>;

package/dist/services/ValidationUtils/transformers/stringDateTimeTransformer.js

@@ -0,0 +1,20 @@
+import 'zod-openapi/extend';
+import z from 'zod';
+export const stringDateTimeTransformer = z.union([
+    z.date(),
+    z.string().refine((input) => {
+        try {
+            const output = new Date(Date.parse(input));
+            const outputStr = output.toISOString().replace('T', ' ');
+            const inputStr = input.replace('T', ' ');
+            console.log(inputStr, outputStr);
+            return inputStr === outputStr;
+        }
+        catch (e) {
+            return false;
+        }
+    }, 'Not a valid date string')
+        .transform((x) => {
+        return new Date(Date.parse(x));
+    }),
+]).openapi({ type: 'string', format: 'date-time' });

package/dist/services/ValidationUtils/transformers/stringDateTimeTransformer.test copy.d.ts

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

package/dist/services/ValidationUtils/transformers/stringDateTimeTransformer.test copy.js

@@ -0,0 +1,13 @@
+import { describe, expect, test } from 'vitest';
+import { stringDateTimeTransformer } from './stringDateTimeTransformer.js';
+describe('stringDateTimeTransformer', () => {
+    test('Can parse ISO datetime', async () => {
+        const result = stringDateTimeTransformer.safeParse('2025-07-03T08:33:32.442Z');
+        expect(result.success).toBe(true);
+        expect(result.data?.toISOString()).toBe('2025-07-03T08:33:32.442Z');
+    });
+    test("Doesn't throw on bad input", async () => {
+        const result = stringDateTimeTransformer.safeParse('jibberish');
+        expect(result.success).toBe(false);
+    });
+});

package/dist/services/ValidationUtils/transformers/stringDateTransformer.d.ts

@@ -1,3 +1,3 @@
 import 'zod-openapi/extend';
 import z from 'zod';
-export declare const stringDateTransformer: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, Date, string>;
+export declare const stringDateTransformer: z.ZodUnion<[z.ZodDate, z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, Date, string>]>;

package/dist/services/ValidationUtils/transformers/stringDateTransformer.js

@@ -1,16 +1,19 @@
 import 'zod-openapi/extend';
 import z from 'zod';
-export const stringDateTransformer = z.string().refine((input) => {
-    try {
-        const output = new Date(Date.parse(input));
-        const outputStr = output.toISOString().replace('T', ' ');
-        const inputStr = input.replace('T', ' ');
-        return inputStr === outputStr;
-    }
-    catch (e) {
-        return false;
-    }
-}, 'Not a valid date string')
-    .transform((x) => {
-    return new Date(Date.parse(x));
-}).openapi({ type: 'string', format: 'date-time' });
+export const stringDateTransformer = z.union([
+    z.date(),
+    z.string().refine((input) => {
+        try {
+            const output = new Date(Date.parse(input));
+            const outputStr = output.toISOString().split('T')[0];
+            const inputStr = input.replace('T', ' ');
+            return inputStr === outputStr;
+        }
+        catch (e) {
+            return false;
+        }
+    }, 'Not a valid date string')
+        .transform((x) => {
+        return new Date(Date.parse(x));
+    }),
+]).openapi({ type: 'string', format: 'date-time' });

package/dist/types/AnyRoute.d.ts

@@ -1,3 +1,3 @@
 import { ZodObject, ZodRawShape, ZodFirstPartySchemaTypes } from 'zod';
 import { Route } from './Route.js';
-export type AnyRoute<TRouteType extends string> = Route<TRouteType, any, ZodFirstPartySchemaTypes, ZodObject<ZodRawShape> | undefined, ZodObject<ZodRawShape> | undefined, ZodObject<ZodRawShape> | undefined, ZodObject<ZodRawShape> | undefined>;
+export type AnyRoute<TRouteType extends string> = Route<TRouteType, any, ZodFirstPartySchemaTypes | undefined, ZodObject<ZodRawShape> | undefined, ZodObject<ZodRawShape> | undefined, ZodFirstPartySchemaTypes | undefined, ZodObject<ZodRawShape> | undefined>;

package/dist/types/Route.d.ts

@@ -1,13 +1,15 @@
 import { z, ZodFirstPartySchemaTypes, ZodObject, ZodRawShape } from 'zod';
 import { Method } from '../enums/Methods.js';
 import { RoutePath } from './RoutePath.js';
-type BodyHandlerResponse<T extends ZodFirstPartySchemaTypes> = Promise<z.infer<T>>;
-type FullHandlerRespnse<T extends ZodFirstPartySchemaTypes, THeaders extends ZodObject<ZodRawShape>> = Promise<{
-    body: z.infer<T>;
-    headers: z.infer<THeaders>;
+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, TH extends ZodObject<ZodRawShape> | undefined> = TH extends undefined ? BodyHandlerResponse<T> : FullHandlerRespnse<T, Exclude<TH, undefined>>;
-export interface Route<TType extends string, TContext extends object, TResponseValidator extends ZodFirstPartySchemaTypes, TPathValidator extends ZodObject<ZodRawShape> | undefined, TQueryValidator extends ZodObject<ZodRawShape> | undefined, TBodyValidator extends ZodObject<ZodRawShape> | undefined, TResponseHeadersValidator extends ZodObject<ZodRawShape> | undefined, TMethod extends Method = Method> {
+type HandlerResponse<T extends ZodFirstPartySchemaTypes | undefined, TH extends ZodObject<ZodRawShape> | undefined> = TH extends undefined ? BodyHandlerResponse<T> : FullHandlerRespnse<T, Exclude<TH, undefined>>;
+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;
     type: TType;
     method: TMethod;
     path: RoutePath;
@@ -16,12 +18,12 @@ export interface Route<TType extends string, TContext extends object, TResponseV
         query?: TQueryValidator;
         path?: TPathValidator;
         body?: TMethod extends 'GET' ? never : TBodyValidator;
-        response: TResponseValidator;
+        response?: TResponseValidator;
         responseHeaders?: TResponseHeadersValidator;
     };
     handler: (context: {
         params: {
-            body: TBodyValidator extends ZodObject<ZodRawShape> ? z.infer<TBodyValidator> : object;
+            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;
         };

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

@@ -1,3 +1,4 @@
+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';
@@ -12,10 +13,18 @@ export type Config<TRouteTypes extends string, TErrorCodes extends string, TErro
     logger?: Logger;
     basePath: RoutePath;
     routes: TRouteConfigMap;
+    generator?: {
+        openApiVersion?: ZodOpenApiVersion;
+        goodResponseDescription?: string;
+        generateErrors?: boolean;
+        requestMediaTypes?: string[];
+        responseMediaTypes?: string[];
+    };
     errors: TErrorConfigMap;
     defaultError: ErrorResponse<TErrorCodes, TErrorConfigMap>;
     skipDescriptionsCheck?: boolean;
     apiName?: string;
+    apiVersion?: string;
     servers?: Server[];
     logLevel?: LogLevel;
     handleError?: (e: unknown, req: Request) => ErrorResponse<TErrorCodes, TErrorConfigMap>;

package/package.json

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