ts-openapi-express 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Jacob Shirley
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# ts-openapi-express
+
+For detailed documentation, examples, and API reference, see the [main README](../../README.md).

package/dist/errors.d.ts

@@ -0,0 +1,21 @@
+import { error as openapiValidatorErrors } from 'express-openapi-validator';
+export type OpenapiValidatorError = (typeof openapiValidatorErrors)[keyof typeof openapiValidatorErrors];
+declare const isExpressOpenAPIValidatorError: (err: any) => err is Error & {
+    status: number;
+};
+declare class HttpError extends Error {
+    readonly status: number;
+    constructor(message: string, status: number);
+    type(): string;
+}
+declare class UnauthorizedError extends HttpError {
+    constructor();
+}
+declare class RequestBodyTooLargeError extends HttpError {
+    constructor(maxSizeBytes: number);
+}
+declare class InvalidJsonError extends HttpError {
+    readonly jsonString: string;
+    constructor(jsonString: string);
+}
+export { isExpressOpenAPIValidatorError, HttpError, RequestBodyTooLargeError, InvalidJsonError, UnauthorizedError, };

package/dist/errors.js

@@ -0,0 +1,38 @@
+import { error as openapiValidatorErrors } from 'express-openapi-validator';
+const isExpressOpenAPIValidatorError = (err) => {
+    for (const key in openapiValidatorErrors) {
+        if (err instanceof
+            openapiValidatorErrors[key]) {
+            return true;
+        }
+    }
+    return false;
+};
+class HttpError extends Error {
+    status;
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+    }
+    type() {
+        return this.constructor.name;
+    }
+}
+class UnauthorizedError extends HttpError {
+    constructor() {
+        super('Unauthorized', 401);
+    }
+}
+class RequestBodyTooLargeError extends HttpError {
+    constructor(maxSizeBytes) {
+        super('Request body too large. Max size: ' + maxSizeBytes + ' bytes', 413);
+    }
+}
+class InvalidJsonError extends HttpError {
+    jsonString;
+    constructor(jsonString) {
+        super(`Invalid JSON: ${jsonString}`, 400);
+        this.jsonString = jsonString;
+    }
+}
+export { isExpressOpenAPIValidatorError, HttpError, RequestBodyTooLargeError, InvalidJsonError, UnauthorizedError, };

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './openapiRoutes.js';
+export * from './openapiExpress.js';
+export * from './types.js';
+export * from './errors.js';
+export { redirect } from './utils.js';

package/dist/index.js

@@ -0,0 +1,5 @@
+export * from './openapiRoutes.js';
+export * from './openapiExpress.js';
+export * from './types.js';
+export * from './errors.js';
+export { redirect } from './utils.js';

package/dist/jsonPointer.d.ts

@@ -0,0 +1,8 @@
+declare function resolveLocal<T>(object: object, ref: string): T;
+declare function resolvePointer<T>(object: T, options?: {
+    resolveLocalRefs?: boolean;
+}, parent?: any, currentPath?: string, element?: string): T;
+declare function resolveFile<T = any>(path: string, options?: {
+    resolveLocalRefs?: boolean;
+}, element?: string): T;
+export { resolveLocal, resolveFile, resolvePointer };

package/dist/jsonPointer.js

@@ -0,0 +1,39 @@
+import { parseDocument } from 'yaml';
+import { get } from 'lodash-es';
+import * as fs from 'fs';
+import * as path from 'path';
+function resolveLocal(object, ref) {
+    const [p, element] = ref.split('#');
+    return get(object, element.split('/').filter(Boolean));
+}
+function resolvePointer(object, options, parent = object, currentPath, element) {
+    const resolveLocal = options?.resolveLocalRefs ?? true;
+    const data = element
+        ? get(object, element.split('/').filter(Boolean))
+        : object;
+    for (const key in data) {
+        const value = data[key];
+        if (typeof value === 'object') {
+            data[key] = resolvePointer(value, options, parent, currentPath, '');
+            continue;
+        }
+        if (key !== '$ref')
+            continue;
+        const [p, element] = (value + '').split('#');
+        if (p === '' && !resolveLocal)
+            continue;
+        return !currentPath
+            ? get(parent, element.split('/').filter(Boolean))
+            : resolveFile(path.join(p ? path.dirname(currentPath) : currentPath, p), options, element);
+    }
+    return data;
+}
+function resolveFile(path, options, element = '') {
+    const src = fs.readFileSync(path, 'utf-8');
+    const object = path.endsWith('.yaml')
+        ? parseDocument(src).toJSON()
+        : JSON.parse(src);
+    const result = resolvePointer(object, options, object, path, element);
+    return result;
+}
+export { resolveLocal, resolveFile, resolvePointer };

