snap-on-openapi 1.0.1

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

@@ -0,0 +1,15 @@
+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';
+export declare class ExpressWrapper<TRouteTypes extends string, TErrorCodes extends string, TConfig extends AnyConfig<TRouteTypes, TErrorCodes>> {
+    protected service: OpenApi<TRouteTypes, TErrorCodes, TConfig>;
+    protected developmentUtils: DevelopmentUtils;
+    protected schemaRoute: RoutePath;
+    constructor(openApi: OpenApi<TRouteTypes, TErrorCodes, TConfig>);
+    createStoplightRoute(route: RoutePath, expressApp: ExpressApp): void;
+    createSwaggerRoute(route: RoutePath, expressApp: ExpressApp): void;
+    createSchemaRoute(route: RoutePath, expressApp: ExpressApp): void;
+    createOpenApiRootRoute(expressApp: ExpressApp): void;
+}

package/dist/services/ExpressWrapper/ExpressWrapper.js

@@ -0,0 +1,68 @@
+import { format } from 'url';
+import { DevelopmentUtils } from '../DevelopmentUtils/DevelopmentUtils.js';
+export class ExpressWrapper {
+    service;
+    developmentUtils;
+    schemaRoute = '/openapi-schema';
+    constructor(openApi) {
+        this.service = openApi;
+        this.developmentUtils = new DevelopmentUtils();
+    }
+    createStoplightRoute(route, expressApp) {
+        const handler = async (req, res) => {
+            const body = this.developmentUtils.getStoplightHtml(this.schemaRoute);
+            res.status(200).header('Content-Type', 'text/html').send(body);
+        };
+        this.createSchemaRoute(this.schemaRoute, expressApp);
+        expressApp.get(route, handler);
+    }
+    createSwaggerRoute(route, expressApp) {
+        const handler = async (req, res) => {
+            const body = this.developmentUtils.getSwaggerHTML(this.schemaRoute);
+            res.status(200).header('Content-Type', 'text/html').send(body);
+        };
+        this.createSchemaRoute(this.schemaRoute, expressApp);
+        expressApp.get(route, handler);
+    }
+    createSchemaRoute(route, expressApp) {
+        const handler = async (req, res) => {
+            const body = this.service.schemaGenerator.getYaml();
+            res.status(200).header('Content-Type', 'text/html').send(body);
+        };
+        expressApp.get(route, handler);
+    }
+    createOpenApiRootRoute(expressApp) {
+        const route = this.service.getBasePath();
+        const headerToStr = (header) => {
+            if (Array.isArray(header)) {
+                return header.join(',');
+            }
+            return header;
+        };
+        const handler = async (req, res) => {
+            const emptyHeaders = {};
+            const headers = Object.entries(req.headers).reduce((acc, val) => ({
+                ...acc,
+                ...(typeof val[1] !== 'undefined' ? { [val[0]]: headerToStr(val[1]) } : {}),
+            }), emptyHeaders);
+            const url = format({
+                protocol: req.protocol,
+                host: req.host,
+                pathname: req.originalUrl,
+            });
+            const openApiRequest = new Request(url, {
+                body: req.body,
+                headers: headers,
+                method: req.method,
+            });
+            const result = await this.service.processRootRoute(openApiRequest);
+            res.status(result.status).header('Content-Type', 'application/json').json(result.body);
+        };
+        const regex = new RegExp(`${route}.*`);
+        expressApp.get(regex, handler);
+        expressApp.post(regex, handler);
+        expressApp.patch(regex, handler);
+        expressApp.delete(regex, handler);
+        expressApp.put(regex, handler);
+    }
+}

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

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

package/dist/services/ExpressWrapper/types/ExpressApp.js

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

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

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

package/dist/services/ExpressWrapper/types/ExpressHandler.js

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

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

@@ -0,0 +1,8 @@
+export interface ExpressRequest {
+    headers: Record<string, string | string[] | undefined>;
+    body: string;
+    method: string;
+    protocol: string;
+    originalUrl: string;
+    host: string;
+}

