chore: release v0.4.2

Update 2.server-side-calls.md

README.md

@@ -1,12 +1,10 @@
 # tRPC-Nuxt
 
-[![Version](https://img.shields.io/npm/v/trpc-nuxt?style=flat&colorA=000000&colorB=000000)](https://www.npmjs.com/package/trpc-nuxt)
-
 End-to-end typesafe APIs with [tRPC.io](https://trpc.io/) in Nuxt applications.
 
 <p align="center">
   <figure>
-    <img src="https://i.imgur.com/AjmNUxj.gif" alt="Demo" />
+    <img src="https://i.imgur.com/3AZlBZH.gif" alt="Demo" />
     <figcaption>
       <p align="center">
         The client above is <strong>not</strong> importing any code from the server, only its type declarations.
@@ -15,154 +13,9 @@ End-to-end typesafe APIs with [tRPC.io](https://trpc.io/) in Nuxt applications.
   </figure>
 </p>
 
-## Install
+Docs: https://trpc-nuxt.vercel.app
 
-```bash
+For version 3 of this module (tRPC v9, auto-imports, auto handlers), [go here](https://github.com/wobsoriano/trpc-nuxt/tree/v3).
-npm i trpc-nuxt
-```
-
-```ts
-// nuxt.config.ts
-import { defineNuxtConfig } from 'nuxt'
-
-export default defineNuxtConfig({
-  modules: ['trpc-nuxt'],
-  trpc: {
-    baseURL: '', // Set empty string (default) to make requests by relative address
-    endpoint: '/trpc', // defaults to /trpc
-    installPlugin: true, // defaults to true. Add @trpc/client plugin and composables
-  },
-  typescript: {
-    strict: true // required to make input/output types work
-  }
-})
-```
-
-## Usage
-
-Expose your tRPC [routes](https://trpc.io/docs/router) under `~/server/trpc/index.ts`:
-
-```ts
-// ~/server/trpc/index.ts
-import type { inferAsyncReturnType } from '@trpc/server'
-import * as trpc from '@trpc/server'
-import { z } from 'zod' //  yup/superstruct/zod/myzod/custom
-
-export const router = trpc.router()
-  // queries and mutations...
-  .query('getUsers', {
-    async resolve(req) {
-      // use your ORM of choice
-      return await UserModel.all()
-    },
-  })
-  .mutation('createUser', {
-    // validate input with Zod
-    input: z.object({ name: z.string().min(5) }),
-    async resolve(req) {
-      // use your ORM of choice
-      return await UserModel.create({
-        data: req.input,
-      })
-    },
-  })
-```
-
-Use the client like so:
-
-```ts
-const client = useClient() // auto-imported
-
-const users = await client.query('getUsers')
-
-const newUser = await client.mutation('createUser', {
-  name: 'wagmi'
-})
-```
-
-## useAsyncQuery
-
-A thin wrapper around [`useAsyncData`](https://v3.nuxtjs.org/api/composables/use-async-data/) and `client.query()`.
-
-The first argument is a `[path, input]`-tuple - if the `input` is optional, you can omit the, `input`-part.
-
-You'll notice that you get autocompletion on the `path` and automatic typesafety on the `input`.
-
-```ts
-const {
-  data,
-  pending,
-  error,
-  refresh
-} = await useAsyncQuery(['getUser', { id: 69 }], {
-  // pass useAsyncData options here
-  lazy: false
-})
-```
-
-## useClientHeaders
-
-A composable that lets you add additional properties to pass to the tRPC Client. It uses `useState` from [nuxt 3](https://v3.nuxtjs.org/api/composables/use-state).
-
-```ts
-const headers = useClientHeaders()
-
-const { data: token } = await useAsyncQuery(['auth.login', { username, password }])
-
-headers.value.Authorization = `Bearer ${token}`
-
-// All client calls will now include the Authorization header.
-```
-
-If your app needs transformers and other option that needs to be passed in `@trpc/client`, you will need to opt-out of the plugin by setting `installPlugin` to false in your `nuxt.config.ts` file and create your own. You can just copy the contents of the client plugin [here](https://github.com/wobsoriano/trpc-nuxt/blob/master/src/runtime/client.ts).
-
-## Options
-
-trpc-nuxt accepts the following options exposed under `~/server/trpc/index.ts`:
-
-```ts
-import * as trpc from '@trpc/server'
-import type { inferAsyncReturnType } from '@trpc/server'
-import type { H3Event } from 'h3'
-import type { OnErrorPayload } from 'trpc-nuxt/api'
-
-export const router = trpc.router<inferAsyncReturnType<typeof createContext>>()
-
-// Optional
-// https://trpc.io/docs/context
-export const createContext = (event: H3Event) => {
-  // ...
-  return {
-    /** context data */
-  }
-}
-
-// Optional
-// https://trpc.io/docs/caching#using-responsemeta--to-cache-responses
-export const responseMeta = () => {
-  // ...
-  return {
-    // { headers: ... }
-  }
-}
-
-// Optional
-// https://trpc.io/docs/error-handling#handling-errors
-export const onError = (payload: OnErrorPayload<typeof router>) => {
-  // Do whatever here like send to bug reporting and stuff
-}
-```
-
-## Recipes
-
-- [Validation](/recipes/validation.md)
-- [Authorization](/recipes/authorization.md)
-- [Merging Routers](/recipes/merging-routers.md)
-- [Error Handling](/recipes/error-handling.md)
-- [Error Formatting](/recipes/error-formatting.md)
-- [Inference Helpers](/recipes/inference-helpers.md)
-
-Learn more about tRPC.io [here](https://trpc.io/docs/v9).
 
 ## Recommended IDE Setup
 

api.d.ts

@@ -1 +0,0 @@
-export * from './dist/runtime/api'

docs/.gitignore

@@ -0,0 +1 @@
+.vercel

docs/README.md

@@ -0,0 +1 @@
+docs

docs/app.config.ts

@@ -0,0 +1,25 @@
+export default defineAppConfig({
+  docus: {
+    title: 'tRPC Nuxt',
+    image: 'https://og-image.vercel.app/tRPC-Nuxt',
+    alt: 'tRPC-Nuxt cover',
+    url: 'https://trpc-nuxt.vercel.app',
+    debug: false,
+    socials: {
+      github: 'wobsoriano/trpc-nuxt'
+    },
+    aside: {
+      level: 1
+    },
+    footer: {
+      credits: true,
+      icons: [
+        {
+          label: 'NuxtJS',
+          href: 'https://nuxtjs.org',
+          component: 'IconNuxt'
+        }
+      ]
+    }
+  }
+})

docs/content/1.get-started/1.installation.md

@@ -0,0 +1,38 @@
+---
+title: Installation
+description: tRPC-Nuxt provides first class integration with tRPC.
+---
+
+# Installation
+
+::code-group
+
+```bash [pnpm]
+pnpm add @trpc/server@next @trpc/client@next trpc-nuxt zod
+```
+
+```bash [npm]
+npm install @trpc/server@next @trpc/client@next trpc-nuxt zod
+```
+
+```bash [yarn]
+yarn add @trpc/server@next @trpc/client@next trpc-nuxt zod
+```
+
+::
+
+#### Why @trpc/server?
+
+For implementing tRPC endpoints and routers.
+
+#### Why @trpc/client?
+
+For making typesafe API calls from your client.
+
+#### Why zod?
+
+Most examples use [Zod](https://github.com/colinhacks/zod) for input validation and tRPC.io highly recommends it, though it isn't required.
+
+## Next Steps
+
+Now that you've installed the required dependencies, you are ready to start building your application.

docs/content/1.get-started/2.usage.md

@@ -0,0 +1,130 @@
+---
+title: Usage
+description: tRPC-Nuxt provides first class integration with tRPC.
+---
+
+# Usage
+
+## Recommended file structure
+
+Recommended but not enforced file structure. This is what you get when starting from [the examples](../main/example-apps.md).
+
+```graphql
+.
+├── server
+│   ├── api
+│   │   └── trpc
+│   │       └── [trpc].ts  # <-- tRPC HTTP handler
+│   │   └── [..]
+│   ├── trpc
+│   │   ├── routers
+│   │   │   ├── index.ts  # <-- main app router
+│   │   │   ├── todo.ts  # <-- sub routers
+│   │   │   └── [..]
+│   │   ├── context.ts   # <-- create app context
+│   │   └── trpc.ts      # <-- procedure helpers
+├── plugins
+│   ├── client.ts  # <-- tRPC Client as a plugin
+└── [..]
+```
+
+## 1. Create a tRPC router
+
+Initialize your tRPC backend using the `initTRPC` function and create your first router.
+
+::code-group
+
+```ts [server/trpc/trpc.ts]
+import { initTRPC } from '@trpc/server'
+
+// Avoid exporting the entire t-object since it's not very
+// descriptive and can be confusing to newcomers used to t
+// meaning translation in i18n libraries.
+const t = initTRPC.create()
+
+// Base router and procedure helpers
+export const router = t.router
+export const publicProcedure = t.procedure
+```
+
+```ts [server/trpc/routers/index.ts]
+import { z } from 'zod'
+import { publicProcedure, router } from '../trpc'
+
+export const appRouter = router({
+  hello: publicProcedure
+    .input(
+      z.object({
+        text: z.string().nullish(),
+      }),
+    )
+    .query(({ input }) => {
+      return {
+        greeting: `hello ${input?.text ?? 'world'}`,
+      }
+    }),
+})
+
+// export type definition of API
+export type AppRouter = typeof appRouter
+```
+
+```ts [server/api/trpc/[trpc].ts]
+import { createNuxtApiHandler } from 'trpc-nuxt'
+import { appRouter } from '@/server/trpc/routers'
+
+// export API handler
+export default createNuxtApiHandler({
+  router: appRouter,
+  createContext: () => ({}),
+})
+```
+
+::
+
+::alert{type=info}
+If you need to split your router into several subrouters, you can implement them in the `server/trpc/routers` directory and import and [merge them](https://trpc.io/docs/v10/merging-routers) to a single root `appRouter`.
+::
+
+## 2. Create tRPC client plugin
+
+Create a strongly-typed plugin using your API's type signature.
+
+```ts [plugins/client.ts]
+import { httpBatchLink, createTRPCProxyClient } from '@trpc/client'
+import type { AppRouter } from '@/server/trpc/routers'
+
+export default defineNuxtPlugin(() => {
+  const client = createTRPCProxyClient<AppRouter>({
+    links: [
+      httpBatchLink({
+        /**
+         * If you want to use SSR, you need to use the server's full URL
+         * @link https://trpc.io/docs/ssr
+         **/
+        url: 'http://localhost:3000/api/trpc',
+      }),
+    ],
+  })
+
+  return {
+    provide: {
+      client,
+    },
+  }
+})
+```
+
+## 3. Make API requests
+
+```vue [pages/index.vue]
+<script setup lang="ts">
+const { $client } = useNuxtApp()
+
+const data = await $client.hello.query({ text: 'client' })
+</script>
+
+<template>
+  <p>{{data?.greeting }}</p>
+</template>
+```

docs/content/1.get-started/3.tips/1.composables.md

@@ -0,0 +1,40 @@
+---
+title: Composables
+---
+
+# Composables
+
+It is often useful to wrap functionality of your `@trpc/client` api within other functions. For this purpose, it's necessary to be able to infer input types and output types generated by your `@trpc/server` router.
+
+## Inference Helpers
+
+`@trpc/server` exports the following helper types to assist with inferring these types from the `AppRouter` exported by your `@trpc/server` router:
+
+- `inferRouterInputs<TRouter>`
+- `inferRouterOutputs<TRouter>`
+
+Let's assume we have this example query wrapped within Nuxt's [useAsyncData](https://v3.nuxtjs.org/api/composables/use-async-data/):
+
+```ts
+const { data, error } = await useAsyncData(() => $client.todo.getTodos.query())
+```
+
+We can wrap this in a composable and also set the client error types:
+
+```ts [composables/useGetTodos.ts]
+import { TRPCClientError } from '@trpc/client'
+import type { inferRouterOutputs } from '@trpc/server'
+import type { AppRouter } from '@/server/trpc/routers'
+
+type RouterOutput = inferRouterOutputs<AppRouter>
+type GetTodosOutput = RouterOutput['todo']['getTodos']
+
+type ErrorOutput = TRPCClientError<AppRouter>
+
+export default function useGetTodos() {
+  const { $client } = useNuxtApp()
+  return useAsyncData<GetTodosOutput, ErrorOutput>(() => $client.todo.getTodos.query())
+}
+```
+
+Now, we have a fully-typed composable.

docs/content/1.get-started/3.tips/2.server-side-calls.md

@@ -0,0 +1,84 @@
+---
+title: Server Side Calls
+---
+
+# Server Side Calls
+
+You may need to call your procedure(s) directly from the server, `createCaller()` function returns you an instance of `RouterCaller` able to execute queries and mutations.
+
+## Input query example
+
+We create the router with a input query and then we call the asynchronous `greeting` procedure to get the result.
+
+::code-group
+
+```ts [server/trpc/trpc.ts]
+import { initTRPC } from '@trpc/server'
+import { z } from 'zod'
+ 
+const t = initTRPC.create()
+ 
+export const router = t.router({
+  // Create procedure at path 'greeting'
+  greeting: t.procedure
+    .input(z.object({ name: z.string() }))
+    .query(({ input }) => `Hello ${input.name}`),
+})
+```
+
+```ts [server/api/greeting.ts]
+import { router } from '@/server/trpc/trpc'
+
+export default eventHandler(async (event) => {
+  const { name } = getQuery(event)
+  const caller = router.createCaller({})
+
+  const greeting = await caller.greeting({ name })
+
+  return {
+    greeting
+  }
+})
+```
+
+::
+
+## Mutation example
+
+We create the router with a mutation and then we call the asynchronous `post` procedure to get the result.
+
+::code-group
+
+```ts [server/trpc/trpc.ts]
+import { initTRPC } from '@trpc/server'
+import { z } from 'zod'
+ 
+const posts = ['One', 'Two', 'Three']
+ 
+const t = initTRPC.create()
+export const router = t.router({
+  post: t.router({
+    add: t.procedure.input(z.string()).mutation(({ input }) => {
+      posts.push(input)
+      return posts
+    }),
+  }),
+})
+```
+
+```ts [server/api/post.ts]
+import { router } from '@/server/trpc/trpc'
+
+export default eventHandler(async (event) => {
+  const body = await getBody(event)
+  const caller = router.createCaller({})
+
+  const post = await caller.post.add(body.post)
+
+  return {
+    post
+  }
+})
+```
+
+::

docs/content/1.get-started/3.tips/3.aborting-procedures.md

@@ -0,0 +1,24 @@
+---
+title: Aborting Procedures
+---
+
+# Aborting Procedures
+
+tRPC adheres to the industry standard when it comes to aborting procedures. All you have to do is pass an `AbortSignal` to the query-options and then call its parent `AbortController`'s `abort` method.
+
+```ts [composables/useGetTodo.ts]
+export default function useGetTodo(id: number) {
+  const { $client } = useNuxtApp()
+  const ac = new AbortController()
+
+  onScopeDispose(() => {
+    ac.abort()
+  })
+  
+  return useAsyncData(() => {
+    return $client.todo.getTodo.query(id, {
+      signal: ac.signal
+    })
+  })
+}
+```

docs/content/1.get-started/3.tips/4.authorization.md

@@ -0,0 +1,104 @@
+---
+title: Authorization
+---
+
+# Authorization
+
+The `createContext` function is called for each incoming request so here you can add contextual information about the calling user from the request object.
+
+## Create context from request headers
+
+```ts [server/trpc/context.ts]
+import type { H3Event } from 'h3'
+import { inferAsyncReturnType } from '@trpc/server'
+import { decodeAndVerifyJwtToken } from './somewhere/in/your/app/utils'
+
+export async function createContext({
+  req,
+  res,
+}: H3Event) {
+  // Create your context based on the request object
+  // Will be available as `ctx` in all your resolvers
+
+  // This is just an example of something you might want to do in your ctx fn
+  async function getUserFromHeader() {
+    if (req.headers.authorization) {
+      const user = await decodeAndVerifyJwtToken(
+        req.headers.authorization.split(' ')[1],
+      )
+      return user
+    }
+    return null
+  }
+  const user = await getUserFromHeader()
+
+  return {
+    user,
+  }
+}
+type Context = inferAsyncReturnType<typeof createContext>
+```
+
+## Option 1: Authorize using resolver
+
+```ts
+import { TRPCError, initTRPC } from '@trpc/server'
+import type { Context } from '../context'
+
+export const t = initTRPC.context<Context>().create()
+
+const appRouter = t.router({
+  // open for anyone
+  hello: t.procedure
+    .input(z.string().nullish())
+    .query(({ input, ctx }) => `hello ${input ?? ctx.user?.name ?? 'world'}`),
+  // checked in resolver
+  secret: t.procedure.query(({ ctx }) => {
+    if (!ctx.user) {
+      throw new TRPCError({ code: 'UNAUTHORIZED' })
+    }
+    return {
+      secret: 'sauce',
+    }
+  }),
+})
+```
+
+## Option 2: Authorize using middleware
+
+```ts
+import { TRPCError, initTRPC } from '@trpc/server'
+
+export const t = initTRPC.context<Context>().create()
+
+const isAuthed = t.middleware(({ next, ctx }) => {
+  if (!ctx.user?.isAdmin) {
+    throw new TRPCError({ code: 'UNAUTHORIZED' })
+  }
+  return next({
+    ctx: {
+      user: ctx.user,
+    },
+  })
+})
+
+// you can reuse this for any procedure
+export const protectedProcedure = t.procedure.use(isAuthed)
+
+t.router({
+  // this is accessible for everyone
+  hello: t.procedure
+    .input(z.string().nullish())
+    .query(({ input, ctx }) => `hello ${input ?? ctx.user?.name ?? 'world'}`),
+  admin: t.router({
+    // this is accessible only to admins
+    secret: protectedProcedure.query(({ ctx }) => {
+      return {
+        secret: 'sauce',
+      }
+    }),
+  }),
+})
+```
+
+This page is entirely based on [authorization docs](https://trpc.io/docs/v10/authorization) of tRPC with a minimal change made to work with Nuxt.

docs/content/1.get-started/index.md

@@ -0,0 +1,4 @@
+---
+navigation: false
+redirect: /get-started/installation
+---

docs/content/2.examples/1.basic.md

@@ -0,0 +1,6 @@
+---
+title: Basic
+description: tRPC-Nuxt provides first class integration with tRPC.
+---
+
+# Basic Example

docs/content/2.examples/2.multiple-routers.md

@@ -0,0 +1,6 @@
+---
+title: Multiple Routers
+description: tRPC-Nuxt provides first class integration with tRPC.
+---
+
+# Multi Routers

docs/content/index.md

@@ -0,0 +1,31 @@
+---
+title: "tRPC Nuxt"
+description: "End-to-end typesafe APIs in Nuxt applications."
+navigation: false
+layout: page
+---
+
+::block-hero
+---
+cta:
+  - Get Started
+  - /get-started/installation
+secondary:
+  - Star on GitHub ->
+  - https://github.com/wobsoriano/trpc-nuxt
+snippet: npm install trpc-nuxt
+---
+
+#title
+tRPC [Nuxt]{.text-primary-500}
+
+#description
+End-to-end typesafe APIs in Nuxt applications. 
+
+#extra
+  ::list
+  - Automatic typesafety 
+  - Snappy DX
+  - Autocompletion on the client, for inputs, outputs and errors
+  ::
+::

docs/nuxt.config.ts

@@ -0,0 +1,22 @@
+export default defineNuxtConfig({
+  app: {
+    pageTransition: false,
+    layoutTransition: false
+  },
+  modules: ['@nuxtlabs/github-module'],
+  extends: process.env.DOCUS_THEME_PATH || '@nuxt-themes/docus',
+  github: {
+    owner: 'wobsoriano',
+    repo: 'trpc-nuxt',
+    branch: 'next'
+  },
+  colorMode: {
+    preference: 'dark'
+  },
+  build: {
+    transpile: [/content-edge/, /github-module/]
+  },
+  nitro: {
+    preset: 'vercel'
+  }
+})

docs/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "docs",
+  "description": "Docs for TRPC-Nuxt",
+  "scripts": {
+    "dev": "nuxi dev",
+    "build": "nuxi build",
+    "generate": "nuxi build",
+    "preview": "nuxi preview"
+  },
+  "dependencies": {
+    "nuxt": "^3.0.0"
+  },
+  "devDependencies": {
+    "@nuxt-themes/docus": "^0.3.1",
+    "@nuxtlabs/github-module": "^1.5.3"
+  }
+}

docs/tokens.config.ts

@@ -0,0 +1,18 @@
+import { defineTheme } from 'pinceau'
+
+export default defineTheme({
+  colors: {
+    primary: {
+      50: '#BFEDFC',
+      100: '#B0E9FB',
+      200: '#93DEFA',
+      300: '#76D4F9',
+      400: '#58C8F7',
+      500: '#3BBBF6',
+      600: '#0BA6F3',
+      700: '#0981C2',
+      800: '#075E91',
+      900: '#043D61'
+    }
+  }
+})

docs/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "./.nuxt/tsconfig.json"
+}

package.json

@@ -1,64 +1,68 @@
 {
   "name": "trpc-nuxt",
+  "description": "End-to-end typesafe APIs in Nuxt applications.",
   "type": "module",
-  "version": "0.3.3",
+  "version": "0.4.2",
   "license": "MIT",
-  "main": "./dist/module.cjs",
+  "sideEffects": false,
-  "types": "./dist/types.d.ts",
   "exports": {
-    "./package.json": "./package.json",
     ".": {
-      "require": "./dist/module.cjs",
+      "require": "./dist/index.cjs",
-      "import": "./dist/module.mjs"
+      "import": "./dist/index.mjs"
-    },
-    "./api": {
-      "types": "./dist/runtime/api.d.ts",
-      "import": "./dist/runtime/api.mjs"
     }
   },
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
   "files": [
-    "dist",
+    "dist"
-    "*.d.ts"
   ],
   "scripts": {
+    "dev": "concurrently \"pnpm build --watch\" \"pnpm --filter playground dev\"",
+    "dev:prepare": "pnpm build && nuxt prepare playground",
     "prepublishOnly": "pnpm build",
-    "build": "nuxt-module-build",
+    "build": "tsup",
-    "play": "pnpm build && nuxi dev playground",
-    "build:playground": "nuxi build playground",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
-    "release": "bumpp --commit --push --tag && npm publish",
+    "release": "bumpp && npm publish"
-    "prepare": "nuxi prepare playground"
   },
   "peerDependencies": {
-    "@trpc/client": "<10.0.0",
+    "@trpc/client": "^10.0.0-proxy-beta.21",
-    "@trpc/server": "<10.0.0"
+    "@trpc/server": "^10.0.0-proxy-beta.21"
   },
   "dependencies": {
-    "@nuxt/kit": "3.0.0-rc.13",
+    "h3": "^1.0.1",
-    "@trpc/client": "^9.27.4",
+    "nanoid": "^4.0.0",
-    "@trpc/server": "^9.27.4",
+    "ohash": "^1.0.0",
-    "dedent": "^0.7.0",
+    "ufo": "^1.0.0"
-    "defu": "^6.1.0",
-    "h3": "^0.8.6",
-    "ohash": "^0.1.5",
-    "pathe": "^0.3.9",
-    "ufo": "^0.8.6"
   },
   "devDependencies": {
-    "@antfu/eslint-config": "^0.23.1",
+    "@nuxtjs/eslint-config-typescript": "^11.0.0",
-    "@nuxt/module-builder": "^0.2.0",
+    "@trpc/client": "10.0.0-rc.8",
-    "@types/dedent": "^0.7.0",
+    "@trpc/server": "10.0.0-rc.8",
-    "bumpp": "^7.2.0",
+    "bumpp": "^8.2.1",
+    "concurrently": "^7.5.0",
     "eslint": "^8.25.0",
-    "nuxt": "3.0.0-rc.13",
+    "tsup": "6.4.0",
-    "trpc-nuxt": "workspace:*",
+    "typescript": "^4.7.4"
-    "zod": "^3.19.1"
   },
   "eslintConfig": {
-    "extends": "@antfu",
+    "extends": [
+      "@nuxtjs/eslint-config-typescript"
+    ],
     "rules": {
-      "no-console": "warn"
+      "@typescript-eslint/no-unused-vars": [
+        "off"
+      ],
+      "vue/multi-word-component-names": "off",
+      "vue/no-multiple-template-root": "off"
     }
-  }
+  },
+  "eslintIgnore": [
+    "*.json",
+    "node_modules",
+    "*.md",
+    "dist",
+    ".output"
+  ]
 }

playground/nuxt.config.ts

@@ -1,9 +1,3 @@
-import Module from '../src/module'
-
 // https://v3.nuxtjs.org/api/configuration/nuxt.config
 export default defineNuxtConfig({
-  modules: [Module],
-  runtimeConfig: {
-    baseURL: '',
-  },
 })

playground/package.json

@@ -1,4 +1,21 @@
 {
   "name": "playground",
-  "private": true
+  "private": true,
+  "scripts": {
+    "build": "nuxt build",
+    "dev": "nuxt dev",
+    "generate": "nuxt generate",
+    "preview": "nuxt preview",
+    "postinstall": "nuxt prepare"
+  },
+  "dependencies": {
+    "@trpc/client": "10.0.0-rc.8",
+    "@trpc/server": "10.0.0-rc.8",
+    "superjson": "^1.11.0",
+    "trpc-nuxt": "workspace:*",
+    "zod": "^3.19.1"
+  },
+  "devDependencies": {
+    "nuxt": "^3.0.0"
+  }
 }

playground/pages/cookie.vue

@@ -1,19 +0,0 @@
-<script setup lang="ts">
-const counter = useCookie('counter')
-counter.value = counter.value || Math.round(Math.random() * 1000)
-</script>
-
-<template>
-  <div>
-    <h1> Counter: {{ counter || '-' }}</h1>
-    <button @click="counter = null">
-      reset
-    </button>
-    <button @click="counter--">
-      -
-    </button>
-    <button @click="counter++">
-      +
-    </button>
-  </div>
-</template>

playground/pages/index.vue

@@ -1,55 +1,61 @@
 <script setup lang="ts">
-const client = useClient()
+import { TRPCClientError } from '@trpc/client';
-const headers = useClientHeaders()
+import type { inferRouterOutputs } from '@trpc/server';
-const { data: todos, pending, error, refresh } = await useAsyncQuery(['getTodos'])
+import type { AppRouter } from '~~/server/trpc/routers';
 
-const addHeader = () => {
+const { $client } = useNuxtApp()
-  headers.value.authorization = 'Bearer abcdefghijklmnop'
+// const headers = useClientHeaders()
-  console.log(headers.value)
+
-}
+// const addHeader = () => {
+//   headers.value.authorization = 'Bearer abcdefghijklmnop'
+//   console.log(headers.value)
+// }
 
 const addTodo = async () => {
   const title = Math.random().toString(36).slice(2, 7)
 
   try {
-    const result = await client.mutation('addTodo', {
+    const x = await $client.todo.addTodo.mutate({
       id: Date.now(),
       userId: 69,
       title,
-      completed: false,
+      completed: false
     })
-    console.log('Todo: ', result)
+    console.log(x)
-  }
+  } catch (e) {
-  catch (e) {
     console.log(e)
   }
 }
+
+type RouterOutput = inferRouterOutputs<AppRouter>;
+type ErrorOutput = TRPCClientError<AppRouter>
+
+const { data: todos, pending, error, refresh } = await useAsyncData<RouterOutput['todo']['getTodos'], ErrorOutput>(() => $client.todo.getTodos.query())
 </script>
 
 <template>
-  <div v-if="pending">
+  <div>
-    Loading...
+    <div v-if="pending">
-  </div>
+      Loading...
-  <div v-else-if="error?.data?.code">
+    </div>
-    Error: {{ error.data.code }}
+    <div v-else-if="error?.data?.code">
-  </div>
+      Error: {{ error.data.code }}
-  <div v-else-if="todos">
+    </div>
-    <ul>
+    <div v-else>
-      <li v-for="t in todos.slice(0, 10)" :key="t.id">
+      <ul>
-        <NuxtLink :class="{ completed: t.completed }" :to="`/todo/${t.id}`">
+        <li v-for="t in todos?.slice(0, 10)" :key="t.id">
-          Title: {{ t.title }}
+          <NuxtLink :class="{ completed: t.completed }" :to="`/todo/${t.id}`">
-        </NuxtLink>
+            Title: {{ t.title }}
-      </li>
+          </NuxtLink>
-    </ul>
+        </li>
-    <button @click="addTodo">
+      </ul>
-      Add Todo
+      <button @click="addTodo">
-    </button>
+        Add Todo
-    <button @click="() => refresh()">
+      </button>
-      Refresh
+      <button @click="() => refresh()">
-    </button>
+        Refresh
-    <button @click="addHeader">
+      </button>
-      Add header
+    </div>
-    </button>
   </div>
 </template>
 

playground/pages/todo/[id].vue

@@ -1,6 +1,7 @@
 <script setup lang="ts">
 const route = useRoute()
-const { data: todo, pending, error } = await useAsyncQuery(['getTodo', Number(route.params.id)])
+const { $client } = useNuxtApp()
+const { data: todo, pending, error } = await useAsyncData(() => $client.todo.getTodo.query(Number(route.params.id)))
 </script>
 
 <template>
@@ -11,8 +12,8 @@ const { data: todo, pending, error } = await useAsyncQuery(['getTodo', Number(ro
     {{ error.data.code }}
   </div>
   <div v-else>
-    ID: {{ todo.id }} <br>
+    ID: {{ todo?.id }} <br>
-    Title: {{ todo.title }} <br>
+    Title: {{ todo?.title }} <br>
-    Completed: {{ todo.completed }}
+    Completed: {{ todo?.completed }}
   </div>
 </template>

playground/plugins/trpc-client.ts

@@ -0,0 +1,26 @@
+import { createTRPCProxyClient, httpBatchLink, loggerLink } from '@trpc/client'
+import superjson from 'superjson'
+import type { AppRouter } from '~~/server/trpc/routers'
+
+export default defineNuxtPlugin(() => {
+  const client = createTRPCProxyClient<AppRouter>({
+    transformer: superjson,
+    links: [
+      // adds pretty logs to your console in development and logs errors in production
+      loggerLink({
+        enabled: opts =>
+          process.env.NODE_ENV === 'development' ||
+          (opts.direction === 'down' && opts.result instanceof Error)
+      }),
+      httpBatchLink({
+        url: 'http://localhost:3000/api/trpc'
+      })
+    ]
+  })
+
+  return {
+    provide: {
+      client
+    }
+  }
+})

playground/server/api/trpc/[trpc].ts

@@ -0,0 +1,23 @@
+import { createNuxtApiHandler } from 'trpc-nuxt'
+import { appRouter } from '@/server/trpc/routers'
+import { createContext } from '@/server/trpc/context'
+
+export default createNuxtApiHandler({
+  router: appRouter,
+  /**
+   * @link https://trpc.io/docs/context
+   */
+  createContext,
+  onError ({ error }) {
+    if (error.code === 'INTERNAL_SERVER_ERROR') {
+      // send to bug reporting
+      console.error('Something went wrong', error)
+    }
+  }
+  /**
+   * @link https://trpc.io/docs/caching#api-response-caching
+   */
+  // responseMeta() {
+  //   // ...
+  // },
+})

playground/server/trpc/context.ts

@@ -0,0 +1,17 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import type { inferAsyncReturnType } from '@trpc/server'
+import type { H3Event } from 'h3'
+
+export type Context = inferAsyncReturnType<typeof createContext>
+
+/**
+ * Creates context for an incoming request
+ * @link https://trpc.io/docs/context
+ */
+export function createContext (
+  opts: H3Event
+) {
+  // for API-response caching see https://trpc.io/docs/caching
+
+  return {}
+}

playground/server/trpc/index.ts

@@ -1,53 +0,0 @@
-import * as trpc from '@trpc/server'
-import type { inferAsyncReturnType } from '@trpc/server'
-import { z } from 'zod'
-import type { H3Event } from 'h3'
-
-const baseURL = 'https://jsonplaceholder.typicode.com'
-
-const TodoShape = z.object({
-  userId: z.number(),
-  id: z.number(),
-  title: z.string(),
-  completed: z.boolean(),
-})
-
-export type Todo = z.infer<typeof TodoShape>
-
-export const router = trpc.router<Context>()
-  .query('getTodos', {
-    async resolve() {
-      return await $fetch<Todo[]>(`${baseURL}/todos`)
-    },
-  })
-  .query('getTodo', {
-    input: z.number(),
-    async resolve(req) {
-      return await $fetch<Todo>(`${baseURL}/todos/${req.input}`)
-    },
-  })
-  .mutation('addTodo', {
-    input: TodoShape,
-    async resolve(req) {
-      console.log(req.input)
-      return await $fetch<Todo>(`${baseURL}/todos`, {
-        method: 'POST',
-        body: req.input,
-      })
-    },
-  })
-
-export async function createContext(event: H3Event) {
-  // Create your context based on the request object
-  // Will be available as `ctx` in all your resolvers
-
-  // This is just an example of something you'd might want to do in your ctx fn
-  // const x = useCookies(event)
-  console.log(event.req.headers)
-
-  return {
-
-  }
-}
-
-  type Context = inferAsyncReturnType<typeof createContext>

playground/server/trpc/routers/index.ts

@@ -0,0 +1,10 @@
+import { router } from '../trpc'
+import { todoRouter } from './todo'
+import { userRouter } from './user'
+
+export const appRouter = router({
+  todo: todoRouter,
+  user: userRouter
+})
+
+export type AppRouter = typeof appRouter

playground/server/trpc/routers/todo.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod'
+import { publicProcedure, router } from '../trpc'
+
+const baseURL = 'https://jsonplaceholder.typicode.com'
+
+const TodoShape = z.object({
+  userId: z.number(),
+  id: z.number(),
+  title: z.string(),
+  completed: z.boolean()
+})
+
+export type Todo = z.infer<typeof TodoShape>
+
+export const todoRouter = router({
+  getTodos: publicProcedure
+    .query(() => {
+      return $fetch<Todo[]>(`${baseURL}/todos`)
+    }),
+  getTodo: publicProcedure
+    .input(z.number())
+    .query((req) => {
+      return $fetch<Todo>(`${baseURL}/todos/${req.input}`)
+    }),
+  addTodo: publicProcedure
+    .input(TodoShape)
+    .mutation((req) => {
+      return $fetch<Todo>(`${baseURL}/todos`, {
+        method: 'POST',
+        body: req.input
+      })
+    })
+})

playground/server/trpc/routers/user.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod'
+import { publicProcedure, router } from '../trpc'
+
+const baseURL = 'https://jsonplaceholder.typicode.com'
+
+const UserShape = z.object({
+  id: z.number(),
+  name: z.string(),
+  username: z.string(),
+  email: z.string()
+})
+
+export type User = z.infer<typeof UserShape>
+
+export const userRouter = router({
+  getUsers: publicProcedure
+    .query(() => {
+      return $fetch<User[]>(`${baseURL}/users`)
+    }),
+  getUser: publicProcedure
+    .input(z.number())
+    .query((req) => {
+      return $fetch<User>(`${baseURL}/users/${req.input}`)
+    }),
+  addUser: publicProcedure
+    .input(UserShape)
+    .mutation((req) => {
+      return $fetch<User>(`${baseURL}/users`, {
+        method: 'POST',
+        body: req.input
+      })
+    })
+})

playground/server/trpc/trpc.ts

@@ -0,0 +1,43 @@
+import { initTRPC } from '@trpc/server'
+import superjson from 'superjson'
+import { ZodError } from 'zod'
+import type { Context } from './context'
+
+const t = initTRPC.context<Context>().create({
+  transformer: superjson,
+  errorFormatter ({ shape, error }) {
+    return {
+      ...shape,
+      data: {
+        ...shape.data,
+        zodError:
+          error.code === 'BAD_REQUEST' &&
+          error.cause instanceof ZodError
+            ? error.cause!.flatten()
+            : null
+      }
+    }
+  }
+})
+
+/**
+ * Create a router
+ * @see https://trpc.io/docs/v10/router
+ */
+export const router = t.router
+
+/**
+  * Create an unprotected procedure
+  * @see https://trpc.io/docs/v10/procedures
+  **/
+export const publicProcedure = t.procedure
+
+/**
+  * @see https://trpc.io/docs/v10/middlewares
+  */
+export const middleware = t.middleware
+
+/**
+  * @see https://trpc.io/docs/v10/merging-routers
+  */
+export const mergeRouters = t.mergeRouters

playground/tsconfig.json

@@ -0,0 +1,4 @@
+{
+  // https://v3.nuxtjs.org/concepts/typescript
+  "extends": "./.nuxt/tsconfig.json"
+}

pnpm-workspace.yaml

@@ -1,2 +1,3 @@
 packages:
   - playground
+  - docs

recipes/authorization.md

@@ -1,102 +0,0 @@
-## Authorization
-
-The `createContext`-function is called for each incoming request so here you can add contextual information about the calling user from the request object.
-
-### Create context from request headers
-
-```ts
-// ~/server/trpc/index.ts
-import type { inferAsyncReturnType } from '@trpc/server'
-import type { H3Event } from 'h3'
-import { decodeAndVerifyJwtToken } from '~/somewhere/in/your/app/utils'
-
-// The app's context - is generated for each incoming request
-export async function createContext({ req }: H3Event) {
-  // Create your context based on the request object
-  // Will be available as `ctx` in all your resolvers
-
-  // This is just an example of something you'd might want to do in your ctx fn
-  async function getUserFromHeader() {
-    if (req.headers.authorization) {
-      const user = await decodeAndVerifyJwtToken(req.headers.authorization.split(' ')[1])
-      return user
-    }
-    return null
-  }
-  const user = await getUserFromHeader()
-
-  return {
-    user,
-  }
-}
-
-type Context = inferAsyncReturnType<typeof createContext>
-
-// [..] Define API handler and app router
-```
-
-### Option 1: Authorize using resolver
-
-```ts
-import { TRPCError } from '@trpc/server'
-
-export const router = trpc
-  .router<Context>()
-  // open for anyone
-  .query('hello', {
-    input: z.string().nullish(),
-    resolve: ({ input, ctx }) => {
-      return `hello ${input ?? ctx.user?.name ?? 'world'}`
-    },
-  })
-  // checked in resolver
-  .query('secret', {
-    resolve: ({ ctx }) => {
-      if (!ctx.user)
-        throw new TRPCError({ code: 'UNAUTHORIZED' })
-
-      return {
-        secret: 'sauce',
-      }
-    },
-  })
-```
-
-### Option 2: Authorize using middleware
-
-```ts
-import * as trpc from '@trpc/server'
-import { TRPCError } from '@trpc/server'
-
-// Merging routers: https://trpc.io/docs/merging-routers
-
-export const router = trpc
-  .router<Context>()
-  // this is accessible for everyone
-  .query('hello', {
-    input: z.string().nullish(),
-    resolve: ({ input, ctx }) => {
-      return `hello ${input ?? ctx.user?.name ?? 'world'}`
-    },
-  })
-  .merge(
-    'admin.',
-    trpc.router<Context>()
-      // this protects all procedures defined next in this router
-      .middleware(async ({ ctx, next }) => {
-        if (!ctx.user?.isAdmin)
-          throw new TRPCError({ code: 'UNAUTHORIZED' })
-
-        return next()
-      })
-      .query('secret', {
-        resolve: ({ ctx }) => {
-          return {
-            secret: 'sauce',
-          }
-        },
-      }),
-  )
-```
-
-Learn more about authorization [here](https://trpc.io/docs/authorization).

recipes/error-formatting.md

@@ -1,41 +0,0 @@
-## Error Formatting
-
-The error formatting in your router will be inferred all the way to your client (& Vue components).
-
-### Adding custom formatting
-
-```ts
-// ~/server/trpc/index.ts
-import * as trpc from '@trpc/server'
-
-export const router = trpc.router<Context>()
-  .formatError(({ shape, error }) => {
-    return {
-      ...shape,
-      data: {
-        ...shape.data,
-        zodError:
-          error.code === 'BAD_REQUEST'
-          && error.cause instanceof ZodError
-            ? error.cause.flatten()
-            : null,
-      }
-    }
-  })
-```
-
-### Usage in Vue
-
-```html
-<script setup lang="ts">
-const { error } = await useAsyncQuery(['getUser', { id: 69 }])
-</script>
-
-<template>
-  <pre v-if="error?.data?.zodError">
-    {{ JSON.stringify(error.data.zodError, null, 2) }}
-  </pre>
-</template>
-```
-
-Learn more about error formatting [here](https://trpc.io/docs/error-formatting).

recipes/error-handling.md

@@ -1,15 +0,0 @@
-## Handling errors
-
-All errors that occur in a procedure go through the `onError` method before being sent to the client. Here you can handle or change errors.
-
-```ts
-// ~/server/trpc/index.ts
-import * as trpc from '@trpc/server'
-
-export function onError({ error, type, path, input, ctx, req }) {
-  console.error('Error:', error)
-  if (error.code === 'INTERNAL_SERVER_ERROR') {
-    // send to bug reporting
-  }
-}
-```

recipes/inference-helpers.md

@@ -1,80 +0,0 @@
-## Inference Helpers
-
-`@trpc/server` exports the following helper types to assist with inferring these types from the `router` exported in `~/server/trpc/index.ts`:
-
-- `inferProcedureOutput<TProcedure>`
-- `inferProcedureInput<TProcedure>`
-- `inferSubscriptionOutput<TRouter, TPath>`
-
-```ts
-// ~/utils/trpc.ts
-import type { router } from '~/server/trpc/index.ts'
-
-type AppRouter = typeof router
-
-/**
- * Enum containing all api query paths
- */
-export type TQuery = keyof AppRouter['_def']['queries']
-
-/**
- * Enum containing all api mutation paths
- */
-export type TMutation = keyof AppRouter['_def']['mutations']
-
-/**
- * Enum containing all api subscription paths
- */
-export type TSubscription = keyof AppRouter['_def']['subscriptions']
-
-/**
- * This is a helper method to infer the output of a query resolver
- * @example type HelloOutput = InferQueryOutput<'hello'>
- */
-export type InferQueryOutput<TRouteKey extends TQuery> = inferProcedureOutput<
-  AppRouter['_def']['queries'][TRouteKey]
->
-
-/**
- * This is a helper method to infer the input of a query resolver
- * @example type HelloInput = InferQueryInput<'hello'>
- */
-export type InferQueryInput<TRouteKey extends TQuery> = inferProcedureInput<
-  AppRouter['_def']['queries'][TRouteKey]
->
-
-/**
- * This is a helper method to infer the output of a mutation resolver
- * @example type HelloOutput = InferMutationOutput<'hello'>
- */
-export type InferMutationOutput<TRouteKey extends TMutation> =
-  inferProcedureOutput<AppRouter['_def']['mutations'][TRouteKey]>
-
-/**
- * This is a helper method to infer the input of a mutation resolver
- * @example type HelloInput = InferMutationInput<'hello'>
- */
-export type InferMutationInput<TRouteKey extends TMutation> =
-  inferProcedureInput<AppRouter['_def']['mutations'][TRouteKey]>
-
-/**
- * This is a helper method to infer the output of a subscription resolver
- * @example type HelloOutput = InferSubscriptionOutput<'hello'>
- */
-export type InferSubscriptionOutput<TRouteKey extends TSubscription> =
-  inferProcedureOutput<AppRouter['_def']['subscriptions'][TRouteKey]>
-
-/**
- * This is a helper method to infer the asynchronous output of a subscription resolver
- * @example type HelloAsyncOutput = InferAsyncSubscriptionOutput<'hello'>
- */
-export type InferAsyncSubscriptionOutput<TRouteKey extends TSubscription> =
-  inferSubscriptionOutput<AppRouter, TRouteKey>
-
-/**
- * This is a helper method to infer the input of a subscription resolver
- * @example type HelloInput = InferSubscriptionInput<'hello'>
- */
-export type InferSubscriptionInput<TRouteKey extends TSubscription> =
-  inferProcedureInput<AppRouter['_def']['subscriptions'][TRouteKey]>
-```

recipes/merging-routers.md

@@ -1,46 +0,0 @@
-# Merging Routers
-
-Writing all API-code in your code in the same file is not a great idea. It's easy to merge routers with other routers.
-
-Define your routes:
-
-```ts
-// ~/server/trpc/routes/posts.ts
-export const posts = trpc.router()
-  .query('list', {
-    resolve() {
-      // ..
-      return []
-    }
-  })
-```
-
-```ts
-// ~/server/trpc/routes/users.ts
-export const users = trpc.router()
-  .query('list', {
-    resolve() {
-      // ..
-      return []
-    }
-  })
-```
-
-```ts
-// ~/server/trpc/index.ts
-import { users } from './routes/users'
-import { posts } from './routes/posts'
-
-export const router = trpc.router()
-  .merge('user.', users) // prefix user procedures with "user."
-  .merge('post.', posts) // prefix post procedures with "post."
-```
-
-and use it like this:
-
-```html
-<script setup lang="ts">
-const { data: users } = await useAsyncQuery(['user.list'])
-const { data: posts } = await useAsyncQuery(['post.list'])
-</script>
-```

recipes/validation.md

@@ -1,49 +0,0 @@
-## Validation
-
-tRPC works out-of-the-box with yup/superstruct/zod/myzod/custom validators.
-
-### Input Validation
-
-```ts
-// ~/server/trpc/index.ts
-import { z } from 'zod'
-
-export const router = trpc
-  .router()
-  .mutation('createUser', {
-    // validate input with Zod
-    input: z.object({
-      name: z.string().min(5)
-    }),
-    async resolve(req) {
-      // use your ORM of choice
-      return await UserModel.create({
-        data: req.input,
-      })
-    },
-  })
-```
-
-### Output Validation
-
-```ts
-// ~/server/trpc/index.ts
-import { z } from 'zod'
-
-export const router = trpc
-  .router()
-  .query('hello', {
-    // validate output with Zod
-    output: z.object({
-      greeting: z.string()
-    }),
-    // expects return type of { greeting: string }
-    resolve() {
-      return {
-        greeting: 'hello!',
-      }
-    },
-  })
-```
-
-Learn more about input validation [here](https://trpc.io/docs/router#input-validation).

src/index.ts

@@ -1,16 +1,18 @@
-import { resolveHTTPResponse } from '@trpc/server'
+import type { ResponseMeta } from '@trpc/server/http'
+import { resolveHTTPResponse } from '@trpc/server/http'
 import type {
   AnyRouter,
   ProcedureType,
-  ResponseMeta,
-  TRPCError,
   inferRouterContext,
-  inferRouterError,
+  inferRouterError
+} from '@trpc/server'
+import {
+  TRPCError
 } from '@trpc/server'
 import { createURL } from 'ufo'
 import type { H3Event } from 'h3'
-import { defineEventHandler, isMethod, readBody } from 'h3'
+import { createError, defineEventHandler, isMethod, readBody } from 'h3'
-import type { TRPCResponse } from '@trpc/server/dist/declarations/src/rpc'
+import type { TRPCResponse } from '@trpc/server/rpc'
 
 type MaybePromise<T> = T | Promise<T>
 
@@ -30,51 +32,85 @@ export interface OnErrorPayload<TRouter extends AnyRouter> {
   error: TRPCError
   type: ProcedureType | 'unknown'
   path: string | undefined
-  req: H3Event['req']
+  req: H3Event['node']['req']
   input: unknown
   ctx: undefined | inferRouterContext<TRouter>
 }
 
 export type OnErrorFn<TRouter extends AnyRouter> = (opts: OnErrorPayload<TRouter>) => void
 
-export function createTRPCHandler<Router extends AnyRouter>({
+export interface ResolveHTTPRequestOptions<TRouter extends AnyRouter> {
+  router: TRouter
+  createContext?: CreateContextFn<TRouter>
+  responseMeta?: ResponseMetaFn<TRouter>
+  onError?: OnErrorFn<TRouter>
+  batching?: {
+    enabled: boolean
+  }
+}
+
+function getPath (event: H3Event): string | null {
+  if (typeof event.context.params.trpc === 'string') { return event.context.params.trpc }
+
+  if (Array.isArray(event.context.params.trpc)) { return event.context.params.trpc.join('/') }
+
+  return null
+}
+
+export function createNuxtApiHandler<TRouter extends AnyRouter> ({
   router,
   createContext,
   responseMeta,
   onError,
-  endpoint,
+  batching
-}: {
+}: ResolveHTTPRequestOptions<TRouter>) {
-  router: Router
-  createContext?: CreateContextFn<Router>
-  responseMeta?: ResponseMetaFn<Router>
-  onError?: OnErrorFn<Router>
-  endpoint: string
-}) {
   return defineEventHandler(async (event) => {
     const {
       req,
-      res,
+      res
-    } = event
+    } = event.node
 
     const $url = createURL(req.url!)
 
+    const path = getPath(event)
+
+    if (path === null) {
+      const error = router.getErrorShape({
+        error: new TRPCError({
+          message:
+            'Param "trpc" not found - is the file named `[trpc]`.ts or `[...trpc].ts`?',
+          code: 'INTERNAL_SERVER_ERROR'
+        }),
+        type: 'unknown',
+        ctx: undefined,
+        path: undefined,
+        input: undefined
+      })
+
+      throw createError({
+        statusCode: 500,
+        statusMessage: JSON.stringify(error)
+      })
+    }
+
     const httpResponse = await resolveHTTPResponse({
+      batching,
       router,
       req: {
         method: req.method!,
         headers: req.headers,
         body: isMethod(event, 'GET') ? null : await readBody(event),
-        query: $url.searchParams,
+        query: $url.searchParams
       },
-      path: $url.pathname.substring(endpoint.length + 1),
+      path,
-      createContext: async () => createContext?.(event),
+      createContext: async () => await createContext?.(event),
       responseMeta,
       onError: (o) => {
         onError?.({
           ...o,
-          req,
+          req
         })
-      },
+      }
     })
 
     const { status, headers, body } = httpResponse

src/module.ts

@@ -1,80 +0,0 @@
-import { fileURLToPath } from 'url'
-import { join, resolve } from 'pathe'
-import { defu } from 'defu'
-import dedent from 'dedent'
-
-import { addImports, addPlugin, addServerHandler, addTemplate, defineNuxtModule, useLogger } from '@nuxt/kit'
-
-export interface ModuleOptions {
-  baseURL: string
-  endpoint: string
-  installPlugin?: boolean
-}
-
-const metaName = 'trpc-nuxt'
-
-export default defineNuxtModule<ModuleOptions>({
-  meta: {
-    name: metaName,
-    configKey: 'trpc',
-  },
-  defaults: {
-    baseURL: '',
-    endpoint: '/trpc',
-    installPlugin: true,
-  },
-  async setup(options, nuxt) {
-    const logger = useLogger(metaName)
-
-    const runtimeDir = fileURLToPath(new URL('./runtime', import.meta.url))
-    nuxt.options.build.transpile.push(runtimeDir, '#build/trpc-handler')
-
-    const handlerPath = join(nuxt.options.buildDir, 'trpc-handler.ts')
-    const trpcOptionsPath = join(nuxt.options.srcDir, 'server/trpc')
-
-    // Final resolved configuration
-    const finalConfig = nuxt.options.runtimeConfig.public.trpc = defu(nuxt.options.runtimeConfig.public.trpc, {
-      baseURL: options.baseURL,
-      endpoint: options.endpoint,
-      installPlugin: options.installPlugin,
-    })
-
-    addServerHandler({
-      route: `${finalConfig.endpoint}/*`,
-      handler: handlerPath,
-    })
-
-    addTemplate({
-      filename: 'trpc-handler.ts',
-      write: true,
-      getContents() {
-        return dedent`
-          import { createTRPCHandler } from 'trpc-nuxt/api'
-          import * as functions from '${trpcOptionsPath}'
-    
-          export default createTRPCHandler({
-            ...functions,
-            endpoint: '${finalConfig.endpoint}'
-          })
-        `
-      },
-    })
-
-    if (finalConfig.installPlugin) {
-      addImports([
-        { name: 'useClient', from: join(runtimeDir, 'client') },
-        { name: 'useAsyncQuery', from: join(runtimeDir, 'client') },
-        { name: 'useClientHeaders', from: join(runtimeDir, 'client') },
-        { name: 'getQueryKey', from: join(runtimeDir, 'client') },
-      ])
-
-      addPlugin(resolve(runtimeDir, 'plugin'))
-
-      logger.success('Plugin successfully installed.')
-    }
-    else {
-      logger.info('Plugin not installed. Create your own @trpc/client client plugin and composables.')
-    }
-  },
-})
-

src/runtime/client.ts

@@ -1,71 +0,0 @@
-import type {
-  AsyncData,
-  AsyncDataOptions,
-  KeyOfRes,
-  PickFrom,
-  _Transform,
-} from 'nuxt/dist/app/composables/asyncData'
-import type { ProcedureRecord, inferHandlerInput, inferProcedureInput, inferProcedureOutput } from '@trpc/server'
-import type { TRPCClient, TRPCClientErrorLike } from '@trpc/client'
-import { objectHash } from 'ohash'
-import type { Ref } from 'vue'
-import { useAsyncData, useNuxtApp, useState } from '#app'
-import type { router } from '~/server/trpc'
-
-type MaybeRef<T> = T | Ref<T>
-
-type AppRouter = typeof router
-
-export type inferProcedures<
-  TObj extends ProcedureRecord<any, any, any, any, any, any>,
-> = {
-  [TPath in keyof TObj]: {
-    input: inferProcedureInput<TObj[TPath]>
-    output: inferProcedureOutput<TObj[TPath]>
-  };
-}
-
-export type TQueries = AppRouter['_def']['queries']
-export type TError = TRPCClientErrorLike<AppRouter>
-
-export type TQueryValues = inferProcedures<AppRouter['_def']['queries']>
-
-/**
- * Calculates the key used for `useAsyncData` call
- * @param pathAndInput
- */
-export function getQueryKey<
-    TPath extends keyof TQueryValues & string,
-    >(pathAndInput: [path: TPath, ...args: inferHandlerInput<TQueries[TPath]>]) {
-  return `${pathAndInput[0]}-${objectHash(pathAndInput[1] ? JSON.stringify(pathAndInput[1]) : '')}`
-}
-
-export async function useAsyncQuery<
-  TPath extends keyof TQueryValues & string,
-  TOutput extends TQueryValues[TPath]['output'] = TQueryValues[TPath]['output'],
-  Transform extends _Transform<TOutput> = _Transform<TOutput, TOutput>,
-  PickKeys extends KeyOfRes<Transform> = KeyOfRes<Transform>,
->(
-  pathAndInput: [path: TPath, ...args: inferHandlerInput<TQueries[TPath]>],
-  options: AsyncDataOptions<TOutput, Transform, PickKeys> = {},
-): Promise<AsyncData<PickFrom<ReturnType<Transform>, PickKeys>, TError>> {
-  const { $client } = useNuxtApp()
-  const key = getQueryKey(pathAndInput)
-  const result = await useAsyncData(
-    key,
-    () => $client.query(...pathAndInput),
-    // @ts-expect-error: Internal
-    options,
-  )
-
-  return result as any
-}
-
-export function useClient(): TRPCClient<AppRouter> {
-  const { $client } = useNuxtApp()
-  return $client
-}
-
-export function useClientHeaders(initialValue: MaybeRef<Record<string, any>> = {}): Ref<Record<string, any>> {
-  return useState('trpc-nuxt-header', () => initialValue)
-}

src/runtime/plugin.ts

@@ -1,45 +0,0 @@
-import * as trpc from '@trpc/client'
-import { unref } from 'vue'
-import { FetchError } from 'ohmyfetch'
-import { useClientHeaders } from './client'
-import { defineNuxtPlugin, useRequestHeaders, useRuntimeConfig } from '#app'
-import type { router } from '~/server/trpc'
-
-declare type AppRouter = typeof router
-
-export default defineNuxtPlugin((nuxtApp) => {
-  const config = useRuntimeConfig().public.trpc
-  const headers = useRequestHeaders()
-  const otherHeaders = useClientHeaders()
-
-  const baseURL = process.server ? '' : config.baseURL
-  const client = trpc.createTRPCClient<AppRouter>({
-    url: `${baseURL}${config.endpoint}`,
-    headers: () => {
-      return {
-        ...unref(otherHeaders),
-        ...headers,
-      }
-    },
-    fetch: (input, options) =>
-      globalThis.$fetch.raw(input.toString(), options)
-        .catch((e) => {
-          if (e instanceof FetchError && e.response)
-            return e.response
-
-          throw e
-        })
-        .then(response => ({
-          ...response,
-          json: () => Promise.resolve(response._data),
-        })),
-  })
-
-  nuxtApp.provide('client', client)
-})
-
-declare module '#app' {
-  interface NuxtApp {
-    $client: trpc.TRPCClient<AppRouter>
-  }
-}

tsconfig.json

@@ -1,3 +1,16 @@
 {
-  "extends": "./playground/.nuxt/tsconfig.json"
+  "compilerOptions": {
+    "target": "es2020",
+    "module": "esnext",
+    "strict": true,
+    "esModuleInterop": true,
+    "moduleResolution": "node",
+    "skipLibCheck": true,
+    "noUnusedLocals": true,
+    "noImplicitAny": true,
+    "allowJs": true,
+    "noEmit": true,
+    "resolveJsonModule": true,
+    "skipDefaultLibCheck": true
+  }
 }

tsup.config.ts

@@ -0,0 +1,15 @@
+import { defineConfig } from 'tsup'
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['cjs', 'esm'],
+  splitting: false,
+  clean: true,
+  external: ['#app', '#imports'],
+  dts: true,
+  outExtension ({ format }) {
+    return {
+      js: format === 'esm' ? '.mjs' : `.${format}`
+    }
+  }
+})