snap-on-openapi 1.0.1

package/dist/enums/ErrorCode.d.ts

@@ -0,0 +1,5 @@
+export declare enum ErrorCode {
+    UnknownError = "UnknownError",
+    ValidationFailed = "ValidationFailed",
+    NotFound = "NotFound"
+}

package/dist/enums/ErrorCode.js

@@ -0,0 +1,6 @@
+export var ErrorCode;
+(function (ErrorCode) {
+    ErrorCode["UnknownError"] = "UnknownError";
+    ErrorCode["ValidationFailed"] = "ValidationFailed";
+    ErrorCode["NotFound"] = "NotFound";
+})(ErrorCode || (ErrorCode = {}));

package/dist/enums/Methods.d.ts

@@ -0,0 +1,7 @@
+export declare enum Method {
+    GET = "GET",
+    POST = "POST",
+    PATCH = "PATCH",
+    PUT = "PUT",
+    DELETE = "DELETE"
+}

package/dist/enums/Methods.js

@@ -0,0 +1,8 @@
+export var Method;
+(function (Method) {
+    Method["GET"] = "GET";
+    Method["POST"] = "POST";
+    Method["PATCH"] = "PATCH";
+    Method["PUT"] = "PUT";
+    Method["DELETE"] = "DELETE";
+})(Method || (Method = {}));

package/dist/enums/SampleRouteType.d.ts

@@ -0,0 +1,3 @@
+export declare enum SampleRouteType {
+    Public = "Public"
+}

package/dist/enums/SampleRouteType.js

@@ -0,0 +1,4 @@
+export var SampleRouteType;
+(function (SampleRouteType) {
+    SampleRouteType["Public"] = "Public";
+})(SampleRouteType || (SampleRouteType = {}));

package/dist/enums/ValidationLocations.d.ts

@@ -0,0 +1,6 @@
+export declare enum ValidationLocation {
+    Query = "Query",
+    Path = "Path",
+    Body = "Body",
+    Response = "Response"
+}

package/dist/enums/ValidationLocations.js

@@ -0,0 +1,7 @@
+export var ValidationLocation;
+(function (ValidationLocation) {
+    ValidationLocation["Query"] = "Query";
+    ValidationLocation["Path"] = "Path";
+    ValidationLocation["Body"] = "Body";
+    ValidationLocation["Response"] = "Response";
+})(ValidationLocation || (ValidationLocation = {}));

package/dist/index.d.ts