package/dist/services/ExpressWrapper/types/ExpressRequest.js

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

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

@@ -0,0 +1,6 @@
+export interface ExpressResponse {
+    header: (name: string, value: string) => ExpressResponse;
+    status: (code: number) => ExpressResponse;
+    json: (data: unknown) => ExpressResponse;
+    send: (body: string) => ExpressResponse;
+}

package/dist/services/ExpressWrapper/types/ExpressResponse.js

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

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

@@ -0,0 +1,15 @@
+import { LogLevel } from './types/LogLevel.js';
+export declare class Logger {
+    protected invoker: string;
+    static logLevel: LogLevel;
+    static showTime: boolean;
+    constructor(invoker: string, originalInvoker?: string);
+    info(message: string, data?: Record<string, unknown>): void;
+    debug(message: string, data?: object): void;
+    error(message: string | null, error: unknown, data?: object): void;
+    getInvoker(): string;
+    static setLogLevel(level: LogLevel): void;
+    protected log(message: string, level: string, data?: object): void;
+    protected transformData(data: object): unknown;
+    protected removeCircularity(data: object): unknown;
+}

package/dist/services/Logger/Logger.js

@@ -0,0 +1,100 @@
+import { LogLevel } from './types/LogLevel.js';
+export class Logger {
+    invoker;
+    static logLevel = LogLevel.all;
+    static showTime = true;
+    constructor(invoker, originalInvoker) {
+        this.invoker = (originalInvoker ? `${originalInvoker}:` : '') + invoker;
+    }
+    info(message, data) {
+        if (Logger.logLevel === LogLevel.error) {
+            return;
+        }
+        this.log(message, 'info', data);
+    }
+    debug(message, data) {
+        if (Logger.logLevel !== LogLevel.all) {
+            return;
+        }
+        this.log(message, 'debug', data);
+    }
+    error(message, error, data) {
+        let newMessage = 'UnkownError: ';
+        if (!message) {
+            if (error instanceof Error) {
+                newMessage = error.message;
+            }
+        }
+        else {
+            newMessage = message;
+        }
+        this.log(newMessage, 'error', data);
+        console.log(error);
+    }
+    getInvoker() {
+        return this.invoker;
+    }
+    static setLogLevel(level) {
+        this.logLevel = level;
+    }
+    log(message, level, data) {
+        const now = new Date();
+        const timePart = Logger.showTime ? now.toISOString() : '';
+        const msg = `${timePart}[${level}][${this.invoker}]: ${message}`;
+        console.log(msg);
+        if (data) {
+            console.dir(this.transformData(data), { depth: null });
+        }
+    }
+    transformData(data) {
+        const plain = this.removeCircularity(data);
+        return plain;
+    }
+    removeCircularity(data) {
+        if (typeof data !== 'object') {
+            return data;
+        }
+        const seen = new Set();
+        const recurse = (obj, path = []) => {
+            if (Array.isArray(obj)) {
+                const result = [];
+                let index = -1;
+                for (const val of obj) {
+                    index++;
+                    if (typeof val === 'object' && val) {
+                        if (seen.has(val)) {
+                            result.push('circular->' + path.join('.'));
+                            continue;
+                        }
+                        seen.add(val);
+                        const newPath = [...path, index.toString()];
+                        result.push(recurse(val, newPath));
+                        continue;
+                    }
+                    result.push(val);
+                }
+                return result;
+            }
+            if (obj instanceof Date) {
+                return obj;
+            }
+            const result = {};
+            for (const key of Object.keys(obj)) {
+                if (typeof obj[key] === 'object' && obj[key]) {
+                    if (seen.has(obj[key])) {
+                        result[key] = 'circular->' + path.join('.');
+                        continue;
+                    }
+                    seen.add(obj[key]);
+                    const newPath = [...path, key];
+                    result[key] = recurse(obj[key], newPath);
+                    continue;
+                }
+                result[key] = obj[key];
+            }
+            return result;
+        };
+        const result = recurse(data);
+        return result;
+    }
+}

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

