snap-on-openapi 1.0.2 → 1.0.3

package/dist/OpenApi.d.ts

@@ -1,26 +1,26 @@
 import 'zod-openapi/extend';
-import { ErrorCode } from './enums/ErrorCode.js';
-import { AnyRoute } from './types/AnyRoute.js';
-import { RoutingFactory } from './services/RoutingFactory/RoutingFactory.js';
-import { RouteMap } from './types/RouteMap.js';
-import { SchemaGenerator } from './services/SchemaGenerator/SchemaGenerator.js';
-import { AnyConfig } from './types/config/AnyConfig.js';
-import { Logger } from './services/Logger/Logger.js';
-import { DescriptionChecker } from './services/DescriptionChecker/DescriptionChecker.js';
-import { DevelopmentUtils } from './services/DevelopmentUtils/DevelopmentUtils.js';
-import { ClientGenerator } from './services/ClientGenerator/ClientGenerator.js';
-import { ValidationUtils } from './services/ValidationUtils/ValidationUtils.js';
-import { Wrappers } from './types/Wrappers.js';
-import { Server } from './types/config/Server.js';
-import { RoutePath } from './types/RoutePath.js';
-import { SampleRouteType } from './enums/SampleRouteType.js';
-import { ConfigBuilder } from './services/ConfigBuilder/ConfigBuilder.js';
-import { DefaultConfig } from './services/ConfigBuilder/types/DefaultConfig.js';
-import { DefaultErrorMap } from './services/ConfigBuilder/types/DefaultErrorMap.js';
-import { DefaultRouteMap } from './services/ConfigBuilder/types/DefaultRouteMap.js';
-import { InitialBuilder } from './types/InitialBuilder.js';
-import { DefaultRouteContextMap } from './services/ConfigBuilder/types/DefaultRouteContextMap.js';
-import { DefaultRouteParamsMap } from './services/ConfigBuilder/types/DefaultRouteParamsMap.js';
+import { ErrorCode } from './enums/ErrorCode';
+import { AnyRoute } from './types/AnyRoute';
+import { RoutingFactory } from './services/RoutingFactory/RoutingFactory';
+import { RouteMap } from './types/RouteMap';
+import { SchemaGenerator } from './services/SchemaGenerator/SchemaGenerator';
+import { AnyConfig } from './types/config/AnyConfig';
+import { Logger } from './services/Logger/Logger';
+import { DescriptionChecker } from './services/DescriptionChecker/DescriptionChecker';
+import { DevelopmentUtils } from './services/DevelopmentUtils/DevelopmentUtils';
+import { ClientGenerator } from './services/ClientGenerator/ClientGenerator';
+import { ValidationUtils } from './services/ValidationUtils/ValidationUtils';
+import { Wrappers } from './types/Wrappers';
+import { Server } from './types/config/Server';
+import { RoutePath } from './types/RoutePath';
+import { SampleRouteType } from './enums/SampleRouteType';
+import { ConfigBuilder } from './services/ConfigBuilder/ConfigBuilder';
+import { DefaultConfig } from './services/ConfigBuilder/types/DefaultConfig';
+import { DefaultErrorMap } from './services/ConfigBuilder/types/DefaultErrorMap';
+import { DefaultRouteMap } from './services/ConfigBuilder/types/DefaultRouteMap';
+import { InitialBuilder } from './types/InitialBuilder';
+import { DefaultRouteContextMap } from './services/ConfigBuilder/types/DefaultRouteContextMap';
+import { DefaultRouteParamsMap } from './services/ConfigBuilder/types/DefaultRouteParamsMap';
 import z from 'zod';
 export declare class OpenApi<TRouteTypes extends string, TErrorCodes extends string, TConfig extends AnyConfig<TRouteTypes, TErrorCodes>> {
     static readonly builder: InitialBuilder;
@@ -52,7 +52,7 @@ export declare class OpenApi<TRouteTypes extends string, TErrorCodes extends str
     }>;
     protected handleError(e: unknown): {
         status: number;
-        body: z.TypeOf<import("./index.js").OpenApiErrorConfigMap<TErrorCodes>[TErrorCodes]["responseValidator"]>;
+        body: z.TypeOf<import(".").OpenApiErrorConfigMap<TErrorCodes>[TErrorCodes]["responseValidator"]>;
     };
     protected static getBuilder(): ConfigBuilder<SampleRouteType, ErrorCode, DefaultErrorMap, DefaultRouteParamsMap, DefaultRouteContextMap, DefaultRouteMap, DefaultConfig>;
 }

