docs: recommend use onError in handlers

apps/content/docs/adapters/astro.md

@@ -13,8 +13,15 @@ description: Use oRPC inside an Astro project
 
 ```ts [pages/rpc/[...rest].ts]
 import { RPCHandler } from '@orpc/server/fetch'
-
-const handler = new RPCHandler(router)
+import { onError } from '@orpc/server'
+
+const handler = new RPCHandler(router, {
+  interceptors: [
+    onError((error) => {
+      console.error(error)
+    }),
+  ],
+})
 
 export const prerender = false
 

apps/content/docs/adapters/browser.md

@@ -19,8 +19,15 @@ The browser extension [Message Passing API](https://developer.chrome.com/docs/ex
 
 ```ts [server]
 import { RPCHandler } from '@orpc/server/message-port'
-
-const handler = new RPCHandler(router)
+import { onError } from '@orpc/server'
+
+const handler = new RPCHandler(router, {
+  interceptors: [
+    onError((error) => {
+      console.error(error)
+    }),
+  ],
+})
 
 browser.runtime.onConnect.addListener((port) => {
   handler.upgrade(port, {
@@ -53,8 +60,15 @@ To enable communication between two window contexts (e.g. parent and popup), one
 
 ```ts [opener]
 import { RPCHandler } from '@orpc/server/message-port'
-
-const handler = new RPCHandler(router)
+import { onError } from '@orpc/server'
+
+const handler = new RPCHandler(router, {
+  interceptors: [
+    onError((error) => {
+      console.error(error)
+    }),
+  ],
+})
 
 window.addEventListener('message', (event) => {
   if (event.data instanceof MessagePort) {
@@ -123,8 +137,15 @@ window.addEventListener('message', (event) => {
 
 ```ts [server]
 import { RPCHandler } from '@orpc/server/message-port'
-
-const handler = new RPCHandler(router)
+import { onError } from '@orpc/server'
+
+const handler = new RPCHandler(router, {
+  interceptors: [
+    onError((error) => {
+      console.error(error)
+    }),
+  ],
+})
 
 browser.runtime.onConnect.addListener((port) => {
   handler.upgrade(port, {

apps/content/docs/adapters/electron.md

@@ -13,8 +13,15 @@ Listen for a port sent from the renderer, then upgrade it:
 
 ```ts
 import { RPCHandler } from '@orpc/server/message-port'
-
-const handler = new RPCHandler(router)
+import { onError } from '@orpc/server'
+
+const handler = new RPCHandler(router, {
+  interceptors: [
+    onError((error) => {
+      console.error(error)
+    }),
+  ],
+})
 
 app.whenReady().then(() => {
   ipcMain.on('start-orpc-server', async (event) => {

apps/content/docs/adapters/elysia.md

@@ -11,9 +11,16 @@ description: Use oRPC inside an Elysia project
 
 ```ts
 import { Elysia } from 'elysia'
-import { OpenAPIHandler } from '@orpc/openapi/fetch'
-
-const handler = new OpenAPIHandler(router)
+import { RPCHandler } from '@orpc/server/fetch'
+import { onError } from '@orpc/server'
+
+const handler = new RPCHandler(router, {
+  interceptors: [
+    onError((error) => {
+      console.error(error)
+    }),
+  ],
+})
 
 const app = new Elysia()
   .all('/rpc*', async ({ request }: { request: Request }) => {

apps/content/docs/adapters/express.md

@@ -17,12 +17,19 @@ Express's [body-parser](https://expressjs.com/en/resources/middleware/body-parse
 import express from 'express'
 import cors from 'cors'
 import { RPCHandler } from '@orpc/server/node'
+import { onError } from '@orpc/server'
 
 const app = express()
 
 app.use(cors())
 
-const handler = new RPCHandler(router)
+const handler = new RPCHandler(router, {
+  interceptors: [
+    onError((error) => {
+      console.error(error)
+    }),
+  ],
+})
 
 app.use('/rpc{/*path}', async (req, res, next) => {
   const { matched } = await handler.handle(req, res, {

apps/content/docs/adapters/h3.md

@@ -12,10 +12,17 @@ description: Use oRPC inside an H3 project
 ```ts
 import { H3, serve } from 'h3'
 import { RPCHandler } from '@orpc/server/fetch'
+import { onError } from '@orpc/server'
 
 const app = new H3()
 
-const handler = new RPCHandler(router)
+const handler = new RPCHandler(router, {
+  interceptors: [
+    onError((error) => {
+      console.error(error)
+    }),
+  ],
+})
 
 app.use('/rpc/**', async (event) => {
   const { matched, response } = await handler.handle(event.req, {

apps/content/docs/adapters/hono.md

@@ -12,10 +12,17 @@ description: Use oRPC inside an Hono project
 ```ts
 import { Hono } from 'hono'
 import { RPCHandler } from '@orpc/server/fetch'
+import { onError } from '@orpc/server'
 
 const app = new Hono()
 
-const handler = new RPCHandler(router)
+const handler = new RPCHandler(router, {
+  interceptors: [
+    onError((error) => {
+      console.error(error)
+    }),
+  ],
+})
 
 app.use('/rpc/*', async (c, next) => {
   const { matched, response } = await handler.handle(c.req.raw, {

apps/content/docs/adapters/http.md

@@ -22,11 +22,17 @@ oRPC includes built-in HTTP support, making it easy to expose RPC endpoints in a
 import { createServer } from 'node:http' // or 'node:http2'
 import { RPCHandler } from '@orpc/server/node'
 import { CORSPlugin } from '@orpc/server/plugins'
+import { onError } from '@orpc/server'
 
 const handler = new RPCHandler(router, {
   plugins: [
     new CORSPlugin()
-  ]
+  ],
+  interceptors: [
+    onError((error) => {
+      console.error(error)
+    }),
+  ],
 })
 
 const server = createServer(async (req, res) => {
@@ -49,11 +55,17 @@ server.listen(3000, '127.0.0.1', () => console.log('Listening on 127.0.0.1:3000'
 ```ts [bun]
 import { RPCHandler } from '@orpc/server/fetch'
 import { CORSPlugin } from '@orpc/server/plugins'
+import { onError } from '@orpc/server'
 
 const handler = new RPCHandler(router, {
   plugins: [
     new CORSPlugin()
-  ]
+  ],
+  interceptors: [
+    onError((error) => {
+      console.error(error)
+    }),
+  ],
 })
 
 Bun.serve({
@@ -75,11 +87,17 @@ Bun.serve({
 ```ts [cloudflare]
 import { RPCHandler } from '@orpc/server/fetch'
 import { CORSPlugin } from '@orpc/server/plugins'
+import { onError } from '@orpc/server'
 
 const handler = new RPCHandler(router, {
   plugins: [
     new CORSPlugin()
-  ]
+  ],
+  interceptors: [
+    onError((error) => {
+      console.error(error)
+    }),
+  ],
 })
 
 export default {
@@ -101,11 +119,17 @@ export default {
 ```ts [deno]
 import { RPCHandler } from '@orpc/server/fetch'
 import { CORSPlugin } from '@orpc/server/plugins'
+import { onError } from '@orpc/server'
 
 const handler = new RPCHandler(router, {
   plugins: [
     new CORSPlugin()
-  ]
+  ],
+  interceptors: [
+    onError((error) => {
+      console.error(error)
+    }),
+  ],
 })
 
 Deno.serve(async (request) => {
@@ -125,8 +149,15 @@ Deno.serve(async (request) => {
 ```ts [fastify]
 import Fastify from 'fastify'
 import { RPCHandler } from '@orpc/server/fastify'
-
-const rpcHandler = new RPCHandler(router)
+import { onError } from '@orpc/server'
+
+const rpcHandler = new RPCHandler(router, {
+  interceptors: [
+    onError((error) => {
+      console.error(error)
+    }),
+  ],
+})
 
 const fastify = Fastify()
 
@@ -152,8 +183,15 @@ fastify.listen({ port: 3000 }).then(() => console.log('Listening on 127.0.0.1:30
 ```ts [aws-lambda]
 import { APIGatewayProxyEventV2 } from 'aws-lambda'
 import { RPCHandler } from '@orpc/server/aws-lambda'
-
-const rpcHandler = new RPCHandler(router)
+import { onError } from '@orpc/server'
+
+const rpcHandler = new RPCHandler(router, {
+  interceptors: [
+    onError((error) => {
+      console.error(error)
+    }),
+  ],
+})
 
 /**
  * oRPC only supports [AWS Lambda response streaming](https://aws.amazon.com/blogs/compute/introducing-aws-lambda-response-streaming/).

apps/content/docs/adapters/message-port.md

@@ -25,8 +25,15 @@ const clientPort = channel.port2
 
 ```ts [server]
 import { RPCHandler } from '@orpc/server/message-port'
+import { onError } from '@orpc/server'
 
-const handler = new RPCHandler(router)
+const handler = new RPCHandler(router, {
+  interceptors: [
+    onError((error) => {
+      console.error(error)
+    }),
+  ],
+})
 
 handler.upgrade(serverPort, {
   context: {}, // Provide initial context if needed

apps/content/docs/adapters/next.md

@@ -19,8 +19,15 @@ You set up an oRPC server inside Next.js using its [Route Handlers](https://next
 
 ```ts [app/rpc/[[...rest]]/route.ts]
 import { RPCHandler } from '@orpc/server/fetch'
-
-const handler = new RPCHandler(router)
+import { onError } from '@orpc/server'
+
+const handler = new RPCHandler(router, {
+  interceptors: [
+    onError((error) => {
+      console.error(error)
+    }),
+  ],
+})
 
 async function handleRequest(request: Request) {
   const { response } = await handler.handle(request, {
@@ -49,8 +56,15 @@ The `handler` can be any supported oRPC handler, such as [RPCHandler](/docs/rpc-
 
 ```ts [pages/api/rpc/[[...rest]].ts]
 import { RPCHandler } from '@orpc/server/node'
-
-const handler = new RPCHandler(router)
+import { onError } from '@orpc/server'
+
+const handler = new RPCHandler(router, {
+  interceptors: [
+    onError((error) => {
+      console.error(error)
+    }),
+  ],
+})
 
 export const config = {
   api: {

apps/content/docs/adapters/nuxt.md

@@ -15,8 +15,15 @@ You set up an oRPC server inside Nuxt using its [Server Routes](https://nuxt.com
 
 ```ts [server/routes/rpc/[...].ts]
 import { RPCHandler } from '@orpc/server/fetch'
-
-const handler = new RPCHandler(router)
+import { onError } from '@orpc/server'
+
+const handler = new RPCHandler(router, {
+  interceptors: [
+    onError((error) => {
+      console.error(error)
+    }),
+  ],
+})
 
 export default defineEventHandler(async (event) => {
   const request = toWebRequest(event)

apps/content/docs/adapters/remix.md

@@ -11,8 +11,15 @@ description: Use oRPC inside an Remix project
 
 ```ts [app/routes/rpc.$.ts]
 import { RPCHandler } from '@orpc/server/fetch'
-
-const handler = new RPCHandler(router)
+import { onError } from '@orpc/server'
+
+const handler = new RPCHandler(router, {
+  interceptors: [
+    onError((error) => {
+      console.error(error)
+    }),
+  ],
+})
 
 export async function loader({ request }: LoaderFunctionArgs) {
   const { response } = await handler.handle(request, {

apps/content/docs/adapters/solid-start.md

@@ -14,8 +14,15 @@ description: Use oRPC inside a Solid Start project
 ```ts [src/routes/rpc/[...rest].ts]
 import type { APIEvent } from '@solidjs/start/server'
 import { RPCHandler } from '@orpc/server/fetch'
-
-const handler = new RPCHandler(router)
+import { onError } from '@orpc/server'
+
+const handler = new RPCHandler(router, {
+  interceptors: [
+    onError((error) => {
+      console.error(error)
+    }),
+  ],
+})
 
 async function handle({ request }: APIEvent) {
   const { response } = await handler.handle(request, {