chore: release v0.3.5

.gitignore

@@ -49,3 +49,5 @@ coverage
 Network Trash Folder
 Temporary Items
 .apdisk
+
+.vercel

.nuxtrc

@@ -0,0 +1,2 @@
+imports.autoImport=false
+typescript.includeWorkspace=true

README.md

@@ -4,7 +4,165 @@
 
 End-to-end typesafe APIs with [tRPC.io](https://trpc.io/) in Nuxt applications.
 
-Learn more about tRPC.io [here](https://trpc.io/docs/v10).
+<p align="center">
+  <figure>
+    <img src="https://i.imgur.com/AjmNUxj.gif" alt="Demo" />
+    <figcaption>
+      <p align="center">
+        The client above is <strong>not</strong> importing any code from the server, only its type declarations.
+      </p>
+    </figcaption>
+  </figure>
+</p>
+
+## Install
+
+```bash
+npm i trpc-nuxt@0.3
+```
+
+```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

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

client.d.ts

@@ -1 +0,0 @@
-export * from './dist/client/index'

docs/README.md

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

docs/app.config.ts

@@ -1,5 +0,0 @@
-export default defineAppConfig({
-  docus: {
-    title: 'tRPC Nuxt',
-  },
-})

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

@@ -1,90 +0,0 @@
----
-title: Installation
-description: tRPC-Nuxt provides first class integration with tRPC.
----
-
-# Installation
-
-## 1. Add to existing Nuxt project
-
-::code-group
-
-```bash [pnpm]
-pnpm add @trpc/server@next @trpc/client@next trpc-nuxt@next zod
-```
-
-```bash [npm]
-npm install @trpc/server@next @trpc/client@next trpc-nuxt@next zod
-```
-
-```bash [yarn]
-yarn add @trpc/server@next @trpc/client@next trpc-nuxt@next 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.
-
-## 2. Enable strict mode
-
-If you want to use Zod for input validation, make sure you have enabled strict mode:
-
-::code-group
-
-```json [tsconfig.json]
-{
-  "extends": "./.nuxt/tsconfig.json",
-  "compilerOptions": {
-    "strict": true
-  }
-}
-```
-
-```ts [nuxt.config.ts]
-export default defineNuxtConfig({
-  typescript: {
-    strict: true
-  }
-})
-```
-
-::
-
-If strict mode is too much, at least enable `strictNullChecks`:
-
-::code-group
-
-```json [tsconfig.json]
-{
-  "extends": "./.nuxt/tsconfig.json",
-  "compilerOptions": {
-    "strictNullChecks": true
-  }
-}
-```
-
-```ts [nuxt.config.ts]
-export default defineNuxtConfig({
-  typescript: {
-    tsConfig: {
-      strictNullChecks: true
-    }
-  }
-})
-```
-
-::
-
-## 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

@@ -1,140 +0,0 @@
----
-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 { TRPCError, 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 '..'
-
-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 '../../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 set of strongly-typed composables using your API's type signature.
-
-```ts [plugins/client.ts]
-import { httpBatchLink } from '@trpc/client'
-import { createTRPCNuxtProxyClient } from 'trpc-nuxt/client'
-import type { AppRouter } from '~~/server/trpc/routers'
-
-export default defineNuxtPlugin(() => {
-  const client = createTRPCNuxtProxyClient<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()
-
-// query and mutate uses useAsyncData under the hood
-const { data, pending, error } = await $client.hello.query({ text: 'client' })
-</script>
-
-<template>
-  <div v-if="pending">
-    Loading...
-  </div>
-  <div v-else-if="error?.data?.code">
-    Error: {{ error.data.code }}
-  </div>
-  <div v-else>
-    <p>{{ hello.data?.greeting }}</p>
-  </div>
-</template>
-```

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

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

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

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

docs/content/index.md

@@ -1,31 +0,0 @@
----
-title: "tRPC Nuxt"
-description: "A supa simple wrapper arousnd supabase-js to enable usage and integration within Nuxt."
-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@next
----
-
-#title
-tRPC [Nuxt]{.text-primary-500}
-
-#description
-End-to-end typesafe APIs in Nuxt applications. 
-
-#extra
-  ::list
-  - Automatic typesafety
-  - Snappy DX
-  - Autocompletion
-  ::
-::

docs/nuxt.config.ts

@@ -1,16 +0,0 @@
-export default defineNuxtConfig({
-  app: {
-    pageTransition: false,
-    layoutTransition: false,
-  },
-  extends: '@nuxt-themes/docus',
-  build: {
-    transpile: [/content-edge/],
-  },
-  nitro: {
-    prerender: {
-      crawlLinks: true,
-      routes: ['/'],
-    },
-  },
-})

docs/package.json

@@ -1,17 +0,0 @@
-{
-  "name": "docs",
-  "description": "Docs for TRPC-Nuxt",
-  "scripts": {
-    "dev": "nuxi dev",
-    "build": "nuxi build",
-    "generate": "nuxi build",
-    "preview": "nuxi preview"
-  },
-  "devDependencies": {
-    "@docus/github": "npm:@docus/github-edge@latest",
-    "@nuxt-themes/docus": "npm:@nuxt-themes/docus-edge@0.1.0-2a7c428",
-    "@nuxt-themes/website": "0.1.7",
-    "nuxt": "^3.0.0-rc.12",
-    "vue-plausible": "^1.3.2"
-  }
-}

docs/tokens.config.ts

@@ -1,25 +0,0 @@
-import { defineTheme } from 'pinceau'
-
-export default defineTheme({
-  title: 'asddsasda 3s',
-  cover: {
-    src: 'https://res.cloudinary.com/nuxt/image/upload/v1650870623/nuxt3-rc-social_z6qh3m.png',
-    alt: 'Nuxt 3 cover image',
-  },
-  aside: {
-    level: 1,
-  },
-  // colors: {
-  //   primary: {
-  //     100: '#77b0db',
-  //     200: '#589ed3',
-  //     300: '#4e98d0',
-  //     400: '#398ccb',
-  //     500: '#398ccb',
-  //     600: '#2BAB71',
-  //     700: '#317eb9',
-  //     800: '#2e77af',
-  //     900: '#266290',
-  //   },
-  // },
-})

docs/tsconfig.json

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

package.json

@@ -1,55 +1,59 @@
 {
   "name": "trpc-nuxt",
-  "version": "0.4.0-beta.3",
-  "packageManager": "pnpm@7.5.0",
+  "type": "module",
+  "version": "0.3.5",
   "license": "MIT",
-  "sideEffects": false,
+  "main": "./dist/module.cjs",
+  "types": "./dist/types.d.ts",
   "exports": {
     "./package.json": "./package.json",
     ".": {
-      "require": "./dist/index.js",
-      "import": "./dist/index.mjs"
+      "require": "./dist/module.cjs",
+      "import": "./dist/module.mjs"
     },
-    "./client": {
-      "require": "./dist/client/index.js",
-      "import": "./dist/client/index.mjs"
+    "./api": {
+      "types": "./dist/runtime/api.d.ts",
+      "import": "./dist/runtime/api.mjs"
     }
   },
-  "main": "./dist/index.js",
-  "module": "./dist/index.mjs",
-  "types": "./dist/index.d.ts",
   "files": [
     "dist",
-    "client.d.ts"
+    "*.d.ts"
   ],
   "scripts": {
-    "prepublishOnly": "nr build",
-    "build": "tsup",
+    "build": "nuxt-module-build",
+    "dev": "nuxi dev playground",
+    "dev:build": "nuxi build playground",
+    "dev:preview": "nuxi preview playground",
+    "dev:prepare": "nuxt-module-build --stub && nuxi prepare playground",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
-    "release": "bumpp --commit --push --tag && npm publish"
+    "release": "bumpp --commit --push --tag && npm publish",
+    "prepare": "nuxi prepare playground"
   },
   "peerDependencies": {
-    "@trpc/client": "^10.0.0-proxy-beta.21",
-    "@trpc/server": "^10.0.0-proxy-beta.21",
-    "nuxt": "^3.0.0-rc.12"
+    "@trpc/client": "<10.0.0",
+    "@trpc/server": "<10.0.0"
   },
   "dependencies": {
-    "h3": "^0.8.5",
-    "ohash": "^0.1.5",
-    "ufo": "^0.8.6"
+    "@nuxt/kit": "3.0.0",
+    "@trpc/client": "^9.27.4",
+    "@trpc/server": "^9.27.4",
+    "dedent": "^0.7.0",
+    "defu": "^6.1.1",
+    "h3": "^1.0.2",
+    "ohash": "^1.0.0",
+    "pathe": "^1.0.0",
+    "ufo": "^1.0.1"
   },
   "devDependencies": {
-    "@antfu/eslint-config": "^0.27.0",
-    "@antfu/ni": "^0.18.3",
-    "@trpc/client": "10.0.0-rc.2",
-    "@trpc/server": "10.0.0-rc.2",
+    "@antfu/eslint-config": "^0.34.0",
+    "@nuxt/module-builder": "^0.2.1",
+    "@types/dedent": "^0.7.0",
     "bumpp": "^8.2.1",
     "eslint": "^8.25.0",
-    "nuxt": "3.0.0-rc.12",
-    "pnpm": "^7.5.0",
-    "tsup": "6.0.1",
-    "typescript": "^4.7.4"
+    "nuxt": "3.0.0",
+    "zod": "^3.20.2"
   },
   "eslintConfig": {
     "extends": "@antfu",

playground/nuxt.config.ts

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

playground/package.json

@@ -1,21 +1,4 @@
 {
   "name": "playground",
-  "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.2",
-    "@trpc/server": "10.0.0-rc.2",
-    "superjson": "^1.11.0",
-    "trpc-nuxt": "workspace:*",
-    "zod": "^3.19.1"
-  },
-  "devDependencies": {
-    "nuxt": "3.0.0-rc.12"
-  }
+  "private": true
 }

playground/pages/index.vue

@@ -1,55 +1,56 @@
 <script setup lang="ts">
-const { $client } = useNuxtApp()
-// const headers = useClientHeaders()
+import { useClient, useClientHeaders, useAsyncQuery } from '#imports'
+const client = useClient()
+const headers = useClientHeaders()
+const { data: todos, pending, error, refresh } = await useAsyncQuery(['getTodos'])
 
-// const addHeader = () => {
-//   headers.value.authorization = 'Bearer abcdefghijklmnop'
-//   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 x = await $client.todo.addTodo.mutate({
+    const result = await client.mutation('addTodo', {
       id: Date.now(),
       userId: 69,
       title,
       completed: false,
     })
-    console.log(x.data.value)
+    console.log('Todo: ', result)
   }
   catch (e) {
     console.log(e)
   }
 }
-
-const { data: todos, pending, error, refresh } = await $client.todo.getTodos.query()
 </script>
 
 <template>
-  <div>
-    <div v-if="pending">
-      Loading...
-    </div>
-    <div v-else-if="error?.data?.code">
-      Error: {{ error.data.code }}
-    </div>
-    <div v-else>
-      <ul>
-        <li v-for="t in todos?.slice(0, 10)" :key="t.id">
-          <NuxtLink :class="{ completed: t.completed }" :to="`/todo/${t.id}`">
-            Title: {{ t.title }}
-          </NuxtLink>
-        </li>
-      </ul>
-      <button @click="addTodo">
-        Add Todo
-      </button>
-      <button @click="() => refresh()">
-        Refresh
-      </button>
-    </div>
+  <div v-if="pending">
+    Loading...
+  </div>
+  <div v-else-if="error?.data?.code">
+    Error: {{ error.data.code }}
+  </div>
+  <div v-else-if="todos">
+    <ul>
+      <li v-for="t in todos.slice(0, 10)" :key="t.id">
+        <NuxtLink :class="{ completed: t.completed }" :to="`/todo/${t.id}`">
+          Title: {{ t.title }}
+        </NuxtLink>
+      </li>
+    </ul>
+    <button @click="addTodo">
+      Add Todo
+    </button>
+    <button @click="() => refresh()">
+      Refresh
+    </button>
+    <button @click="addHeader">
+      Add header
+    </button>
   </div>
 </template>
 

playground/pages/todo/[id].vue

@@ -1,7 +1,7 @@
 <script setup lang="ts">
+import { useRoute, useAsyncQuery } from '#imports'
 const route = useRoute()
-const { $client } = useNuxtApp()
-const { data: todo, pending, error } = await $client.todo.getTodo.query(Number(route.params.id))
+const { data: todo, pending, error } = await useAsyncQuery(['getTodo', Number(route.params.id)])
 </script>
 
 <template>

playground/plugins/trpc-client.ts

@@ -1,50 +0,0 @@
-import { httpBatchLink, loggerLink } from '@trpc/client'
-import { createTRPCNuxtProxyClient } from 'trpc-nuxt/client'
-import superjson from 'superjson'
-import type { AppRouter } from '~~/server/trpc/routers'
-
-export default defineNuxtPlugin((nuxtApp) => {
-  const client = createTRPCNuxtProxyClient<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',
-        /**
-           * Set custom request headers on every request from tRPC
-           * @link https://trpc.io/docs/ssr
-           */
-        headers() {
-          if (nuxtApp.ssrContext?.event?.req) {
-            // To use SSR properly, you need to forward the client's headers to the server
-            // This is so you can pass through things like cookies when we're server-side rendering
-
-            // If you're using Node 18, omit the "connection" header
-            const {
-              // eslint-disable-next-line @typescript-eslint/no-unused-vars
-              connection: _connection,
-              ...headers
-            } = nuxtApp.ssrContext.event.req.headers
-            return {
-              ...headers,
-              // Optional: inform server that it's an SSR request
-              'x-ssr': '1',
-            }
-          }
-          return {}
-        },
-      }),
-    ],
-  })
-
-  return {
-    provide: {
-      client,
-    },
-  }
-})

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