@@ -0,0 +1,39 @@
+import 'zod-openapi/extend';
+export { Method as OpenApiMethod } from './enums/Methods.js';
+export { ErrorCode as OpenApiErrorCode } from './enums/ErrorCode.js';
+export { SampleRouteType as OpenApiSampleRouteType } from './enums/SampleRouteType.js';
+export { ValidationLocation as OpenApiValidationLocation } from './enums/ValidationLocations.js';
+export { ApiError as OpenApiError } from './types/errors/ApiError.js';
+export { ValidationError as OpenApiValidationError } from './types/errors/ValidationError.js';
+export { BuiltInError as OpenApiBuiltInError } from './types/errors/BuiltInError.js';
+export type { FieldError as OpenApiFieldError } from './types/errors/FieldError.js';
+export type { ErrorConfig as OpenApiErrorConfig } from './types/config/ErrorConfig.js';
+export type { ErrorConfigMap as OpenApiErrorConfigMap } from './types/config/ErrorConfigMap.js';
+export type { RouteConfig as OpenApiRouteConfig } from './types/config/RouteConfig.js';
+export type { RouteConfigMap as OpenApiRouteConfigMap } from './types/config/RouteConfigMap.js';
+export type { ContextParams as OpenApiContextParams } from './types/config/ContextParams.js';
+export type { ErrorResponse as OpenApiErrorResponse } from './types/config/ErrorResponse.js';
+export type { RouteExtraPropsMap as OpenApiRouteExtraPropsMap } from './types/config/RouteExtraPropsMap.js';
+export type { RouteContextMap as OpenApiRouteContextMap } from './types/config/RouteContextMap.js';
+export type { Config as OpenApiConfig } from './types/config/Config.js';
+export { DefaultConfig as OpenApiDefaultConfig } from './services/ConfigBuilder/types/DefaultConfig.js';
+export { DefaultErrorMap as OpenApiDefaultErrorMap } from './services/ConfigBuilder/types/DefaultErrorMap.js';
+export { DefaultRouteContextMap as OpenApiDefaultRouteContextMap } from './services/ConfigBuilder/types/DefaultRouteContextMap.js';
+export { DefaultRouteMap as OpenApiDefaultRouteMap } from './services/ConfigBuilder/types/DefaultRouteMap.js';
+export { DefaultRouteParamsMap as OpenApiDefaultRouteParamsMap } from './services/ConfigBuilder/types/DefaultRouteParamsMap.js';
+export { OpenApi } from './OpenApi.js';
+export type { AnyConfig as OpenApiAnyConfig } from './types/config/AnyConfig.js';
+export type { AnyRouteConfigMap as OpenApiAnyRouteConfigMap } from './types/config/AnyRouteConfigMap.js';
+export type { RouteMap as OpenApiRouteMap } from './types/RouteMap.js';
+export type { Route as OpenApiRoute } from './types/Route.js';
+export type { AnyRoute as OpenApiAnyRoute } from './types/AnyRoute.js';
+export type { DevelopmentUtils as OpenApiDevelopmentUtils } from './services/DevelopmentUtils/DevelopmentUtils.js';
+export { ClientGenerator as OpenApiClientGenerator } from './services/ClientGenerator/ClientGenerator.js';
+export { RoutingFactory as OpenApiRoutingFactory } from './services/RoutingFactory/RoutingFactory.js';
+export { SchemaGenerator as OpenApiSchemaGenerator } from './services/SchemaGenerator/SchemaGenerator.js';
+export { ValidationUtils as OpenApiValidationUtils } from './services/ValidationUtils/ValidationUtils.js';
+export { TanstackStartWrapper as OpenApiTanstackStartWrapper } from './services/TanstackStartWrapper/TanstackStartWrapper.js';
+export { ExpressWrapper as OpenApiExpressWrapper } from './services/ExpressWrapper/ExpressWrapper.js';
+export { Logger as OpenApiLogger } from './services/Logger/Logger.js';
+export { LogLevel as OpenApiLogLevel } from './services/Logger/types/LogLevel.js';
+export { ConfigBuilder as OpenApiConfigBuilder } from './services/ConfigBuilder/ConfigBuilder.js';

package/dist/index.js

@@ -0,0 +1,23 @@
+import 'zod-openapi/extend';
+export { Method as OpenApiMethod } from './enums/Methods.js';
+export { ErrorCode as OpenApiErrorCode } from './enums/ErrorCode.js';
+export { SampleRouteType as OpenApiSampleRouteType } from './enums/SampleRouteType.js';
+export { ValidationLocation as OpenApiValidationLocation } from './enums/ValidationLocations.js';
+export { ApiError as OpenApiError } from './types/errors/ApiError.js';
+export { ValidationError as OpenApiValidationError } from './types/errors/ValidationError.js';
+export { BuiltInError as OpenApiBuiltInError } from './types/errors/BuiltInError.js';
+export { DefaultConfig as OpenApiDefaultConfig } from './services/ConfigBuilder/types/DefaultConfig.js';
+export { DefaultErrorMap as OpenApiDefaultErrorMap } from './services/ConfigBuilder/types/DefaultErrorMap.js';
+export { DefaultRouteContextMap as OpenApiDefaultRouteContextMap } from './services/ConfigBuilder/types/DefaultRouteContextMap.js';
+export { DefaultRouteMap as OpenApiDefaultRouteMap } from './services/ConfigBuilder/types/DefaultRouteMap.js';
+export { DefaultRouteParamsMap as OpenApiDefaultRouteParamsMap } from './services/ConfigBuilder/types/DefaultRouteParamsMap.js';
+export { OpenApi } from './OpenApi.js';
+export { ClientGenerator as OpenApiClientGenerator } from './services/ClientGenerator/ClientGenerator.js';
+export { RoutingFactory as OpenApiRoutingFactory } from './services/RoutingFactory/RoutingFactory.js';
+export { SchemaGenerator as OpenApiSchemaGenerator } from './services/SchemaGenerator/SchemaGenerator.js';
+export { ValidationUtils as OpenApiValidationUtils } from './services/ValidationUtils/ValidationUtils.js';
+export { TanstackStartWrapper as OpenApiTanstackStartWrapper } from './services/TanstackStartWrapper/TanstackStartWrapper.js';
+export { ExpressWrapper as OpenApiExpressWrapper } from './services/ExpressWrapper/ExpressWrapper.js';
+export { Logger as OpenApiLogger } from './services/Logger/Logger.js';
+export { LogLevel as OpenApiLogLevel } from './services/Logger/types/LogLevel.js';
+export { ConfigBuilder as OpenApiConfigBuilder } from './services/ConfigBuilder/ConfigBuilder.js';