package/dist/OpenApi.js

@@ -1,19 +1,19 @@
 import 'zod-openapi/extend';
-import { ErrorCode } from './enums/ErrorCode.js';
-import { ValidationLocation } from './enums/ValidationLocations.js';
-import { ValidationError } from './types/errors/ValidationError.js';
-import { RoutingFactory } from './services/RoutingFactory/RoutingFactory.js';
-import { SchemaGenerator } from './services/SchemaGenerator/SchemaGenerator.js';
-import { Method } from './enums/Methods.js';
-import { BuiltInError } from './types/errors/BuiltInError.js';
-import { Logger } from './services/Logger/Logger.js';
-import { DescriptionChecker } from './services/DescriptionChecker/DescriptionChecker.js';
-import { DevelopmentUtils } from './services/DevelopmentUtils/DevelopmentUtils.js';
-import { ClientGenerator } from './services/ClientGenerator/ClientGenerator.js';
-import { ValidationUtils } from './services/ValidationUtils/ValidationUtils.js';
-import { TanstackStartWrapper } from './services/TanstackStartWrapper/TanstackStartWrapper.js';
-import { ExpressWrapper } from './services/ExpressWrapper/ExpressWrapper.js';
-import { ConfigBuilder } from './services/ConfigBuilder/ConfigBuilder.js';
+import { ErrorCode } from './enums/ErrorCode';
+import { ValidationLocation } from './enums/ValidationLocations';
+import { ValidationError } from './types/errors/ValidationError';
+import { RoutingFactory } from './services/RoutingFactory/RoutingFactory';
+import { SchemaGenerator } from './services/SchemaGenerator/SchemaGenerator';
+import { Method } from './enums/Methods';
+import { BuiltInError } from './types/errors/BuiltInError';
+import { Logger } from './services/Logger/Logger';
+import { DescriptionChecker } from './services/DescriptionChecker/DescriptionChecker';
+import { DevelopmentUtils } from './services/DevelopmentUtils/DevelopmentUtils';
+import { ClientGenerator } from './services/ClientGenerator/ClientGenerator';
+import { ValidationUtils } from './services/ValidationUtils/ValidationUtils';
+import { TanstackStartWrapper } from './services/TanstackStartWrapper/TanstackStartWrapper';
+import { ExpressWrapper } from './services/ExpressWrapper/ExpressWrapper';
+import { ConfigBuilder } from './services/ConfigBuilder/ConfigBuilder';
 import z from 'zod';
 export class OpenApi {
     static builder = OpenApi.getBuilder();

package/dist/OpenApi.test.d.ts

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

package/dist/OpenApi.test.js

@@ -0,0 +1,418 @@
+import { afterEach, beforeEach, describe, expect, test } from 'vitest';
+import { TestUtils } from './services/TestUtils/TestUtils';
+import { Method } from './enums/Methods';
+import z from 'zod';
+import { OpenApi } from './OpenApi';
+import { SampleRouteType } from './enums/SampleRouteType';
+import { ErrorCode } from './enums/ErrorCode';
+import { ValidationLocation } from './enums/ValidationLocations';
+import { LogLevel } from './services/Logger/types/LogLevel';
+import { DefaultConfig } from './services/ConfigBuilder/types/DefaultConfig';
+import { Logger } from './services/Logger/Logger';
+describe('OpenApi', () => {
+    test('Happy Path', async () => {
+        const api = OpenApi.builder.create();
+        const route = api.factory.createRoute({
+            type: SampleRouteType.Public,
+            method: Method.GET,
+            path: '/test',
+            description: 'My Test Route',
+            validators: {
+                response: z.string().openapi({ description: 'Test Response' }),
+            },
+            handler: async () => {
+                return '1';
+            },
+        });
+        api.addRoutes('/', [route]);
+        const req = new Request('http://localhost/api/test', {});
+        const response = await api.processRootRoute(req);
+        expect(response.status).toBe(200);
+        expect(response.body).toBe('1');
+    });
+    describe('Logging', () => {
+        const consoleLogBackup = console.log;
+        let messages = [];
+        beforeEach(() => {
+            messages = [];
+            console.log = (...args) => {
+                messages.push(...args);
+                consoleLogBackup(...args);
+            };
+        });
+        afterEach(() => {
+            console.log = consoleLogBackup;
+        });
+        test('Log level can be controlled', async () => {
+            const api = OpenApi.builder.defineGlobalConfig({
+                basePath: '/api',
+                skipDescriptionsCheck: true,
+            }).create();
+            const route = api.factory.createRoute({
+                method: Method.GET,
+                type: SampleRouteType.Public,
+                path: '/',
+                description: 'My test route',
+                validators: {
+                    response: z.number(),
+                },
+                handler: async () => 1,
+            });
+            api.addRoute(route);
+            const response = await TestUtils.sendRequest(api, '/api', Method.GET);
+            expect(response.status).toBe(200);
+            expect(messages[0]).toContain('Calling route /');
+        });
+        test('Logs can be suppressed', async () => {
+            const api = OpenApi.builder.defineGlobalConfig({
+                basePath: '/api',
+                skipDescriptionsCheck: true,
+                logLevel: LogLevel.error,
+            }).create();
+            const route = api.factory.createRoute({
+                method: Method.GET,
+                type: SampleRouteType.Public,
+                path: '/',
+                description: 'My test route',
+                validators: {
+                    response: z.number(),
+                },
+                handler: async () => 1,
+            });
+            api.addRoute(route);
+            const response = await TestUtils.sendRequest(api, '/api', Method.GET);
+            expect(response.status).toBe(200);
+            expect(messages.length, 'No logs should be shown').toBe(0);
+        });
+        test('Logger can be overriden', async () => {
+            class MooLogger extends Logger {
+                log() {
+                    console.log('moo');
+                }
+            }
+            const api = OpenApi.builder.defineGlobalConfig({
+                basePath: '/api',
+                skipDescriptionsCheck: true,
+                logger: new MooLogger('Moo'),
+                logLevel: LogLevel.all,
+            }).create();
+            const route = api.factory.createRoute({
+                method: Method.GET,
+                type: SampleRouteType.Public,
+                path: '/',
+                description: 'My test route',
+                validators: {
+                    response: z.number(),
+                },
+                handler: async () => 1,
+            });
+            api.addRoute(route);
+            const response = await TestUtils.sendRequest(api, '/api', Method.GET);
+            expect(response.status).toBe(200);
+            expect(messages[0], 'Logs should be changed to "moo" lines').toBe('moo');
+        });
+    });
+    test('Has 1 default server and it should be localhost', async () => {
+        const api = OpenApi.builder.create();
+        const servers = api.getServers();
+        expect(servers[0]?.url, 'Default server URL is incorrect').toBe('/api');
+        expect(servers[0]?.description, 'Default server description is incorrect').toBe('Local');
+    });
+    test('Can add more servers', async () => {
+        const api = OpenApi.builder.create();
+        api.addServer('http://production-website.com/api', 'Production');
+        const servers = api.getServers();
+        expect(servers[1]?.url, 'URL is incorrect').toBe('http://production-website.com/api');
+        expect(servers[1]?.description, 'Description is incorrect').toBe('Production');
+    });
+    test('Routes can be added via routemap', async () => {
+        const api = OpenApi.builder.defineGlobalConfig({
+            basePath: '/api',
+            skipDescriptionsCheck: true,
+        }).create();
+        const route1 = api.factory.createRoute({
+            method: Method.GET,
+            type: SampleRouteType.Public,
+            path: '/one',
+            description: 'My test route',
+            validators: {
+                response: z.number(),
+            },
+            handler: async () => 1,
+        });
+        const route2 = api.factory.createRoute({
+            method: Method.GET,
+            type: SampleRouteType.Public,
+            path: '/two',
+            description: 'My test route',
+            validators: {
+                response: z.number(),
+            },
+            handler: async () => 2,
+        });
+        const route3 = api.factory.createRoute({
+            method: Method.GET,
+            type: SampleRouteType.Public,
+            path: '/three',
+            description: 'My test route',
+            validators: {
+                response: z.number(),
+            },
+            handler: async () => 3,
+        });
+        const routeMap = {
+            '/path1': [
+                route1,
+                route3,
+            ],
+            '/path2': [
+                route2,
+            ],
+        };
+        api.addRouteMap(routeMap);
+        const response1 = await TestUtils.sendRequest(api, '/path1/one', Method.GET);
+        expect(response1.body).toBe(1);
+        const response2error = await TestUtils.sendRequest(api, '/path1/two', Method.GET);
+        expect(response2error.status).toBe(404);
+        const response2 = await TestUtils.sendRequest(api, '/path2/two', Method.GET);
+        expect(response2.body).toBe(2);
+        const response3 = await TestUtils.sendRequest(api, '/path1/three', Method.GET);
+        expect(response3.body).toBe(3);
+    });
+    describe('Context and Route Props Constructor', () => {
+        let RouteType;
+        (function (RouteType) {
+            RouteType["User"] = "User";
+        })(RouteType || (RouteType = {}));
+        test('Context is working', async () => {
+            const api = OpenApi.builder.customizeRoutes(RouteType).defineRouteContexts({
+                [RouteType.User]: async () => {
+                    return { currentPermission: 'user' };
+                },
+            }).defineRoutes({
+                [RouteType.User]: {
+                    authorization: false,
+                },
+            }).create();
+            const route = api.factory.createRoute({
+                type: RouteType.User,
+                method: Method.GET,
+                path: '/',
+                description: 'My fantastic route',
+                validators: {
+                    response: z.string().openapi({ description: 'response' }),
+                },
+                handler: async (context) => {
+                    return context.currentPermission;
+                },
+            });
+            api.addRoutes('/', [route]);
+            const req = TestUtils.createRequest('/api', Method.GET);
+            const res = await api.processRootRoute(req);
+            expect(res.status).toBe(200);
+            expect(res.body).toBe('user');
+        });
+        test('Route props working', async () => {
+            const api = OpenApi.builder.customizeRoutes(RouteType).defineRouteExtraProps({
+                [RouteType.User]: z.object({
+                    permission: z.enum(['read', 'write']),
+                }),
+            }).defineRouteContexts({
+                [RouteType.User]: async (ctx) => {
+                    return {
+                        routePermission: ctx.route.permission,
+                    };
+                },
+            }).defineRoutes({
+                [RouteType.User]: {
+                    authorization: false,
+                },
+            }).create();
+            const route = api.factory.createRoute({
+                type: RouteType.User,
+                method: Method.GET,
+                path: '/',
+                description: 'Something long',
+                validators: {
+                    response: z.string().openapi({ description: 'Hello threre' }),
+                },
+                handler: async (context) => context.routePermission,
+                permission: 'read',
+            });
+            api.addRoutes('/', [route]);
+            const req = TestUtils.createRequest('/api', Method.GET);
+            const res = await api.processRootRoute(req);
+            expect(res.status).toBe(200);
+            expect(res.body).toBe('read');
+        });
+    });
+    describe('Route params', async () => {
+        test('Can process arrays in query', async () => {
+            const api = OpenApi.builder.defineGlobalConfig({
+                basePath: '/api',
+                skipDescriptionsCheck: true,
+            }).create();
+            const route = api.factory.createRoute({
+                method: Method.GET,
+                type: SampleRouteType.Public,
+                path: '/',
+                description: 'My test route',
+                validators: {
+                    query: z.object({
+                        ids: api.validators.strings.number.array(),
+                    }),
+                    response: z.number().array(),
+                },
+                handler: async (ctx) => ctx.params.query.ids,
+            });
+            api.addRoute(route);
+            const response = await TestUtils.sendRequest(api, '/api/?ids=1&ids=2&ids=3', Method.GET);
+            expect(response.status).toBe(200);
+            expect(response.body).toEqual([1, 2, 3]);
+        });
+    });
+    describe('Validation and Errors', () => {
+        test('Validates path', async () => {
+            const api = OpenApi.builder.defineGlobalConfig({
+                basePath: '/api',
+                skipDescriptionsCheck: true,
+            }).create();
+            const route = api.factory.createRoute({
+                method: Method.GET,
+                type: SampleRouteType.Public,
+                path: '/{id}',
+                description: 'My test route',
+                validators: {
+                    path: z.object({
+                        id: api.validators.strings.number,
+                    }),
+                    response: z.object({ ok: z.boolean() }),
+                },
+                handler: async () => ({ ok: true }),
+            });
+            api.addRoute(route);
+            const response = await TestUtils.sendRequest(api, '/api/23', Method.GET);
+            expect(response.body.ok).toBe(true);
+            const response2 = await TestUtils.sendRequest(api, '/api/check', Method.GET);
+            expect(response2.status).toBe(400);
+            expect(response2.body?.error?.code).toBe(ErrorCode.ValidationFailed);
+            expect(response2.body?.error?.location).toBe(ValidationLocation.Path);
+        });
+        test('Validates query', async () => {
+            const api = OpenApi.builder.defineGlobalConfig({
+                basePath: '/api',
+                skipDescriptionsCheck: true,
+            }).create();
+            const route = api.factory.createRoute({
+                method: Method.GET,
+                type: SampleRouteType.Public,
+                path: '/',
+                description: 'My test route',
+                validators: {
+                    query: z.object({
+                        id: api.validators.strings.number,
+                    }),
+                    response: z.object({ ok: z.boolean() }),
+                },
+                handler: async () => ({ ok: true }),
+            });
+            api.addRoute(route);
+            const response = await TestUtils.sendRequest(api, '/api/?id=12', Method.GET);
+            expect(response.body.ok).toBe(true);
+            const response2 = await TestUtils.sendRequest(api, '/api/?id=check', Method.GET);
+            expect(response2.status).toBe(400);
+            expect(response2.body?.error?.code).toBe(ErrorCode.ValidationFailed);
+            expect(response2.body?.error?.location).toBe(ValidationLocation.Query);
+        });
+        test('Validates response', async () => {
+            const api = OpenApi.builder.defineGlobalConfig({
+                basePath: '/api',
+                skipDescriptionsCheck: true,
+            }).create();
+            const route = api.factory.createRoute({
+                method: Method.GET,
+                type: SampleRouteType.Public,
+                path: '/',
+                description: 'My test route',
+                validators: {
+                    response: z.object({ ok: z.boolean() }),
+                },
+                handler: async () => ({ ok: 1 }),
+            });
+            api.addRoute(route);
+            const response = await TestUtils.sendRequest(api, '/api', Method.GET);
+            expect(response.status, 'Response errors should come with status 500').toBe(500);
+            expect(response.body.error, 'Response validation errors come with code UnknownError').toBe(ErrorCode.UnknownError);
+        });
+        test('Responds with default error if no error handler present', async () => {
+            const conf = new DefaultConfig();
+            conf.handleError = undefined;
+            conf.skipDescriptionsCheck = true;
+            const api = OpenApi.builder.create(SampleRouteType, ErrorCode, conf);
+            const route = api.factory.createRoute({
+                method: Method.GET,
+                type: SampleRouteType.Public,
+                path: '/',
+                description: 'My test route',
+                validators: {
+                    response: z.object({ ok: z.boolean() }),
+                },
+                handler: async () => {
+                    throw new Error('Test');
+                },
+            });
+            api.addRoute(route);
+            const response = await TestUtils.sendRequest(api, '/api', Method.GET);
+            expect(response.status, 'Default default error has status 500').toBe(500);
+            expect(response.body.error, 'Default default error is UnknownError').toBe(ErrorCode.UnknownError);
+        });
+        test('Responds with default error if there is error in error handler', async () => {
+            const conf = new DefaultConfig();
+            conf.handleError = () => {
+                throw new Error('Something went wrong');
+            };
+            conf.skipDescriptionsCheck = true;
+            const api = OpenApi.builder.create(SampleRouteType, ErrorCode, conf);
+            const route = api.factory.createRoute({
+                method: Method.GET,
+                type: SampleRouteType.Public,
+                path: '/',
+                description: 'My test route',
+                validators: {
+                    response: z.object({ ok: z.boolean() }),
+                },
+                handler: async () => {
+                    throw new Error('Test');
+                },
+            });
+            api.addRoute(route);
+            const response = await TestUtils.sendRequest(api, '/api', Method.GET);
+            expect(response.status, 'Default default error has status 500').toBe(500);
+            expect(response.body.error, 'Default default error is UnknownError').toBe(ErrorCode.UnknownError);
+        });
+        test('Responds with default error if error handler responded with unregistered error', async () => {
+            const conf = new DefaultConfig();
+            conf.handleError = () => {
+                return { code: ErrorCode.UnknownError, body: 'Something' };
+            };
+            conf.skipDescriptionsCheck = true;
+            const api = OpenApi.builder.create(SampleRouteType, ErrorCode, conf);
+            const route = api.factory.createRoute({
+                method: Method.GET,
+                type: SampleRouteType.Public,
+                path: '/',
+                description: 'My test route',
+                validators: {
+                    response: z.object({ ok: z.boolean() }),
+                },
+                handler: async () => {
+                    throw new Error('Test');
+                },
+            });
+            api.addRoute(route);
+            const response = await TestUtils.sendRequest(api, '/api', Method.GET);
+            expect(response.status, 'Default default error has status 500').toBe(500);
+            expect(response.body.error, 'Default default error is UnknownError').toBe(ErrorCode.UnknownError);
+        });
+    });
+});

package/dist/index.d.ts

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

package/dist/index.js

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