@dokploy/trpc-openapi 0.0.1

package/examples/with-nextjs/src/server/router.ts

@@ -0,0 +1,426 @@
+import { TRPCError, initTRPC } from "@trpc/server";
+import { CreateNextContextOptions } from "@trpc/server/adapters/next";
+import jwt from "jsonwebtoken";
+import { OpenApiMeta } from "trpc-openapi";
+import { v4 as uuid } from "uuid";
+import { z } from "zod";
+
+import { Post, User, database } from "./database";
+
+const jwtSecret = uuid();
+
+export type Context = {
+	user: User | null;
+	requestId: string;
+};
+
+const t = initTRPC
+	.context<Context>()
+	.meta<OpenApiMeta>()
+	.create({
+		errorFormatter: ({ error, shape }) => {
+			if (
+				error.code === "INTERNAL_SERVER_ERROR" &&
+				process.env.NODE_ENV === "production"
+			) {
+				return { ...shape, message: "Internal server error" };
+			}
+			return shape;
+		},
+	});
+
+export const createContext = async ({
+	req,
+	res,
+}: CreateNextContextOptions): Promise<Context> => {
+	const requestId = uuid();
+	res.setHeader("x-request-id", requestId);
+
+	let user: User | null = null;
+
+	try {
+		if (req.headers.authorization) {
+			const token = req.headers.authorization.split(" ")[1];
+			const userId = jwt.verify(token, jwtSecret) as string;
+			if (userId) {
+				user = database.users.find((_user) => _user.id === userId) ?? null;
+			}
+		}
+	} catch (cause) {
+		console.error(cause);
+	}
+
+	return { user, requestId };
+};
+
+const publicProcedure = t.procedure;
+const protectedProcedure = t.procedure.use(({ ctx, next }) => {
+	if (!ctx.user) {
+		throw new TRPCError({
+			message: "User not found",
+			code: "UNAUTHORIZED",
+		});
+	}
+	return next({ ctx: { ...ctx, user: ctx.user } });
+});
+
+const authRouter = t.router({
+	register: publicProcedure
+		.meta({
+			openapi: {
+				method: "POST",
+				path: "/auth/register",
+				tags: ["auth"],
+				summary: "Register as a new user",
+			},
+		})
+		.input(
+			z.object({
+				email: z.string().email(),
+				passcode: z.preprocess(
+					(arg) => (typeof arg === "string" ? parseInt(arg) : arg),
+					z.number().min(1000).max(9999),
+				),
+				name: z.string().min(3),
+			}),
+		)
+		.output(
+			z.object({
+				user: z.object({
+					id: z.string().uuid(),
+					email: z.string().email(),
+					name: z.string().min(3),
+				}),
+			}),
+		)
+		.mutation(({ input }) => {
+			let user = database.users.find((_user) => _user.email === input.email);
+
+			if (user) {
+				throw new TRPCError({
+					message: "User with email already exists",
+					code: "UNAUTHORIZED",
+				});
+			}
+
+			user = {
+				id: uuid(),
+				email: input.email,
+				passcode: input.passcode,
+				name: input.name,
+			};
+
+			database.users.push(user);
+
+			return { user: { id: user.id, email: user.email, name: user.name } };
+		}),
+	login: publicProcedure
+		.meta({
+			openapi: {
+				method: "POST",
+				path: "/auth/login",
+				tags: ["auth"],
+				summary: "Login as an existing user",
+			},
+		})
+		.input(
+			z.object({
+				email: z.string().email(),
+				passcode: z.preprocess(
+					(arg) => (typeof arg === "string" ? parseInt(arg) : arg),
+					z.number().min(1000).max(9999),
+				),
+			}),
+		)
+		.output(
+			z.object({
+				token: z.string(),
+			}),
+		)
+		.mutation(({ input }) => {
+			const user = database.users.find((_user) => _user.email === input.email);
+
+			if (!user) {
+				throw new TRPCError({
+					message: "User with email not found",
+					code: "UNAUTHORIZED",
+				});
+			}
+			if (user.passcode !== input.passcode) {
+				throw new TRPCError({
+					message: "Passcode was incorrect",
+					code: "UNAUTHORIZED",
+				});
+			}
+
+			return {
+				token: jwt.sign(user.id, jwtSecret),
+			};
+		}),
+});
+
+const usersRouter = t.router({
+	getUsers: publicProcedure
+		.meta({
+			openapi: {
+				method: "GET",
+				path: "/users",
+				tags: ["users"],
+				summary: "Read all users",
+			},
+		})
+		// .input(z.void())
+		// .output(
+		// 	z.object({
+		// 		users: z.array(
+		// 			z.object({
+		// 				id: z.string().uuid(),
+		// 				email: z.string().email(),
+		// 				name: z.string(),
+		// 			}),
+		// 		),
+		// 	}),
+		// )
+		.query(() => {
+			const users = database.users.map((user) => ({
+				id: user.id,
+				email: user.email,
+				name: user.name,
+			}));
+
+			return { users };
+		}),
+	getUserById: publicProcedure
+		.meta({
+			openapi: {
+				method: "GET",
+				path: "/users/{id}",
+				tags: ["users"],
+				summary: "Read a user by id",
+			},
+		})
+		.input(
+			z.object({
+				id: z.string().uuid(),
+			}),
+		)
+		.output(
+			z.object({
+				user: z.object({
+					id: z.string().uuid(),
+					email: z.string().email(),
+					name: z.string(),
+				}),
+			}),
+		)
+		.query(({ input }) => {
+			const user = database.users.find((_user) => _user.id === input.id);
+
+			if (!user) {
+				throw new TRPCError({
+					message: "User not found",
+					code: "NOT_FOUND",
+				});
+			}
+
+			return { user };
+		}),
+});
+
+const postsRouter = t.router({
+	getPosts: publicProcedure
+		.meta({
+			openapi: {
+				method: "GET",
+				path: "/posts",
+				tags: ["posts"],
+				summary: "Read all posts",
+			},
+		})
+		.input(
+			z.object({
+				userId: z.string().uuid().optional(),
+			}),
+		)
+		.output(
+			z.object({
+				posts: z.array(
+					z.object({
+						id: z.string().uuid(),
+						content: z.string(),
+						userId: z.string().uuid(),
+					}),
+				),
+			}),
+		)
+		.query(({ input }) => {
+			let posts: Post[] = database.posts;
+
+			if (input.userId) {
+				posts = posts.filter((post) => {
+					return post.userId === input.userId;
+				});
+			}
+
+			return { posts };
+		}),
+	getPostById: publicProcedure
+		.meta({
+			openapi: {
+				method: "GET",
+				path: "/posts/{id}",
+				tags: ["posts"],
+				summary: "Read a post by id",
+			},
+		})
+		.input(
+			z.object({
+				id: z.string().uuid(),
+			}),
+		)
+		.output(
+			z.object({
+				post: z.object({
+					id: z.string().uuid(),
+					content: z.string(),
+					userId: z.string().uuid(),
+				}),
+			}),
+		)
+		.query(({ input }) => {
+			const post = database.posts.find((_post) => _post.id === input.id);
+
+			if (!post) {
+				throw new TRPCError({
+					message: "Post not found",
+					code: "NOT_FOUND",
+				});
+			}
+
+			return { post };
+		}),
+	createPost: protectedProcedure
+		.meta({
+			openapi: {
+				method: "POST",
+				path: "/posts",
+				tags: ["posts"],
+				protect: true,
+				summary: "Create a new post",
+			},
+		})
+		.input(
+			z.object({
+				content: z.string().min(1).max(140),
+			}),
+		)
+		.output(
+			z.object({
+				post: z.object({
+					id: z.string().uuid(),
+					content: z.string(),
+					userId: z.string().uuid(),
+				}),
+			}),
+		)
+		.mutation(({ input, ctx }) => {
+			const post: Post = {
+				id: uuid(),
+				content: input.content,
+				userId: ctx.user.id,
+			};
+
+			database.posts.push(post);
+
+			return { post };
+		}),
+	updatePostById: protectedProcedure
+		.meta({
+			openapi: {
+				method: "PUT",
+				path: "/posts/{id}",
+				tags: ["posts"],
+				protect: true,
+				summary: "Update an existing post",
+			},
+		})
+		.input(
+			z.object({
+				id: z.string().uuid(),
+				content: z.string().min(1),
+			}),
+		)
+		.output(
+			z.object({
+				post: z.object({
+					id: z.string().uuid(),
+					content: z.string(),
+					userId: z.string().uuid(),
+				}),
+			}),
+		)
+		.mutation(({ input, ctx }) => {
+			const post = database.posts.find((_post) => _post.id === input.id);
+
+			if (!post) {
+				throw new TRPCError({
+					message: "Post not found",
+					code: "NOT_FOUND",
+				});
+			}
+			if (post.userId !== ctx.user.id) {
+				throw new TRPCError({
+					message: "Cannot edit post owned by other user",
+					code: "FORBIDDEN",
+				});
+			}
+
+			post.content = input.content;
+
+			return { post };
+		}),
+	deletePostById: protectedProcedure
+		.meta({
+			openapi: {
+				method: "DELETE",
+				path: "/posts/{id}",
+				tags: ["posts"],
+				protect: true,
+				summary: "Delete a post",
+			},
+		})
+		.input(
+			z.object({
+				id: z.string().uuid(),
+			}),
+		)
+		.output(z.null())
+		.mutation(({ input, ctx }) => {
+			const post = database.posts.find((_post) => _post.id === input.id);
+			console.log(post);
+			if (!post) {
+				throw new TRPCError({
+					message: "Post not found",
+					code: "NOT_FOUND",
+				});
+			}
+			if (post.userId !== ctx.user.id) {
+				throw new TRPCError({
+					message: "Cannot delete post owned by other user",
+					code: "FORBIDDEN",
+				});
+			}
+
+			database.posts = database.posts.filter((_post) => _post !== post);
+
+			return null;
+		}),
+});
+
+export const appRouter = t.router({
+	auth: authRouter,
+	users: usersRouter,
+	posts: postsRouter,
+});
+
+export type AppRouter = typeof appRouter;

