release v0.2.3

fix: auto-import `getQueryKey`

.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

@@ -29,10 +29,10 @@ export default defineNuxtConfig({
   modules: ['trpc-nuxt'],
   trpc: {
     baseURL: 'http://localhost:3000', // defaults to http://localhost:3000
-    trpcURL: '/api/trpc', // defaults to /api/trpc
+    endpoint: '/trpc', // defaults to /trpc
   },
   typescript: {
-    strict: true // set this to true to make input/output types work
+    strict: true // required to make input/output types work
   }
 })
 ```
@@ -111,7 +111,6 @@ const { data: token } = await useAsyncQuery(['auth.login', { username, password
 headers.value.Authorization = `Bearer ${token}`
 
 // All client calls will now include the Authorization header.
-// For SSR, please follow this until I found a solution https://github.com/trpc/trpc/discussions/1686
 ```
 
 ## Options

package.json

@@ -1,7 +1,7 @@
 {
   "name": "trpc-nuxt",
   "type": "module",
-  "version": "0.1.19",
+  "version": "0.2.3",
   "packageManager": "pnpm@7.1.1",
   "license": "MIT",
   "main": "./dist/module.cjs",
@@ -32,30 +32,34 @@
     "prepare": "nuxi prepare playground"
   },
   "dependencies": {
-    "@nuxt/kit": "^3.0.0-rc.3",
+    "@nuxt/kit": "^3.0.0-rc.4",
-    "@trpc/client": "^9.23.3",
+    "@trpc/client": "^9.26.0",
-    "@trpc/server": "^9.23.2",
+    "@trpc/server": "^9.26.0",
-    "@vueuse/core": "^8.5.0",
+    "@vueuse/core": "^8.9.3",
-    "@vueuse/nuxt": "^8.5.0",
+    "@vueuse/nuxt": "^8.9.3",
+    "dedent": "^0.7.0",
     "defu": "^6.0.0",
-    "h3": "^0.7.8",
+    "h3": "^0.7.10",
     "pathe": "^0.3.0",
-    "ufo": "^0.8.4"
+    "ufo": "^0.8.5"
   },
   "devDependencies": {
     "@antfu/eslint-config": "^0.23.1",
     "@antfu/ni": "^0.16.2",
     "@nuxt/module-builder": "latest",
-    "bumpp": "^7.1.1",
+    "@types/dedent": "^0.7.0",
+    "bumpp": "^7.2.0",
     "eslint": "^8.14.0",
-    "nuxt": "^3.0.0-rc.3",
+    "nuxt": "3.0.0-rc.4",
     "ohash": "^0.1.0",
     "pnpm": "^7.1.1",
-    "superjson": "^1.9.1",
     "trpc-nuxt": "workspace:*",
     "zod": "^3.16.0"
   },
   "eslintConfig": {
-    "extends": "@antfu"
+    "extends": "@antfu",
+    "rules": {
+      "no-console": "warn"
+    }
   }
 }

playground/server/trpc/index.ts

@@ -2,7 +2,6 @@ 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'
 
