@dokploy/trpc-openapi 0.0.2 → 0.0.4

package/src/adapters/node-http/core.ts

@@ -1,203 +0,0 @@
-// @ts-nocheck
-import { type AnyProcedure, TRPCError } from "@trpc/server";
-import type {
-	NodeHTTPHandlerOptions,
-	NodeHTTPRequest,
-	NodeHTTPResponse,
-} from "@trpc/server/dist/adapters/node-http";
-import cloneDeep from "lodash.clonedeep";
-import type { ZodError, z } from "zod";
-
-import { generateOpenApiDocument } from "../../generator";
-import type {
-	OpenApiErrorResponse,
-	OpenApiMethod,
-	OpenApiResponse,
-	OpenApiRouter,
-	OpenApiSuccessResponse,
-} from "../../types";
-import { acceptsRequestBody } from "../../utils/method";
-import { normalizePath } from "../../utils/path";
-import { getInputOutputParsers } from "../../utils/procedure";
-import {
-	instanceofZodTypeCoercible,
-	instanceofZodTypeLikeVoid,
-	instanceofZodTypeObject,
-	unwrapZodType,
-	zodSupportsCoerce,
-} from "../../utils/zod";
-import { TRPC_ERROR_CODE_HTTP_STATUS, getErrorFromUnknown } from "./errors";
-import { getBody, getQuery } from "./input";
-import { createProcedureCache } from "./procedures";
-
-export type CreateOpenApiNodeHttpHandlerOptions<
-	TRouter extends OpenApiRouter,
-	TRequest extends NodeHTTPRequest,
-	TResponse extends NodeHTTPResponse,
-> = Pick<
-	NodeHTTPHandlerOptions<TRouter, TRequest, TResponse>,
-	"router" | "createContext" | "responseMeta" | "onError" | "maxBodySize"
->;
-
-export type OpenApiNextFunction = () => void;
-
-export const createOpenApiNodeHttpHandler = <
-	TRouter extends OpenApiRouter,
-	TRequest extends NodeHTTPRequest,
-	TResponse extends NodeHTTPResponse,
->(
-	opts: CreateOpenApiNodeHttpHandlerOptions<TRouter, TRequest, TResponse>,
-) => {
-	const router = cloneDeep(opts.router);
-
-	// Validate router
-	if (process.env.NODE_ENV !== "production") {
-		generateOpenApiDocument(router, { title: "", version: "", baseUrl: "" });
-	}
-
-	const { createContext, responseMeta, onError, maxBodySize } = opts;
-	const getProcedure = createProcedureCache(router);
-
-	return async (req: TRequest, res: TResponse, next?: OpenApiNextFunction) => {
-		const sendResponse = (
-			statusCode: number,
-			headers: Record<string, string>,
-			body: OpenApiResponse | undefined,
-		) => {
-			res.statusCode = statusCode;
-			res.setHeader("Content-Type", "application/json");
-			for (const [key, value] of Object.entries(headers)) {
-				if (typeof value !== "undefined") {
-					res.setHeader(key, value);
-				}
-			}
-			res.end(JSON.stringify(body));
-		};
-
-		const method = req.method! as OpenApiMethod & "HEAD";
-		const reqUrl = req.url!;
-		const url = new URL(
-			reqUrl.startsWith("/") ? `http://127.0.0.1${reqUrl}` : reqUrl,
-		);
-		const path = normalizePath(url.pathname);
-		const { procedure, pathInput } = getProcedure(method, path) ?? {};
-
-		let input: any = undefined;
-		let ctx: any = undefined;
-		let data: any = undefined;
-
-		try {
-			if (!procedure) {
-				if (next) {
-					return next();
-				}
-
-				// Can be used for warmup
-				if (method === "HEAD") {
-					sendResponse(204, {}, undefined);
-					return;
-				}
-
-				throw new TRPCError({
-					message: "Not found",
-					code: "NOT_FOUND",
-				});
-			}
-
-			const useBody = acceptsRequestBody(method);
-			const schema = getInputOutputParsers(procedure.procedure)
-				.inputParser as z.ZodTypeAny;
-			const unwrappedSchema = unwrapZodType(schema, true);
-
-			// input should stay undefined if z.void()
-			if (!instanceofZodTypeLikeVoid(unwrappedSchema)) {
-				input = {
-					...(useBody ? await getBody(req, maxBodySize) : getQuery(req, url)),
-					...pathInput,
-				};
-			}
-
-			// if supported, coerce all string values to correct types
-			if (zodSupportsCoerce) {
-				if (instanceofZodTypeObject(unwrappedSchema)) {
-					Object.values(unwrappedSchema.shape).forEach((shapeSchema) => {
-						const unwrappedShapeSchema = unwrapZodType(shapeSchema, false);
-						if (instanceofZodTypeCoercible(unwrappedShapeSchema)) {
-							unwrappedShapeSchema._def.coerce = true;
-						}
-					});
-				}
-			}
-
-			ctx = await createContext?.({ req, res });
-			const caller = router.createCaller(ctx);
-
-			const segments = procedure.path.split(".");
-			const procedureFn = segments.reduce(
-				(acc, curr) => acc[curr],
-				caller as any,
-			) as AnyProcedure;
-
-			data = await procedureFn(input);
-
-			const meta = responseMeta?.({
-				type: procedure.type,
-				paths: [procedure.path],
-				ctx,
-				data: [data],
-				errors: [],
-			});
-
-			const statusCode = meta?.status ?? 200;
-			const headers = meta?.headers ?? {};
-			const body: OpenApiSuccessResponse<typeof data> = data;
-			sendResponse(statusCode, headers, body);
-		} catch (cause) {
-			const error = getErrorFromUnknown(cause);
-
-			onError?.({
-				error,
-				type: procedure?.type ?? "unknown",
-				path: procedure?.path,
-				input,
-				ctx,
-				req,
-			});
-
-			const meta = responseMeta?.({
-				type: procedure?.type ?? "unknown",
-				paths: procedure?.path ? [procedure?.path] : undefined,
-				ctx,
-				data: [data],
-				errors: [error],
-			});
-
-			const errorShape = router.getErrorShape({
-				error,
-				type: procedure?.type ?? "unknown",
-				path: procedure?.path,
-				input,
-				ctx,
-			});
-
-			const isInputValidationError =
-				error.code === "BAD_REQUEST" &&
-				error.cause instanceof Error &&
-				error.cause.name === "ZodError";
-
-			const statusCode =
-				meta?.status ?? TRPC_ERROR_CODE_HTTP_STATUS[error.code] ?? 500;
-			const headers = meta?.headers ?? {};
-			const body: OpenApiErrorResponse = {
-				message: isInputValidationError
-					? "Input validation failed"
-					: errorShape?.message ?? error.message ?? "An error occurred",
-				code: error.code,
-				issues: isInputValidationError
-					? (error.cause as ZodError).errors
-					: undefined,
-			};
-			sendResponse(statusCode, headers, body);
-		}
-	};
-};