package/dist/middleware/json.d.ts

@@ -0,0 +1,5 @@
+import { ExpressMiddleware } from '../types.js';
+declare function json(options?: {
+    limit?: number;
+}): ExpressMiddleware;
+export { json };

package/dist/middleware/json.js

@@ -0,0 +1,28 @@
+import { InvalidJsonError, RequestBodyTooLargeError } from '../errors.js';
+const DEFAULT_LIMIT_BYTES = 10 * 1024 * 1024;
+function json(options) {
+    const limit = options?.limit ?? DEFAULT_LIMIT_BYTES;
+    return async function json(req, res, next) {
+        const contentType = req.headers['content-type'];
+        if (contentType?.trim()?.includes('application/json')) {
+            let body = '';
+            for await (const chunk of req) {
+                body += chunk.toString();
+                if (body.length > limit) {
+                    next(new RequestBodyTooLargeError(limit));
+                    return;
+                }
+            }
+            req.bodyAsString = body;
+            try {
+                req.body = JSON.parse(body);
+            }
+            catch (e) {
+                next(new InvalidJsonError(body));
+                return;
+            }
+        }
+        next();
+    };
+}
+export { json };

package/dist/middleware/validation.d.ts

@@ -0,0 +1,11 @@
+import type { OpenapiSpec } from '../openapi-types/index.js';
+import { Request, Response, NextFunction } from 'express';
+declare function makeQueryWritable(req: Request, res: Response, next: NextFunction): void;
+declare function requestResponseValidatorMiddleware(options: {
+    spec: OpenapiSpec;
+    validation?: {
+        requests?: boolean;
+        responses?: boolean;
+    } | false;
+}): (import("express-openapi-validator/dist/framework/types.js").OpenApiRequestHandler[] | typeof makeQueryWritable)[];
+export { requestResponseValidatorMiddleware };

package/dist/middleware/validation.js

@@ -0,0 +1,40 @@
+import { middleware as openapiExpressValidatorMiddleware } from 'express-openapi-validator';
+// TODO: remove this when express-openapi-validator supports Express 5.x. See: https://github.com/cdimascio/express-openapi-validator/issues/969
+// This is caused by a breaking change in Express 5.x, where query is immutable by default
+function makeQueryWritable(req, res, next) {
+    if (req.query)
+        Object.defineProperty(req, 'query', {
+            writable: true,
+            value: { ...req.query },
+        });
+    next();
+}
+function makeQueryReadOnly(req, res, next) {
+    if (req.query)
+        Object.defineProperty(req, 'query', {
+            writable: false,
+            value: { ...req.query },
+        });
+    next();
+}
+function requestResponseValidatorMiddleware(options) {
+    const { spec, validation } = options;
+    const middleware = openapiExpressValidatorMiddleware({
+        apiSpec: spec,
+        validateApiSpec: true,
+        ignoreUndocumented: true,
+        validateSecurity: false,
+        validateRequests: validation === false
+            ? false
+            : validation?.requests === false
+                ? false
+                : true,
+        validateResponses: validation === false
+            ? false
+            : validation?.responses === false
+                ? false
+                : true,
+    });
+    return [makeQueryWritable, middleware, makeQueryReadOnly];
+}
+export { requestResponseValidatorMiddleware };

package/dist/openapi-types/http.d.ts