package/examples/with-nextjs/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "target": "es5",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "forceConsistentCasingInFileNames": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "node",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "preserve",
+    "incremental": true,
+    "baseUrl": ".",
+    "paths": {
+      "trpc-openapi": ["../../dist"]
+    }
+  },
+  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx"],
+  "exclude": ["node_modules"]
+}

package/jest.config.ts

@@ -0,0 +1,12 @@
+// @ts-check
+
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  rootDir: './test',
+  snapshotFormat: {
+    escapeString: true,
+    printBasicPrototype: true,
+  },
+};

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@dokploy/trpc-openapi",
+  "version": "0.0.1",
+  "description": "tRPC OpenAPI",
+  "author": "Mauricio Siu <siumauricio@hotmail.com>",
+  "private": false,
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "trpc",
+    "openapi",
+    "swagger"
+  ],
+  "homepage": "https://github.com/jlalmes/trpc-openapi",
+  "repository": "github:jlalmes/trpc-openapi",
+  "bugs": "https://github.com/jlalmes/trpc-openapi/issues",
+  "main": "dist/index.js",
+  "typings": "dist/index.d.ts",
+  "workspaces": [
+    ".",
+    "examples/with-nextjs",
+    "examples/with-express",
+    "examples/with-interop"
+  ],
+  "peerDependencies": {
+    "@trpc/server": "^10.0.0",
+    "zod": "^3.14.4"
+  },
+  "dependencies": {
+    "co-body": "^6.1.0",
+    "h3": "^1.6.4",
+    "lodash.clonedeep": "^4.5.0",
+    "node-mocks-http": "^1.12.2",
+    "openapi-types": "^12.1.1",
+    "zod-to-json-schema": "^3.21.1"
+  },
+  "devDependencies": {
+    "@trivago/prettier-plugin-sort-imports": "^4.1.1",
+    "@trpc/client": "^10.27.1",
+    "@types/aws-lambda": "^8.10.115",
+    "@types/co-body": "^6.1.0",
+    "@types/express": "^4.17.17",
+    "@types/jest": "^29.5.1",
+    "@types/lodash.clonedeep": "^4.5.7",
+    "@types/node": "^20.2.3",
+    "@types/node-fetch": "^2.6.4",
+    "@typescript-eslint/eslint-plugin": "^5.59.7",
+    "@typescript-eslint/parser": "^5.59.7",
+    "aws-lambda": "^1.0.7",
+    "eslint": "^8.41.0",
+    "eslint-config-prettier": "^8.8.0",
+    "eslint-plugin-import": "^2.27.5",
+    "eslint-plugin-prettier": "^4.2.1",
+    "eslint-plugin-promise": "^6.1.1",
+    "express": "^4.18.2",
+    "fastify": "^4.17.0",
+    "jest": "^29.5.0",
+    "next": "^13.4.3",
+    "node-fetch": "^2.6.11",
+    "openapi-schema-validator": "^12.1.1",
+    "prettier": "^2.8.8",
+    "rimraf": "^5.0.1",
+    "superjson": "^1.12.3",
+    "ts-jest": "^29.1.0",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.0.4"
+  },
+  "scripts": {
+    "test": "tsc --noEmit && jest --verbose",
+    "build": "rimraf dist && tsc -p tsconfig.build.json"
+  }
+}

