feat(trpc): tRPC integration (#1683)

## Summary

Brings the tRPC integration (`@orpc/trpc`) to v2. You can now convert a
tRPC router into an oRPC router and use it with any oRPC feature:

```ts
const orpcRouter = toORPCRouter(trpcRouter)
```

- Works with RPC/OpenAPI handlers, server-side clients, OpenAPI spec
generation, subscriptions (including tracked events), and lazy routers
- `toTRPCMeta` lets you use oRPC meta plugins (like `openapi(...)`)
directly in tRPC's `.meta()`
- New [tRPC Integration](https://orpc.dev/docs/integrations/trpc) docs
page
- 100% test coverage

---------

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

Author: dinwwwh

apps/content/.vitepress/config.ts

@@ -193,6 +193,7 @@ export default withMermaid(defineConfig({
             { text: 'OpenTelemetry', link: '/docs/integrations/opentelemetry' },
             { text: 'Pino', link: '/docs/integrations/pino' },
             { text: 'Tanstack Query', link: '/docs/integrations/tanstack-query' },
+            { text: 'tRPC', link: '/docs/integrations/trpc' },
           ],
         },
         {

apps/content/docs/integrations/trpc.md

@@ -0,0 +1,107 @@
+# tRPC Integration
+
+This guide shows how to integrate [tRPC](https://trpc.io/) with oRPC, so you can use oRPC features in your existing tRPC applications.
+
+## Installation
+
+::: code-group
+
+```sh [npm]
+npm install @orpc/trpc@beta
+```
+
+```sh [yarn]
+yarn add @orpc/trpc@beta
+```
+
+```sh [pnpm]
+pnpm add @orpc/trpc@beta
+```
+
+```sh [bun]
+bun add @orpc/trpc@beta
+```
+
+```sh [deno]
+deno add npm:@orpc/trpc@beta
+```
+
+:::
+
+## Router Conversion
+
+`toORPCRouter` converts a [tRPC router](https://trpc.io/docs/server/routers) into an [oRPC router](/docs/router):
+
+```ts
+import { toORPCRouter } from '@orpc/trpc'
+
+const orpcRouter = toORPCRouter(trpcRouter)
+```
+
+The result is a regular oRPC router that works with any oRPC feature. For example, you can expose it through an [RPC Handler](/docs/rpc/handler) or [OpenAPI Handler](/docs/openapi/handler), or call it directly with [Server-Side Clients](/docs/client/server-side).
+
+### Error Formatting
+
+`toORPCRouter` does not support [tRPC Error Formatting](https://trpc.io/docs/server/error-formatting). Instead, errors thrown by tRPC are wrapped in `ORPCError`.
+
+```ts
+const handler = new OpenAPIHandler(orpcRouter, {
+  interceptors: [
+    async ({ next }) => {
+      try {
+        return await next()
+      }
+      catch (error) {
+        if (
+          error instanceof ORPCError
+          && error.cause instanceof TRPCError
+          && error.cause.cause instanceof z.ZodError
+        ) {
+          throw new ORPCError('UNPROCESSABLE_CONTENT', {
+            message: z.prettifyError(error.cause.cause),
+            data: z.flattenError(error.cause.cause),
+            cause: error.cause.cause,
+          })
+        }
+
+        throw error
+      }
+    },
+  ],
+})
+```
+
+## Metadata
+
+`toTRPCMeta` bridges [oRPC metadata](/docs/metadata) with tRPC meta. It returns a plain object that you can pass to tRPC `.meta` calls.
+
+```ts
+import { openapi } from '@orpc/openapi'
+import { toTRPCMeta } from '@orpc/trpc'
+
+export const t = initTRPC.context<Context>().create()
+
+const example = t.procedure
+  .meta(toTRPCMeta(openapi({ path: '/hello', summary: 'Hello procedure' }))) // [!code highlight]
+  .input(z.object({ name: z.string() }))
+  .query(({ input }) => {
+    return `Hello, ${input.name}!`
+  })
+
+const merged = t.procedure
+  .meta({
+    ...toTRPCMeta( // [!code highlight]
+      openapi({ path: '/hello' }), // [!code highlight]
+      openapi({ method: 'POST' }), // [!code highlight]
+    ), // [!code highlight]
+    other: 'value',
+  })
+  .input(z.object({ name: z.string() }))
+  .mutation(({ input }) => {
+    return `Hello, ${input.name}!`
+  })
+```
+
+::: warning
+Chained tRPC `.meta()` calls merge shallowly, so oRPC metadata merge logic (e.g. accumulating `openapi.tags`) only works within a single `toTRPCMeta` call.
+:::

apps/content/docs/migrations/from-trpc.md

@@ -3,7 +3,7 @@
 This guide shows how to migrate an existing tRPC app to oRPC. Because oRPC is heavily inspired by tRPC, most concepts map directly, so the migration should feel familiar.
 
 ::: info
-If you want to add oRPC features to an existing tRPC app without a full migration, see [tRPC Integration](/docs/openapi/integrations/trpc).
+If you want to add oRPC features to an existing tRPC app without a full migration, see [tRPC Integration](/docs/integrations/trpc).
 :::
 
 ## Core Concepts Comparison

packages/trpc/.gitignore

@@ -0,0 +1,26 @@
+# Hidden folders and files
+.*
+!.gitignore
+!.*.example
+
+# Common generated folders
+logs/
+node_modules/
+out/
+dist/
+dist-ssr/
+build/
+coverage/
+temp/
+
+# Common generated files
+*.log
+*.log.*
+*.tsbuildinfo
+*.vitest-temp.json
+vite.config.ts.timestamp-*
+vitest.config.ts.timestamp-*
+
+# Common manual ignore files
+*.local
+*.pem

packages/trpc/README.md

@@ -0,0 +1,51 @@
+{
+  "name": "@orpc/trpc",
+  "type": "module",
+  "version": "2.0.0-beta.18",
+  "license": "MIT",
+  "homepage": "https://orpc.dev",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/middleapi/orpc.git",
+    "directory": "packages/trpc"
+  },
+  "keywords": [
+    "orpc",
+    "trpc"
+  ],
+  "sideEffects": false,
+  "publishConfig": {
+    "exports": {
+      "./package.json": "./package.json",
+      ".": {
+        "types": "./dist/index.d.mts",
+        "import": "./dist/index.mjs",
+        "default": "./dist/index.mjs"
+      }
+    }
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    ".": "./src/index.ts"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "unbuild",
+    "type:check": "tsc -b"
+  },
+  "peerDependencies": {
+    "@trpc/server": ">=11.4.2"
+  },
+  "dependencies": {
+    "@orpc/contract": "workspace:*",
+    "@orpc/server": "workspace:*",
+    "@orpc/shared": "workspace:*"
+  },
+  "devDependencies": {
+    "@orpc/openapi": "workspace:*",
+    "@trpc/server": "^11.12.0",
+    "zod": "^4.4.3"
+  }
+}

packages/trpc/package.json

@@ -0,0 +1,2 @@
+export * from './to-orpc-router'
+export * from './to-trpc-meta'

packages/trpc/src/index.ts

@@ -0,0 +1,99 @@
+import type { InferRouterInitialContext, Procedure, Router, Schema } from '@orpc/server'
+import type { AsyncIteratorClass } from '@orpc/shared'
+import type { TrackedData } from '@trpc/server/unstable-core-do-not-import'
+import { initTRPC, lazy, tracked, TRPCError } from '@trpc/server'
+import * as z from 'zod'
+import { toORPCRouter } from './to-orpc-router'
+
+type TRPCContext = { a: string }
+
+const inputSchema = z.object({ input: z.number().transform(n => `${n}`) })
+
+const outputSchema = z.object({ output: z.number().transform(n => `${n}`) })
+
+const t = initTRPC.context<(req: Request) => TRPCContext>().create()
+
+const trpcRouter = t.router({
+  ping: t.procedure
+    .input(inputSchema)
+    .output(outputSchema)
+    .query(({ input }) => {
+      return { output: Number(input.input) }
+    }),
+
+  throw: t.procedure
+    .input(z.object({ b: z.number(), c: z.string() }))
+    .query(() => {
+      throw new TRPCError({
+        code: 'PARSE_ERROR',
+        message: 'throw',
+      })
+    }),
+
+  subscribe: t.procedure
+    .input(z.object({ u: z.string() }))
+    .subscription(async function* () {
+      yield 'pong'
+      yield tracked('id-1', { order: 1 })
+    }),
+
+  nested: {
+    ping: t.procedure
+      .input(z.object({ a: z.string() }))
+      .output(z.string().transform(val => Number(val)))
+      .query(({ input }) => {
+        return `1234${input.a}`
+      }),
+  },
+
+  lazy: lazy(() => Promise.resolve({ default: t.router({
+    subscribe: t.procedure
+      .subscription(async function* () {
+        yield 'pong'
+      }),
+
+    lazy: lazy(() => Promise.resolve({ default: t.router({
+      throw: t.procedure
+        .input(inputSchema)
+        .output(outputSchema)
+        .query(() => {
+          throw new Error('lazy.lazy.throw')
+        }),
+    }) })),
+  }) })),
+})
+
+describe('toORPCRouter', () => {
+  const orpcRouter = toORPCRouter(trpcRouter)
+
+  expectTypeOf(orpcRouter).toExtend<Router<TRPCContext>>()
+
+  expectTypeOf<InferRouterInitialContext<typeof orpcRouter>>().toEqualTypeOf<{ a: string }>()
+
+  expectTypeOf(orpcRouter.ping).toEqualTypeOf<
+    Procedure<TRPCContext, object, Schema<{ input: number }, unknown>, Schema<unknown, { output: string }>, object, never>
+  >()
+
+  expectTypeOf(orpcRouter.throw).toEqualTypeOf<
+    Procedure<TRPCContext, object, Schema<{ b: number, c: string }, unknown>, Schema<unknown, never>, object, never>
+  >()
+
+  expectTypeOf(orpcRouter.subscribe).toEqualTypeOf<
+    Procedure<TRPCContext, object, Schema<{ u: string }, unknown>, Schema<unknown, AsyncIteratorClass<'pong' | TrackedData<{ order: number }>, void, any>>, object, never>
+  >()
+
+  expectTypeOf(orpcRouter.nested).toEqualTypeOf<
+    {
+      ping: Procedure<TRPCContext, object, Schema<{ a: string }, unknown>, Schema<unknown, number>, object, never>
+    }
+  >()
+
+  expectTypeOf(orpcRouter.lazy).toEqualTypeOf<
+    {
+      subscribe: Procedure<TRPCContext, object, Schema<void, unknown>, Schema<unknown, AsyncIteratorClass<string, void, any>>, object, never>
+      lazy: {
+        throw: Procedure<TRPCContext, object, Schema<{ input: number }, unknown>, Schema<unknown, { output: string }>, object, never>
+      }
+    }
+  >()
+})