snap-on-openapi 1.0.1

package/dist/OpenApi.d.ts

@@ -0,0 +1,58 @@
+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 z from 'zod';
+export declare class OpenApi<TRouteTypes extends string, TErrorCodes extends string, TConfig extends AnyConfig<TRouteTypes, TErrorCodes>> {
+    static readonly builder: InitialBuilder;
+    readonly validators: ValidationUtils;
+    readonly factory: RoutingFactory<TRouteTypes, TErrorCodes, TConfig>;
+    readonly schemaGenerator: SchemaGenerator<TRouteTypes, TErrorCodes, TConfig>;
+    readonly clientGenerator: ClientGenerator<TRouteTypes, TErrorCodes, TConfig>;
+    readonly wrappers: Wrappers<TRouteTypes, TErrorCodes, TConfig>;
+    protected routes: AnyRoute<TRouteTypes>[];
+    protected logger: Logger;
+    protected basePath: RoutePath;
+    protected developmentUtils: DevelopmentUtils;
+    protected config: TConfig;
+    protected descriptionChecker: DescriptionChecker;
+    protected servers: Server[];
+    protected constructor(config: TConfig);
+    getConfig(): TConfig;
+    getBasePath(): RoutePath;
+    getServers(): Server[];
+    addRoute(route: AnyRoute<TRouteTypes>): void;
+    addRoutes(pathExtension: RoutePath, routes: AnyRoute<TRouteTypes>[]): void;
+    addRouteMap(routeMap: RouteMap<TRouteTypes>): void;
+    mergePaths(...paths: RoutePath[]): RoutePath;
+    addServer(url: string, description: string): void;
+    protected getRouteForPath(path: string, method: string): AnyRoute<TRouteTypes> | null;
+    processRootRoute(originalReq: Request): Promise<{
+        status: number;
+        body: unknown;
+    }>;
+    protected handleError(e: unknown): {
+        status: number;
+        body: z.TypeOf<import("./index.js").OpenApiErrorConfigMap<TErrorCodes>[TErrorCodes]["responseValidator"]>;
+    };
+    protected static getBuilder(): ConfigBuilder<SampleRouteType, ErrorCode, DefaultErrorMap, DefaultRouteParamsMap, DefaultRouteContextMap, DefaultRouteMap, DefaultConfig>;
+}

package/dist/OpenApi.js

