chore: release v0.4.0-beta.4

fix: don't discard error in client

.github/workflows/release.yml

@@ -0,0 +1,22 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 16.x
+
+      - run: npx changelogithub
+        env:
+          GITHUB_TOKEN: ${{secrets.GITHUB_TOKEN}}

README.md

@@ -4,137 +4,11 @@
 
 End-to-end typesafe APIs with [tRPC.io](https://trpc.io/) in Nuxt applications.
 
-## Install
+Learn more about tRPC.io [here](https://trpc.io/docs/v10).
 
-```bash
-npm i trpc-nuxt
-```
+## Recommended IDE Setup
 
-```ts
-// nuxt.config.ts
-import { defineNuxtConfig } from 'nuxt'
-
-export default defineNuxtConfig({
-  modules: ['trpc-nuxt'],
-  trpc: {
-    baseURL: 'http://localhost:3000', // defaults to http://localhost:3000
-    trpcURL: '/api/trpc', // defaults to /api/trpc
-  },
-  typescript: {
-    strict: true // set this to true 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 addUser = async () => {
-  const mutate = 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
-  server: true
-})
-```
-
-## 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 { CompatibilityEvent } 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: CompatibilityEvent) => {
-  // ...
-  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)
-- [Error Handling](/recipes/error-handling.md)
-- [Error Formatting](/recipes/error-formatting.md)
-
-Learn more about tRPC.io [here](https://trpc.io/docs).
+- [VS Code](https://code.visualstudio.com/) + [Volar](https://marketplace.visualstudio.com/items?itemName=Vue.volar)
 
 ## License
 

api.d.ts

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

client.d.ts

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

docs/README.md

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

docs/app.config.ts

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

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

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

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

@@ -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: "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

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

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"
+  },
+  "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

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

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

package.json

@@ -1,68 +1,60 @@
 {
   "name": "trpc-nuxt",
-  "type": "module",
-  "version": "0.1.0",
-  "publishConfig": {
-    "directory": "package"
-  },
-  "packageManager": "pnpm@7.1.0",
+  "version": "0.4.0-beta.4",
+  "packageManager": "pnpm@7.14.1",
   "license": "MIT",
-  "main": "./dist/module.cjs",
-  "types": "./dist/types.d.ts",
+  "sideEffects": false,
   "exports": {
     "./package.json": "./package.json",
     ".": {
-      "import": "./dist/module.mjs",
-      "require": "./dist/module.cjs"
+      "require": "./dist/index.js",
+      "import": "./dist/index.mjs"
     },
-    "./api": {
-      "import": "./dist/runtime/api.mjs",
-      "types": "./dist/runtime/api.d.ts"
+    "./client": {
+      "require": "./dist/client/index.js",
+      "import": "./dist/client/index.mjs"
     }
   },
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
   "files": [
     "dist",
-    "*.d.ts"
+    "client.d.ts"
   ],
-  "clean-publish": {
-    "withoutPublish": true,
-    "tempDir": "package"
-  },
   "scripts": {
-    "prepublishOnly": "rimraf ./package && nr build && clean-publish",
-    "postpublish": "rimraf ./package",
-    "build": "nuxt-module-build",
-    "play": "nr build && nuxi dev playground",
+    "prepublishOnly": "nr build",
+    "build": "tsup",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
-    "release": "bumpp --commit --push --tag && pnpm publish",
-    "prepare": "nuxi prepare playground"
+    "release": "bumpp && npm publish"
+  },
+  "peerDependencies": {
+    "@trpc/client": "^10.0.0-proxy-beta.21",
+    "@trpc/server": "^10.0.0-proxy-beta.21",
+    "nuxt": "^3.0.0-rc.12"
   },
   "dependencies": {
-    "@nuxt/kit": "^3.0.0-rc.3",
-    "@trpc/client": "^9.23.3",
-    "@trpc/server": "^9.23.2",
-    "fs-extra": "^10.1.0",
-    "h3": "^0.7.8",
-    "pathe": "^0.3.0",
-    "ufo": "^0.8.4"
+    "h3": "^0.8.5",
+    "ohash": "^0.1.5",
+    "ufo": "^0.8.6"
   },
   "devDependencies": {
-    "@antfu/eslint-config": "^0.23.1",
-    "@antfu/ni": "^0.16.2",
-    "@nuxt/module-builder": "latest",
-    "@types/fs-extra": "^9.0.13",
-    "bumpp": "^7.1.1",
-    "clean-publish": "^4.0.0",
-    "eslint": "^8.14.0",
-    "nuxt": "^3.0.0-rc.3",
-    "ohash": "^0.1.0",
-    "pnpm": "^7.1.0",
-    "superjson": "^1.9.1",
-    "trpc-nuxt": "workspace:*",
-    "zod": "^3.16.0"
+    "@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",
+    "bumpp": "^8.2.1",
+    "eslint": "^8.25.0",
+    "nuxt": "3.0.0-rc.12",
+    "pnpm": "^7.14.1",
+    "tsup": "6.0.1",
+    "typescript": "^4.7.4"
   },
   "eslintConfig": {
-    "extends": "@antfu"
+    "extends": "@antfu",
+    "rules": {
+      "no-console": "warn"
+    }
   }
 }

package/.gitignore

@@ -1,51 +0,0 @@
-# Dependencies
-node_modules
-
-# Logs
-*.log*
-
-# Temp directories
-.temp
-.tmp
-.cache
-
-# Yarn
-**/.yarn/cache
-**/.yarn/*state*
-
-# Generated dirs
-dist
-
-# Nuxt
-.nuxt
-.output
-.vercel_build_output
-.build-*
-.env
-.netlify
-
-# Env
-.env
-
-# Testing
-reports
-coverage
-*.lcov
-.nyc_output
-
-# VSCode
-.vscode
-
-# Intellij idea
-*.iml
-.idea
-
-# OSX
-.DS_Store
-.AppleDouble
-.LSOverride
-.AppleDB
-.AppleDesktop
-Network Trash Folder
-Temporary Items
-.apdisk

package/.npmrc

@@ -1,2 +0,0 @@
-ignore-workspace-root-check=true
-shamefully-hoist=true

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2022 Robert Soriano <https://github.com/wobsoriano>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/README.md

@@ -1,141 +0,0 @@
-# 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.
-
-## Install
-
-```bash
-npm i trpc-nuxt
-```
-
-```ts
-// nuxt.config.ts
-import { defineNuxtConfig } from 'nuxt'
-
-export default defineNuxtConfig({
-  modules: ['trpc-nuxt'],
-  trpc: {
-    baseURL: 'http://localhost:3000', // defaults to http://localhost:3000
-    trpcURL: '/api/trpc', // defaults to /api/trpc
-  },
-  typescript: {
-    strict: true // set this to true 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 addUser = async () => {
-  const mutate = 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
-  server: true
-})
-```
-
-## 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 { CompatibilityEvent } 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: CompatibilityEvent) => {
-  // ...
-  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)
-- [Error Handling](/recipes/error-handling.md)
-- [Error Formatting](/recipes/error-formatting.md)
-
-Learn more about tRPC.io [here](https://trpc.io/docs).
-
-## License
-
-MIT

package/api.d.ts

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

package/package.json

@@ -1,39 +0,0 @@
-{
-  "name": "trpc-nuxt",
-  "type": "module",
-  "version": "0.0.3",
-  "publishConfig": {
-    "directory": "package"
-  },
-  "packageManager": "pnpm@7.1.0",
-  "license": "MIT",
-  "main": "./dist/module.cjs",
-  "types": "./dist/types.d.ts",
-  "exports": {
-    "./package.json": "./package.json",
-    ".": {
-      "import": "./dist/module.mjs",
-      "require": "./dist/module.cjs"
-    },
-    "./api": {
-      "import": "./dist/runtime/api.mjs",
-      "types": "./dist/runtime/api.d.ts"
-    }
-  },
-  "files": [
-    "dist",
-    "*.d.ts"
-  ],
-  "dependencies": {
-    "@nuxt/kit": "^3.0.0-rc.3",
-    "@trpc/client": "^9.23.3",
-    "@trpc/server": "^9.23.2",
-    "fs-extra": "^10.1.0",
-    "h3": "^0.7.8",
-    "pathe": "^0.3.0",
-    "ufo": "^0.8.4"
-  },
-  "scripts": {
-    "postpublish": "rimraf ./package"
-  }
-}

package/playground/.gitignore

@@ -1,7 +0,0 @@
-node_modules
-*.log*
-.nuxt
-.nitro
-.cache
-.output
-.env

package/playground/README.md

@@ -1,31 +0,0 @@
-# dev playground
-
-## Setup
-
-Make sure to install the dependencies:
-
-```bash
-pnpm install
-```
-
-## Development Server
-
-Start the development server on http://localhost:3000
-
-```bash
-pnpm dev
-```
-
-## Production
-
-Build the application for production:
-
-```bash
-pnpm build
-```
-
-Locally preview production build:
-
-```bash
-pnpm preview
-```

package/playground/app.vue

@@ -1,18 +0,0 @@
-<script setup lang="ts">
-const { data, error } = await useAsyncQuery(['getUser', { username: 'jcena' }], {
-  lazy: true,
-})
-
-const client = useClient()
-</script>
-
-<template>
-  <div>
-    <div v-if="data">
-      {{ JSON.stringify(data, null, 2) }}
-    </div>
-    <div v-else-if="error">
-      asdx  {{ JSON.stringify(error, null, 2) }}
-    </div>
-  </div>
-</template>

package/playground/nuxt.config.ts

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

package/playground/package.json

@@ -1,4 +0,0 @@
-{
-  "name": "playground",
-  "private": true
-}

package/playground/server/trpc/index.ts

@@ -1,82 +0,0 @@
-// ~/server/trpc/index.ts
-import { ZodError, z } from 'zod'
-import * as trpc from '@trpc/server'
-import type { inferAsyncReturnType } from '@trpc/server'
-import type { CompatibilityEvent } from 'h3'
-import type { ResponseMetaFnPayload } from 'trpc-nuxt/api'
-// import superjson from 'superjson'
-
-const fakeUsers = [
-  { id: 1, username: 'jcena' },
-  { id: 2, username: 'dbatista' },
-  { id: 3, username: 'jbiden' },
-]
-
-export const router = trpc
-  .router<inferAsyncReturnType<typeof createContext>>()
-  .formatError(({ shape, error }) => {
-    return {
-      ...shape,
-      data: {
-        ...shape.data,
-        zodError:
-          error.code === 'BAD_REQUEST'
-          && error.cause instanceof ZodError
-            ? error.cause.flatten()
-            : null,
-      },
-    }
-  })
-  .query('getUsers', {
-    resolve() {
-      return fakeUsers
-    },
-  })
-  .query('getUser', {
-    // validate input with Zod
-    input: z.object({
-      username: z.string().min(5),
-    }),
-    resolve(req) {
-      return fakeUsers.find(i => i.username === req.input.username) ?? null
-    },
-  })
-  .mutation('createUser', {
-    input: z.object({ username: z.string().min(5) }),
-    resolve(req) {
-      const newUser = {
-        id: fakeUsers.length + 1,
-        username: req.input.username,
-      }
-      fakeUsers.push(newUser)
-      return newUser
-    },
-  })
-
-export const createContext = (event: CompatibilityEvent) => {
-  event.res.setHeader('x-ssr', 1)
-  return {}
-}
-
-export const responseMeta = (opts: ResponseMetaFnPayload<any>) => {
-  // const nuxtApp = useNuxtApp()
-  // const client = useClient()
-  // console.log(opts)
-
-  // if (nuxtApp.nuxtState) {
-  //   nuxtApp.nuxtState.trpc = client.runtime.transformer.serialize({
-  //     ctx: opts.ctx,
-  //     errors: opts.errors,
-  //   })
-  // }
-  // else {
-  //   nuxtApp.nuxtState = {
-  //     trpc: client.runtime.transformer.serialize({
-  //       ctx: opts.ctx,
-  //       errors: opts.errors,
-  //     }),
-  //   }
-  // }
-
-  return {}
-}

package/pnpm-workspace.yaml

@@ -1,2 +0,0 @@
-packages:
-  - playground/*

package/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 { CompatibilityEvent } 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 }: CompatibilityEvent) {
-  // 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).

package/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).

package/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
-  }
-}
-```

package/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).

package/src/module.ts

@@ -1,61 +0,0 @@
-import { fileURLToPath } from 'url'
-import { dirname, join } from 'pathe'
-
-import { addServerHandler, defineNuxtModule } from '@nuxt/kit'
-import fs from 'fs-extra'
-
-export interface ModuleOptions {
-  baseURL: string
-  trpcURL: string
-}
-
-export default defineNuxtModule<ModuleOptions>({
-  meta: {
-    name: 'trpc-nuxt',
-    configKey: 'trpc',
-  },
-  defaults: {
-    baseURL: 'http://localhost:3000',
-    trpcURL: '/api/trpc',
-  },
-  async setup(options, nuxt) {
-    const runtimeDir = fileURLToPath(new URL('./runtime', import.meta.url))
-    nuxt.options.build.transpile.push(runtimeDir)
-
-    const clientPath = join(nuxt.options.buildDir, 'trpc-client.ts')
-    const handlerPath = join(nuxt.options.buildDir, 'trpc-handler.ts')
-
-    addServerHandler({
-      route: `${options.trpcURL}/*`,
-      handler: handlerPath,
-    })
-
-    nuxt.hook('autoImports:extend', (imports) => {
-      imports.push(
-        { name: 'useClient', from: clientPath },
-        { name: 'useAsyncQuery', from: join(runtimeDir, 'client') },
-      )
-    })
-
-    await fs.ensureDir(dirname(clientPath))
-
-    await fs.writeFile(clientPath, `
-      import * as trpc from '@trpc/client'
-      import type { router } from '~/server/trpc'
-
-      const client = trpc.createTRPCClient<typeof router>({
-        url: '${options.baseURL}${options.trpcURL}',
-      })
-    
-      export const useClient = () => client
-    `)
-
-    await fs.writeFile(handlerPath, `
-      import { createTRPCHandler } from 'trpc-nuxt/api'
-      import * as functions from '~/server/trpc'
-
-      export default createTRPCHandler(functions)
-    `)
-  },
-})
-

package/src/runtime/client.ts

@@ -1,64 +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 { TRPCClientErrorLike } from '@trpc/client'
-import { objectHash } from 'ohash'
-// @ts-expect-error: Resolved by Nuxt
-import { useAsyncData, useState } from '#imports'
-// @ts-expect-error: Resolved by Nuxt
-import { useClient } from '#build/trpc-client'
-// @ts-expect-error: Resolved by Nuxt
-import type { router } from '~/server/trpc'
-
-type AppRouter = typeof router
-
-type inferProcedures<
-  TObj extends ProcedureRecord<any, any, any, any, any, any>,
-> = {
-  [TPath in keyof TObj]: {
-    input: inferProcedureInput<TObj[TPath]>
-    output: inferProcedureOutput<TObj[TPath]>
-  };
-}
-
-type TQueries = AppRouter['_def']['queries']
-type TError = TRPCClientErrorLike<AppRouter>
-
-type TQueryValues = inferProcedures<AppRouter['_def']['queries']>
-
-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 = useClient()
-  const key = `${pathAndInput[0]}-${objectHash(pathAndInput[1] ? JSON.stringify(pathAndInput[1]) : '')}`
-  const serverError = useState<TError | null>(`error-${key}`, () => null)
-  const { error, data, ...rest } = await useAsyncData(
-    key,
-    () => client.query(...pathAndInput),
-    options,
-  )
-
-  // @ts-expect-error: Resolved by Nuxt
-  if (process.server && error.value && !serverError.value)
-    serverError.value = error.value as any
-
-  if (data.value)
-    serverError.value = null
-
-  return {
-    ...rest,
-    data,
-    error: serverError,
-  } as any
-}

package/tsconfig.json

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

playground/app.vue

@@ -1,18 +1,5 @@
-<script setup lang="ts">
-const { data, error } = await useAsyncQuery(['getUser', { username: 'jcena' }], {
-  lazy: true,
-})
-
-const client = useClient()
-</script>
-
 <template>
   <div>
-    <div v-if="data">
-      {{ JSON.stringify(data, null, 2) }}
-    </div>
-    <div v-else-if="error">
-      asdx  {{ JSON.stringify(error, null, 2) }}
-    </div>
+    <NuxtPage />
   </div>
 </template>

playground/nuxt.config.ts

@@ -1,11 +1,7 @@
-import { defineNuxtConfig } from 'nuxt'
-import Module from '..'
-
 // https://v3.nuxtjs.org/api/configuration/nuxt.config
 export default defineNuxtConfig({
-  modules: [Module],
   runtimeConfig: {
-    baseURL: 'http://localhost:3000',
+    baseURL: '',
   },
   typescript: {
     strict: true,

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.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"
+  }
 }

playground/pages/index.vue

@@ -0,0 +1,64 @@
+<script setup lang="ts">
+const { $client } = useNuxtApp()
+// const headers = useClientHeaders()
+
+// 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({
+      id: Date.now(),
+      userId: 69,
+      title,
+      completed: false,
+    })
+    console.log(x.data.value)
+  }
+  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>
+</template>
+
+<style>
+a {
+  text-decoration: none;
+}
+
+.completed {
+  text-decoration: line-through;
+}
+</style>

playground/pages/todo/[id].vue

@@ -0,0 +1,19 @@
+<script setup lang="ts">
+const route = useRoute()
+const { $client } = useNuxtApp()
+const { data: todo, pending, error } = await $client.todo.getTodo.query(Number(route.params.id))
+</script>
+
+<template>
+  <div v-if="pending">
+    Loading...
+  </div>
+  <div v-else-if="error?.data?.code">
+    {{ error.data.code }}
+  </div>
+  <div v-else>
+    ID: {{ todo?.id }} <br>
+    Title: {{ todo?.title }} <br>
+    Completed: {{ todo?.completed }}
+  </div>
+</template>

playground/plugins/trpc-client.ts

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

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

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

playground/server/trpc/index.ts

@@ -1,82 +0,0 @@
-// ~/server/trpc/index.ts
-import { ZodError, z } from 'zod'
-import * as trpc from '@trpc/server'
-import type { inferAsyncReturnType } from '@trpc/server'
-import type { CompatibilityEvent } from 'h3'
-import type { ResponseMetaFnPayload } from 'trpc-nuxt/api'
-// import superjson from 'superjson'
-
-const fakeUsers = [
-  { id: 1, username: 'jcena' },
-  { id: 2, username: 'dbatista' },
-  { id: 3, username: 'jbiden' },
-]
-
-export const router = trpc
-  .router<inferAsyncReturnType<typeof createContext>>()
-  .formatError(({ shape, error }) => {
-    return {
-      ...shape,
-      data: {
-        ...shape.data,
-        zodError:
-          error.code === 'BAD_REQUEST'
-          && error.cause instanceof ZodError
-            ? error.cause.flatten()
-            : null,
-      },
-    }
-  })
-  .query('getUsers', {
-    resolve() {
-      return fakeUsers
-    },
-  })
-  .query('getUser', {
-    // validate input with Zod
-    input: z.object({
-      username: z.string().min(5),
-    }),
-    resolve(req) {
-      return fakeUsers.find(i => i.username === req.input.username) ?? null
-    },
-  })
-  .mutation('createUser', {
-    input: z.object({ username: z.string().min(5) }),
-    resolve(req) {
-      const newUser = {
-        id: fakeUsers.length + 1,
-        username: req.input.username,
-      }
-      fakeUsers.push(newUser)
-      return newUser
-    },
-  })
-
-export const createContext = (event: CompatibilityEvent) => {
-  event.res.setHeader('x-ssr', 1)
-  return {}
-}
-
-export const responseMeta = (opts: ResponseMetaFnPayload<any>) => {
-  // const nuxtApp = useNuxtApp()
-  // const client = useClient()
-  // console.log(opts)
-
-  // if (nuxtApp.nuxtState) {
-  //   nuxtApp.nuxtState.trpc = client.runtime.transformer.serialize({
-  //     ctx: opts.ctx,
-  //     errors: opts.errors,
-  //   })
-  // }
-  // else {
-  //   nuxtApp.nuxtState = {
-  //     trpc: client.runtime.transformer.serialize({
-  //       ctx: opts.ctx,
-  //       errors: opts.errors,
-  //     }),
-  //   }
-  // }
-
-  return {}
-}

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,29 @@
+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

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

pnpm-workspace.yaml

@@ -1,2 +1,3 @@
 packages:
-  - playground/*
+  - 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 { CompatibilityEvent } 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 }: CompatibilityEvent) {
-  // 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/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/client/index.ts

@@ -0,0 +1,73 @@
+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'
+// @ts-ignore: nuxt internal
+import { useAsyncData, useState } from '#app'
+
+/**
+ * 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()`
+
+    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) {
+  const serverError = useState(`error-${queryKey}`, () => null)
+  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

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

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

src/module.ts

@@ -1,61 +0,0 @@
-import { fileURLToPath } from 'url'
-import { dirname, join } from 'pathe'
-
-import { addServerHandler, defineNuxtModule } from '@nuxt/kit'
-import fs from 'fs-extra'
-
-export interface ModuleOptions {
-  baseURL: string
-  trpcURL: string
-}
-
-export default defineNuxtModule<ModuleOptions>({
-  meta: {
-    name: 'trpc-nuxt',
-    configKey: 'trpc',
-  },
-  defaults: {
-    baseURL: 'http://localhost:3000',
-    trpcURL: '/api/trpc',
-  },
-  async setup(options, nuxt) {
-    const runtimeDir = fileURLToPath(new URL('./runtime', import.meta.url))
-    nuxt.options.build.transpile.push(runtimeDir)
-
-    const clientPath = join(nuxt.options.buildDir, 'trpc-client.ts')
-    const handlerPath = join(nuxt.options.buildDir, 'trpc-handler.ts')
-
-    addServerHandler({
-      route: `${options.trpcURL}/*`,
-      handler: handlerPath,
-    })
-
-    nuxt.hook('autoImports:extend', (imports) => {
-      imports.push(
-        { name: 'useClient', from: clientPath },
-        { name: 'useAsyncQuery', from: join(runtimeDir, 'client') },
-      )
-    })
-
-    await fs.ensureDir(dirname(clientPath))
-
-    await fs.writeFile(clientPath, `
-      import * as trpc from '@trpc/client'
-      import type { router } from '~/server/trpc'
-
-      const client = trpc.createTRPCClient<typeof router>({
-        url: '${options.baseURL}${options.trpcURL}',
-      })
-    
-      export const useClient = () => client
-    `)
-
-    await fs.writeFile(handlerPath, `
-      import { createTRPCHandler } from 'trpc-nuxt/api'
-      import * as functions from '~/server/trpc'
-
-      export default createTRPCHandler(functions)
-    `)
-  },
-})
-

src/runtime/api.ts

@@ -1,92 +0,0 @@
-import { resolveHTTPResponse } from '@trpc/server'
-import type {
-  AnyRouter,
-  ProcedureType,
-  ResponseMeta,
-  TRPCError,
-  inferRouterContext,
-  inferRouterError,
-} from '@trpc/server'
-import { createURL } from 'ufo'
-import type { CompatibilityEvent } from 'h3'
-import { defineEventHandler, isMethod, useBody } from 'h3'
-import type { TRPCResponse } from '@trpc/server/dist/declarations/src/rpc'
-
-type MaybePromise<T> = T | Promise<T>
-
-export type CreateContextFn<TRouter extends AnyRouter> = (event: CompatibilityEvent) => MaybePromise<inferRouterContext<TRouter>>
-
-export interface ResponseMetaFnPayload<TRouter extends AnyRouter> {
-  data: TRPCResponse<unknown, inferRouterError<TRouter>>[]
-  ctx?: inferRouterContext<TRouter>
-  paths?: string[]
-  type: ProcedureType | 'unknown'
-  errors: TRPCError[]
-}
-
-export type ResponseMetaFn<TRouter extends AnyRouter> = (opts: ResponseMetaFnPayload<TRouter>) => ResponseMeta
-
-export interface OnErrorPayload<TRouter extends AnyRouter> {
-  error: TRPCError
-  type: ProcedureType | 'unknown'
-  path: string | undefined
-  req: CompatibilityEvent['req']
-  input: unknown
-  ctx: undefined | inferRouterContext<TRouter>
-}
-
-export type OnErrorFn<TRouter extends AnyRouter> = (opts: OnErrorPayload<TRouter>) => void
-
-export function createTRPCHandler<Router extends AnyRouter>({
-  router,
-  createContext,
-  responseMeta,
-  onError,
-}: {
-  router: Router
-  createContext?: CreateContextFn<Router>
-  responseMeta?: ResponseMetaFn<Router>
-  onError?: OnErrorFn<Router>
-}) {
-  const url = '/api/trpc'
-
-  return defineEventHandler(async (event) => {
-    const {
-      req,
-      res,
-    } = event
-
-    const $url = createURL(req.url)
-
-    event.context.hello = 'world'
-
-    const httpResponse = await resolveHTTPResponse({
-      router,
-      req: {
-        method: req.method,
-        headers: req.headers,
-        body: isMethod(event, 'GET') ? null : await useBody(event),
-        query: $url.searchParams,
-      },
-      path: $url.pathname.substring(url.length + 1),
-      createContext: async () => createContext?.(event),
-      responseMeta,
-      onError: (o) => {
-        onError?.({
-          ...o,
-          req,
-        })
-      },
-    })
-
-    const { status, headers, body } = httpResponse
-
-    res.statusCode = status
-
-    Object.keys(headers).forEach((key) => {
-      res.setHeader(key, headers[key])
-    })
-
-    return body
-  })
-}

src/runtime/client.ts

@@ -1,64 +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 { TRPCClientErrorLike } from '@trpc/client'
-import { objectHash } from 'ohash'
-// @ts-expect-error: Resolved by Nuxt
-import { useAsyncData, useState } from '#imports'
-// @ts-expect-error: Resolved by Nuxt
-import { useClient } from '#build/trpc-client'
-// @ts-expect-error: Resolved by Nuxt
-import type { router } from '~/server/trpc'
-
-type AppRouter = typeof router
-
-type inferProcedures<
-  TObj extends ProcedureRecord<any, any, any, any, any, any>,
-> = {
-  [TPath in keyof TObj]: {
-    input: inferProcedureInput<TObj[TPath]>
-    output: inferProcedureOutput<TObj[TPath]>
-  };
-}
-
-type TQueries = AppRouter['_def']['queries']
-type TError = TRPCClientErrorLike<AppRouter>
-
-type TQueryValues = inferProcedures<AppRouter['_def']['queries']>
-
-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 = useClient()
-  const key = `${pathAndInput[0]}-${objectHash(pathAndInput[1] ? JSON.stringify(pathAndInput[1]) : '')}`
-  const serverError = useState<TError | null>(`error-${key}`, () => null)
-  const { error, data, ...rest } = await useAsyncData(
-    key,
-    () => client.query(...pathAndInput),
-    options,
-  )
-
-  // @ts-expect-error: Resolved by Nuxt
-  if (process.server && error.value && !serverError.value)
-    serverError.value = error.value as any
-
-  if (data.value)
-    serverError.value = null
-
-  return {
-    ...rest,
-    data,
-    error: serverError,
-  } as any
-}

src/server.ts

@@ -1,20 +1,20 @@
-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,
 } from '@trpc/server'
 import { createURL } from 'ufo'
-import type { CompatibilityEvent } from 'h3'
-import { defineEventHandler, isMethod, useBody } from 'h3'
-import type { TRPCResponse } from '@trpc/server/dist/declarations/src/rpc'
+import type { H3Event } from 'h3'
+import { defineEventHandler, isMethod, readBody } from 'h3'
+import type { TRPCResponse } from '@trpc/server/rpc'
 
 type MaybePromise<T> = T | Promise<T>
 
-export type CreateContextFn<TRouter extends AnyRouter> = (event: CompatibilityEvent) => MaybePromise<inferRouterContext<TRouter>>
+export type CreateContextFn<TRouter extends AnyRouter> = (event: H3Event) => MaybePromise<inferRouterContext<TRouter>>
 
 export interface ResponseMetaFnPayload<TRouter extends AnyRouter> {
   data: TRPCResponse<unknown, inferRouterError<TRouter>>[]
@@ -30,42 +30,40 @@ export interface OnErrorPayload<TRouter extends AnyRouter> {
   error: TRPCError
   type: ProcedureType | 'unknown'
   path: string | undefined
-  req: CompatibilityEvent['req']
+  req: H3Event['req']
   input: unknown
   ctx: undefined | inferRouterContext<TRouter>
 }
 
 export type OnErrorFn<TRouter extends AnyRouter> = (opts: OnErrorPayload<TRouter>) => void
 
-export function createTRPCHandler<Router extends AnyRouter>({
+export function createNuxtApiHandler<TRouter extends AnyRouter>({
   router,
   createContext,
   responseMeta,
   onError,
+  url = '/api/trpc',
 }: {
-  router: Router
-  createContext?: CreateContextFn<Router>
-  responseMeta?: ResponseMetaFn<Router>
-  onError?: OnErrorFn<Router>
+  router: TRouter
+  createContext?: CreateContextFn<TRouter>
+  responseMeta?: ResponseMetaFn<TRouter>
+  onError?: OnErrorFn<TRouter>
+  url?: string
 }) {
-  const url = '/api/trpc'
-
   return defineEventHandler(async (event) => {
     const {
       req,
       res,
     } = event
 
-    const $url = createURL(req.url)
-
-    event.context.hello = 'world'
+    const $url = createURL(req.url!)
 
     const httpResponse = await resolveHTTPResponse({
       router,
       req: {
-        method: req.method,
+        method: req.method!,
         headers: req.headers,
-        body: isMethod(event, 'GET') ? null : await useBody(event),
+        body: isMethod(event, 'GET') ? null : await readBody(event),
         query: $url.searchParams,
       },
       path: $url.pathname.substring(url.length + 1),
@@ -83,8 +81,8 @@ export function createTRPCHandler<Router extends AnyRouter>({
 
     res.statusCode = status
 
-    Object.keys(headers).forEach((key) => {
-      res.setHeader(key, headers[key])
+    headers && Object.keys(headers).forEach((key) => {
+      res.setHeader(key, headers[key]!)
     })
 
     return body

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,10 @@
+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,
+})