update types

src/module.ts

@@ -0,0 +1,84 @@
+import { dirname, join, resolve } from 'pathe'
+import { addServerHandler, defineNuxtModule } from '@nuxt/kit'
+import fs from 'fs-extra'
+
+export interface ModuleOptions {}
+
+export default defineNuxtModule<ModuleOptions>({
+  meta: {
+    name: 'trpc-nuxt',
+    configKey: 'trpc',
+  },
+  defaults: {},
+  async setup(_options, nuxt) {
+    const clientPath = join(nuxt.options.buildDir, 'trpc-client.ts')
+    const handlerPath = join(nuxt.options.buildDir, 'trpc-handler.ts')
+
+    nuxt.hook('config', (options) => {
+      options?.build?.transpile?.push('trpc-nuxt/client')
+    })
+
+    addServerHandler({
+      route: '/trpc/*',
+      handler: handlerPath,
+    })
+
+    nuxt.hook('autoImports:extend', (imports) => {
+      imports.push(
+        { name: 'useTrpcQuery', from: clientPath },
+        { name: 'useLazyTrpcQuery', from: clientPath },
+        { name: 'useTrpcMutation', from: clientPath },
+      )
+    })
+
+    const srcDir = nuxt.options.srcDir
+    const optionsPath = resolve(srcDir, 'server/fn/index.ts')
+
+    await fs.ensureDir(dirname(clientPath))
+
+    await fs.writeFile(clientPath, `
+      import * as trpc from '@trpc/client'
+      import { createTRPCComposables } from 'trpc-nuxt/client'
+      import { router } from '~/server/fn'
+
+      const client = trpc.createTRPCClient<typeof router>({
+        url: process.browser ? '/trpc' : 'http://localhost:3000/trpc',
+      })
+
+      const {
+        useTrpcQuery,
+        useLazyTrpcQuery,
+        useTrpcMutation
+      } = createTRPCComposables<typeof router>(client)
+
+      export {
+        useTrpcQuery,
+        useLazyTrpcQuery,
+        useTrpcMutation
+      }
+    `)
+
+    await fs.writeFile(handlerPath, `
+      import { createTRPCHandler } from 'trpc-nuxt/api'
+      import * as functions from '~/server/fn'
+      export default createTRPCHandler({
+        router: functions.router
+      })
+    `)
+
+    if (!fs.existsSync(optionsPath)) {
+      await fs.writeFile(optionsPath, `
+      // Generated by trpc-nuxt
+      import * as trpc from '@trpc/server'
+      
+      export const router = trpc
+        .router()
+        .query('hello', {
+          resolve: () => 'world',
+        });
+      
+      export type Router = typeof router
+    `.trimStart())
+    }
+  },
+})

src/runtime/api.ts

@@ -0,0 +1,69 @@
+import { resolveHTTPResponse } from '@trpc/server'
+import type {
+  AnyRouter,
+  ProcedureType,
+  ResponseMeta,
+  TRPCError,
+  inferRouterContext,
+  inferRouterError,
+} from '@trpc/server'
+import { createURL } from 'ufo'
+import type { IncomingMessage } from 'h3'
+import type { TRPCResponse } from '@trpc/server/dist/declarations/src/rpc'
+import { isMethod, useBody } from 'h3'
+
+type MaybePromise<T> = T | Promise<T>
+
+type CreateContextFn<TRouter extends AnyRouter> = (req: IncomingMessage) => MaybePromise<inferRouterContext<TRouter>>
+
+type ResponseMetaFn<TRouter extends AnyRouter> = (opts: {
+  data: TRPCResponse<unknown, inferRouterError<TRouter>>[]
+  ctx?: inferRouterContext<TRouter>
+  paths?: string[]
+  type: ProcedureType | 'unknown'
+  errors: TRPCError[]
+}) => ResponseMeta
+
+export function createTRPCHandler<Router extends AnyRouter>({
+  router,
+  createContext,
+  responseMeta,
+}: {
+  router: Router
+  createContext?: CreateContextFn<Router>
+  responseMeta?: ResponseMetaFn<Router>
+}) {
+  const url = '/trpc'
+
+  return async (event) => {
+    const {
+      req,
+      res,
+    } = event
+
+    const $url = createURL(req.url)
+
+    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?.(req),
+      responseMeta,
+    })
+
+    const { status, headers, body } = httpResponse
+
+    res.statusCode = status
+
+    Object.keys(headers).forEach((key) => {
+      res.setHeader(key, headers[key])
+    })
+
+    return body
+  }
+}