@@ -1,23 +0,0 @@
-import { createNuxtApiHandler } from 'trpc-nuxt'
-import { appRouter } from '../../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

@@ -1,17 +0,0 @@
-/* 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 async function createContext(
-  opts: H3Event,
-) {
-  // for API-response caching see https://trpc.io/docs/caching
-
-  return {}
-}

playground/server/trpc/index.ts

@@ -0,0 +1,53 @@
+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

@@ -1,10 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,29 +0,0 @@
-import { initTRPC } from '@trpc/server'
-import superjson from 'superjson'
-import type { Context } from './context'
-
-const t = initTRPC.context<Context>().create({
-  transformer: superjson,
-})
-
-/**
- * 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

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

pnpm-workspace.yaml

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

recipes/authorization.md

@@ -0,0 +1,102 @@
+## 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

@@ -0,0 +1,41 @@
+## 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

@@ -0,0 +1,15 @@
+## 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

@@ -0,0 +1,80 @@
+## 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

@@ -0,0 +1,46 @@
+# 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

@@ -0,0 +1,49 @@
+## 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/client/index.ts

@@ -1,73 +0,0 @@
-import type { CreateTRPCClientOptions, inferRouterProxyClient } from '@trpc/client'
-import { createTRPCProxyClient } from '@trpc/client'
-import type {
-  AnyRouter,
-} from '@trpc/server'
-import { createFlatProxy, createRecursiveProxy } from '@trpc/server/shared'
-import { hash } from 'ohash'
-import type { DecoratedProcedureRecord } from './types'
-
-/**
- * Calculates the key used for `useAsyncData` call
- */
-export function getQueryKey(
-  path: string,
-  input: unknown,
-): string {
-  return input === undefined ? path : `${path}-${hash(input || '')}`
-}
-
-/**
- * @internal
- */
-export function createNuxtProxyDecoration<TRouter extends AnyRouter>(name: string, client: inferRouterProxyClient<TRouter>) {
-  return createRecursiveProxy((opts) => {
-    const args = opts.args
-
-    const pathCopy = [name, ...opts.path]
-
-    // The last arg is for instance `.mutate` or `.query()`
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    const lastArg = pathCopy.pop()!
-
-    const path = pathCopy.join('.')
-
-    const [input, asyncDataOptions] = args
-
-    const queryKey = getQueryKey(path, input)
-
-    return useAsyncDataWithError(queryKey, () => (client as any)[path][lastArg](input), asyncDataOptions)
-  })
-}
-
-/**
- * Custom useAsyncData to add server error to client
- */
-async function useAsyncDataWithError(queryKey: string, cb: any, asyncDataOptions: any) {
-  // @ts-ignore: nuxt internal
-  const serverError = useState(`error-${queryKey}`, () => null)
-  // @ts-ignore: nuxt internal
-  const { error, data, ...rest } = await useAsyncData(queryKey, cb, asyncDataOptions)
-
-  if (error.value && !serverError.value)
-    serverError.value = error.value as any
-
-  if (data.value)
-    serverError.value = null
-
-  return {
-    ...rest,
-    data,
-    error: serverError,
-  }
-}
-
-export function createTRPCNuxtProxyClient<TRouter extends AnyRouter>(opts: CreateTRPCClientOptions<TRouter>) {
-  const client = createTRPCProxyClient(opts)
-
-  const decoratedClient = createFlatProxy((key) => {
-    return createNuxtProxyDecoration(key, client)
-  }) as DecoratedProcedureRecord<TRouter['_def']['record']>
-
-  return decoratedClient
-}

