snap-on-openapi 1.0.1 → 1.0.3

package/dist/services/Logger/Logger.test.js

@@ -0,0 +1,113 @@
+import { afterEach, beforeEach, describe, expect, test } from 'vitest';
+import { Logger } from './Logger';
+import { LogLevel } from './types/LogLevel';
+describe('Logger', () => {
+    const consoleLogBackup = console.log;
+    const consoleDirBackup = console.dir;
+    let messages = [];
+    const fakeLog = (msg) => {
+        messages.push(msg);
+        consoleLogBackup(msg);
+    };
+    const fakeDir = (msg) => {
+        messages.push(msg);
+        consoleDirBackup(msg);
+    };
+    beforeEach(() => {
+        console.log = fakeLog;
+        console.dir = fakeDir;
+        messages = [];
+        Logger.showTime = true;
+        Logger.setLogLevel(LogLevel.all);
+    });
+    afterEach(() => {
+        console.log = consoleLogBackup;
+        console.dir = consoleDirBackup;
+    });
+    test('Logs output to console', async () => {
+        const logger = new Logger('invoker');
+        const now = new Date();
+        logger.info('Hello there');
+        const nowStr = now.toISOString();
+        expect(messages[messages.length - 1]).toContain('Hello there');
+        expect(messages[messages.length - 1]).toContain(nowStr.substring(0, nowStr.length - 4));
+        expect(messages[messages.length - 1]).toContain('[invoker]');
+        expect(messages[messages.length - 1]).toContain('[info]');
+    });
+    test('Time can be omitted', async () => {
+        const logger = new Logger('invoker');
+        const now = new Date();
+        logger.info('Hello there');
+        const nowStr = now.toISOString();
+        expect(messages[messages.length - 1]).toContain(nowStr.substring(0, nowStr.length - 4));
+        messages = [];
+        Logger.showTime = false;
+        logger.info('Hello there');
+        expect(messages[messages.length - 1]).not.toContain(nowStr.substring(0, nowStr.length - 4));
+    });
+    test('Outputs data to console', async () => {
+        const logger = new Logger('invoker');
+        logger.info('Hello there', { myNameIs: 'Alex' });
+        consoleLogBackup(messages);
+        expect(JSON.stringify(messages[messages.length - 1])).toContain('myNameIs');
+        expect(JSON.stringify(messages[messages.length - 1])).toContain('Alex');
+        expect(messages[messages.length - 2]).toContain('Hello there');
+    });
+    test('Outputs error messages', async () => {
+        const logger = new Logger('invoker2');
+        logger.error('Hello myerror', new Error('My error message'));
+        expect(messages[messages.length - 1]?.toString()).toContain('My error message');
+        expect(messages[messages.length - 2]).toContain('Hello myerror');
+        expect(messages[messages.length - 2]).toContain('[error]');
+        expect(messages[messages.length - 2]).toContain('[invoker2]');
+    });
+    test('Outputs message from error if no message given', async () => {
+        const logger = new Logger('invoker2');
+        logger.error(null, new Error('My error message'));
+        expect(messages[messages.length - 1]?.toString()).toContain('My error message');
+        expect(messages[messages.length - 2]).toContain('My error message');
+        expect(messages[messages.length - 2]).toContain('[error]');
+        expect(messages[messages.length - 2]).toContain('[invoker2]');
+    });
+    test('Silent on info and debug if error log level is set', async () => {
+        const logger = new Logger('invoker2');
+        logger.info('My info message');
+        expect(messages[messages.length - 1]).toContain('My info message');
+        messages = [];
+        Logger.setLogLevel(LogLevel.error);
+        logger.info('My info message');
+        expect(messages[messages.length - 1]).toBe(undefined);
+        logger.info('My info message');
+        expect(messages[messages.length - 1]).toBe(undefined);
+        logger.error('My error message', new Error('asdas'));
+        expect(messages[messages.length - 2]).toContain('My error message');
+    });
+    test('Silent on debug if info log level is set', async () => {
+        const logger = new Logger('invoker2');
+        logger.debug('My debug message');
+        expect(messages[messages.length - 1]).toContain('My debug message');
+        messages = [];
+        Logger.setLogLevel(LogLevel.info);
+        logger.debug('My debug message');
+        expect(messages[messages.length - 1]).toBe(undefined);
+        logger.info('My info message');
+        expect(messages[messages.length - 1]).toContain('My info message');
+        logger.error('My error message', new Error('asdas'));
+        expect(messages[messages.length - 2]).toContain('My error message');
+    });
+    test('Returns correct invoker when extended', async () => {
+        const logger = new Logger('NewInvoker', 'OriginalInvoker');
+        expect(logger.getInvoker()).toBe('OriginalInvoker:NewInvoker');
+    });
+    test('Can Handle circular objects', async () => {
+        const logger = new Logger('invoker');
+        const obj = { myNameIs: 'Alex', x: [1, 2, 3] };
+        obj.obj = obj;
+        obj.arr = [obj, obj];
+        logger.info('Hello there', obj);
+        consoleLogBackup(messages);
+        expect(JSON.stringify(messages[messages.length - 1])).toContain('myNameIs');
+        expect(JSON.stringify(messages[messages.length - 1])).toContain('circular->obj');
+        expect(messages[messages.length - 2]).toContain('Hello there');
+    });
+});