package/dist/services/ClientGenerator/ClientGenerator.d.ts

@@ -0,0 +1,9 @@
+import { UserConfig } from '@hey-api/openapi-ts';
+import { OpenApi } from '../../OpenApi.js';
+import { AnyConfig } from '../../types/config/AnyConfig.js';
+export declare class ClientGenerator<TRouteTypes extends string, TErrorCodes extends string, TConfig extends AnyConfig<TRouteTypes, TErrorCodes>> {
+    protected api: OpenApi<TRouteTypes, TErrorCodes, TConfig>;
+    constructor(api: OpenApi<TRouteTypes, TErrorCodes, TConfig>);
+    generate(config?: Partial<Omit<UserConfig, 'input'>>): Promise<void>;
+    protected getDefaultConfig(): Omit<UserConfig, 'input'>;
+}

package/dist/services/ClientGenerator/ClientGenerator.js

@@ -0,0 +1,48 @@
+import { createClient } from '@hey-api/openapi-ts';
+import { parse } from 'yaml';
+export class ClientGenerator {
+    api;
+    constructor(api) {
+        this.api = api;
+    }
+    async generate(config = {}) {
+        const obj = parse(this.api.schemaGenerator.getYaml());
+        const conf = {
+            ...this.getDefaultConfig(),
+            ...config,
+            input: {
+                path: obj,
+            },
+        };
+        createClient(conf);
+    }
+    getDefaultConfig() {
+        const config = {
+            output: {
+                path: './open-api-client',
+            },
+            plugins: [
+                {
+                    name: '@hey-api/client-axios',
+                    throwOnError: false,
+                },
+                {
+                    name: '@tanstack/react-query',
+                },
+                {
+                    name: '@hey-api/transformers',
+                    dates: true,
+                },
+                {
+                    name: '@hey-api/sdk',
+                    transformer: true,
+                },
+                {
+                    name: '@hey-api/typescript',
+                    enums: 'javascript',
+                },
+            ],
+        };
+        return config;
+    }
+}

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