@@ -0,0 +1,272 @@
+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 z from 'zod';
+export class OpenApi {
+    static builder = OpenApi.getBuilder();
+    validators = new ValidationUtils();
+    factory;
+    schemaGenerator;
+    clientGenerator = new ClientGenerator(this);
+    wrappers;
+    routes = [];
+    logger;
+    basePath;
+    developmentUtils;
+    config;
+    descriptionChecker;
+    servers = [];
+    constructor(config) {
+        this.config = config;
+        this.logger = new Logger('OpenAPI');
+        if (config.logLevel) {
+            Logger.logLevel = config.logLevel;
+        }
+        this.descriptionChecker = new DescriptionChecker({
+            checkValidators: !config.skipDescriptionsCheck,
+        });
+        this.developmentUtils = new DevelopmentUtils();
+        this.factory = new RoutingFactory(config);
+        this.basePath = config.basePath;
+        const info = {
+            title: config.apiName ?? 'My API',
+            version: '3.1.0',
+        };
+        this.schemaGenerator = new SchemaGenerator(this.logger.getInvoker(), info, this.config, this.routes, this.servers);
+        this.wrappers = {
+            tanstackStart: new TanstackStartWrapper(this),
+            express: new ExpressWrapper(this),
+        };
+        this.servers.push({
+            description: 'Local',
+            url: this.basePath,
+        });
+        const servers = this.config.servers ?? [];
+        this.servers.push(...servers);
+    }
+    getConfig() {
+        return this.config;
+    }
+    getBasePath() {
+        return this.basePath;
+    }
+    getServers() {
+        return this.servers;
+    }
+    addRoute(route) {
+        if (!this.config.skipDescriptionsCheck) {
+            this.descriptionChecker.checkRoutes([route]);
+        }
+        this.routes.push(route);
+    }
+    addRoutes(pathExtension, routes) {
+        const newRoutes = routes.map((x) => ({
+            ...x,
+            path: this.mergePaths(pathExtension, x.path),
+        }));
+        if (!this.config.skipDescriptionsCheck) {
+            this.descriptionChecker.checkRoutes(newRoutes);
+        }
+        this.routes.push(...newRoutes);
+    }
+    addRouteMap(routeMap) {
+        for (const [path, routes] of Object.entries(routeMap)) {
+            this.addRoutes(path, routes);
+        }
+    }
+    mergePaths(...paths) {
+        let final = '/';
+        for (const path of paths) {
+            if (path === '/') {
+                continue;
+            }
+            if (final === '/') {
+                final = path;
+                continue;
+            }
+            final = `${final}${path}`;
+        }
+        return final;
+    }
+    addServer(url, description) {
+        this.servers.push({ description, url });
+    }
+    getRouteForPath(path, method) {
+        const fittingRoutes = [];
+        outer: for (const route of this.routes) {
+            if (route.method === method) {
+                fittingRoutes.push(route);
+                const routeParts = route.path.split('/').filter((x) => x !== '');
+                const pathParts = path.split('/').filter((x) => x !== '');
+                if (routeParts.length !== pathParts.length) {
+                    continue;
+                }
+                for (const [i, chunk] of routeParts.entries()) {
+                    if (chunk.includes('{')) {
+                        continue;
+                    }
+                    if (chunk !== pathParts[i]) {
+                        continue outer;
+                    }
+                }
+                return route;
+            }
+        }
+        return null;
+    }
+    async processRootRoute(originalReq) {
+        try {
+            const url = new URL(originalReq.url);
+            const urlPath = url.pathname.replace(this.getBasePath(), '');
+            const route = this.getRouteForPath(urlPath, originalReq.method);
+            if (!route) {
+                this.logger.info(`Route for ${originalReq.method}:${urlPath} not found`);
+                throw new BuiltInError(ErrorCode.NotFound);
+            }
+            const pathParams = {};
+            const routeParts = route.path.split('/');
+            const pathParts = urlPath.split('/');
+            for (const [i, chunk] of routeParts.entries()) {
+                if (chunk.startsWith('{') && chunk.endsWith('}')) {
+                    const name = chunk.slice(1, chunk.length - 1);
+                    if (!pathParts[i]) {
+                        throw new Error(`Can't find '${name}' param in path`);
+                    }
+                    pathParams[name] = pathParts[i];
+                    continue;
+                }
+            }
+            let body = {};
+            try {
+                body = await originalReq.json();
+            }
+            catch {
+            }
+            const reqQuery = {};
+            const queryEntries = url.searchParams.entries();
+            for (const [key, val] of queryEntries) {
+                if (reqQuery[key] !== undefined) {
+                    if (Array.isArray(reqQuery[key])) {
+                        reqQuery[key].push(val);
+                        continue;
+                    }
+                    reqQuery[key] = [reqQuery[key], val];
+                    continue;
+                }
+                reqQuery[key] = val;
+            }
+            const req = {
+                path: urlPath,
+                method: originalReq.method,
+                params: pathParams,
+                query: reqQuery,
+                body: body,
+            };
+            this.logger.info(`Calling route ${route.path}`);
+            this.logger.info(`${req.method}: ${req.path}`, {
+                params: req.params,
+                query: req.query,
+                body: req.body,
+            });
+            const queryValidator = route.validators.query?.strict() ?? z.object({});
+            const query = queryValidator.safeParse(req.query);
+            if (!query.success) {
+                throw new ValidationError(query.error, ValidationLocation.Query);
+            }
+            const pathvalidator = route.validators.path?.strict() ?? z.object({});
+            const path = pathvalidator.safeParse(req.params);
+            if (!path.success) {
+                throw new ValidationError(path.error, ValidationLocation.Path);
+            }
+            let response;
+            const containsBody = route.method !== Method.GET;
+            if (containsBody && route.validators.body) {
+                const body = route.validators.body.strict().safeParse(req.body);
+                if (!body.success) {
+                    throw new ValidationError(body.error, ValidationLocation.Body);
+                }
+                const context = await this.config.routes[route.type].contextFactory({
+                    route: route,
+                    request: originalReq,
+                    params: {
+                        query: query.data,
+                        path: path.data,
+                        body: body.data,
+                    },
+                });
+                response = await route.handler({
+                    ...context,
+                    params: {
+                        query: query.data,
+                        path: path.data,
+                        body: body.data,
+                    },
+                });
+            }
+            else {
+                const context = await this.config.routes[route.type].contextFactory({
+                    route: route,
+                    request: originalReq,
+                    params: {
+                        query: query.data,
+                        path: path.data,
+                        body: {},
+                    },
+                });
+                response = await route.handler({
+                    ...context,
+                    params: {
+                        query: query.data,
+                        path: path.data,
+                        body: {},
+                    }
+                });
+            }
+            const validated = route.validators.response.safeParse(response);
+            if (!validated.success) {
+                throw new ValidationError(validated.error, ValidationLocation.Response);
+            }
+            this.logger.info('Response: 200', validated.data);
+            return { status: 200, body: validated.data };
+        }
+        catch (e) {
+            return this.handleError(e);
+        }
+    }
+    handleError(e) {
+        this.logger.error('Error during request openAPI route handling', e);
+        try {
+            const response = this.config.handleError ? this.config.handleError(e) : this.config.defaultError;
+            const status = this.config.errors[response.code].status;
+            const valid = this.config.errors[response.code].responseValidator.safeParse(response.body);
+            if (!valid.success) {
+                throw new Error("Error response haven't passed validation");
+            }
+            this.logger.info(`Response: '${status}'`, response.body);
+            return { status: Number(status), body: response.body };
+        }
+        catch (e) {
+            this.logger.error('Error during error handling', e);
+            const status = this.config.errors[this.config.defaultError.code].status;
+            return { status: Number(status), body: this.config.defaultError.body };
+        }
+    }
+    static getBuilder() {
+        return new ConfigBuilder((conf) => {
+            return new OpenApi(conf);
+        });
+    }
+}