@@ -0,0 +1,77 @@
+interface IncomingHttpHeaders {
+    accept?: string | undefined;
+    'accept-language'?: string | undefined;
+    'accept-patch'?: string | undefined;
+    'accept-ranges'?: string | undefined;
+    'access-control-allow-credentials'?: string | undefined;
+    'access-control-allow-headers'?: string | undefined;
+    'access-control-allow-methods'?: string | undefined;
+    'access-control-allow-origin'?: string | undefined;
+    'access-control-expose-headers'?: string | undefined;
+    'access-control-max-age'?: string | undefined;
+    'access-control-request-headers'?: string | undefined;
+    'access-control-request-method'?: string | undefined;
+    age?: string | undefined;
+    allow?: string | undefined;
+    'alt-svc'?: string | undefined;
+    authorization?: string | undefined;
+    'cache-control'?: string | undefined;
+    connection?: string | undefined;
+    'content-disposition'?: string | undefined;
+    'content-encoding'?: string | undefined;
+    'content-language'?: string | undefined;
+    'content-length'?: string | undefined;
+    'content-location'?: string | undefined;
+    'content-range'?: string | undefined;
+    'content-type'?: string | undefined;
+    cookie?: string | undefined;
+    date?: string | undefined;
+    etag?: string | undefined;
+    expect?: string | undefined;
+    expires?: string | undefined;
+    forwarded?: string | undefined;
+    from?: string | undefined;
+    host?: string | undefined;
+    'if-match'?: string | undefined;
+    'if-modified-since'?: string | undefined;
+    'if-none-match'?: string | undefined;
+    'if-unmodified-since'?: string | undefined;
+    'last-modified'?: string | undefined;
+    location?: string | undefined;
+    origin?: string | undefined;
+    pragma?: string | undefined;
+    'proxy-authenticate'?: string | undefined;
+    'proxy-authorization'?: string | undefined;
+    'public-key-pins'?: string | undefined;
+    range?: string | undefined;
+    referer?: string | undefined;
+    'retry-after'?: string | undefined;
+    'sec-websocket-accept'?: string | undefined;
+    'sec-websocket-extensions'?: string | undefined;
+    'sec-websocket-key'?: string | undefined;
+    'sec-websocket-protocol'?: string | undefined;
+    'sec-websocket-version'?: string | undefined;
+    'set-cookie'?: string[] | undefined;
+    'strict-transport-security'?: string | undefined;
+    tk?: string | undefined;
+    trailer?: string | undefined;
+    'transfer-encoding'?: string | undefined;
+    upgrade?: string | undefined;
+    'user-agent'?: string | undefined;
+    vary?: string | undefined;
+    via?: string | undefined;
+    warning?: string | undefined;
+    'www-authenticate'?: string | undefined;
+}
+type StandardRequestHeaders = {
+    [K in keyof IncomingHttpHeaders as string extends K ? never : number extends K ? never : K]: IncomingHttpHeaders[K];
+};
+type StandardRequestHeader = Lowercase<keyof StandardRequestHeaders>;
+type StandardResponseHeader = Lowercase<'Accept-Ranges' | 'Age' | 'Allow' | 'Cache-Control' | 'Content-Disposition' | 'Content-Encoding' | 'Content-Language' | 'Content-Length' | 'Content-Location' | 'Content-MD5' | 'Content-Range' | 'Content-Security-Policy' | 'Content-Type' | 'Date' | 'ETag' | 'Expires' | 'Last-Modified' | 'Link' | 'Location' | 'P3P' | 'Pragma' | 'Proxy-Authenticate' | 'Refresh' | 'Retry-After' | 'Server' | 'Set-Cookie' | 'Strict-Transport-Security' | 'Trailer' | 'Transfer-Encoding' | 'Upgrade' | 'User-Agent' | 'Vary' | 'Via' | 'Warning' | 'WWW-Authenticate' | 'X-Content-Type-Options' | 'X-Frame-Options' | 'X-Powered-By' | 'X-XSS-Protection'>;
+type StandardHeaderMap = {
+    [x in StandardResponseHeader]?: string;
+};
+type HeadersMap = {
+    [x in `x-${string}` | `X-${string}` | StandardRequestHeader]?: string;
+};
+export type { StandardRequestHeader, StandardResponseHeader, StandardHeaderMap, HeadersMap, };

package/dist/openapi-types/http.js

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

package/dist/openapi-types/index.d.ts

@@ -0,0 +1,2 @@
+export * from './types.js';
+export * from './http.js';

package/dist/openapi-types/index.js

@@ -0,0 +1,2 @@
+export * from './types.js';
+export * from './http.js';

package/dist/openapi-types/types.d.ts