src/client/types.ts

@@ -1,64 +0,0 @@
-import type { TRPCClientErrorLike } from '@trpc/client'
-import type {
-  AnyMutationProcedure,
-  AnyProcedure,
-  AnyQueryProcedure,
-  AnyRouter,
-  ProcedureRouterRecord,
-  inferProcedureInput,
-  inferProcedureOutput,
-} from '@trpc/server'
-import type {
-  AsyncData,
-  AsyncDataOptions,
-  KeyOfRes,
-  PickFrom,
-  _Transform,
-} from 'nuxt/dist/app/composables/asyncData'
-
-// Inspired by trpc/react-query client types
-// https://github.com/trpc/trpc/blob/next/packages/react-query/src/createTRPCReact.tsx
-
-/**
- * @internal
- */
-export type DecorateProcedure<
- TProcedure extends AnyProcedure,
- TPath extends string,
-> = TProcedure extends AnyQueryProcedure
-  ? {
-      query: <
-      TData = inferProcedureOutput<TProcedure>,
-      Transform extends _Transform<TData> = _Transform<TData, TData>,
-      PickKeys extends KeyOfRes<Transform> = KeyOfRes<Transform>,
-     >(
-        input: inferProcedureInput<TProcedure>,
-        opts?: AsyncDataOptions<TData, Transform, PickKeys>,
-      ) => AsyncData<PickFrom<ReturnType<Transform>, PickKeys>, TRPCClientErrorLike<TProcedure>>
-    } : TProcedure extends AnyMutationProcedure ? {
-      mutate: <
-      TData = inferProcedureOutput<TProcedure>,
-      Transform extends _Transform<TData> = _Transform<TData, TData>,
-      PickKeys extends KeyOfRes<Transform> = KeyOfRes<Transform>,
-     >(
-        input: inferProcedureInput<TProcedure>,
-        opts?: AsyncDataOptions<TData, Transform, PickKeys>,
-      ) => AsyncData<PickFrom<ReturnType<Transform>, PickKeys>, TRPCClientErrorLike<TProcedure>>
-    } : never
-
-/**
-* @internal
-*/
-export type DecoratedProcedureRecord<
- TProcedures extends ProcedureRouterRecord,
- TPath extends string = '',
-> = {
-  [TKey in keyof TProcedures]: TProcedures[TKey] extends AnyRouter
-    ? DecoratedProcedureRecord<
-       TProcedures[TKey]['_def']['record'],
-       `${TPath}${TKey & string}.`
-     >
-    : TProcedures[TKey] extends AnyProcedure
-      ? DecorateProcedure<TProcedures[TKey], `${TPath}${TKey & string}`>
-      : never;
-}