@@ -0,0 +1,31 @@
+import { ErrorConfigMap } from '../../types/config/ErrorConfigMap.js';
+import { Config } from '../../types/config/Config.js';
+import { RouteConfigMap } from '../../types/config/RouteConfigMap.js';
+import { OpenApi } from '../../OpenApi.js';
+import { AnyConfig } from '../../types/config/AnyConfig.js';
+import { OpenApiConstructor } from './types/OpenApiConstructor.js';
+import { OmitMappedField } from '../../types/config/OmitMappedField.js';
+import { RouteExtraPropsMap } from '../../types/config/RouteExtraPropsMap.js';
+import { ZodRawShape, ZodObject } from 'zod';
+import { RouteContextMap } from '../../types/config/RouteContextMap.js';
+export declare class ConfigBuilder<TRouteTypes extends string, TErrorCodes extends string, TErrorConfigMap extends ErrorConfigMap<TErrorCodes>, TRouteParamMap extends RouteExtraPropsMap<TRouteTypes, ZodObject<ZodRawShape> | undefined>, TRouteContextMap extends RouteContextMap<TRouteTypes, TRouteParamMap>, TRouteConfigMap extends RouteConfigMap<TRouteTypes, TErrorCodes, TRouteParamMap, TRouteContextMap>, TConfig extends Config<TRouteTypes, TErrorCodes, TErrorConfigMap, TRouteParamMap, TRouteContextMap, TRouteConfigMap> = Config<TRouteTypes, TErrorCodes, TErrorConfigMap, TRouteParamMap, TRouteContextMap, TRouteConfigMap>> {
+    protected x: Config<TRouteTypes, TErrorCodes, ErrorConfigMap<TErrorCodes>, RouteExtraPropsMap<TRouteTypes>, RouteContextMap<TRouteTypes, RouteExtraPropsMap<TRouteTypes>>, RouteConfigMap<TRouteTypes, TErrorCodes, RouteExtraPropsMap<TRouteTypes>, RouteContextMap<TRouteTypes, RouteExtraPropsMap<TRouteTypes>>>>;
+    protected construct: OpenApiConstructor;
+    protected errorMap?: TErrorConfigMap;
+    protected defaultError?: TConfig['defaultError'];
+    protected routeMap?: TRouteConfigMap;
+    protected routeParamMap?: TRouteParamMap;
+    protected routeContextMap?: TRouteContextMap;
+    protected conf?: Omit<TConfig, 'errors' | 'routes' | 'defaultError'>;
+    constructor(construct: OpenApiConstructor, errorMap?: TErrorConfigMap, defaultError?: TConfig['defaultError'], routeParamMap?: TRouteParamMap, routeContextMap?: TRouteContextMap, routeMap?: TRouteConfigMap, conf?: Omit<TConfig, 'errors' | 'routes' | 'defaultError'>);
+    customizeRoutes<T extends string>(routeTypes: Record<string, T>): Pick<ConfigBuilder<T, TErrorCodes, TErrorConfigMap, RouteExtraPropsMap<T>, RouteContextMap<T, RouteExtraPropsMap<T>>, RouteConfigMap<T, TErrorCodes, RouteExtraPropsMap<T>, RouteContextMap<T, RouteExtraPropsMap<T>>>>, 'defineRouteExtraProps' | 'defineRouteContexts' | 'defineRoutes'>;
+    customizeErrors<T extends string>(errorCodes: Record<string, T>): Pick<ConfigBuilder<TRouteTypes, T, ErrorConfigMap<T>, RouteExtraPropsMap<TRouteTypes>, RouteContextMap<TRouteTypes, RouteExtraPropsMap<TRouteTypes>>, RouteConfigMap<TRouteTypes, T, RouteExtraPropsMap<TRouteTypes>, RouteContextMap<TRouteTypes, RouteExtraPropsMap<TRouteTypes>>>>, 'defineErrors'>;
+    defineErrors<T extends ErrorConfigMap<TErrorCodes>>(map: T): Pick<ConfigBuilder<TRouteTypes, TErrorCodes, T, TRouteParamMap, TRouteContextMap, TRouteConfigMap>, 'defineDefaultError'>;
+    defineDefaultError(defaultError: TConfig['defaultError']): Pick<ConfigBuilder<TRouteTypes, TErrorCodes, TErrorConfigMap, TRouteParamMap, TRouteContextMap, TRouteConfigMap>, 'customizeRoutes' | 'defineGlobalConfig'>;
+    defineRouteExtraProps<T extends RouteExtraPropsMap<TRouteTypes, ZodObject<ZodRawShape> | undefined>>(map: T): Pick<ConfigBuilder<TRouteTypes, TErrorCodes, TErrorConfigMap, T, RouteContextMap<TRouteTypes, T>, RouteConfigMap<TRouteTypes, TErrorCodes, T, RouteContextMap<TRouteTypes, T>>>, 'defineRoutes' | 'defineRouteContexts' | 'customizeErrors'>;
+    defineRouteContexts<T extends RouteContextMap<TRouteTypes, TRouteParamMap>>(map: T): Pick<ConfigBuilder<TRouteTypes, TErrorCodes, TErrorConfigMap, TRouteParamMap, T, RouteConfigMap<TRouteTypes, TErrorCodes, TRouteParamMap, T>>, 'defineRoutes' | 'customizeErrors'>;
+    defineRoutes<T extends RouteConfigMap<TRouteTypes, TErrorCodes, TRouteParamMap, TRouteContextMap>>(map: OmitMappedField<T, 'extraProps' | 'context' | 'contextFactory'>): Pick<ConfigBuilder<TRouteTypes, TErrorCodes, TErrorConfigMap, TRouteParamMap, TRouteContextMap, T>, 'customizeErrors' | 'defineGlobalConfig' | 'create'>;
+    defineGlobalConfig<T extends Config<TRouteTypes, TErrorCodes, TErrorConfigMap, TRouteParamMap, TRouteContextMap, TRouteConfigMap>>(conf: Omit<T, 'errors' | 'routes' | 'defaultError'>): Pick<ConfigBuilder<TRouteTypes, TErrorCodes, TErrorConfigMap, TRouteParamMap, TRouteContextMap, TRouteConfigMap, T>, 'create'>;
+    create<TRouteTypes extends string, TErrorCodes extends string, TConfig extends AnyConfig<TRouteTypes, TErrorCodes>>(routes: Record<string, TRouteTypes>, errors: Record<string, TErrorCodes>, spec: TConfig): OpenApi<TRouteTypes, TErrorCodes, TConfig>;
+    create(): OpenApi<TRouteTypes, TErrorCodes, TConfig>;
+}

