snap-on-openapi 1.0.1 → 1.0.3

package/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/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();
@@ -31,7 +31,7 @@ export class OpenApi {
     servers = [];
     constructor(config) {
         this.config = config;
-        this.logger = new Logger('OpenAPI');
+        this.logger = config.logger ?? new Logger('OpenAPI');
         if (config.logLevel) {
             Logger.logLevel = config.logLevel;
         }
@@ -45,7 +45,7 @@ export class OpenApi {
             title: config.apiName ?? 'My API',
             version: '3.1.0',
         };
-        this.schemaGenerator = new SchemaGenerator(this.logger.getInvoker(), info, this.config, this.routes, this.servers);
+        this.schemaGenerator = new SchemaGenerator(this.logger.derrive('SchemaGenerator'), info, this.config, this.routes, this.servers);
         this.wrappers = {
             tanstackStart: new TanstackStartWrapper(this),
             express: new ExpressWrapper(this),

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);
+        });
+    });
+});