@@ -0,0 +1,6 @@
+export declare enum LogLevel {
+    all = "all",
+    info = "info",
+    warn = "warn",
+    error = "error"
+}

package/dist/services/Logger/types/LogLevel.js

@@ -0,0 +1,7 @@
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel["all"] = "all";
+    LogLevel["info"] = "info";
+    LogLevel["warn"] = "warn";
+    LogLevel["error"] = "error";
+})(LogLevel || (LogLevel = {}));

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

@@ -0,0 +1,10 @@
+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';
+export declare class RoutingFactory<TRouteTypes extends string, TErrorCodes extends string, TConfig extends AnyConfig<TRouteTypes, TErrorCodes>> {
+    protected map: TConfig;
+    constructor(map: TConfig);
+    createRoute<TType extends TRouteTypes, TMethod extends Method, TResponseValidator extends ZodFirstPartySchemaTypes, TQueryValidator extends ZodObject<ZodRawShape> | undefined = undefined, TPathValidator extends ZodObject<ZodRawShape> | undefined = undefined, TBodyValidator extends ZodObject<ZodRawShape> | undefined = undefined>(params: Route<TType, Awaited<ReturnType<TConfig['routes'][TType]['contextFactory']>>, TResponseValidator, TPathValidator, TQueryValidator, TBodyValidator, TMethod> & (RouteExtraProps<TConfig['routes'][TType]['extraProps']>)): Route<TType, Awaited<ReturnType<TConfig['routes'][TType]['contextFactory']>>, TResponseValidator, TPathValidator, TQueryValidator, TBodyValidator>;
+}

package/dist/services/RoutingFactory/RoutingFactory.js

@@ -0,0 +1,23 @@
+export class RoutingFactory {
+    map;
+    constructor(map) {
+        this.map = map;
+    }
+    createRoute(params) {
+        const result = {
+            ...params,
+            method: params.method,
+            type: params.type,
+            path: params.path,
+            description: params.description,
+            validators: {
+                query: params.validators.query,
+                path: params.validators.path,
+                response: params.validators.response,
+                body: params.validators.body,
+            },
+            handler: params.handler,
+        };
+        return result;
+    }
+}

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

@@ -0,0 +1,19 @@
+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';
+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[]);
+    getYaml(): string;
+    saveYaml(path: string): void;
+    protected createDocument(): ReturnType<typeof createDocument>;
+    protected createOperation(route: AnyRoute<TRouteTypes>): ZodOpenApiOperationObject;
+}

package/dist/services/SchemaGenerator/SchemaGenerator.js