package/dist/services/ConfigBuilder/ConfigBuilder.js

@@ -0,0 +1,65 @@
+import { DefaultConfig } from './types/DefaultConfig.js';
+export class ConfigBuilder {
+    x;
+    construct;
+    errorMap;
+    defaultError;
+    routeMap;
+    routeParamMap;
+    routeContextMap;
+    conf;
+    constructor(construct, errorMap, defaultError, routeParamMap, routeContextMap, routeMap, conf) {
+        this.construct = construct;
+        this.errorMap = errorMap;
+        this.defaultError = defaultError;
+        this.routeParamMap = routeParamMap;
+        this.routeContextMap = routeContextMap;
+        this.routeMap = routeMap;
+        this.conf = conf;
+    }
+    customizeRoutes(routeTypes) {
+        return new ConfigBuilder(this.construct, this.errorMap, this.defaultError);
+    }
+    customizeErrors(errorCodes) {
+        return new ConfigBuilder(this.construct);
+    }
+    defineErrors(map) {
+        return new ConfigBuilder(this.construct, map);
+    }
+    defineDefaultError(defaultError) {
+        return new ConfigBuilder(this.construct, this.errorMap, defaultError);
+    }
+    defineRouteExtraProps(map) {
+        return new ConfigBuilder(this.construct, this.errorMap, this.defaultError, map, undefined, undefined, undefined);
+    }
+    defineRouteContexts(map) {
+        return new ConfigBuilder(this.construct, this.errorMap, this.defaultError, this.routeParamMap, map, undefined, undefined);
+    }
+    defineRoutes(map) {
+        return new ConfigBuilder(this.construct, this.errorMap, this.defaultError, this.routeParamMap, this.routeContextMap, map);
+    }
+    defineGlobalConfig(conf) {
+        return new ConfigBuilder(this.construct, this.errorMap, this.defaultError, this.routeParamMap, this.routeContextMap, this.routeMap, conf);
+    }
+    create(a, b, conf) {
+        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];
+            }
+        }
+        const def = new DefaultConfig();
+        const builtConf = {
+            ...def,
+            ...this.conf,
+            ...(routeMap ? { routes: routeMap } : {}),
+            ...(this.errorMap ? { errors: this.errorMap } : {}),
+            ...(this.defaultError ? { defaultError: this.defaultError } : {}),
+        };
+        return this.construct(builtConf);
+    }
+}

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

@@ -0,0 +1,22 @@
+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 { RoutePath } from '../../../types/RoutePath.js';
+import { DefaultErrorMap } from './DefaultErrorMap.js';
+import { DefaultRouteContextMap } from './DefaultRouteContextMap.js';
+import { DefaultRouteMap } from './DefaultRouteMap.js';
+import { DefaultRouteParamsMap } from './DefaultRouteParamsMap.js';
+export declare class DefaultConfig implements Config<SampleRouteType, ErrorCode, DefaultErrorMap, DefaultRouteParamsMap, DefaultRouteContextMap, DefaultRouteMap> {
+    basePath: RoutePath;
+    routes: DefaultRouteMap;
+    errors: DefaultErrorMap;
+    defaultError: {
+        readonly code: ErrorCode.UnknownError;
+        readonly body: {
+            readonly error: ErrorCode.UnknownError;
+        };
+    };
+    handleError?: (e: unknown) => ErrorResponse<ErrorCode, DefaultErrorMap>;
+    skipDescriptionsCheck?: boolean;
+}

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