package/src/adapters/node-http/errors.ts

@@ -1,45 +0,0 @@
-import { TRPCError } from "@trpc/server";
-
-export const TRPC_ERROR_CODE_HTTP_STATUS: Record<TRPCError["code"], number> = {
-	PARSE_ERROR: 400,
-	BAD_REQUEST: 400,
-	NOT_FOUND: 404,
-	INTERNAL_SERVER_ERROR: 500,
-	UNAUTHORIZED: 401,
-	FORBIDDEN: 403,
-	TIMEOUT: 408,
-	CONFLICT: 409,
-	CLIENT_CLOSED_REQUEST: 499,
-	PRECONDITION_FAILED: 412,
-	PAYLOAD_TOO_LARGE: 413,
-	METHOD_NOT_SUPPORTED: 405,
-	TOO_MANY_REQUESTS: 429,
-	UNPROCESSABLE_CONTENT: 422,
-	NOT_IMPLEMENTED: 501,
-};
-
-export function getErrorFromUnknown(cause: unknown): TRPCError {
-	if (cause instanceof Error && cause.name === "TRPCError") {
-		return cause as TRPCError;
-	}
-
-	let errorCause: Error | undefined = undefined;
-	let stack: string | undefined = undefined;
-
-	if (cause instanceof Error) {
-		errorCause = cause;
-		stack = cause.stack;
-	}
-
-	const error = new TRPCError({
-		message: "Internal server error",
-		code: "INTERNAL_SERVER_ERROR",
-		cause: errorCause,
-	});
-
-	if (stack) {
-		error.stack = stack;
-	}
-
-	return error;
-}