src/runtime/client.ts

@@ -0,0 +1,81 @@
+import { objectHash } from 'ohash'
+import type { TRPCClient } from '@trpc/client'
+import type { AnyRouter, inferProcedureInput, inferProcedureOutput } from '@trpc/server'
+import type { AsyncData, KeyOfRes, PickFrom, _Transform } from 'nuxt/dist/app/composables/asyncData'
+// @ts-expect-error: Resolved by Nuxt
+import { useAsyncData, useLazyAsyncData } from '#imports'
+
+export function createTRPCComposables<
+  Router extends AnyRouter,
+  Client extends TRPCClient<Router> = TRPCClient<Router>,
+  TQuery extends keyof Router['_def']['queries'] = keyof Router['_def']['queries'],
+  TMutation extends keyof Router['_def']['mutations'] = keyof Router['_def']['mutations'],
+>(
+  client: Client
+): {
+  useTrpcQuery: <TRouteKey extends TQuery>(
+    args_0: TRouteKey,
+    args_1: inferProcedureInput<Router['_def']['queries'][TRouteKey]>
+  ) => AsyncData<
+    PickFrom<
+      inferProcedureOutput<Router['_def']['queries'][TRouteKey]>,
+      KeyOfRes<
+        _Transform<
+          inferProcedureOutput<Router['_def']['queries'][TRouteKey]>,
+          inferProcedureOutput<Router['_def']['queries'][TRouteKey]>
+        >
+      >
+    >,
+    true | Error
+  >
+  useLazyTrpcQuery: <TRouteKey extends TQuery>(
+    args_0: TRouteKey,
+    args_1: inferProcedureInput<Router['_def']['queries'][TRouteKey]>
+  ) => AsyncData<
+    PickFrom<
+      inferProcedureOutput<Router['_def']['queries'][TRouteKey]>,
+      KeyOfRes<
+        _Transform<
+          inferProcedureOutput<Router['_def']['queries'][TRouteKey]>,
+          inferProcedureOutput<Router['_def']['queries'][TRouteKey]>
+        >
+      >
+    >,
+    true | Error
+  >
+  useTrpcMutation: <TRouteKey extends TMutation>(
+    args_0: TRouteKey,
+    args_1: inferProcedureInput<Router['_def']['mutations'][TRouteKey]>
+  ) => AsyncData<
+    PickFrom<
+      inferProcedureOutput<Router['_def']['mutations'][TRouteKey]>,
+      KeyOfRes<
+        _Transform<
+          inferProcedureOutput<Router['_def']['mutations'][TRouteKey]>,
+          inferProcedureOutput<Router['_def']['mutations'][TRouteKey]>
+        >
+      >
+    >,
+    true | Error
+  >
+}
+
+export function createTRPCComposables(client: any) {
+  const useTrpcQuery = (...args) => {
+    return useAsyncData(`trpc-${objectHash(args[0] + (args[1] ? JSON.stringify(args[1]) : ''))}`, () => client.query(...args))
+  }
+
+  const useLazyTrpcQuery = (...args) => {
+    return useLazyAsyncData(`trpc-${objectHash(args[0] + (args[1] ? JSON.stringify(args[1]) : ''))}`, () => client.query(...args))
+  }
+
+  const useTrpcMutation = (...args) => {
+    return useAsyncData(`trpc-${objectHash(args[0] + (args[1] ? JSON.stringify(args[1]) : ''))}`, () => client.mutation(...args))
+  }
+
+  return {
+    useTrpcQuery,
+    useLazyTrpcQuery,
+    useTrpcMutation,
+  }
+}