src/index.ts

@@ -1 +0,0 @@
-export * from './server'

src/module.ts

@@ -0,0 +1,80 @@
+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)
+
+    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 ${JSON.stringify(join(runtimeDir, '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/api.ts

@@ -1,8 +1,8 @@
-import type { ResponseMeta } from '@trpc/server/http'
-import { resolveHTTPResponse } from '@trpc/server/http'
+import { resolveHTTPResponse } from '@trpc/server'
 import type {
   AnyRouter,
   ProcedureType,
+  ResponseMeta,
   TRPCError,
   inferRouterContext,
   inferRouterError,
@@ -10,7 +10,7 @@ import type {
 import { createURL } from 'ufo'
 import type { H3Event } from 'h3'
 import { defineEventHandler, isMethod, readBody } from 'h3'
-import type { TRPCResponse } from '@trpc/server/rpc'
+import type { TRPCResponse } from '@trpc/server/dist/declarations/src/rpc'
 
 type MaybePromise<T> = T | Promise<T>
 
@@ -30,31 +30,31 @@ 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 createNuxtApiHandler<TRouter extends AnyRouter>({
+export function createTRPCHandler<Router extends AnyRouter>({
   router,
   createContext,
   responseMeta,
   onError,
-  url = '/api/trpc',
+  endpoint,
 }: {
-  router: TRouter
-  createContext?: CreateContextFn<TRouter>
-  responseMeta?: ResponseMetaFn<TRouter>
-  onError?: OnErrorFn<TRouter>
-  url?: string
+  router: Router
+  createContext?: CreateContextFn<Router>
+  responseMeta?: ResponseMetaFn<Router>
+  onError?: OnErrorFn<Router>
+  endpoint: string
 }) {
   return defineEventHandler(async (event) => {
     const {
       req,
       res,
-    } = event
+    } = event.node
 
     const $url = createURL(req.url!)
 
@@ -66,7 +66,7 @@ export function createNuxtApiHandler<TRouter extends AnyRouter>({
         body: isMethod(event, 'GET') ? null : await readBody(event),
         query: $url.searchParams,
       },
-      path: $url.pathname.substring(url.length + 1),
+      path: $url.pathname.substring(endpoint.length + 1),
       createContext: async () => createContext?.(event),
       responseMeta,
       onError: (o) => {

src/runtime/client.ts

@@ -0,0 +1,71 @@
+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 '#imports'
+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

@@ -0,0 +1,45 @@
+import * as trpc from '@trpc/client'
+import { unref } from 'vue'
+import { FetchError } from 'ohmyfetch'
+import { useClientHeaders } from './client'
+import { defineNuxtPlugin, useRequestHeaders, useRuntimeConfig } from '#imports'
+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,16 +1,3 @@
 {
-  "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
-  }
+  "extends": "./playground/.nuxt/tsconfig.json"
 }

tsup.config.ts

@@ -1,10 +0,0 @@
-import { defineConfig } from 'tsup'
-
-export default defineConfig({
-  entry: ['src/index.ts', 'src/client/index.ts'],
-  format: ['cjs', 'esm'],
-  splitting: false,
-  clean: true,
-  external: ['#app'],
-  dts: true,
-})