@@ -0,0 +1,59 @@
+import { OpenAPIV3 } from 'openapi-types';
+type LowercaseKeys<T> = {
+    [K in keyof T as K extends string ? Lowercase<K> : K]: T[K];
+};
+type HttpMethod = 'post' | 'get' | 'put' | 'patch' | 'delete' | 'head' | 'options' | 'trace' | 'connect';
+type OpenapiSpec = OpenAPIV3.Document;
+type GetQueryParameters<T> = T extends {
+    parameters: {
+        query?: any;
+    };
+} ? T['parameters']['query'] : never;
+type GetPathParameters<T> = T extends {
+    parameters: {
+        path: any;
+    };
+} ? T['parameters']['path'] : never;
+type GetRequestHeaders<T> = T extends {
+    parameters: {
+        header?: any;
+    };
+} ? [T['parameters']['header']] extends [never | undefined] ? never : LowercaseKeys<T['parameters']['header']> : never;
+type GetRequestBody<T> = T extends {
+    requestBody?: {
+        content?: any;
+    };
+} ? undefined extends T['requestBody'] ? NonNullable<T['requestBody']>['content'][keyof NonNullable<T['requestBody']>['content']] | undefined : NonNullable<T['requestBody']>['content'][keyof NonNullable<T['requestBody']>['content']] : never;
+type GetStatusCodes<T> = T extends {
+    responses: {
+        [x: number]: any;
+    };
+} ? Extract<keyof T['responses'], number> : never;
+type GetResponseBody<T, Code extends number = number> = T extends {
+    responses: {
+        [x in Code]: {
+            content?: {
+                [key: string]: any;
+            };
+        };
+    };
+} ? T['responses'][Code]['content'][keyof T['responses'][Code]['content']] : never;
+type GetJsonBody<T, Code extends number = number> = T extends {
+    responses: {
+        [x in Code]: {
+            content?: {
+                'application/json': any;
+            };
+        };
+    };
+} ? Extract<T['responses'][Code extends never ? Extract<keyof T['responses'], number> : Code]['content'], object>['application/json'] : never;
+type GetResponseHeaders<T, Code extends number = GetStatusCodes<T>> = T extends {
+    responses: {
+        [code in Code]: {
+            headers: {
+                [headerName: string]: any;
+            };
+        };
+    };
+} ? T['responses'][Code]['headers'] : never;
+export type { HttpMethod, OpenapiSpec, GetJsonBody, GetStatusCodes, GetPathParameters, GetRequestBody, GetQueryParameters, GetRequestHeaders, GetResponseHeaders, GetResponseBody, };

package/dist/openapi-types/types.js

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

package/dist/openapiExpress.d.ts

@@ -0,0 +1,13 @@
+import { Application } from 'express';
+import { ExpressMiddleware, OpenapiApplication, Routes } from './types.js';
+declare function openapiExpress<Spec>(options: {
+    specPath: string;
+    routes: Routes<Spec>;
+    middleware?: ExpressMiddleware[];
+    validateRequest?: boolean;
+    validateResponse?: boolean;
+    decodeJsonBody?: boolean;
+    app?: Application;
+    disableXPoweredBy?: boolean;
+}): OpenapiApplication<Spec>;
+export { openapiExpress };

package/dist/openapiExpress.js

@@ -0,0 +1,37 @@
+import express from 'express';
+import { json } from './middleware/json.js';
+import { requestResponseValidatorMiddleware } from './middleware/validation.js';
+import { resolveFile } from './jsonPointer.js';
+import { openapiRoutes } from './openapiRoutes.js';
+function openapiExpress(options) {
+    const { specPath, routes, decodeJsonBody = true, disableXPoweredBy = true, validateRequest = true, validateResponse = true, middleware = [], } = options;
+    const spec = resolveFile(specPath, { resolveLocalRefs: false });
+    const app = options.app || express();
+    if (disableXPoweredBy)
+        app.disable('x-powered-by');
+    app.use('/openapi.json', (req, res) => {
+        res.json(spec);
+    });
+    if (decodeJsonBody) {
+        app.use(json());
+    }
+    if (validateRequest || validateResponse)
+        app.use(...requestResponseValidatorMiddleware({
+            spec,
+            validation: {
+                requests: validateRequest,
+                responses: validateResponse,
+            },
+        }));
+    for (const m of middleware) {
+        app.use(m);
+    }
+    openapiRoutes(routes, app);
+    return Object.assign(app, {
+        version: spec.info.version,
+        openApiPath: specPath,
+        spec,
+        routes: routes,
+    });
+}
+export { openapiExpress };