@@ -0,0 +1,131 @@
+import 'zod-openapi/extend';
+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';
+export class SchemaGenerator {
+    logger;
+    info;
+    routes;
+    servers;
+    routeSpec;
+    constructor(invoker, info, spec, routes, servers) {
+        this.logger = new Logger(SchemaGenerator.name, invoker);
+        this.routes = routes;
+        this.routeSpec = spec;
+        this.servers = servers;
+        this.info = info;
+    }
+    getYaml() {
+        const document = this.createDocument();
+        const yaml = stringify(document, { aliasDuplicateObjects: false });
+        return yaml;
+    }
+    saveYaml(path) {
+        this.logger.info('Generating YAML for Open API');
+        const yaml = this.getYaml();
+        writeFileSync(path, yaml);
+    }
+    createDocument() {
+        const openApi = {
+            openapi: '3.1.0',
+            info: this.info,
+            components: {
+                securitySchemes: {
+                    bearerHttpAuthentication: {
+                        type: 'apiKey',
+                        scheme: 'bearer',
+                        bearerFormat: 'jwt',
+                        name: 'authorization',
+                        in: 'header',
+                    },
+                },
+            },
+            paths: {},
+            servers: this.servers,
+        };
+        const paths = {};
+        for (const route of this.routes) {
+            const operation = this.createOperation(route);
+            const existingPath = paths[route.path] ?? {};
+            paths[route.path] = {
+                ...existingPath,
+                [route.method.toLowerCase()]: operation,
+            };
+        }
+        openApi.paths = paths;
+        const document = createDocument(openApi, {
+            unionOneOf: true,
+            defaultDateSchema: {
+                type: 'string', format: 'date-time',
+            },
+        });
+        return document;
+    }
+    createOperation(route) {
+        const requestParams = {
+            query: route.validators.query,
+            path: route.validators.path,
+        };
+        const operation = {
+            requestParams: requestParams,
+            description: route.description,
+            responses: {
+                200: {
+                    description: 'Good Response',
+                    content: {
+                        'application/json': { schema: route.validators.response },
+                    },
+                },
+            },
+        };
+        const enabledErrors = Object.keys(this.routeSpec.routes[route.type].errors ?? {});
+        if (!enabledErrors.find((x) => x === this.routeSpec.defaultError.code)) {
+            enabledErrors.push(this.routeSpec.defaultError.code);
+        }
+        const httpStatusMap = new Map();
+        for (const [key, error] of Object.entries(this.routeSpec.errors)) {
+            const errorConfig = error;
+            if (!enabledErrors.includes(key)) {
+                continue;
+            }
+            const errors = httpStatusMap.get(errorConfig.status) ?? [];
+            errors.push(errorConfig);
+            httpStatusMap.set(errorConfig.status, errors);
+        }
+        for (const [code, errors] of httpStatusMap.entries()) {
+            const error = errors[0];
+            if (!error) {
+                throw new Error(`No errors found for code '${code}'`);
+            }
+            const description = errors.map((x) => x.description).join(' or ');
+            const validators = errors.map((x) => x.responseValidator);
+            const schema = errors.length === 1 ? error.responseValidator : z.union(validators).openapi({ unionOneOf: true });
+            operation.responses[error.status] = {
+                description: description,
+                content: {
+                    'application/json': {
+                        schema: schema,
+                    },
+                },
+            };
+        }
+        if (this.routeSpec.routes[route.type].authorization) {
+            operation.security = [
+                {
+                    bearerHttpAuthentication: [],
+                },
+            ];
+        }
+        if (route.method !== Method.GET) {
+            operation.requestBody = {
+                content: {
+                    'application/json': { schema: route.validators.body },
+                },
+            };
+        }
+        return operation;
+    }
+}

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

@@ -0,0 +1,35 @@
+import { OpenApi } from '../../OpenApi.js';
+import { AnyConfig } from '../../types/config/AnyConfig.js';
+import { RoutePath } from '../../types/RoutePath.js';
+import { DevelopmentUtils } from '../DevelopmentUtils/DevelopmentUtils.js';
+export declare class TanstackStartWrapper<TRouteTypes extends string, TErrorCodes extends string, TConfig extends AnyConfig<TRouteTypes, TErrorCodes>> {
+    protected service: OpenApi<TRouteTypes, TErrorCodes, TConfig>;
+    protected developmentUtils: DevelopmentUtils;
+    constructor(openApi: OpenApi<TRouteTypes, TErrorCodes, TConfig>);
+    createShemaMethods(): {
+        GET: () => Promise<Response>;
+    };
+    createStoplightMethods(schemaRoutePath: RoutePath): {
+        GET: () => Promise<Response>;
+    };
+    createSwaggerMethods(schemaRoutePath: RoutePath): {
+        GET: () => Promise<Response>;
+    };
+    getOpenApiRootMethods(): {
+        GET: (ctx: {
+            request: Request;
+        }) => Promise<Response>;
+        POST: (ctx: {
+            request: Request;
+        }) => Promise<Response>;
+        PATCH: (ctx: {
+            request: Request;
+        }) => Promise<Response>;
+        PUT: (ctx: {
+            request: Request;
+        }) => Promise<Response>;
+        DELETE: (ctx: {
+            request: Request;
+        }) => Promise<Response>;
+    };
+}