@@ -0,0 +1,47 @@
+import { ErrorCode } from '../../../enums/ErrorCode.js';
+import { ValidationLocation } from '../../../enums/ValidationLocations.js';
+import { BuiltInError } from '../../../types/errors/BuiltInError.js';
+import { ValidationError } from '../../../types/errors/ValidationError.js';
+import { DefaultErrorMap } from './DefaultErrorMap.js';
+import { DefaultRouteMap } from './DefaultRouteMap.js';
+export class DefaultConfig {
+    basePath = '/api';
+    routes = new DefaultRouteMap();
+    errors = new DefaultErrorMap();
+    defaultError = {
+        code: ErrorCode.UnknownError,
+        body: {
+            error: ErrorCode.UnknownError,
+        },
+    };
+    handleError = (e) => {
+        if (e instanceof ValidationError) {
+            const zodError = e.getZodError();
+            const map = [];
+            for (const issue of zodError.issues) {
+                map.push({
+                    field: issue.path.map((x) => x.toString()).join('.'),
+                    message: issue.message,
+                });
+            }
+            if (e.getLocation() !== ValidationLocation.Response) {
+                const response = {
+                    error: {
+                        code: ErrorCode.ValidationFailed,
+                        location: e.getLocation(),
+                        fieldErrors: map,
+                    },
+                };
+                return { code: ErrorCode.ValidationFailed, body: response };
+            }
+        }
+        if (e instanceof BuiltInError && e.getCode() === ErrorCode.NotFound) {
+            return { code: ErrorCode.NotFound, body: { error: ErrorCode.NotFound } };
+        }
+        const unknownError = {
+            error: ErrorCode.UnknownError,
+        };
+        return { code: ErrorCode.UnknownError, body: unknownError };
+    };
+    skipDescriptionsCheck = false;
+}

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

@@ -0,0 +1,113 @@
+import { ErrorCode } from '../../../enums/ErrorCode.js';
+import { ErrorConfigMap } from '../../../types/config/ErrorConfigMap.js';
+export declare class DefaultErrorMap implements ErrorConfigMap<ErrorCode> {
+    [ErrorCode.UnknownError]: {
+        readonly status: "500";
+        readonly description: "Unknown Error";
+        readonly responseValidator: import("zod").ZodObject<{
+            error: import("zod").ZodLiteral<ErrorCode.UnknownError>;
+        }, "strip", import("zod").ZodTypeAny, {
+            error: ErrorCode.UnknownError;
+        }, {
+            error: ErrorCode.UnknownError;
+        }>;
+    };
+    [ErrorCode.ValidationFailed]: {
+        readonly status: "400";
+        readonly description: "Validation Failed";
+        readonly responseValidator: import("zod").ZodObject<{
+            error: import("zod").ZodObject<{
+                code: import("zod").ZodLiteral<ErrorCode.ValidationFailed>;
+                fieldErrors: import("zod").ZodArray<import("zod").ZodObject<{
+                    field: import("zod").ZodString;
+                    message: import("zod").ZodString;
+                } & {
+                    fieldErrors: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                        field: import("zod").ZodString;
+                        message: import("zod").ZodString;
+                    }, "strip", import("zod").ZodTypeAny, {
+                        message: string;
+                        field: string;
+                    }, {
+                        message: string;
+                        field: string;
+                    }>, "many">>;
+                }, "strip", import("zod").ZodTypeAny, {
+                    message: string;
+                    field: string;
+                    fieldErrors?: {
+                        message: string;
+                        field: string;
+                    }[] | undefined;
+                }, {
+                    message: string;
+                    field: string;
+                    fieldErrors?: {
+                        message: string;
+                        field: string;
+                    }[] | undefined;
+                }>, "many">;
+                location: import("zod").ZodNativeEnum<typeof import("../../../index.js").OpenApiValidationLocation>;
+            }, "strip", import("zod").ZodTypeAny, {
+                code: ErrorCode.ValidationFailed;
+                fieldErrors: {
+                    message: string;
+                    field: string;
+                    fieldErrors?: {
+                        message: string;
+                        field: string;
+                    }[] | undefined;
+                }[];
+                location: import("../../../index.js").OpenApiValidationLocation;
+            }, {
+                code: ErrorCode.ValidationFailed;
+                fieldErrors: {
+                    message: string;
+                    field: string;
+                    fieldErrors?: {
+                        message: string;
+                        field: string;
+                    }[] | undefined;
+                }[];
+                location: import("../../../index.js").OpenApiValidationLocation;
+            }>;
+        }, "strip", import("zod").ZodTypeAny, {
+            error: {
+                code: ErrorCode.ValidationFailed;
+                fieldErrors: {
+                    message: string;
+                    field: string;
+                    fieldErrors?: {
+                        message: string;
+                        field: string;
+                    }[] | undefined;
+                }[];
+                location: import("../../../index.js").OpenApiValidationLocation;
+            };
+        }, {
+            error: {
+                code: ErrorCode.ValidationFailed;
+                fieldErrors: {
+                    message: string;
+                    field: string;
+                    fieldErrors?: {
+                        message: string;
+                        field: string;
+                    }[] | undefined;
+                }[];
+                location: import("../../../index.js").OpenApiValidationLocation;
+            };
+        }>;
+    };
+    [ErrorCode.NotFound]: {
+        readonly status: "404";
+        readonly description: "Route Not Found";
+        readonly responseValidator: import("zod").ZodObject<{
+            error: import("zod").ZodLiteral<ErrorCode.NotFound>;
+        }, "strip", import("zod").ZodTypeAny, {
+            error: ErrorCode.NotFound;
+        }, {
+            error: ErrorCode.NotFound;
+        }>;
+    };
+}

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