package/dist/services/RoutingFactory/RoutingFactory.d.ts

@@ -1,8 +1,8 @@
 import { ZodFirstPartySchemaTypes, ZodObject, ZodRawShape } from 'zod';
-import { Method } from '../../enums/Methods.js';
-import { Route } from '../../types/Route.js';
-import { AnyConfig } from '../../types/config/AnyConfig.js';
-import { RouteExtraProps } from '../../types/config/RouteExtraProps.js';
+import { Method } from '../../enums/Methods';
+import { Route } from '../../types/Route';
+import { AnyConfig } from '../../types/config/AnyConfig';
+import { RouteExtraProps } from '../../types/config/RouteExtraProps';
 export declare class RoutingFactory<TRouteTypes extends string, TErrorCodes extends string, TConfig extends AnyConfig<TRouteTypes, TErrorCodes>> {
     protected map: TConfig;
     constructor(map: TConfig);

package/dist/services/SchemaGenerator/SchemaGenerator.d.ts

@@ -1,17 +1,17 @@
 import 'zod-openapi/extend';
 import { createDocument, ZodOpenApiOperationObject } from 'zod-openapi';
-import { AnyRoute } from '../../types/AnyRoute.js';
-import { AnyConfig } from '../../types/config/AnyConfig.js';
-import { Logger } from '../Logger/Logger.js';
-import { Server } from '../../types/config/Server.js';
-import { Info } from '../../types/config/Info.js';
+import { AnyRoute } from '../../types/AnyRoute';
+import { AnyConfig } from '../../types/config/AnyConfig';
+import { Logger } from '../Logger/Logger';
+import { Server } from '../../types/config/Server';
+import { Info } from '../../types/config/Info';
 export declare class SchemaGenerator<TRouteTypes extends string, TErrorCodes extends string, TConfig extends AnyConfig<TRouteTypes, TErrorCodes>> {
     protected logger: Logger;
     protected info: Info;
     protected routes: AnyRoute<TRouteTypes>[];
     protected servers: Server[];
     protected routeSpec: TConfig;
-    constructor(invoker: string, info: Info, spec: TConfig, routes: AnyRoute<TRouteTypes>[], servers: Server[]);
+    constructor(logger: Logger, info: Info, spec: TConfig, routes: AnyRoute<TRouteTypes>[], servers: Server[]);
     getYaml(): string;
     saveYaml(path: string): void;
     protected createDocument(): ReturnType<typeof createDocument>;

package/dist/services/SchemaGenerator/SchemaGenerator.js

@@ -3,16 +3,15 @@ import { writeFileSync } from 'fs';
 import { stringify } from 'yaml';
 import { createDocument } from 'zod-openapi';
 import { z } from 'zod';
-import { Method } from '../../enums/Methods.js';
-import { Logger } from '../Logger/Logger.js';
+import { Method } from '../../enums/Methods';
 export class SchemaGenerator {
     logger;
     info;
     routes;
     servers;
     routeSpec;
-    constructor(invoker, info, spec, routes, servers) {
-        this.logger = new Logger(SchemaGenerator.name, invoker);
+    constructor(logger, info, spec, routes, servers) {
+        this.logger = logger;
         this.routes = routes;
         this.routeSpec = spec;
         this.servers = servers;

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

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

package/dist/services/SchemaGenerator/SchemaGenerator.test.js

@@ -0,0 +1,142 @@
+import { beforeEach, describe, expect, test } from 'vitest';
+import { TestUtils } from '../TestUtils/TestUtils';
+import { existsSync, mkdirSync, readFileSync, rmSync } from 'fs';
+import z from 'zod';
+import { Method } from '../../enums/Methods';
+import { SampleRouteType } from '../../enums/SampleRouteType';
+import { OpenApi } from '../../OpenApi';
+import { ErrorCode } from '../../enums/ErrorCode';
+import { notFoundErrorResponseValidator } from '../../types/errors/responses/NotFoundErrorResponse';
+import { validationErrorResponseValidator } from '../../types/errors/responses/ValidationErrorResponse';
+import { unknownErrorResponseValidator } from '../../types/errors/responses/UnknownErrorResponse';
+describe('SchemaGenerator', () => {
+    beforeEach(async () => {
+        if (!existsSync('temp')) {
+            mkdirSync('temp');
+        }
+        if (existsSync('temp/schema.yml')) {
+            rmSync('temp/schema.yml');
+        }
+    });
+    test('Can create error unions on same status', async () => {
+        const api = OpenApi.builder.customizeErrors(ErrorCode).defineErrors({
+            [ErrorCode.UnknownError]: {
+                status: '500',
+                description: 'Unknown Error',
+                responseValidator: unknownErrorResponseValidator,
+            },
+            [ErrorCode.ValidationFailed]: {
+                status: '500',
+                description: 'Validation Error',
+                responseValidator: validationErrorResponseValidator,
+            },
+            [ErrorCode.NotFound]: {
+                status: '500',
+                description: 'Not Found Error',
+                responseValidator: notFoundErrorResponseValidator,
+            },
+        }).defineDefaultError({
+            code: ErrorCode.UnknownError,
+            body: { error: ErrorCode.UnknownError },
+        }).customizeRoutes(SampleRouteType).defineRoutes({
+            [SampleRouteType.Public]: {
+                authorization: false,
+                errors: {
+                    NotFound: true,
+                },
+            },
+        }).create();
+        const expectedPartial = `
+        "500":
+          description: Unknown Error or Not Found Error
+          content:
+            application/json:
+              schema:
+                oneOf:
+                  - type: object
+                    properties:
+                      error:
+                        type: string
+                        const: UnknownError
+                        description: Code to handle on the frontend
+                    required:
+                      - error
+                    description: Error response
+                  - type: object
+                    properties:
+                      error:
+                        type: string
+                        const: NotFound
+                        description: Code to handle on the frontend
+                    required:
+                      - error
+                    description: Error response`;
+        api.addRoute(api.factory.createRoute({
+            type: SampleRouteType.Public,
+            method: Method.GET,
+            path: '/',
+            description: 'Sample route',
+            validators: {
+                response: z.string().openapi({ description: 'Sample response' }),
+            },
+            handler: () => Promise.resolve('something'),
+        }));
+        const yml = api.schemaGenerator.getYaml().toString();
+        console.log(yml);
+        expect(yml).toContain(expectedPartial);
+    });
+    test('Poperly prints POST methods schema', () => {
+        const api = OpenApi.builder.customizeRoutes(SampleRouteType).defineRoutes({
+            [SampleRouteType.Public]: {
+                authorization: true,
+            },
+        }).create();
+        api.addRoute(api.factory.createRoute({
+            type: SampleRouteType.Public,
+            method: Method.POST,
+            path: '/',
+            description: 'My post method',
+            validators: {
+                body: z.object({
+                    name: z.string().openapi({ description: 'Name of something' }),
+                }),
+                response: z.string().openapi({ description: 'Status' }),
+            },
+            handler: () => Promise.resolve('Hello'),
+        }));
+        const expectedPartial = `
+  /:
+    post:
+      description: My post method
+      security:
+        - bearerHttpAuthentication: []
+      requestBody:
+        content:
+          application/json:
+            schema:
+              type: object
+              properties:
+                name:
+                  type: string
+                  description: Name of something
+              required:
+                - name
+      responses:
+        "200":
+          description: Good Response
+          content:
+            application/json:
+              schema:
+                type: string
+                description: Status`;
+        const yml = api.schemaGenerator.getYaml().toString();
+        expect(yml).toContain(expectedPartial);
+    });
+    test('Can save schema to file', () => {
+        const api = TestUtils.createOpenApi();
+        expect(existsSync('/temp/schema.yml')).toBe(false);
+        api.schemaGenerator.saveYaml('temp/schema.yml');
+        readFileSync('temp/schema.yml');
+        expect(existsSync('temp/schema.yml')).toBe(true);
+    });
+});

package/dist/services/TanstackStartWrapper/TanstackStartWrapper.d.ts

@@ -1,7 +1,7 @@
-import { OpenApi } from '../../OpenApi.js';
-import { AnyConfig } from '../../types/config/AnyConfig.js';
-import { RoutePath } from '../../types/RoutePath.js';
-import { DevelopmentUtils } from '../DevelopmentUtils/DevelopmentUtils.js';
+import { OpenApi } from '../../OpenApi';
+import { AnyConfig } from '../../types/config/AnyConfig';
+import { RoutePath } from '../../types/RoutePath';
+import { DevelopmentUtils } from '../DevelopmentUtils/DevelopmentUtils';
 export declare class TanstackStartWrapper<TRouteTypes extends string, TErrorCodes extends string, TConfig extends AnyConfig<TRouteTypes, TErrorCodes>> {
     protected service: OpenApi<TRouteTypes, TErrorCodes, TConfig>;
     protected developmentUtils: DevelopmentUtils;

package/dist/services/TanstackStartWrapper/TanstackStartWrapper.js

@@ -1,4 +1,4 @@
-import { DevelopmentUtils } from '../DevelopmentUtils/DevelopmentUtils.js';
+import { DevelopmentUtils } from '../DevelopmentUtils/DevelopmentUtils';
 export class TanstackStartWrapper {
     service;
     developmentUtils;

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

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

package/dist/services/TanstackStartWrapper/TanstackStartWrapper.test.js

@@ -0,0 +1,44 @@
+import { describe, expect, test } from 'vitest';
+import { TestUtils } from '../TestUtils/TestUtils';
+import { ErrorCode } from '../../enums/ErrorCode';
+describe('TanstackStartWrapper', () => {
+    test.skip('Can mount api on tanstack start', async () => {
+    });
+    describe('unit', () => {
+        test('Can mount the api correctly', async () => {
+            const api = TestUtils.createOpenApi();
+            const methods = api.wrappers.tanstackStart.getOpenApiRootMethods();
+            const errResponse = await methods.GET({ request: TestUtils.createRequest('/api') });
+            expect(errResponse.status, 'Should be 404 on unknown route').toBe(404);
+            expect(await errResponse.json(), 'Should be error on unknown route').toEqual({ error: ErrorCode.NotFound });
+            const goodResponse = await methods.GET({ request: TestUtils.createRequest('/sample') });
+            expect(goodResponse.status, 'Should be 200 on sample route').toBe(200);
+            expect(await goodResponse.json(), "Should be body 'success'").toEqual('success');
+        });
+        test('Can mount swagger routes correctly', async () => {
+            const api = TestUtils.createOpenApi();
+            const methods = api.wrappers.tanstackStart.createSwaggerMethods('/openapi-schema');
+            const goodResponse = await methods.GET();
+            expect(goodResponse.status, 'Should be 200 on swagger route').toBe(200);
+            const body = await goodResponse.text();
+            expect(body, 'Swagger UI pieces should be in HTML').toContain('swagger-ui');
+            expect(body, 'Default schema path should be present').toContain('/openapi-schema');
+        });
+        test('Can mount stoplight routes correctly', async () => {
+            const api = TestUtils.createOpenApi();
+            const methods = api.wrappers.tanstackStart.createStoplightMethods('/openapi-schema');
+            const goodResponse = await methods.GET();
+            expect(goodResponse.status, 'Should be 200 on stoplight route').toBe(200);
+            const body = await goodResponse.text();
+            expect(body, 'Stoplight UI pieces should be in HTML').toContain('@stoplight');
+            expect(body, 'Default schema path should be present').toContain('/openapi-schema');
+        });
+        test('Can mount schema routes correctly', async () => {
+            const api = TestUtils.createOpenApi();
+            const methods = api.wrappers.tanstackStart.createShemaMethods();
+            const goodResponse = await methods.GET();
+            expect(goodResponse.status, 'Should be 200 on schema route').toBe(200);
+            expect(await goodResponse.text(), 'Response should contain pieces of openapi schema').toContain('Sample route');
+        });
+    });
+});

package/dist/services/TestUtils/TestUtils.d.ts

@@ -1,13 +1,13 @@
-import { OpenApi } from '../../OpenApi.js';
-import { Method } from '../../enums/Methods.js';
-import { SampleRouteType } from '../../enums/SampleRouteType.js';
-import { RoutePath } from '../../types/RoutePath.js';
+import { OpenApi } from '../../OpenApi';
+import { Method } from '../../enums/Methods';
+import { SampleRouteType } from '../../enums/SampleRouteType';
+import { RoutePath } from '../../types/RoutePath';
 export declare class TestUtils {
     static createRequest(route: RoutePath, method?: Method, body?: object): Request;
     static sendRequest(api: OpenApi<any, any, any>, route: RoutePath, method?: Method, body?: object): Promise<{
         status: number;
         body: any;
     }>;
-    static createOpenApi(): OpenApi<SampleRouteType, import("../../index.js").OpenApiErrorCode, import("../../index.js").OpenApiDefaultConfig>;
+    static createOpenApi(): OpenApi<SampleRouteType, import("../..").OpenApiErrorCode, import("../..").OpenApiDefaultConfig>;
     static awaitGeneric<T>(timeoutMs: number, intervalMs: number, callback: () => Promise<T | null>): Promise<T | null>;
 }

package/dist/services/TestUtils/TestUtils.js

@@ -1,7 +1,7 @@
 import z from 'zod';
-import { OpenApi } from '../../OpenApi.js';
-import { Method } from '../../enums/Methods.js';
-import { SampleRouteType } from '../../enums/SampleRouteType.js';
+import { OpenApi } from '../../OpenApi';
+import { Method } from '../../enums/Methods';
+import { SampleRouteType } from '../../enums/SampleRouteType';
 export class TestUtils {
     static createRequest(route, method = Method.GET, body) {
         const request = new Request(`http://localhost${route}`, {

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

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

package/dist/services/TestUtils/TestUtils.test.js

@@ -0,0 +1,20 @@
+import { describe, expect, test } from 'vitest';
+import { TestUtils } from './TestUtils';
+describe('TestUtils', () => {
+    test('Await generic fails on timeout', async () => {
+        const nullVal = await TestUtils.awaitGeneric(500, 50, async () => {
+            return null;
+        });
+        expect(nullVal).toBe(null);
+    });
+    test('Await generic fails on timeout', async () => {
+        let val = null;
+        setTimeout(() => {
+            val = true;
+        }, 300);
+        const gatheredVal = await TestUtils.awaitGeneric(1000, 50, async () => {
+            return val;
+        });
+        expect(val).toBe(gatheredVal);
+    });
+});

package/dist/services/ValidationUtils/ValidationUtils.js

@@ -1,8 +1,8 @@
 import 'zod-openapi/extend';
 import { array, number, object } from 'zod';
-import { stringDateTransformer } from './transformers/stringDateTransformer.js';
-import { stringNumberTransformer } from './transformers/stringNumberTransfromer.js';
-import { stringBooleanTransformer } from './transformers/stringBooleanTransformer.js';
+import { stringDateTransformer } from './transformers/stringDateTransformer';
+import { stringNumberTransformer } from './transformers/stringNumberTransfromer';
+import { stringBooleanTransformer } from './transformers/stringBooleanTransformer';
 export class ValidationUtils {
     strings = {
         datetime: stringDateTransformer,

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

@@ -0,0 +1 @@
+import 'zod-openapi/extend';

package/dist/services/ValidationUtils/ValidationUtils.test.js

@@ -0,0 +1,165 @@
+import 'zod-openapi/extend';
+import { describe, expect, test } from 'vitest';
+import { ValidationUtils } from './ValidationUtils';
+import { OpenApi } from '../../OpenApi';
+import z from 'zod';
+import { SampleRouteType } from '../../enums/SampleRouteType';
+import { Method } from '../../enums/Methods';
+import { TestUtils } from '../TestUtils/TestUtils';
+describe('ValidationUtils', () => {
+    const utils = new ValidationUtils();
+    const api = OpenApi.builder.defineGlobalConfig({
+        basePath: '/api',
+        skipDescriptionsCheck: true,
+    }).create();
+    describe('Transformers', () => {
+        test('Correctly parses numbers from query', async () => {
+            const route = api.factory.createRoute({
+                type: SampleRouteType.Public,
+                method: Method.GET,
+                path: '/number',
+                description: 'Some description',
+                validators: {
+                    query: z.object({
+                        number: utils.strings.number.openapi({ description: 'test' }),
+                    }).openapi({ description: 'response' }),
+                    response: z.number().openapi({ description: 'test' }),
+                },
+                handler: (ctx) => Promise.resolve(ctx.params.query.number),
+            });
+            api.addRoute(route);
+            const req = TestUtils.createRequest('/api/number?number=10');
+            const res = await api.processRootRoute(req);
+            expect(res.status).toBe(200);
+            expect(res.body).toBe(10);
+        });
+        test('Correctly parses Dates from query', async () => {
+            const route = api.factory.createRoute({
+                type: SampleRouteType.Public,
+                method: Method.GET,
+                path: '/date',
+                description: 'Some description',
+                validators: {
+                    query: z.object({
+                        date: utils.strings.datetime.openapi({ description: 'test' }),
+                    }).openapi({ description: 'response' }),
+                    response: z.date().openapi({ description: 'test' }),
+                },
+                handler: (ctx) => Promise.resolve(ctx.params.query.date),
+            });
+            api.addRoute(route);
+            const req = TestUtils.createRequest('/api/date?date=2025-07-03T08:28:26.268Z');
+            const res = await api.processRootRoute(req);
+            expect(res.status).toBe(200);
+            expect(z.date().safeParse(res.body).data?.toISOString()).toBe('2025-07-03T08:28:26.268Z');
+        });
+    });
+    describe('Validators', () => {
+        test('Paginated Query', async () => {
+            const route = api.factory.createRoute({
+                type: SampleRouteType.Public,
+                method: Method.GET,
+                path: '/paginatedQuery',
+                description: 'Some description',
+                validators: {
+                    query: utils.paginatedQuery({
+                        name: z.string(),
+                        date: utils.strings.datetime,
+                    }),
+                    response: z.object({
+                        name: z.string(),
+                        date: z.date(),
+                        page: z.number().optional(),
+                        pageSize: z.number().optional(),
+                    }).openapi({ description: 'test' }),
+                },
+                handler: (ctx) => Promise.resolve(ctx.params.query),
+            });
+            api.addRoute(route);
+            const req = TestUtils.createRequest('/api/paginatedQuery?name=hello&date=2025-07-03T08:28:26.268Z');
+            const res = await api.processRootRoute(req);
+            expect(res.status).toBe(200);
+            expect(res.body).toStrictEqual({
+                page: 1,
+                name: 'hello',
+                date: new Date('2025-07-03T08:28:26.268Z'),
+            });
+        });
+        test('Paginated Response', async () => {
+            const route = api.factory.createRoute({
+                type: SampleRouteType.Public,
+                method: Method.GET,
+                path: '/paginatedResponse',
+                description: 'Some description',
+                validators: {
+                    response: utils.paginatedResponse(z.object({
+                        name: z.string(),
+                    })),
+                },
+                handler: async () => {
+                    const res = {
+                        items: [{ name: 'John' }, { name: 'Snow' }],
+                        info: {
+                            count: 1000,
+                            page: 10,
+                            pageSize: 15,
+                        },
+                    };
+                    return res;
+                },
+            });
+            api.addRoute(route);
+            const req = TestUtils.createRequest('/api/paginatedResponse');
+            const res = await api.processRootRoute(req);
+            expect(res.status).toBe(200);
+            expect(res.body).toStrictEqual({
+                items: [{ name: 'John' }, { name: 'Snow' }],
+                info: {
+                    count: 1000,
+                    page: 10,
+                    pageSize: 15,
+                },
+            });
+        });
+        test('DescribeShape creates comprehensive descriptions for flat objects', async () => {
+            const api = OpenApi.builder.defineGlobalConfig({
+                basePath: '/api',
+                skipDescriptionsCheck: false,
+            }).create();
+            const validator = z.object({
+                name: z.string(),
+                age: z.number(),
+            }).openapi({ description: 'Test object' });
+            const route = api.factory.createRoute({
+                type: SampleRouteType.Public,
+                method: Method.GET,
+                path: '/test',
+                description: 'Test method',
+                validators: {
+                    response: validator,
+                },
+                handler: async () => ({ name: 'Alex', age: 20 }),
+            });
+            expect(() => {
+                api.addRoute(route);
+            }).toThrowError(new Error("Route 'GET:/test': responseValidator missing openapi description on field 'name'"));
+            const updatedValidator = api.validators.describeShape(validator, {
+                name: 'Name of the object',
+                age: 'Age of the object',
+            }).openapi({ description: 'something' });
+            const route2 = api.factory.createRoute({
+                type: SampleRouteType.Public,
+                method: Method.GET,
+                path: '/test',
+                description: 'Test method',
+                validators: {
+                    response: updatedValidator,
+                },
+                handler: async () => ({ name: 'Alex', age: 20 }),
+            });
+            expect(() => {
+                api.addRoute(route2);
+            }).not.toThrowError();
+        });
+    });
+});

package/dist/services/ValidationUtils/transformers/stringBooleanTransformer.test.d.ts

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

package/dist/services/ValidationUtils/transformers/stringBooleanTransformer.test.js

@@ -0,0 +1,19 @@
+import { describe, expect, test } from 'vitest';
+import { stringBooleanTransformer } from './stringBooleanTransformer';
+describe('stringBooleanTransformer', () => {
+    test('Can parse true', async () => {
+        const result = stringBooleanTransformer.safeParse('true');
+        expect(result.success).toBe(true);
+        expect(result.data).toBe(true);
+    });
+    test('Can parse false', async () => {
+        const result = stringBooleanTransformer.safeParse('true');
+        expect(result.success).toBe(true);
+        expect(result.data).toBe(true);
+    });
+    test('Fails on non booleans', async () => {
+        const result = stringBooleanTransformer.safeParse('');
+        expect(result.success).toBe(false);
+        expect(result.error?.errors[0]?.message).toContain('Invalid enum value');
+    });
+});

package/dist/services/ValidationUtils/transformers/stringDateTransformer.test.d.ts

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