package/src/adapters/node-http/input.ts

@@ -1,76 +0,0 @@
-import { TRPCError } from '@trpc/server';
-import { NodeHTTPRequest } from '@trpc/server/dist/adapters/node-http';
-import parse from 'co-body';
-
-export const getQuery = (req: NodeHTTPRequest, url: URL): Record<string, string> => {
-  const query: Record<string, string> = {};
-
-  if (!req.query) {
-    const parsedQs: Record<string, string[]> = {};
-    url.searchParams.forEach((value, key) => {
-      if (!parsedQs[key]) {
-        parsedQs[key] = [];
-      }
-      parsedQs[key]!.push(value);
-    });
-    req.query = parsedQs;
-  }
-
-  // normalize first value in array
-  Object.keys(req.query).forEach((key) => {
-    const value = req.query![key];
-    if (value) {
-      if (typeof value === 'string') {
-        query[key] = value;
-      } else if (Array.isArray(value)) {
-        if (typeof value[0] === 'string') {
-          query[key] = value[0];
-        }
-      }
-    }
-  });
-
-  return query;
-};
-
-const BODY_100_KB = 100000;
-export const getBody = async (req: NodeHTTPRequest, maxBodySize = BODY_100_KB): Promise<any> => {
-  if ('body' in req) {
-    return req.body;
-  }
-
-  req.body = undefined;
-
-  const contentType = req.headers['content-type'];
-  if (contentType === 'application/json' || contentType === 'application/x-www-form-urlencoded') {
-    try {
-      const { raw, parsed } = await parse(req, {
-        limit: maxBodySize,
-        strict: false,
-        returnRawBody: true,
-      });
-      req.body = raw ? parsed : undefined;
-    } catch (cause) {
-      if (cause instanceof Error && cause.name === 'PayloadTooLargeError') {
-        throw new TRPCError({
-          message: 'Request body too large',
-          code: 'PAYLOAD_TOO_LARGE',
-          cause: cause,
-        });
-      }
-
-      let errorCause: Error | undefined = undefined;
-      if (cause instanceof Error) {
-        errorCause = cause;
-      }
-
-      throw new TRPCError({
-        message: 'Failed to parse request body',
-        code: 'PARSE_ERROR',
-        cause: errorCause,
-      });
-    }
-  }
-
-  return req.body;
-};

package/src/adapters/node-http/procedures.ts