package/dist/services/TanstackStartWrapper/TanstackStartWrapper.js

@@ -0,0 +1,67 @@
+import { DevelopmentUtils } from '../DevelopmentUtils/DevelopmentUtils.js';
+export class TanstackStartWrapper {
+    service;
+    developmentUtils;
+    constructor(openApi) {
+        this.service = openApi;
+        this.developmentUtils = new DevelopmentUtils();
+    }
+    createShemaMethods() {
+        const processor = async () => {
+            const body = this.service.schemaGenerator.getYaml();
+            const res = new Response(body, {
+                headers: {
+                    'Content-Type': 'text/html',
+                },
+            });
+            return res;
+        };
+        return {
+            GET: processor,
+        };
+    }
+    createStoplightMethods(schemaRoutePath) {
+        const processor = async () => {
+            const body = this.developmentUtils.getStoplightHtml(schemaRoutePath);
+            const res = new Response(body, {
+                headers: {
+                    'Content-Type': 'text/html',
+                },
+            });
+            return res;
+        };
+        return {
+            GET: processor,
+        };
+    }
+    createSwaggerMethods(schemaRoutePath) {
+        const processor = async () => {
+            const body = this.developmentUtils.getSwaggerHTML(schemaRoutePath);
+            const res = new Response(body, {
+                headers: {
+                    'Content-Type': 'text/html',
+                },
+            });
+            return res;
+        };
+        return {
+            GET: processor,
+        };
+    }
+    getOpenApiRootMethods() {
+        const processor = async (ctx) => {
+            const response = await this.service.processRootRoute(ctx.request);
+            const res = new Response(JSON.stringify(response.body), {
+                status: response.status,
+            });
+            return res;
+        };
+        return {
+            GET: processor,
+            POST: processor,
+            PATCH: processor,
+            PUT: processor,
+            DELETE: processor,
+        };
+    }
+}

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

@@ -0,0 +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';
+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 awaitGeneric<T>(timeoutMs: number, intervalMs: number, callback: () => Promise<T | null>): Promise<T | null>;
+}

package/dist/services/TestUtils/TestUtils.js

@@ -0,0 +1,48 @@
+import z from 'zod';
+import { OpenApi } from '../../OpenApi.js';
+import { Method } from '../../enums/Methods.js';
+import { SampleRouteType } from '../../enums/SampleRouteType.js';
+export class TestUtils {
+    static createRequest(route, method = Method.GET, body) {
+        const request = new Request(`http://localhost${route}`, {
+            method: method,
+            body: JSON.stringify(body),
+        });
+        return request;
+    }
+    static sendRequest(api, route, method = Method.GET, body) {
+        const req = this.createRequest(route, method, body);
+        return api.processRootRoute(req);
+    }
+    static createOpenApi() {
+        const api = OpenApi.builder.create();
+        const sampleRoute = api.factory.createRoute({
+            type: SampleRouteType.Public,
+            method: Method.GET,
+            path: '/sample',
+            description: 'Sample route',
+            validators: {
+                response: z.string().openapi({ description: 'Sample response' }),
+            },
+            handler: () => Promise.resolve('success'),
+        });
+        api.addRoute(sampleRoute);
+        return api;
+    }
+    static async awaitGeneric(timeoutMs, intervalMs, callback) {
+        let now = new Date().getTime();
+        const deadline = now + timeoutMs;
+        let counter = 1;
+        do {
+            const left = (deadline - now) / 1000;
+            console.log(`Iteration ${counter++}: ${left} sec. left`);
+            const result = await callback();
+            if (result !== null) {
+                return result;
+            }
+            await new Promise((resolve) => setTimeout(resolve, intervalMs));
+            now = new Date().getTime();
+        } while (now < deadline);
+        return null;
+    }
+}