@@ -30,6 +29,7 @@ export const router = trpc.router<Context>()
   .mutation('addTodo', {
     input: TodoShape,
     async resolve(req) {
+      console.log(req.input)
       return await $fetch<Todo>(`${baseURL}/todos`, {
         method: 'POST',
         body: req.input,

pnpm-workspace.yaml

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

src/module.ts

@@ -1,12 +1,13 @@
 import { fileURLToPath } from 'url'
 import { join, resolve } from 'pathe'
 import { defu } from 'defu'
+import dedent from 'dedent'
 
-import { addPlugin, addServerHandler, addTemplate, defineNuxtModule } from '@nuxt/kit'
+import { addAutoImport, addPlugin, addServerHandler, addTemplate, defineNuxtModule } from '@nuxt/kit'
 
 export interface ModuleOptions {
   baseURL: string
-  trpcURL: string
+  endpoint: string
 }
 
 export default defineNuxtModule<ModuleOptions>({
@@ -16,14 +17,14 @@ export default defineNuxtModule<ModuleOptions>({
   },
   defaults: {
     baseURL: 'http://localhost:3000',
-    trpcURL: '/api/trpc',
+    endpoint: '/trpc',
   },
   async setup(options, nuxt) {
     const runtimeDir = fileURLToPath(new URL('./runtime', import.meta.url))
     nuxt.options.build.transpile.push(runtimeDir, '#build/trpc-handler')
 
     const handlerPath = join(nuxt.options.buildDir, 'trpc-handler.ts')
-    const trpcOptionsPath = join(nuxt.options.rootDir, 'server/trpc')
+    const trpcOptionsPath = join(nuxt.options.srcDir, 'server/trpc')
 
     // Add vueuse
     nuxt.options.modules.push('@vueuse/nuxt')
@@ -31,19 +32,18 @@ export default defineNuxtModule<ModuleOptions>({
     // Final resolved configuration
     const finalConfig = nuxt.options.runtimeConfig.public.trpc = defu(nuxt.options.runtimeConfig.public.trpc, {
       baseURL: options.baseURL,
-      trpcURL: options.trpcURL,
+      endpoint: options.endpoint,
     })
 
-    nuxt.hook('autoImports:extend', (imports) => {
+    addAutoImport([
-      imports.push(
+      { name: 'useClient', from: join(runtimeDir, 'client') },
-        { name: 'useClient', from: join(runtimeDir, 'client') },
+      { name: 'useAsyncQuery', from: join(runtimeDir, 'client') },
-        { name: 'useAsyncQuery', from: join(runtimeDir, 'client') },
+      { name: 'useClientHeaders', from: join(runtimeDir, 'client') },
-        { name: 'useClientHeaders', from: join(runtimeDir, 'client') },
+      { name: 'getQueryKey', from: join(runtimeDir, 'client') },
-      )
+    ])
-    })
 
     addServerHandler({
-      route: `${finalConfig.trpcURL}/*`,
+      route: `${finalConfig.endpoint}/*`,
       handler: handlerPath,
     })
 
@@ -53,13 +53,13 @@ export default defineNuxtModule<ModuleOptions>({
       filename: 'trpc-handler.ts',
       write: true,
       getContents() {
-        return `
+        return dedent`
           import { createTRPCHandler } from 'trpc-nuxt/api'
           import * as functions from '${trpcOptionsPath}'
     
           export default createTRPCHandler({
             ...functions,
-            trpcURL: '${finalConfig.trpcURL}'
+            endpoint: '${finalConfig.endpoint}'
           })
         `
       },

src/runtime/api.ts

@@ -42,13 +42,13 @@ export function createTRPCHandler<Router extends AnyRouter>({
   createContext,
   responseMeta,
   onError,
-  trpcURL,
+  endpoint,
 }: {
   router: Router
   createContext?: CreateContextFn<Router>
   responseMeta?: ResponseMetaFn<Router>
   onError?: OnErrorFn<Router>
-  trpcURL: string
+  endpoint: string
 }) {
   return defineEventHandler(async (event) => {
     const {
@@ -56,17 +56,17 @@ export function createTRPCHandler<Router extends AnyRouter>({
       res,
     } = event
 
-    const $url = createURL(req.url)
+    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),
         query: $url.searchParams,
       },
-      path: $url.pathname.substring(trpcURL.length + 1),
+      path: $url.pathname.substring(endpoint.length + 1),
       createContext: async () => createContext?.(event),
       responseMeta,
       onError: (o) => {
@@ -81,8 +81,8 @@ export function createTRPCHandler<Router extends AnyRouter>({
 
     res.statusCode = status
 
-    Object.keys(headers).forEach((key) => {
+    headers && Object.keys(headers).forEach((key) => {
-      res.setHeader(key, headers[key])
+      res.setHeader(key, headers[key]!)
     })
 
     return body

src/runtime/client.ts

@@ -8,11 +8,13 @@ import type {
 import type { ProcedureRecord, inferHandlerInput, inferProcedureInput, inferProcedureOutput } from '@trpc/server'
 import type { TRPCClient, TRPCClientErrorLike } from '@trpc/client'
 import { objectHash } from 'ohash'
-import type { MaybeRef } from '@vueuse/core'
+import type { Ref } from 'vue'
 import { useStorage } from '@vueuse/core'
 import { useAsyncData, useNuxtApp, useState } from '#app'
 import type { router } from '~/server/trpc'
 
+type MaybeRef<T> = T | Ref<T>
+
 type AppRouter = typeof router
 
 export type inferProcedures<
@@ -30,12 +32,15 @@ export type TError = TRPCClientErrorLike<AppRouter>
 export type TQueryValues = inferProcedures<AppRouter['_def']['queries']>
 
 /**
- * Additional header properties to pass to tRPC client.
+ * Calculates the key used for `useAsyncData` call
- *
+ * @param pathAndInput
- * @see https://trpc.io/docs/vanilla
- * @param pathAndInput tRPC client path and input.
- * @param options Options to pass to useAsyncData.
  */
+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'],
@@ -46,7 +51,7 @@ export async function useAsyncQuery<
   options: AsyncDataOptions<TOutput, Transform, PickKeys> = {},
 ): Promise<AsyncData<PickFrom<ReturnType<Transform>, PickKeys>, TError>> {
   const { $client } = useNuxtApp()
-  const key = `${pathAndInput[0]}-${objectHash(pathAndInput[1] ? JSON.stringify(pathAndInput[1]) : '')}`
+  const key = getQueryKey(pathAndInput)
   const serverError = useState<TError | null>(`error-${key}`, () => null)
   const { error, data, ...rest } = await useAsyncData(
     key,
@@ -68,22 +73,11 @@ export async function useAsyncQuery<
   } as any
 }
 
-/**
- * tRPC Client.
- *
- * @see https://trpc.io/docs/vanilla
- */
 export function useClient(): TRPCClient<AppRouter> {
   const { $client } = useNuxtApp()
   return $client
 }
 
-/**
+export function useClientHeaders(initialValue: MaybeRef<Record<string, any>> = {}): Ref<Record<string, any>> {
- * Additional header properties to pass to tRPC client.
+  return useStorage('trpc-nuxt-header', initialValue)
- *
- * @see https://github.com/trpc/trpc/discussions/1686
- * @param initialValue
- */
-export function useClientHeaders(initialValue?: MaybeRef<Record<string, any>>) {
-  return useStorage('trpc-nuxt-header', initialValue || {})
 }

src/runtime/plugin.ts

@@ -11,7 +11,7 @@ export default defineNuxtPlugin((nuxtApp) => {
   const headers = useRequestHeaders()
   const otherHeaders = useClientHeaders()
   const client = trpc.createTRPCClient<AppRouter>({
-    url: `${config.baseURL}${config.trpcURL}`,
+    url: `${config.baseURL}${config.endpoint}`,
     headers: () => {
       return {
         ...unref(otherHeaders),