package/pnpm-workspace.yaml

@@ -0,0 +1,7 @@
+packages:
+  - 'examples/with-nextjs'
+  - 'examples/with-express'
+  - 'examples/with-interop'
+  - 'examples/with-serverless'
+  - 'examples/with-fastify'
+  - 'examples/with-nuxtjs'

package/src/adapters/express.ts

@@ -0,0 +1,20 @@
+import { Request, Response } from 'express';
+
+import { OpenApiRouter } from '../types';
+import {
+  CreateOpenApiNodeHttpHandlerOptions,
+  createOpenApiNodeHttpHandler,
+} from './node-http/core';
+
+export type CreateOpenApiExpressMiddlewareOptions<TRouter extends OpenApiRouter> =
+  CreateOpenApiNodeHttpHandlerOptions<TRouter, Request, Response>;
+
+export const createOpenApiExpressMiddleware = <TRouter extends OpenApiRouter>(
+  opts: CreateOpenApiExpressMiddlewareOptions<TRouter>,
+) => {
+  const openApiHttpHandler = createOpenApiNodeHttpHandler(opts);
+
+  return async (req: Request, res: Response) => {
+    await openApiHttpHandler(req, res);
+  };
+};

package/src/adapters/index.ts

@@ -0,0 +1,3 @@
+export * from "./standalone";
+export * from "./express";
+export * from "./next";

