release v0.1.14

README.md

@@ -143,6 +143,7 @@ export const onError = (payload: OnErrorPayload<typeof router>) => {
 - [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).
 

package.json

@@ -1,7 +1,7 @@
 {
   "name": "trpc-nuxt",
   "type": "module",
-  "version": "0.1.3",
+  "version": "0.1.14",
   "packageManager": "pnpm@7.1.1",
   "license": "MIT",
   "main": "./dist/module.cjs",

playground/pages/cookie.vue

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

playground/server/trpc/index.ts

@@ -1,5 +1,8 @@
 import * as trpc from '@trpc/server'
+import type { inferAsyncReturnType } from '@trpc/server'
 import { z } from 'zod'
+import type { CompatibilityEvent } from 'h3'
+import { useCookies } from 'h3'
 
 const baseURL = 'https://jsonplaceholder.typicode.com'
 
@@ -12,7 +15,7 @@ const TodoShape = z.object({
 
 export type Todo = z.infer<typeof TodoShape>
 
-export const router = trpc.router()
+export const router = trpc.router<Context>()
   .query('getTodos', {
     async resolve() {
       return await $fetch<Todo[]>(`${baseURL}/todos`)
@@ -33,3 +36,18 @@ export const router = trpc.router()
       })
     },
   })
+
+export async function createContext(event: 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
+  // const x = useCookies(event)
+  console.log('Headers', event.req.headers)
+
+  return {
+
+  }
+}
+
+  type Context = inferAsyncReturnType<typeof createContext>

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]>
+```

src/module.ts

@@ -1,8 +1,8 @@
 import { fileURLToPath } from 'url'
-import { join } from 'pathe'
+import { join, resolve } from 'pathe'
 import { defu } from 'defu'
 
-import { addServerHandler, addTemplate, defineNuxtModule } from '@nuxt/kit'
+import { addPlugin, addServerHandler, addTemplate, defineNuxtModule } from '@nuxt/kit'
 
 export interface ModuleOptions {
   baseURL: string
@@ -20,7 +20,7 @@ export default defineNuxtModule<ModuleOptions>({
   },
   async setup(options, nuxt) {
     const runtimeDir = fileURLToPath(new URL('./runtime', import.meta.url))
-    nuxt.options.build.transpile.push(runtimeDir, '#build/trpc-client', '#build/trpc-handler')
+    nuxt.options.build.transpile.push(runtimeDir, '#build/trpc-handler')
 
     const handlerPath = join(nuxt.options.buildDir, 'trpc-handler.ts')
     const trpcOptionsPath = join(nuxt.options.rootDir, 'server/trpc')
@@ -33,7 +33,7 @@ export default defineNuxtModule<ModuleOptions>({
 
     nuxt.hook('autoImports:extend', (imports) => {
       imports.push(
-        { name: 'useClient', from: '#build/trpc-client' },
+        { name: 'useClient', from: join(runtimeDir, 'client') },
         { name: 'useAsyncQuery', from: join(runtimeDir, 'client') },
       )
     })
@@ -43,22 +43,7 @@ export default defineNuxtModule<ModuleOptions>({
       handler: handlerPath,
     })
 
-    addTemplate({
-      filename: 'trpc-client.ts',
-      write: true,
-      getContents() {
-        return `
-          import * as trpc from '@trpc/client'
-          import type { router } from '${trpcOptionsPath}'
-    
-          const client = trpc.createTRPCClient<typeof router>({
-            url: '${finalConfig.baseURL}${finalConfig.trpcURL}',
-          })
-        
-          export const useClient = () => client
-        `
-      },
-    })
+    addPlugin(resolve(runtimeDir, 'plugin'))
 
     addTemplate({
       filename: 'trpc-handler.ts',

src/runtime/client.ts

@@ -6,15 +6,15 @@ import type {
   _Transform,
 } from 'nuxt/dist/app/composables/asyncData'
 import type { ProcedureRecord, inferHandlerInput, inferProcedureInput, inferProcedureOutput } from '@trpc/server'
-import type { TRPCClientErrorLike } from '@trpc/client'
+import type { TRPCClient, TRPCClientErrorLike } from '@trpc/client'
 import { objectHash } from 'ohash'
-import { useAsyncData, useState } from '#app'
-import { useClient } from '#build/trpc-client'
+import { useAsyncData, useNuxtApp, useState } from '#app'
+// @ts-expect-error: Resolved by Nuxt
 import type { router } from '~/server/trpc'
 
 type AppRouter = typeof router
 
-type inferProcedures<
+export type inferProcedures<
   TObj extends ProcedureRecord<any, any, any, any, any, any>,
 > = {
   [TPath in keyof TObj]: {
@@ -23,10 +23,10 @@ type inferProcedures<
   };
 }
 
-type TQueries = AppRouter['_def']['queries']
-type TError = TRPCClientErrorLike<AppRouter>
+export type TQueries = AppRouter['_def']['queries']
+export type TError = TRPCClientErrorLike<AppRouter>
 
-type TQueryValues = inferProcedures<AppRouter['_def']['queries']>
+export type TQueryValues = inferProcedures<AppRouter['_def']['queries']>
 
 export async function useAsyncQuery<
   TPath extends keyof TQueryValues & string,
@@ -37,12 +37,12 @@ export async function useAsyncQuery<
   pathAndInput: [path: TPath, ...args: inferHandlerInput<TQueries[TPath]>],
   options: AsyncDataOptions<TOutput, Transform, PickKeys> = {},
 ): Promise<AsyncData<PickFrom<ReturnType<Transform>, PickKeys>, TError>> {
-  const client = useClient()
+  const { $client } = useNuxtApp()
   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),
+    () => $client.query(...pathAndInput),
     options,
   )
 
@@ -58,3 +58,8 @@ export async function useAsyncQuery<
     error: serverError,
   } as any
 }
+
+export function useClient(): TRPCClient<AppRouter> {
+  const { $client } = useNuxtApp()
+  return $client
+}

src/runtime/plugin.ts

@@ -0,0 +1,26 @@
+import * as trpc from '@trpc/client'
+// @ts-expect-error: Resolved by Nuxt
+import { defineNuxtPlugin, useRequestHeaders, useRuntimeConfig } from '#app'
+import type { router } from '~/server/trpc'
+
+type AppRouter = typeof router
+
+const config = useRuntimeConfig().public.trpc
+const client = trpc.createTRPCClient<AppRouter>({
+  url: `${config.baseURL}${config.trpcURL}`,
+  headers: useRequestHeaders(),
+})
+
+export default defineNuxtPlugin(() => {
+  return {
+    provide: {
+      client,
+    },
+  }
+})
+
+declare module '#app' {
+  interface NuxtApp {
+    $client: trpc.TRPCClient<AppRouter>
+  }
+}