snap-on-openapi 1.0.2 → 1.0.3

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

@@ -1,6 +1,6 @@
 import { UserConfig } from '@hey-api/openapi-ts';
-import { OpenApi } from '../../OpenApi.js';
-import { AnyConfig } from '../../types/config/AnyConfig.js';
+import { OpenApi } from '../../OpenApi';
+import { AnyConfig } from '../../types/config/AnyConfig';
 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>);

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

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

package/dist/services/ClientGenerator/ClientGenerator.test.js

@@ -0,0 +1,37 @@
+import { afterEach, describe, expect, test } from 'vitest';
+import { TestUtils } from '../TestUtils/TestUtils';
+import { existsSync, rmSync } from 'fs';
+import { resolve } from 'path';
+describe('ClientGenerator', async () => {
+    const api = TestUtils.createOpenApi();
+    const dirs = [
+        'open-api-client',
+        'temp/client',
+    ];
+    afterEach(() => {
+        for (const dir of dirs) {
+            if (!existsSync(dir)) {
+                continue;
+            }
+            rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    test('Happy Path', async () => {
+        await api.clientGenerator.generate();
+        const directoryCreated = await TestUtils.awaitGeneric(1000, 200, async () => {
+            const fileExists = existsSync(resolve('open-api-client'));
+            return fileExists || null;
+        });
+        expect(directoryCreated).toBe(true);
+    });
+    test('Config overrides work', async () => {
+        await api.clientGenerator.generate({
+            output: 'temp/client',
+        });
+        const directoryCreated = await TestUtils.awaitGeneric(1000, 200, async () => {
+            const fileExists = existsSync(resolve('temp/client'));
+            return fileExists || null;
+        });
+        expect(directoryCreated).toBe(true);
+    });
+});

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

@@ -1,13 +1,13 @@
-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 { ErrorConfigMap } from '../../types/config/ErrorConfigMap';
+import { Config } from '../../types/config/Config';
+import { RouteConfigMap } from '../../types/config/RouteConfigMap';
+import { OpenApi } from '../../OpenApi';
+import { AnyConfig } from '../../types/config/AnyConfig';
+import { OpenApiConstructor } from './types/OpenApiConstructor';
+import { OmitMappedField } from '../../types/config/OmitMappedField';
+import { RouteExtraPropsMap } from '../../types/config/RouteExtraPropsMap';
 import { ZodRawShape, ZodObject } from 'zod';
-import { RouteContextMap } from '../../types/config/RouteContextMap.js';
+import { RouteContextMap } from '../../types/config/RouteContextMap';
 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;

package/dist/services/ConfigBuilder/ConfigBuilder.js

@@ -1,4 +1,4 @@
-import { DefaultConfig } from './types/DefaultConfig.js';
+import { DefaultConfig } from './types/DefaultConfig';
 export class ConfigBuilder {
     x;
     construct;

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

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

package/dist/services/ConfigBuilder/ConfigBuilder.test.js

@@ -0,0 +1,207 @@
+import { describe, expect, test } from 'vitest';
+import { ErrorCode } from '../../enums/ErrorCode';
+import z from 'zod';
+import { OpenApi } from '../../OpenApi';
+import { Method } from '../../enums/Methods';
+import { SampleRouteType } from '../../enums/SampleRouteType';
+import { TestUtils } from '../TestUtils/TestUtils';
+describe('ConfigBuilder', () => {
+    let MyRouteTypes;
+    (function (MyRouteTypes) {
+        MyRouteTypes["Public"] = "Public";
+        MyRouteTypes["User"] = "User";
+    })(MyRouteTypes || (MyRouteTypes = {}));
+    test('Can be created without config', async () => {
+        const defaultApi = OpenApi.builder.create();
+        const route = defaultApi.factory.createRoute({
+            type: SampleRouteType.Public,
+            method: Method.GET,
+            path: '/route',
+            description: 'Test route',
+            validators: {
+                response: z.string().openapi({ description: 'Test response' }),
+            },
+            handler: () => Promise.resolve('success'),
+        });
+        defaultApi.addRoute(route);
+        const req = TestUtils.createRequest('/api/something');
+        const res = await defaultApi.processRootRoute(req);
+        expect(res.body, 'Should throw error since no route is present').toEqual({
+            error: ErrorCode.NotFound,
+        });
+        const req2 = TestUtils.createRequest('/api/route');
+        const res2 = await defaultApi.processRootRoute(req2);
+        expect(res2.body, 'Should be able to respond correctly').toEqual('success');
+    });
+    test('Can be created with only configuring globals', async () => {
+        const defaultApi = OpenApi.builder.defineGlobalConfig({
+            basePath: '/non-default-placement',
+        }).create();
+        const route = defaultApi.factory.createRoute({
+            type: SampleRouteType.Public,
+            method: Method.GET,
+            path: '/route',
+            description: 'Test route',
+            validators: {
+                response: z.string().openapi({ description: 'Test response' }),
+            },
+            handler: () => Promise.resolve('success'),
+        });
+        defaultApi.addRoute(route);
+        const req = TestUtils.createRequest('/api/route');
+        const res = await defaultApi.processRootRoute(req);
+        expect(res.body, 'Should have bad response on default base path').toEqual({
+            error: ErrorCode.NotFound,
+        });
+        const req2 = TestUtils.createRequest('/non-default-placement/route');
+        const res2 = await defaultApi.processRootRoute(req2);
+        expect(res2.body, 'Should be able to respond on custom base path').toEqual('success');
+    });
+    test('Works Well with inferred config', async () => {
+        const api3 = OpenApi.builder.customizeErrors(ErrorCode).defineErrors({
+            [ErrorCode.UnknownError]: {
+                status: '500',
+                description: 'Unkwown Error',
+                responseValidator: z.object({
+                    error: z.object({
+                        code: z.literal(ErrorCode.UnknownError),
+                    }),
+                }),
+            },
+            [ErrorCode.ValidationFailed]: {
+                status: '400',
+                description: 'Validation Failed',
+                responseValidator: z.object({
+                    error: z.object({
+                        code: z.literal(ErrorCode.ValidationFailed),
+                    }),
+                }),
+            },
+            [ErrorCode.NotFound]: {
+                status: '404',
+                description: 'Route Not Found',
+                responseValidator: z.object({
+                    error: z.object({
+                        code: z.literal(ErrorCode.NotFound),
+                    }),
+                }),
+            },
+        }).defineDefaultError({
+            code: ErrorCode.UnknownError,
+            body: { error: { code: ErrorCode.UnknownError } },
+        }).customizeRoutes(SampleRouteType).defineRouteExtraProps({
+            [SampleRouteType.Public]: z.object({ routeParam: z.string() }),
+        }).defineRouteContexts({
+            [SampleRouteType.Public]: (ctx) => Promise.resolve({ contextParam: ctx.route.routeParam }),
+        }).defineRoutes({
+            [SampleRouteType.Public]: {
+                authorization: false,
+                errors: {
+                    ValidationFailed: true,
+                },
+            },
+        }).defineGlobalConfig({
+            basePath: '/api',
+            skipDescriptionsCheck: true,
+            handleError: () => {
+                throw new Error('Function not implemented.');
+            },
+        }).create();
+        const route = api3.factory.createRoute({
+            type: SampleRouteType.Public,
+            method: Method.GET,
+            path: '/test',
+            description: 'Test Route',
+            validators: {
+                response: z.string(),
+            },
+            handler: (ctx) => Promise.resolve(ctx.contextParam),
+            routeParam: 'myRouteParam',
+        });
+        api3.addRoutes('/', [route]);
+        const req = TestUtils.createRequest('/api/test', Method.GET);
+        const res = await api3.processRootRoute(req);
+        expect(res.status).toBe(200);
+        expect(res.body).toBe('myRouteParam');
+    });
+    test('Works Well with class-based config', async () => {
+        const userRouteExtraPropsvalidator = z.object({
+            permission: z.string(),
+        });
+        class AppErrorConfig {
+            [ErrorCode.UnknownError] = {
+                status: '500',
+                description: 'Unkwown Error',
+                responseValidator: z.object({
+                    error: z.object({
+                        code: z.literal(ErrorCode.UnknownError),
+                    }),
+                }),
+            };
+            [ErrorCode.ValidationFailed] = {
+                status: '400',
+                description: 'Validation Failed',
+                responseValidator: z.object({
+                    error: z.object({
+                        code: z.literal(ErrorCode.ValidationFailed),
+                    }),
+                }),
+            };
+            [ErrorCode.NotFound] = {
+                status: '404',
+                description: 'Route Not Found',
+                responseValidator: z.object({
+                    error: z.object({
+                        code: z.literal(ErrorCode.NotFound),
+                    }),
+                }),
+            };
+        }
+        class AppRouteConfig {
+            Public = {
+                authorization: false,
+                extraProps: undefined,
+                contextFactory: async () => (undefined),
+            };
+            User = {
+                authorization: false,
+                contextFactory: async (ctx) => ({ permission: ctx.route.permission }),
+                extraProps: userRouteExtraPropsvalidator,
+            };
+        }
+        class AppConfig {
+            basePath = '/api';
+            routes = new AppRouteConfig();
+            errors = new AppErrorConfig();
+            defaultError = {
+                code: ErrorCode.UnknownError,
+                body: {
+                    error: {
+                        code: ErrorCode.UnknownError,
+                    },
+                },
+            };
+            handleError() {
+                return this.defaultError;
+            }
+            ;
+        }
+        const api = OpenApi.builder.create(MyRouteTypes, ErrorCode, new AppConfig());
+        const route = api.factory.createRoute({
+            type: MyRouteTypes.User,
+            method: Method.GET,
+            path: '/',
+            description: 'Test route',
+            validators: {
+                response: z.string().openapi({ description: 'Test response' }),
+            },
+            handler: (ctx) => Promise.resolve(ctx.permission),
+            permission: 'My Test Permission',
+        });
+        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('My Test Permission');
+    });
+});

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

@@ -1,12 +1,12 @@
-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';
+import { ErrorCode } from '../../../enums/ErrorCode';
+import { SampleRouteType } from '../../../enums/SampleRouteType';
+import { Config } from '../../../types/config/Config';
+import { ErrorResponse } from '../../../types/config/ErrorResponse';
+import { RoutePath } from '../../../types/RoutePath';
+import { DefaultErrorMap } from './DefaultErrorMap';
+import { DefaultRouteContextMap } from './DefaultRouteContextMap';
+import { DefaultRouteMap } from './DefaultRouteMap';
+import { DefaultRouteParamsMap } from './DefaultRouteParamsMap';
 export declare class DefaultConfig implements Config<SampleRouteType, ErrorCode, DefaultErrorMap, DefaultRouteParamsMap, DefaultRouteContextMap, DefaultRouteMap> {
     basePath: RoutePath;
     routes: DefaultRouteMap;

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

@@ -1,9 +1,9 @@
-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';
+import { ErrorCode } from '../../../enums/ErrorCode';
+import { ValidationLocation } from '../../../enums/ValidationLocations';
+import { BuiltInError } from '../../../types/errors/BuiltInError';
+import { ValidationError } from '../../../types/errors/ValidationError';
+import { DefaultErrorMap } from './DefaultErrorMap';
+import { DefaultRouteMap } from './DefaultRouteMap';
 export class DefaultConfig {
     basePath = '/api';
     routes = new DefaultRouteMap();

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

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

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

@@ -0,0 +1,82 @@
+import { describe, expect, test } from 'vitest';
+import z from 'zod';
+import { OpenApi } from '../../../OpenApi';
+import { ErrorCode } from '../../../enums/ErrorCode';
+import { Method } from '../../../enums/Methods';
+import { SampleRouteType } from '../../../enums/SampleRouteType';
+import { TestUtils } from '../../TestUtils/TestUtils';
+describe('DefaultConfig', () => {
+    describe('Error handler', () => {
+        test('Default Config checks', async () => {
+            const defaultApi = OpenApi.builder.create();
+            expect(defaultApi.getConfig().skipDescriptionsCheck, 'By default we check validator descriptions').toBe(false);
+        });
+        test('Returns not found error on unkown route', async () => {
+            const defaultApi = OpenApi.builder.create();
+            const req = TestUtils.createRequest('/api/route');
+            const res = await defaultApi.processRootRoute(req);
+            expect(res.body, 'Should throw error since no route is present').toEqual({
+                error: ErrorCode.NotFound,
+            });
+            expect(res.status, 'Should status 404 for not found error').toEqual(404);
+        });
+        test('Returns unknown error on random error', async () => {
+            const defaultApi = OpenApi.builder.create();
+            const route = defaultApi.factory.createRoute({
+                type: SampleRouteType.Public,
+                method: Method.GET,
+                path: '/route',
+                description: 'Test route',
+                validators: {
+                    response: z.string().openapi({ description: 'Test response' }),
+                },
+                handler: async () => {
+                    throw new Error('dasdsaa');
+                },
+            });
+            defaultApi.addRoute(route);
+            const req = TestUtils.createRequest('/api/route');
+            const res = await defaultApi.processRootRoute(req);
+            expect(res.body, 'Should return unknown error if error happens').toEqual({
+                error: ErrorCode.UnknownError,
+            });
+            expect(res.status, 'Should status 500 for unknown error').toEqual(500);
+        });
+        test('Returns validation error on invalid params', async () => {
+            const defaultApi = OpenApi.builder.create();
+            const route = defaultApi.factory.createRoute({
+                type: SampleRouteType.Public,
+                method: Method.POST,
+                path: '/route',
+                description: 'Test route',
+                validators: {
+                    body: z.object({
+                        name: z.string().openapi({ description: 'Name' }),
+                    }),
+                    response: z.string().openapi({ description: 'Test response' }),
+                },
+                handler: async () => Promise.resolve('success'),
+            });
+            defaultApi.addRoute(route);
+            const happyReq = TestUtils.createRequest('/api/route', Method.POST, { name: 'king' });
+            const happyRes = await defaultApi.processRootRoute(happyReq);
+            expect(happyRes.body, 'Should return normal response if body is valid').toBe('success');
+            expect(happyRes.status, 'Should return status 200 on normal response').toBe(200);
+            const req = TestUtils.createRequest('/api/route', Method.POST);
+            const res = await defaultApi.processRootRoute(req);
+            expect(res.body, 'Should return unknown error if error happens').toEqual({
+                error: {
+                    code: ErrorCode.ValidationFailed,
+                    fieldErrors: [
+                        {
+                            field: 'name',
+                            message: 'Required',
+                        },
+                    ],
+                    location: 'Body',
+                },
+            });
+            expect(res.status, 'Should return status 400 on validation error').toEqual(400);
+        });
+    });
+});

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

@@ -1,5 +1,5 @@
-import { ErrorCode } from '../../../enums/ErrorCode.js';
-import { ErrorConfigMap } from '../../../types/config/ErrorConfigMap.js';
+import { ErrorCode } from '../../../enums/ErrorCode';
+import { ErrorConfigMap } from '../../../types/config/ErrorConfigMap';
 export declare class DefaultErrorMap implements ErrorConfigMap<ErrorCode> {
     [ErrorCode.UnknownError]: {
         readonly status: "500";
@@ -47,7 +47,7 @@ export declare class DefaultErrorMap implements ErrorConfigMap<ErrorCode> {
                         field: string;
                     }[] | undefined;
                 }>, "many">;
-                location: import("zod").ZodNativeEnum<typeof import("../../../index.js").OpenApiValidationLocation>;
+                location: import("zod").ZodNativeEnum<typeof import("../../..").OpenApiValidationLocation>;
             }, "strip", import("zod").ZodTypeAny, {
                 code: ErrorCode.ValidationFailed;
                 fieldErrors: {
@@ -58,7 +58,7 @@ export declare class DefaultErrorMap implements ErrorConfigMap<ErrorCode> {
                         field: string;
                     }[] | undefined;
                 }[];
-                location: import("../../../index.js").OpenApiValidationLocation;
+                location: import("../../..").OpenApiValidationLocation;
             }, {
                 code: ErrorCode.ValidationFailed;
                 fieldErrors: {
@@ -69,7 +69,7 @@ export declare class DefaultErrorMap implements ErrorConfigMap<ErrorCode> {
                         field: string;
                     }[] | undefined;
                 }[];
-                location: import("../../../index.js").OpenApiValidationLocation;
+                location: import("../../..").OpenApiValidationLocation;
             }>;
         }, "strip", import("zod").ZodTypeAny, {
             error: {
@@ -82,7 +82,7 @@ export declare class DefaultErrorMap implements ErrorConfigMap<ErrorCode> {
                         field: string;
                     }[] | undefined;
                 }[];
-                location: import("../../../index.js").OpenApiValidationLocation;
+                location: import("../../..").OpenApiValidationLocation;
             };
         }, {
             error: {
@@ -95,7 +95,7 @@ export declare class DefaultErrorMap implements ErrorConfigMap<ErrorCode> {
                         field: string;
                     }[] | undefined;
                 }[];
-                location: import("../../../index.js").OpenApiValidationLocation;
+                location: import("../../..").OpenApiValidationLocation;
             };
         }>;
     };

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

@@ -1,7 +1,7 @@
-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';
+import { ErrorCode } from '../../../enums/ErrorCode';
+import { unknownErrorResponseValidator } from '../../../types/errors/responses/UnknownErrorResponse';
+import { validationErrorResponseValidator } from '../../../types/errors/responses/ValidationErrorResponse';
+import { notFoundErrorResponseValidator } from '../../../types/errors/responses/NotFoundErrorResponse';
 export class DefaultErrorMap {
     [ErrorCode.UnknownError] = {
         status: '500',

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

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

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

@@ -1,8 +1,8 @@
-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';
+import { SampleRouteType } from '../../../enums/SampleRouteType';
+import { RouteConfigMap } from '../../../types/config/RouteConfigMap';
+import { ErrorCode } from '../../../enums/ErrorCode';
+import { DefaultRouteContextMap } from './DefaultRouteContextMap';
+import { DefaultRouteParamsMap } from './DefaultRouteParamsMap';
 export declare class DefaultRouteMap implements RouteConfigMap<SampleRouteType, ErrorCode, DefaultRouteParamsMap, DefaultRouteContextMap> {
     Public: {
         readonly authorization: false;

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

@@ -1,5 +1,5 @@
-import { DefaultRouteContextMap } from './DefaultRouteContextMap.js';
-import { DefaultRouteParamsMap } from './DefaultRouteParamsMap.js';
+import { DefaultRouteContextMap } from './DefaultRouteContextMap';
+import { DefaultRouteParamsMap } from './DefaultRouteParamsMap';
 export class DefaultRouteMap {
     Public = {
         authorization: false,

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

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

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

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

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

@@ -1,6 +1,6 @@
 import { ZodTypeAny, ZodRawShape } from 'zod';
-import { AnyRoute } from '../../types/AnyRoute.js';
-import { ValidationUtils } from '../ValidationUtils/ValidationUtils.js';
+import { AnyRoute } from '../../types/AnyRoute';
+import { ValidationUtils } from '../ValidationUtils/ValidationUtils';
 interface DescriptionCheckerConfig {
     checkValidators: boolean;
 }

package/dist/services/DescriptionChecker/DescriptionChecker.js

@@ -1,5 +1,5 @@
 import z from 'zod';
-import { ValidationUtils } from '../ValidationUtils/ValidationUtils.js';
+import { ValidationUtils } from '../ValidationUtils/ValidationUtils';
 export class DescriptionChecker {
     utils = new ValidationUtils();
     config;

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

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