package/dist/openapiRoutes.d.ts

@@ -0,0 +1,4 @@
+import { Routes } from './types.js';
+import { Application } from 'express';
+declare function openapiRoutes<TPaths>(routes: Routes<TPaths>, app?: Application): Application;
+export { openapiRoutes };

package/dist/openapiRoutes.js

@@ -0,0 +1,91 @@
+import { openapiPathToExpressPath } from './utils.js';
+import express from 'express';
+import { Readable } from 'stream';
+function assertHttpMethod(method) {
+    if (![
+        'get',
+        'post',
+        'put',
+        'patch',
+        'delete',
+        'trace',
+        'options',
+        'connect',
+    ].includes(method)) {
+        throw new Error(`Invalid HTTP method: ${method}`);
+    }
+}
+function routeResponse(route) {
+    return async (request, res) => {
+        const result = await route.handler(request);
+        const responseCodes = Object.keys(result).map(Number);
+        if (responseCodes.length === 0) {
+            throw new Error('No response code defined');
+        }
+        if (responseCodes.length > 1) {
+            throw new Error('Multiple response codes defined');
+        }
+        const responseCode = responseCodes[0];
+        if (!result[responseCode]) {
+            throw new Error(`No response defined for status code ${responseCode}`);
+        }
+        for (const header in result[responseCode].headers) {
+            res.set(String(header), String(result[responseCode].headers[header]));
+        }
+        res.status(responseCode);
+        const body = 'body' in result[responseCode]
+            ? result[responseCode].body
+            : undefined;
+        if (body === undefined) {
+            res.end();
+        }
+        else if (body instanceof Readable) {
+            body.pipe(res);
+        }
+        else if (body instanceof ReadableStream) {
+            const reader = body.getReader();
+            const read = async () => {
+                const { done, value } = await reader.read();
+                if (done) {
+                    res.end();
+                    return;
+                }
+                res.write(value.toString());
+                await read();
+            };
+            await read();
+        }
+        else if (typeof body === 'string') {
+            res.send(body);
+        }
+        else if (typeof body === 'object' &&
+            body !== null &&
+            (Symbol.asyncIterator in body || Symbol.iterator in body)) {
+            if (Array.isArray(body)) {
+                res.json(body);
+                return;
+            }
+            for await (const chunk of body) {
+                res.write(chunk.toString());
+            }
+            res.end();
+        }
+        else {
+            res.json(typeof body === 'object' && body && 'toJSON' in body
+                ? body.toJSON()
+                : body);
+        }
+    };
+}
+function openapiRoutes(routes, app = express()) {
+    for (const path of Object.keys(routes)) {
+        for (const method in routes[path]) {
+            assertHttpMethod(method);
+            const route = routes[path][method];
+            const expressPath = openapiPathToExpressPath(String(path));
+            app[method](expressPath, routeResponse(route));
+        }
+    }
+    return app;
+}
+export { openapiRoutes };

package/dist/types.d.ts