package/src/adapters/next.ts

@@ -0,0 +1,64 @@
+import { TRPCError } from "@trpc/server";
+import type { NextApiRequest, NextApiResponse } from "next";
+
+import type { OpenApiErrorResponse, OpenApiRouter } from "../types";
+import { normalizePath } from "../utils/path";
+import {
+	type CreateOpenApiNodeHttpHandlerOptions,
+	createOpenApiNodeHttpHandler,
+} from "./node-http/core";
+
+export type CreateOpenApiNextHandlerOptions<TRouter extends OpenApiRouter> =
+	Omit<
+		CreateOpenApiNodeHttpHandlerOptions<
+			TRouter,
+			NextApiRequest,
+			NextApiResponse
+		>,
+		"maxBodySize"
+	>;
+
+export const createOpenApiNextHandler = <TRouter extends OpenApiRouter>(
+	opts: CreateOpenApiNextHandlerOptions<TRouter>,
+) => {
+	const openApiHttpHandler = createOpenApiNodeHttpHandler(opts);
+
+	return async (req: NextApiRequest, res: NextApiResponse) => {
+		let pathname: string | null = null;
+		if (typeof req.query.trpc === "string") {
+			pathname = req.query.trpc;
+		} else if (Array.isArray(req.query.trpc)) {
+			pathname = req.query.trpc.join("/");
+		}
+
+		if (pathname === null) {
+			const error = new TRPCError({
+				message:
+					'Query "trpc" not found - is the `trpc-openapi` file named `[...trpc].ts`?',
+				code: "INTERNAL_SERVER_ERROR",
+			});
+
+			opts.onError?.({
+				error,
+				type: "unknown",
+				path: undefined,
+				input: undefined,
+				ctx: undefined,
+				req,
+			});
+
+			res.statusCode = 500;
+			res.setHeader("Content-Type", "application/json");
+			const body: OpenApiErrorResponse = {
+				message: error.message,
+				code: error.code,
+			};
+			res.end(JSON.stringify(body));
+
+			return;
+		}
+
+		req.url = normalizePath(pathname);
+		await openApiHttpHandler(req, res);
+	};
+};