snap-on-openapi 1.0.1 → 1.0.3

package/dist/README.md

@@ -1,8 +1,8 @@
-# Strap-on OpenAPI
+# Snap-On OpenAPI
 
 Bring a fully-fledged, type-checked API to your app in just 5 minutes.
 
-[What is Strap-On OpenAPI](#what-is-strap-on-openapi)
+[What is Snap-On OpenAPI](#what-is-snap-on-openapi)
 
 [Installation](#installation)
 
@@ -21,7 +21,7 @@ Bring a fully-fledged, type-checked API to your app in just 5 minutes.
 - TypeScript client generator included
 - Since you have OpenAPI, you can generate clients for any language you want
 
-## What is Strap-On OpenAPI?
+## What is Snap-On OpenAPI?
 
 OpenAPI is a standard for documenting your REST APIs. It's similar to JSDoc generators but with one major difference: it uses schemas that can be strictly typed and used for code generation.
 
@@ -35,14 +35,14 @@ Zod works so well that I stopped using classes for models and DTOs in my own pro
 
 You might have the same idea I had some time ago: why not combine Zod and OpenAPI and make our API absolutely type-checked both on the frontend and backend? That would be a blast!
 
-Strap-On OpenAPI is a lightweight, non-opinionated framework that allows you to do exactly that. It's highly customizable and easy to use, while providing fully type-checked context. You can forget about those "any" types that pop up here and there in your APIs.
+Snap-On OpenAPI is a lightweight, non-opinionated framework that allows you to do exactly that. It's highly customizable and easy to use, while providing fully type-checked context. You can forget about those "any" types that pop up here and there in your APIs.
 
 The framework doesn't have any predefined middlewares (I don't even use such a concept) or excessive code. It has a few built-in errors and validators which I found helpful, and even those are made with the same utilities that are available to you.
 
-Simply put, Strap-On OpenAPI is the glue that ties together OpenAPI, Zod, and Openapi-TS. And you are in charge of how your API is shaped—that's what sets this framework apart from tools like `GraphQL` and `tRPC`.
+Simply put, Snap-On OpenAPI is the glue that ties together OpenAPI, Zod, and Openapi-TS. And you are in charge of how your API is shaped—that's what sets this framework apart from tools like `GraphQL` and `tRPC`.
 
 You can check out some sample code here:
-https://github.com/Freddis/strap-on-openapi-samples
+https://github.com/Freddis/snap-on-openapi-samples
 
 ## Disclaimer
 Configuration is a bit clunky due to the huge amount of inferred types. But trust me, when you learn the basics (and there is no advanced level—it's really lightweight) you will be able to configure your API in just 5 minutes.
@@ -70,13 +70,13 @@ export const upsertWorkouts = openApi.factory.createRoute({
 ## Installation
 
 ```shell
-npm install strap-on-openapi
+npm install snap-on-openapi
 ```
 
 ## Quick Start
-The idea behind Strap-On OpenAPI is that you don't need to bother with configuration right away. It is designed to be configured as you go. Fire it up, focus on your business logic, then add errors, routes, and contexts as you go.
+The idea behind Snap-On OpenAPI is that you don't need to bother with configuration right away. It is designed to be configured as you go. Fire it up, focus on your business logic, then add errors, routes, and contexts as you go.
 
-Right now, Strap-On OpenAPI provides quickstart wrappers for Tanstack Start and Express.
+Right now, Snap-On OpenAPI provides quickstart wrappers for Tanstack Start and Express.
 
 ### Express
 
@@ -183,7 +183,7 @@ As you can see, it's not rocket science to integrate it with any framework.
 
 ## Adding Routes
 
-Now let's get deeper with Strap-On OpenAPI. Let's add some hot action.
+Now let's get deeper with Snap-On OpenAPI. Let's add some hot action.
 
 We need to create a route and then add it to our OpenAPI instance. I recommend using a separate file for each route and one more file for the route map:
 ```typescript
@@ -229,7 +229,7 @@ export const getCars = openapi.factory.createRoute({
 Now let's create a route map:
 ```typescript
 // file: src/openapi/routes.ts
-import {OpenApiRouteMap, OpenApiSampleRouteType} from 'strap-on-openapi';
+import {OpenApiRouteMap, OpenApiSampleRouteType} from 'snap-on-openapi';
 import {getCars} from './getCars';
 
 export const openApiRoutes: OpenApiRouteMap<OpenApiSampleRouteType> = {
@@ -313,9 +313,9 @@ And you can always write your own wrapper function to make it even less verbose
 
 ## Configuration
 
-Strap-On OpenAPI comes with a default configuration that covers basic errors and provides public route types. You can start with that, but eventually you will grow out of it.
+Snap-On OpenAPI comes with a default configuration that covers basic errors and provides public route types. You can start with that, but eventually you will grow out of it.
 
-There are two ways to configure Strap-On OpenAPI:
+There are two ways to configure Snap-On OpenAPI:
 1. Inferred config (recommended at the beginning)
 2. Implement OpenApiConfig interface
 
@@ -480,7 +480,7 @@ With that said, you can see that you don't have to list all possible kinds of er
 
 > [!NOTE] 
 > Every error that can be thrown corresponds to one or multiple error responses. Whatever happens during API call processing, the consumer will 
-> always receive a response. That's why Strap-On OpenAPI requires at least one error response to be defined: it has to have the default error.
+> always receive a response. That's why Snap-On OpenAPI requires at least one error response to be defined: it has to have the default error.
 
 The `customizeErrors()` call will set you on the path of configuring errors. Similar to `customizeRoutes()`, you won't be able to call `create()` until you have provided everything required for the API to function properly.
 
@@ -538,7 +538,7 @@ export const openApi = OpenApi.builder.customizeErrors(
 > [!NOTE]
 > Note that the interface of `defineDefaultError` forces you to use synchronous context. It's no coincidence: errors may happen during your own error handling. This approach guarantees that whatever happens, we always have a suitable response ready.
 
-The last thing we need to do is write the error handler itself. Strap-On OpenAPI can't magically know what error to respond with; the best it can do is respond with the default error response.
+The last thing we need to do is write the error handler itself. Snap-On OpenAPI can't magically know what error to respond with; the best it can do is respond with the default error response.
 
 Surprisingly enough, the last call related to error handling is `customizeGlobalConfig()`, which was already covered above. The reason why it's done this way is to allow you to tweak error handling when you work with `DefaultConfig`. The built-in error types are quite good, and many people may prefer to use them for a while before actually setting up their own error responses.
 

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';

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 {};