@@ -1,64 +0,0 @@
-import { OpenApiMethod, OpenApiProcedure, OpenApiRouter } from '../../types';
-import { getPathRegExp, normalizePath } from '../../utils/path';
-import { forEachOpenApiProcedure } from '../../utils/procedure';
-
-export const createProcedureCache = (router: OpenApiRouter) => {
-  const procedureCache = new Map<
-    OpenApiMethod,
-    Map<
-      RegExp,
-      {
-        type: 'query' | 'mutation';
-        path: string;
-        procedure: OpenApiProcedure;
-      }
-    >
-  >();
-
-  const { queries, mutations } = router._def;
-
-  forEachOpenApiProcedure(queries, ({ path: queryPath, procedure, openapi }) => {
-    const { method } = openapi;
-    if (!procedureCache.has(method)) {
-      procedureCache.set(method, new Map());
-    }
-    const path = normalizePath(openapi.path);
-    const pathRegExp = getPathRegExp(path);
-    procedureCache.get(method)!.set(pathRegExp, {
-      type: 'query',
-      path: queryPath,
-      procedure,
-    });
-  });
-
-  forEachOpenApiProcedure(mutations, ({ path: mutationPath, procedure, openapi }) => {
-    const { method } = openapi;
-    if (!procedureCache.has(method)) {
-      procedureCache.set(method, new Map());
-    }
-    const path = normalizePath(openapi.path);
-    const pathRegExp = getPathRegExp(path);
-    procedureCache.get(method)!.set(pathRegExp, {
-      type: 'mutation',
-      path: mutationPath,
-      procedure,
-    });
-  });
-
-  return (method: OpenApiMethod, path: string) => {
-    const procedureMethodCache = procedureCache.get(method);
-    if (!procedureMethodCache) {
-      return undefined;
-    }
-
-    const procedureRegExp = Array.from(procedureMethodCache.keys()).find((re) => re.test(path));
-    if (!procedureRegExp) {
-      return undefined;
-    }
-
-    const procedure = procedureMethodCache.get(procedureRegExp)!;
-    const pathInput = procedureRegExp.exec(path)?.groups ?? {};
-
-    return { procedure, pathInput };
-  };
-};

package/src/adapters/standalone.ts

@@ -1,19 +0,0 @@
-import type { IncomingMessage, ServerResponse } from "node:http";
-
-import type { OpenApiRouter } from "../types";
-import {
-	type CreateOpenApiNodeHttpHandlerOptions,
-	createOpenApiNodeHttpHandler,
-} from "./node-http/core";
-
-export type CreateOpenApiHttpHandlerOptions<TRouter extends OpenApiRouter> =
-	CreateOpenApiNodeHttpHandlerOptions<TRouter, IncomingMessage, ServerResponse>;
-
-export const createOpenApiHttpHandler = <TRouter extends OpenApiRouter>(
-	opts: CreateOpenApiHttpHandlerOptions<TRouter>,
-) => {
-	const openApiHttpHandler = createOpenApiNodeHttpHandler(opts);
-	return async (req: IncomingMessage, res: ServerResponse) => {
-		await openApiHttpHandler(req, res);
-	};
-};

package/src/generator/index.ts

@@ -1,51 +0,0 @@
-import { OpenAPIV3 } from 'openapi-types';
-
-import { OpenApiRouter } from '../types';
-import { getOpenApiPathsObject } from './paths';
-import { errorResponseObject } from './schema';
-
-export const openApiVersion = '3.0.3';
-
-export type GenerateOpenApiDocumentOptions = {
-  title: string;
-  description?: string;
-  version: string;
-  baseUrl: string;
-  docsUrl?: string;
-  tags?: string[];
-  securitySchemes?: OpenAPIV3.ComponentsObject['securitySchemes'];
-};
-
-export const generateOpenApiDocument = (
-  appRouter: OpenApiRouter,
-  opts: GenerateOpenApiDocumentOptions,
-): OpenAPIV3.Document => {
-  const securitySchemes = opts.securitySchemes || {
-    Authorization: {
-      type: 'http',
-      scheme: 'bearer',
-    },
-  };
-  return {
-    openapi: openApiVersion,
-    info: {
-      title: opts.title,
-      description: opts.description,
-      version: opts.version,
-    },
-    servers: [
-      {
-        url: opts.baseUrl,
-      },
-    ],
-    paths: getOpenApiPathsObject(appRouter, Object.keys(securitySchemes)),
-    components: {
-      securitySchemes,
-      responses: {
-        error: errorResponseObject,
-      },
-    },
-    tags: opts.tags?.map((tag) => ({ name: tag })),
-    externalDocs: opts.docsUrl ? { url: opts.docsUrl } : undefined,
-  };
-};