@@ -0,0 +1,21 @@
+import { ErrorCode } from '../../../enums/ErrorCode.js';
+import { unknownErrorResponseValidator } from '../../../types/errors/responses/UnknownErrorResponse.js';
+import { validationErrorResponseValidator } from '../../../types/errors/responses/ValidationErrorResponse.js';
+import { notFoundErrorResponseValidator } from '../../../types/errors/responses/NotFoundErrorResponse.js';
+export class DefaultErrorMap {
+    [ErrorCode.UnknownError] = {
+        status: '500',
+        description: 'Unknown Error',
+        responseValidator: unknownErrorResponseValidator,
+    };
+    [ErrorCode.ValidationFailed] = {
+        status: '400',
+        description: 'Validation Failed',
+        responseValidator: validationErrorResponseValidator,
+    };
+    [ErrorCode.NotFound] = {
+        status: '404',
+        description: 'Route Not Found',
+        responseValidator: notFoundErrorResponseValidator,
+    };
+}

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

@@ -0,0 +1,6 @@
+import { SampleRouteType } from '../../../enums/SampleRouteType.js';
+import { RouteContextMap } from '../../../types/config/RouteContextMap.js';
+import { DefaultRouteParamsMap } from './DefaultRouteParamsMap.js';
+export declare class DefaultRouteContextMap implements RouteContextMap<SampleRouteType, DefaultRouteParamsMap> {
+    Public: () => Promise<{}>;
+}

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

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

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

@@ -0,0 +1,12 @@
+import { SampleRouteType } from '../../../enums/SampleRouteType.js';
+import { RouteConfigMap } from '../../../types/config/RouteConfigMap.js';
+import { ErrorCode } from '../../../enums/ErrorCode.js';
+import { DefaultRouteContextMap } from './DefaultRouteContextMap.js';
+import { DefaultRouteParamsMap } from './DefaultRouteParamsMap.js';
+export declare class DefaultRouteMap implements RouteConfigMap<SampleRouteType, ErrorCode, DefaultRouteParamsMap, DefaultRouteContextMap> {
+    Public: {
+        readonly authorization: false;
+        readonly extraProps: undefined;
+        readonly contextFactory: () => Promise<{}>;
+    };
+}

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

@@ -0,0 +1,9 @@
+import { DefaultRouteContextMap } from './DefaultRouteContextMap.js';
+import { DefaultRouteParamsMap } from './DefaultRouteParamsMap.js';
+export class DefaultRouteMap {
+    Public = {
+        authorization: false,
+        extraProps: new DefaultRouteParamsMap().Public,
+        contextFactory: new DefaultRouteContextMap().Public,
+    };
+}

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

@@ -0,0 +1,5 @@
+import { SampleRouteType } from '../../../enums/SampleRouteType.js';
+import { RouteExtraPropsMap } from '../../../types/config/RouteExtraPropsMap.js';
+export declare class DefaultRouteParamsMap implements RouteExtraPropsMap<SampleRouteType> {
+    Public: undefined;
+}

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

