snap-on-openapi 1.0.2 → 1.0.4

package/dist/services/DescriptionChecker/DescriptionChecker.test.js

@@ -0,0 +1,120 @@
+import { describe } from 'node:test';
+import { expect, test } from 'vitest';
+import { TestUtils } from '../TestUtils/TestUtils';
+import { SampleRouteType } from '../../enums/SampleRouteType';
+import { Method } from '../../enums/Methods';
+import z from 'zod';
+describe('DescriptionChecker', () => {
+    test('Checks route descriptions', async ({ expect }) => {
+        const api = TestUtils.createOpenApi();
+        const route = api.factory.createRoute({
+            type: SampleRouteType.Public,
+            method: Method.GET,
+            path: '/something',
+            description: '',
+            validators: {
+                response: z.string().openapi({ description: 'Testing' }),
+            },
+            handler: () => Promise.resolve('Something'),
+        });
+        expect(() => {
+            api.addRoute(route);
+        }).toThrowError(new Error('Description for /something is missing or too small'));
+        route.description = 'Testing route description';
+        expect(() => {
+            api.addRoute(route);
+        }).not.toThrowError();
+    });
+    test('Checks response validator descriptions', async ({ expect }) => {
+        const api = TestUtils.createOpenApi();
+        const route = api.factory.createRoute({
+            type: SampleRouteType.Public,
+            method: Method.GET,
+            path: '/something',
+            description: 'Testing route description',
+            validators: {
+                response: z.string(),
+            },
+            handler: () => Promise.resolve('Something'),
+        });
+        expect(() => {
+            api.addRoute(route);
+        }).toThrowError(new Error("Route 'GET:/something': responseValidator missing openapi description on field 'responseValidator'"));
+        route.validators.response = route.validators.response.openapi({ description: 'Something useful' });
+        expect(() => {
+            api.addRoute(route);
+        }).not.toThrowError();
+    });
+    test('Checks body validator descriptions', async ({ expect }) => {
+        const api = TestUtils.createOpenApi();
+        const route = api.factory.createRoute({
+            type: SampleRouteType.Public,
+            method: Method.POST,
+            path: '/something',
+            description: 'Testing route description',
+            validators: {
+                response: z.string().openapi({ description: 'Test description' }),
+                body: z.object({
+                    name: z.string(),
+                }),
+            },
+            handler: () => Promise.resolve('Something'),
+        });
+        expect(() => {
+            api.addRoute(route);
+        }).toThrowError(new Error("Route 'POST:/something': bodyValidator missing openapi description on field 'name'"));
+        const route2 = api.factory.createRoute({
+            type: SampleRouteType.Public,
+            method: Method.POST,
+            path: '/something',
+            description: 'Testing route description',
+            validators: {
+                response: z.string().openapi({ description: 'Test description' }),
+                body: z.object({
+                    name: z.string().openapi({ description: 'Name' }),
+                }),
+            },
+            handler: () => Promise.resolve('Something'),
+        });
+        expect(() => {
+            api.addRoute(route2);
+        }).not.toThrowError();
+    });
+    test('Checks validator descriptions in array items', async () => {
+        const api = TestUtils.createOpenApi();
+        const route = api.factory.createRoute({
+            type: SampleRouteType.Public,
+            method: Method.POST,
+            path: '/something',
+            description: 'Testing route description',
+            validators: {
+                response: z.object({
+                    items: z.array(z.object({
+                        name: z.string(),
+                    })).openapi({ description: 'Items of array' }),
+                }).openapi({ description: 'Test response' }),
+            },
+            handler: () => Promise.resolve({ items: [{ name: 'Something' }] }),
+        });
+        expect(() => {
+            api.addRoute(route);
+        }).toThrowError(new Error("Route 'POST:/something': responseValidator missing openapi description on field 'name'"));
+        const route2 = api.factory.createRoute({
+            type: SampleRouteType.Public,
+            method: Method.POST,
+            path: '/something',
+            description: 'Testing route description',
+            validators: {
+                response: z.object({
+                    items: z.array(z.object({
+                        name: z.string().openapi({ description: 'Name of item' }),
+                    })).openapi({ description: 'Items of array' }),
+                }).openapi({ description: 'Test response' }),
+            },
+            handler: () => Promise.resolve({ items: [{ name: 'Something' }] }),
+        });
+        expect(() => {
+            api.addRoute(route2);
+        }).not.toThrowError();
+    });
+});

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

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