package/src/generator/paths.ts

@@ -1,127 +0,0 @@
-import { TRPCError } from "@trpc/server";
-import { OpenAPIV3 } from "openapi-types";
-
-import { OpenApiProcedureRecord, OpenApiRouter } from "../types";
-import { acceptsRequestBody } from "../utils/method";
-import { getPathParameters, normalizePath } from "../utils/path";
-import {
-	forEachOpenApiProcedure,
-	getInputOutputParsers,
-} from "../utils/procedure";
-import {
-	getParameterObjects,
-	getRequestBodyObject,
-	getResponsesObject,
-} from "./schema";
-
-export const getOpenApiPathsObject = (
-	appRouter: OpenApiRouter,
-	securitySchemeNames: string[],
-): OpenAPIV3.PathsObject => {
-	const pathsObject: OpenAPIV3.PathsObject = {};
-	const procedures = appRouter._def.procedures as OpenApiProcedureRecord;
-
-	forEachOpenApiProcedure(
-		procedures,
-		({ path: procedurePath, type, procedure, openapi }) => {
-			const procedureName = `${type}.${procedurePath}`;
-
-			try {
-				if (type === "subscription") {
-					throw new TRPCError({
-						message: "Subscriptions are not supported by OpenAPI v3",
-						code: "INTERNAL_SERVER_ERROR",
-					});
-				}
-
-				const { method, protect, summary, description, tags, headers } =
-					openapi;
-
-				const path = normalizePath(openapi.path);
-				const pathParameters = getPathParameters(path);
-				const headerParameters =
-					headers?.map((header) => ({ ...header, in: "header" })) || [];
-
-				const httpMethod = OpenAPIV3.HttpMethods[method];
-				if (!httpMethod) {
-					throw new TRPCError({
-						message: "Method must be GET, POST, PATCH, PUT or DELETE",
-						code: "INTERNAL_SERVER_ERROR",
-					});
-				}
-
-				if (pathsObject[path]?.[httpMethod]) {
-					throw new TRPCError({
-						message: `Duplicate procedure defined for route ${method} ${path}`,
-						code: "INTERNAL_SERVER_ERROR",
-					});
-				}
-
-				const contentTypes = openapi.contentTypes || ["application/json"];
-				if (contentTypes.length === 0) {
-					throw new TRPCError({
-						message: "At least one content type must be specified",
-						code: "INTERNAL_SERVER_ERROR",
-					});
-				}
-
-				const { inputParser, outputParser } = getInputOutputParsers(procedure);
-
-				pathsObject[path] = {
-					...pathsObject[path],
-					[httpMethod]: {
-						operationId: procedurePath.replace(/\./g, "-"),
-						summary,
-						description,
-						tags: tags,
-						security: protect
-							? securitySchemeNames.map((name) => ({ [name]: [] }))
-							: undefined,
-						...(acceptsRequestBody(method)
-							? {
-									requestBody: getRequestBodyObject(
-										inputParser,
-										pathParameters,
-										contentTypes,
-										openapi.example?.request,
-									),
-									parameters: [
-										...headerParameters,
-										...(getParameterObjects(
-											inputParser,
-											pathParameters,
-											"path",
-											openapi.example?.request,
-										) || []),
-									],
-								}
-							: {
-									requestBody: undefined,
-									parameters: [
-										...headerParameters,
-										...(getParameterObjects(
-											inputParser,
-											pathParameters,
-											"all",
-											openapi.example?.request,
-										) || []),
-									],
-								}),
-						responses: getResponsesObject(
-							outputParser,
-							openapi.example?.response,
-							openapi.responseHeaders,
-						),
-						// ...(openapi.deprecated ? { deprecated: openapi.deprecated } : {}),
-					},
-				};
-			} catch (error: any) {
-				// eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-				error.message = `[${procedureName}] - ${error.message}`;
-				throw error;
-			}
-		},
-	);
-
-	return pathsObject;
-};