@@ -0,0 +1,3 @@
+export class DefaultRouteParamsMap {
+    Public = undefined;
+}

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

@@ -0,0 +1,2 @@
+import { OpenApi } from '../../../OpenApi.js';
+export type OpenApiConstructor = (conf: any) => OpenApi<any, any, any>;

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

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

package/dist/services/DescriptionChecker/DescriptionChecker.d.ts

@@ -0,0 +1,16 @@
+import { ZodTypeAny, ZodRawShape } from 'zod';
+import { AnyRoute } from '../../types/AnyRoute.js';
+import { ValidationUtils } from '../ValidationUtils/ValidationUtils.js';
+interface DescriptionCheckerConfig {
+    checkValidators: boolean;
+}
+export declare class DescriptionChecker {
+    protected utils: ValidationUtils;
+    protected config: DescriptionCheckerConfig;
+    constructor(config: DescriptionCheckerConfig);
+    checkRoutes(routes: AnyRoute<string>[]): void;
+    protected checkRouteDescriptions(route: AnyRoute<string>): void;
+    protected checkValidatorDescriptions(route: AnyRoute<string>, validatorName: string, field: string | undefined, validator: ZodTypeAny, checkValidatorDescription?: boolean): void;
+    protected checkShapeDescription(route: AnyRoute<string>, validatorName: string, shape: ZodRawShape): void;
+}
+export {};

package/dist/services/DescriptionChecker/DescriptionChecker.js

@@ -0,0 +1,47 @@
+import z from 'zod';
+import { ValidationUtils } from '../ValidationUtils/ValidationUtils.js';
+export class DescriptionChecker {
+    utils = new ValidationUtils();
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    checkRoutes(routes) {
+        for (const route of routes) {
+            this.checkRouteDescriptions(route);
+        }
+    }
+    checkRouteDescriptions(route) {
+        const minimalLength = 10;
+        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, '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);
+    }
+    checkValidatorDescriptions(route, validatorName, field, validator, checkValidatorDescription = true) {
+        const openapi = validator._def.openapi ?? validator._def.zodOpenApi?.openapi;
+        if (this.config.checkValidators && checkValidatorDescription && !openapi?.description) {
+            throw new Error(`Route '${route.method}:${route.path}': ${validatorName} missing openapi description on field '${field}'`);
+        }
+        if (validator._def.typeName === 'ZodArray') {
+            const arr = validator;
+            const nonPrimitiveArray = arr.element.shape !== undefined;
+            if (nonPrimitiveArray) {
+                this.checkShapeDescription(route, validatorName, arr.element.shape);
+            }
+        }
+        if (validator._def.typeName === 'ZodObject') {
+            const obj = validator;
+            this.checkShapeDescription(route, validatorName, obj.shape);
+        }
+    }
+    checkShapeDescription(route, validatorName, shape) {
+        for (const field of Object.keys(shape)) {
+            const value = shape[field];
+            this.checkValidatorDescriptions(route, validatorName, field, value);
+        }
+    }
+}

package/dist/services/DevelopmentUtils/DevelopmentUtils.d.ts

@@ -0,0 +1,4 @@
+export declare class DevelopmentUtils {
+    getSwaggerHTML(schemaUrl: string): string;
+    getStoplightHtml(schemaUrl: string): string;
+}

package/dist/services/DevelopmentUtils/DevelopmentUtils.js

@@ -0,0 +1,15 @@
+import { readFileSync } from 'fs';
+import { dirname } from 'path';
+import { fileURLToPath } from 'url';
+export class DevelopmentUtils {
+    getSwaggerHTML(schemaUrl) {
+        const file = readFileSync(`${dirname(fileURLToPath(import.meta.url))}/../../assets/swagger.html`);
+        const result = file.toString();
+        return result.replaceAll('{{SCHEMA_URL}}', schemaUrl);
+    }
+    getStoplightHtml(schemaUrl) {
+        const file = readFileSync(`${dirname(fileURLToPath(import.meta.url))}/../../assets/stoplight.html`);
+        const result = file.toString();
+        return result.replaceAll('{{SCHEMA_URL}}', schemaUrl);
+    }
+}