package/dist/services/DevelopmentUtils/DevelopmentUtils.test.js

@@ -0,0 +1,10 @@
+import { expect, test } from 'vitest';
+import { DevelopmentUtils } from './DevelopmentUtils';
+import { describe } from 'node:test';
+describe('Development Utils', () => {
+    test('Swagger HTML returned correctly', () => {
+        const utils = new DevelopmentUtils();
+        const html = utils.getSwaggerHTML('/test');
+        expect(html).toContain('SwaggerUIBundle');
+    });
+});

package/dist/services/ExpressWrapper/ExpressWrapper.d.ts

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

package/dist/services/ExpressWrapper/ExpressWrapper.js

@@ -1,5 +1,5 @@
 import { format } from 'url';
-import { DevelopmentUtils } from '../DevelopmentUtils/DevelopmentUtils.js';
+import { DevelopmentUtils } from '../DevelopmentUtils/DevelopmentUtils';
 export class ExpressWrapper {
     service;
     developmentUtils;

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

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

package/dist/services/ExpressWrapper/ExpressWrapper.test.js

@@ -0,0 +1,136 @@
+import { describe, expect, test } from 'vitest';
+import express from 'express';
+import supertest from 'supertest';
+import { TestUtils } from '../TestUtils/TestUtils';
+import { ErrorCode } from '../../enums/ErrorCode';
+import z from 'zod';
+import { Method } from '../../enums/Methods';
+import { SampleRouteType } from '../../enums/SampleRouteType';
+import { OpenApi } from '../../OpenApi';
+describe('ExpressWrapper', () => {
+    test('Can mount the api correctly', async () => {
+        const api = TestUtils.createOpenApi();
+        const app = express();
+        api.wrappers.express.createOpenApiRootRoute(app);
+        const errResponse = await supertest(app).get('/api');
+        expect(errResponse.status, 'Should be 404 on unknown route').toBe(404);
+        expect(errResponse.body, 'Should be error on unknown route').toEqual({ error: ErrorCode.NotFound });
+        const goodResponse = await supertest(app).get('/api/sample');
+        expect(goodResponse.status, 'Should be 200 on sample route').toBe(200);
+        expect(goodResponse.body, "Should be body 'success'").toEqual('success');
+    });
+    test('Can mount swagger routes correctly', async () => {
+        const api = TestUtils.createOpenApi();
+        const app = express();
+        api.wrappers.express.createSwaggerRoute('/swagger', app);
+        const goodResponse = await supertest(app).get('/swagger');
+        expect(goodResponse.status, 'Should be 200 on swagger route').toBe(200);
+        expect(goodResponse.text, 'Swagger UI pieces should be in HTML').toContain('swagger-ui');
+        expect(goodResponse.text, 'Default schema path should be present').toContain('/openapi-schema');
+    });
+    test('Can mount stoplight routes correctly', async () => {
+        const api = TestUtils.createOpenApi();
+        const app = express();
+        api.wrappers.express.createStoplightRoute('/light', app);
+        const goodResponse = await supertest(app).get('/light');
+        expect(goodResponse.status, 'Should be 200 on stoplight route').toBe(200);
+        expect(goodResponse.text, 'Stoplight UI pieces should be in HTML').toContain('@stoplight');
+        expect(goodResponse.text, 'Default schema path should be present').toContain('/openapi-schema');
+    });
+    test('Can mount schema routes correctly', async () => {
+        const api = TestUtils.createOpenApi();
+        const app = express();
+        api.wrappers.express.createSchemaRoute('/schema', app);
+        const goodResponse = await supertest(app).get('/schema');
+        expect(goodResponse.status, 'Should be 200 on schema route').toBe(200);
+        expect(goodResponse.text, 'Response should contain pieces of openapi schema').toContain('Sample route');
+    });
+    test('Can mount stoplight routes correctly', async () => {
+        const api = TestUtils.createOpenApi();
+        const app = express();
+        api.wrappers.express.createStoplightRoute('/light', app);
+        const goodResponse = await supertest(app).get('/light');
+        expect(goodResponse.status, 'Should be 200 on stoplight route').toBe(200);
+        expect(goodResponse.text, 'Stoplight UI pieces should be in HTML').toContain('@stoplight');
+        expect(goodResponse.text, 'Default schema path should be present').toContain('/openapi-schema');
+    });
+    test('Works correctly with array header values', async () => {
+        class ExpressAppMock {
+            handler;
+            post(route, handler) {
+                this.handler = handler;
+            }
+            ;
+            get = () => { };
+            delete = () => { };
+            put = () => { };
+            patch = () => { };
+            async test(req) {
+                let body;
+                let status = 0;
+                const res = {
+                    header: function () {
+                        return this;
+                    },
+                    status: function (code) {
+                        status = code;
+                        return this;
+                    },
+                    json: function (data) {
+                        body = data;
+                        return this;
+                    },
+                    send: function () {
+                        return this;
+                    },
+                };
+                if (!this.handler) {
+                    throw new Error("Handler wasn't set");
+                }
+                await this.handler(req, res);
+                return { status, body };
+            }
+        }
+        ;
+        const appMock = new ExpressAppMock();
+        const api = OpenApi.builder
+            .customizeRoutes(SampleRouteType)
+            .defineRouteContexts({
+            [SampleRouteType.Public]: (ctx) => Promise.resolve({
+                authorization: ctx.request.headers.get('Authorization'),
+            }),
+        })
+            .defineRoutes({
+            [SampleRouteType.Public]: {
+                authorization: true,
+            },
+        })
+            .create();
+        api.wrappers.express.createOpenApiRootRoute(appMock);
+        const route = api.factory.createRoute({
+            type: SampleRouteType.Public,
+            method: Method.POST,
+            path: '/test-multi-headers',
+            description: 'Multiheader test route',
+            validators: {
+                response: z.unknown().nullable().openapi({ description: 'Authorization header' }),
+            },
+            handler: (ctx) => Promise.resolve(ctx.authorization),
+        });
+        api.addRoute(route);
+        const req = {
+            headers: {
+                Authorization: ['Bearer1', 'Bearer2'],
+                ContentType: undefined,
+            },
+            body: '',
+            method: 'POST',
+            protocol: '',
+            originalUrl: '/api/test-multi-headers',
+            host: 'http://localhost',
+        };
+        const goodResponse = await appMock.test(req);
+        expect(goodResponse.status, 'Should be 200 on sample route').toBe(200);
+        expect(goodResponse.body, 'Route should return both headers').toBe('Bearer1,Bearer2');
+    });
+});

package/dist/services/ExpressWrapper/types/ExpressApp.d.ts

@@ -1,4 +1,4 @@
-import { ExpressHandler } from './ExpressHandler.js';
+import { ExpressHandler } from './ExpressHandler';
 export interface ExpressApp {
     get: (route: string | RegExp, handler: ExpressHandler) => void;
     post: (route: string | RegExp, handler: ExpressHandler) => void;

package/dist/services/ExpressWrapper/types/ExpressHandler.d.ts

@@ -1,3 +1,3 @@
-import { ExpressRequest } from './ExpressRequest.js';
-import { ExpressResponse } from './ExpressResponse.js';
+import { ExpressRequest } from './ExpressRequest';
+import { ExpressResponse } from './ExpressResponse';
 export type ExpressHandler = (req: ExpressRequest, res: ExpressResponse) => void | Promise<void>;

package/dist/services/Logger/Logger.d.ts

@@ -1,4 +1,4 @@
-import { LogLevel } from './types/LogLevel.js';
+import { LogLevel } from './types/LogLevel';
 export declare class Logger {
     protected invoker: string;
     static logLevel: LogLevel;

package/dist/services/Logger/Logger.js

@@ -1,4 +1,4 @@
-import { LogLevel } from './types/LogLevel.js';
+import { LogLevel } from './types/LogLevel';
 export class Logger {
     invoker;
     static logLevel = LogLevel.all;

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

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

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,10 +1,10 @@
 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;

package/dist/services/SchemaGenerator/SchemaGenerator.js

@@ -3,7 +3,7 @@ import { writeFileSync } from 'fs';
 import { stringify } from 'yaml';
 import { createDocument } from 'zod-openapi';
 import { z } from 'zod';
-import { Method } from '../../enums/Methods.js';
+import { Method } from '../../enums/Methods';
 export class SchemaGenerator {
     logger;
     info;

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