@@ -0,0 +1,59 @@
+import type { Application, NextFunction, Request as ExpressRequest, Response as ExpressResponse } from 'express';
+import { GetRequestBody, GetRequestHeaders, GetResponseBody, GetPathParameters, GetQueryParameters, GetResponseHeaders, GetStatusCodes, HttpMethod, OpenapiSpec, StandardHeaderMap, StandardRequestHeader } from './openapi-types/index.js';
+import { Readable } from 'stream';
+type OpenapiRequest<T> = Omit<ExpressRequest, 'query' | 'params' | 'body' | 'header' | 'headers'> & {
+    query: GetQueryParameters<T>;
+    params: GetPathParameters<T>;
+    body: GetRequestBody<T>;
+    header: <const THeader extends keyof GetRequestHeaders<T>>(header: StandardRequestHeader | THeader) => GetRequestHeaders<T>[THeader];
+    headers: StandardHeaderMap & GetRequestHeaders<T>;
+};
+type OpenapiResponse<T, Code extends GetStatusCodes<T> = GetStatusCodes<T>> = {
+    [code in NoInfer<Code>]?: {
+        headers: GetResponseHeaders<T, code> & StandardHeaderMap;
+    } & (GetResponseBody<T, code> extends [undefined] ? {} : {
+        body: GetResponseBody<T, code> | {
+            toJSON(): GetResponseBody<T, code>;
+        } | Readable | ReadableStream<{
+            toString(): string;
+        }> | Iterable<{
+            toString(): string;
+        }> | AsyncIterable<{
+            toString(): string;
+        }>;
+    });
+};
+type HandlerResult<Schema> = Promise<OpenapiResponse<Schema>> | OpenapiResponse<Schema>;
+type Route<Schema> = {
+    handler: (request: OpenapiRequest<Schema>) => HandlerResult<Schema>;
+    middleware?: ((request: OpenapiRequest<Schema>) => HandlerResult<Schema>)[];
+};
+type Routes<Paths> = {
+    [Path in keyof Paths]: {
+        [Method in Extract<keyof Paths[Path], HttpMethod> as [
+            undefined
+        ] extends [Paths[Path][Method]] ? never : Method]: Route<Paths[Path][Method]>;
+    };
+};
+type OpenapiApplication<T> = Application & {
+    version: string;
+    openApiPath: string;
+    routes: Routes<T>;
+    spec: OpenapiSpec;
+};
+type ExpressMiddleware = (request: ExpressRequest, response: ExpressResponse, next: NextFunction) => void;
+type ExpressMiddlewareWithError = (error: any, request: ExpressRequest, response: ExpressResponse, next: NextFunction) => void;
+type ErrorResponse = {
+    message: string;
+    detail: string;
+    path: string;
+    errorCode: string;
+};
+declare global {
+    namespace Express {
+        interface Request {
+            bodyAsString: string;
+        }
+    }
+}
+export type { OpenapiApplication, OpenapiRequest, OpenapiResponse, OpenapiSpec, Route, Routes, HandlerResult, ExpressMiddleware, ExpressMiddlewareWithError, ErrorResponse, ExpressRequest, ExpressResponse, };

package/dist/types.js

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

package/dist/utils.d.ts

@@ -0,0 +1,10 @@
+import { OpenapiRequest } from './types.js';
+declare const validateRequest: <T>(req: any) => req is OpenapiRequest<T>;
+declare const openapiPathToExpressPath: (openapiPath: string) => string;
+declare const redirect: (url: string) => {
+    302: {
+        headers: {};
+        body: string;
+    };
+};
+export { validateRequest, openapiPathToExpressPath, redirect };

package/dist/utils.js

@@ -0,0 +1,16 @@
+const validateRequest = (req) => {
+    //TODO: validate the request
+    return true;
+};
+const openapiPathToExpressPath = (openapiPath) => {
+    return openapiPath.replace(/\{/gm, ':').replace(/\}/gm, '');
+};
+const redirect = (url) => {
+    return {
+        302: {
+            headers: {},
+            body: `<head><meta http-equiv="Refresh" content="0; URL=${url}" /></head>`,
+        },
+    };
+};
+export { validateRequest, openapiPathToExpressPath, redirect };

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "ts-openapi-express",
+  "type": "module",
+  "version": "0.0.1",
+  "description": "",
+  "main": "dist/index.js",
+  "directories": {
+    "test": "test"
+  },
+  "keywords": [
+    "openapi",
+    "express",
+    "typescript",
+    "rest-api",
+    "api",
+    "validation",
+    "type-safe",
+    "schema-validation",
+    "openapi-typescript",
+    "request-validation",
+    "response-validation",
+    "nodejs"
+  ],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "express": "^5.0.0",
+    "express-openapi-validator": "^5.3.9",
+    "lodash-es": "^4.17.23",
+    "yaml": "^2.8.1"
+  },
+  "devDependencies": {
+    "@types/express": "^5.0.0",
+    "@types/lodash-es": "^4.17.12",
+    "@types/node": "^22.0.0",
+    "@types/supertest": "^6.0.2",
+    "@types/swagger-ui-express": "^4.1.6",
+    "openapi-types": "^12.1.0",
+    "openapi-typescript": "^7.4.1",
+    "supertest": "^7.0.0",
+    "typescript": "^5.0.4",
+    "vitest": "^4.0.18"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "pnpm test:unit",
+    "test:unit": "pnpm test:compile:spec && vitest run",
+    "test:compile:spec": "openapi-typescript test/unit/openapi.test.yaml --output test/unit/test-schema.ts",
+    "compile": "tsc -p tsconfig.prod.json",
+    "watch": "tsc -p tsconfig.prod.json --watch"
+  }
+}