@orpc/server 0.0.0-unsafe-pr-2-20241118033608

package/src/adapters/fetch.ts

@@ -0,0 +1,228 @@
+/// <reference lib="dom" />
+
+import {
+  type HTTPPath,
+  ORPC_HEADER,
+  ORPC_HEADER_VALUE,
+  standardizeHTTPPath,
+} from '@orpc/contract'
+import {
+  type PartialOnUndefinedDeep,
+  get,
+  isPlainObject,
+  trim,
+} from '@orpc/shared'
+import { ORPCError } from '@orpc/shared/error'
+import {
+  ORPCDeserializer,
+  ORPCSerializer,
+  OpenAPIDeserializer,
+  OpenAPISerializer,
+} from '@orpc/transformer'
+import { LinearRouter } from 'hono/router/linear-router'
+import { RegExpRouter } from 'hono/router/reg-exp-router'
+import { type WELL_DEFINED_PROCEDURE, isProcedure } from '../procedure'
+import { createProcedureCaller } from '../procedure-caller'
+import type { Router } from '../router'
+import type { Meta, Promisable } from '../types'
+import { hook } from '../utils'
+
+export interface CreateFetchHandlerOptions<TRouter extends Router<any>> {
+  router: TRouter
+
+  hooks?: (
+    context: TRouter extends Router<infer UContext> ? UContext : never,
+    meta: Meta<unknown>,
+  ) => Promisable<void>
+
+  /**
+   * It will help improve the cold start time. But it will increase the performance.
+   *
+   * @default false
+   */
+  serverless?: boolean
+}
+
+export function createFetchHandler<TRouter extends Router<any>>(
+  options: CreateFetchHandlerOptions<TRouter>,
+): FetchHandler<TRouter> {
+  const routing = options.serverless
+    ? new LinearRouter<[string[], WELL_DEFINED_PROCEDURE]>()
+    : new RegExpRouter<[string[], WELL_DEFINED_PROCEDURE]>()
+
+  const addRouteRecursively = (router: Router<any>, basePath: string[]) => {
+    for (const key in router) {
+      const currentPath = [...basePath, key]
+      const item = router[key] as WELL_DEFINED_PROCEDURE | Router<any>
+
+      if (isProcedure(item)) {
+        if (item.zz$p.contract.zz$cp.path) {
+          const method = item.zz$p.contract.zz$cp.method ?? 'POST'
+          const path = openAPIPathToRouterPath(item.zz$p.contract.zz$cp.path)
+
+          routing.add(method, path, [currentPath, item])
+        }
+      } else {
+        addRouteRecursively(item, currentPath)
+      }
+    }
+  }
+
+  addRouteRecursively(options.router, [])
+
+  return async (requestOptions) => {
+    const isORPCTransformer =
+      requestOptions.request.headers.get(ORPC_HEADER) === ORPC_HEADER_VALUE
+    const accept = requestOptions.request.headers.get('Accept') ?? undefined
+
+    const serializer = isORPCTransformer
+      ? new ORPCSerializer()
+      : new OpenAPISerializer({ accept })
+
+    try {
+      return await hook(async (hooks) => {
+        const url = new URL(requestOptions.request.url)
+        const pathname = `/${trim(url.pathname.replace(requestOptions.prefix ?? '', ''), '/')}`
+
+        let path: string[] | undefined
+        let procedure: WELL_DEFINED_PROCEDURE | undefined
+        let params: Record<string, string | number> | undefined
+
+        if (isORPCTransformer) {
+          path = trim(pathname, '/').split('/').map(decodeURIComponent)
+          const val = get(options.router, path)
+
+          if (isProcedure(val)) {
+            procedure = val
+          }
+        } else {
+          const [[match]] = routing.match(
+            requestOptions.request.method,
+            pathname,
+          )
+          path = match?.[0][0]
+          procedure = match?.[0][1]
+          params = match?.[1]
+
+          if (!path || !procedure) {
+            path = trim(pathname, '/').split('/').map(decodeURIComponent)
+
+            const val = get(options.router, path)
+
+            if (isProcedure(val)) {
+              procedure = val
+            }
+          }
+        }
+
+        if (!path || !procedure) {
+          throw new ORPCError({ code: 'NOT_FOUND', message: 'Not found' })
+        }
+
+        const meta: Meta<unknown> = {
+          ...hooks,
+          procedure,
+          path: path,
+          internal: false,
+        }
+
+        await options.hooks?.(requestOptions.context as any, meta)
+
+        const deserializer = isORPCTransformer
+          ? new ORPCDeserializer()
+          : new OpenAPIDeserializer({
+              schema: procedure.zz$p.contract.zz$cp.InputSchema,
+            })
+
+        const input_ = await (async () => {
+          try {
+            return await deserializer.deserialize(requestOptions.request)
+          } catch (e) {
+            throw new ORPCError({
+              code: 'BAD_REQUEST',
+              message:
+                'Cannot parse request. Please check the request body and Content-Type header.',
+              cause: e,
+            })
+          }
+        })()
+
+        const input = (() => {
+          if (
+            params &&
+            Object.keys(params).length > 0 &&
+            (input_ === undefined || isPlainObject(input_))
+          ) {
+            return {
+              ...params,
+              ...input_,
+            }
+          }
+
+          return input_
+        })()
+
+        const caller = createProcedureCaller({
+          context: requestOptions.context,
+          internal: false,
+          validate: true,
+          procedure,
+          path,
+        })
+
+        const output = await caller(input)
+
+        const { body, headers } = serializer.serialize(output)
+
+        return new Response(body, {
+          status: 200,
+          headers,
+        })
+      })
+    } catch (e) {
+      const error =
+        e instanceof ORPCError
+          ? e
+          : new ORPCError({
+              code: 'INTERNAL_SERVER_ERROR',
+              message: 'Internal server error',
+              cause: e,
+            })
+
+      const { body, headers } = serializer.serialize(error.toJSON())
+
+      return new Response(body, {
+        status: error.status,
+        headers: headers,
+      })
+    }
+  }
+}
+
+function openAPIPathToRouterPath(path: HTTPPath): string {
+  return standardizeHTTPPath(path).replace(/\{([^}]+)\}/g, ':$1')
+}
+
+export type FetchHandlerOptions<TRouter extends Router<any>> = {
+  /**
+   * The request need to be handled.
+   */
+  request: Request
+
+  /**
+   * Remove the prefix from the request path.
+   *
+   * @example /orpc
+   * @example /api
+   */
+  prefix?: string
+} & PartialOnUndefinedDeep<{
+  /**
+   * The context used to handle the request.
+   */
+  context: TRouter extends Router<infer UContext> ? UContext : never
+}>
+
+export interface FetchHandler<TRouter extends Router<any>> {
+  (options: FetchHandlerOptions<TRouter>): Promise<Response>
+}

package/src/builder.test.ts

@@ -0,0 +1,362 @@
+import { oc } from '@orpc/contract'
+import { z } from 'zod'
+import {
+  os,
+  type Builder,
+  type DecoratedMiddleware,
+  type DecoratedProcedure,
+  type Meta,
+  ProcedureBuilder,
+  ProcedureImplementer,
+  RouterImplementer,
+  isProcedure,
+} from '.'
+import { RouterBuilder } from './router-builder'
+
+test('context method', () => {
+  expectTypeOf<
+    typeof os extends Builder<infer TContext, any> ? TContext : never
+  >().toEqualTypeOf<undefined | Record<string, unknown>>()
+
+  const os2 = os.context<{ foo: 'bar' }>()
+
+  expectTypeOf<
+    typeof os2 extends Builder<infer TContext, any> ? TContext : never
+  >().toEqualTypeOf<{ foo: 'bar' }>()
+
+  const os3 = os.context<{ foo: 'bar' }>().context()
+
+  expectTypeOf<
+    typeof os3 extends Builder<infer TContext, any> ? TContext : never
+  >().toEqualTypeOf<{ foo: 'bar' }>()
+})
+
+describe('use middleware', () => {
+  type Context = { auth: boolean }
+
+  const osw = os.context<Context>()
+
+  it('infer types', () => {
+    osw.use((input, context, meta) => {
+      expectTypeOf(input).toEqualTypeOf<unknown>()
+      expectTypeOf(context).toEqualTypeOf<Context>()
+      expectTypeOf(meta).toEqualTypeOf<Meta<unknown>>()
+    })
+  })
+
+  it('can map context', () => {
+    osw
+      .use(() => {
+        return { context: { userId: '1' } }
+      })
+      .use((_, context) => {
+        expectTypeOf(context).toMatchTypeOf<Context & { userId: string }>()
+      })
+  })
+
+  it('can map input', () => {
+    osw
+      // @ts-expect-error mismatch input
+      .use((input: { postId: string }) => {})
+      .use(
+        (input: { postId: string }) => {
+          return { context: { user: '1' } }
+        },
+        (input) => {
+          expectTypeOf(input).toEqualTypeOf<unknown>()
+          return { postId: '1' }
+        },
+      )
+      .handler((_, context) => {
+        expectTypeOf(context).toMatchTypeOf<{ user: string }>()
+      })
+  })
+})
+
+describe('create middleware', () => {
+  it('infer types', () => {
+    const mid = os
+      .context<{ auth: boolean }>()
+      .middleware((input, context, meta) => {
+        expectTypeOf(input).toEqualTypeOf<unknown>()
+        expectTypeOf(context).toEqualTypeOf<{ auth: boolean }>()
+        expectTypeOf(meta).toEqualTypeOf<Meta<unknown>>()
+      })
+
+    expectTypeOf(mid).toEqualTypeOf<
+      DecoratedMiddleware<{ auth: boolean }, undefined, unknown, unknown>
+    >()
+  })
+
+  it('map context', () => {
+    const mid = os.context<{ auth: boolean }>().middleware(() => {
+      return { context: { userId: '1' } }
+    })
+
+    expectTypeOf(mid).toEqualTypeOf<
+      DecoratedMiddleware<
+        { auth: boolean },
+        { userId: string },
+        unknown,
+        unknown
+      >
+    >()
+  })
+})
+
+test('router method', () => {
+  const pingContract = oc.input(z.string()).output(z.string())
+  const userFindContract = oc
+    .input(z.object({ id: z.string() }))
+    .output(z.object({ name: z.string() }))
+
+  const contract = oc.router({
+    ping: pingContract,
+    user: {
+      find: userFindContract,
+    },
+
+    user2: oc.router({
+      find: userFindContract,
+    }),
+
+    router: userFindContract,
+  })
+
+  const osw = os.contract(contract)
+
+  expect(osw.ping).instanceOf(ProcedureImplementer)
+  expect(osw.ping.zz$pi.contract).toEqual(pingContract)
+
+  expect(osw.user).instanceOf(RouterImplementer)
+
+  expect(osw.user.find).instanceOf(ProcedureImplementer)
+  expect(osw.user.find.zz$pi.contract).toEqual(userFindContract)
+
+  // Because of the router keyword is special, we can't use instanceof
+  expect(osw.router.zz$pi.contract).toEqual(userFindContract)
+  expect(
+    osw.router.handler(() => {
+      return { name: '' }
+    }),
+  ).toSatisfy(isProcedure)
+})
+
+describe('define procedure builder', () => {
+  const osw = os.context<{ auth: boolean }>()
+  const schema1 = z.object({})
+  const example1 = {}
+  const schema2 = z.object({ a: z.string() })
+  const example2 = { a: '' }
+
+  test('input method', () => {
+    const builder = osw.input(schema1, example1)
+
+    expectTypeOf(builder).toEqualTypeOf<
+      ProcedureBuilder<{ auth: boolean }, undefined, typeof schema1, undefined>
+    >()
+
+    expect(builder).instanceOf(ProcedureBuilder)
+    expect(builder.zz$pb.middlewares).toBe(undefined)
+    expect(builder.zz$pb).toMatchObject({
+      contract: {
+        zz$cp: {
+          InputSchema: schema1,
+          inputExample: example1,
+        },
+      },
+    })
+  })
+
+  test('output method', () => {
+    const builder = osw.output(schema2, example2)
+
+    expectTypeOf(builder).toEqualTypeOf<
+      ProcedureBuilder<{ auth: boolean }, undefined, undefined, typeof schema2>
+    >()
+
+    expect(builder).instanceOf(ProcedureBuilder)
+    expect(builder.zz$pb.middlewares).toBe(undefined)
+    expect(builder.zz$pb).toMatchObject({
+      contract: {
+        zz$cp: {
+          OutputSchema: schema2,
+          outputExample: example2,
+        },
+      },
+    })
+  })
+
+  test('route method', () => {
+    const builder = osw.route({
+      method: 'GET',
+      path: '/test',
+      deprecated: true,
+      description: 'des',
+      summary: 'sum',
+      tags: ['cccc'],
+    })
+
+    expectTypeOf(builder).toEqualTypeOf<
+      ProcedureBuilder<{ auth: boolean }, undefined, undefined, undefined>
+    >()
+
+    expect(builder).instanceOf(ProcedureBuilder)
+    expect(builder.zz$pb.middlewares).toBe(undefined)
+    expect(builder.zz$pb).toMatchObject({
+      contract: {
+        zz$cp: {
+          method: 'GET',
+          path: '/test',
+          deprecated: true,
+          description: 'des',
+          summary: 'sum',
+          tags: ['cccc'],
+        },
+      },
+    })
+  })
+
+  test('with middlewares', () => {
+    const mid = os.middleware(() => {
+      return {
+        context: {
+          userId: 'string',
+        },
+      }
+    })
+
+    const mid2 = os.middleware(() => {
+      return {
+        context: {
+          mid2: true,
+        },
+      }
+    })
+
+    const osw = os.context<{ auth: boolean }>().use(mid).use(mid2)
+
+    const builder1 = osw.input(schema1)
+    const builder2 = osw.output(schema2)
+    const builder3 = osw.route({ method: 'GET', path: '/test' })
+
+    expectTypeOf(builder1).toEqualTypeOf<
+      ProcedureBuilder<
+        { auth: boolean },
+        { userId: string } & { mid2: boolean },
+        typeof schema1,
+        undefined
+      >
+    >()
+
+    expectTypeOf(builder2).toEqualTypeOf<
+      ProcedureBuilder<
+        { auth: boolean },
+        { userId: string } & { mid2: boolean },
+        undefined,
+        typeof schema2
+      >
+    >()
+
+    expectTypeOf(builder3).toEqualTypeOf<
+      ProcedureBuilder<
+        { auth: boolean },
+        { userId: string } & { mid2: boolean },
+        undefined,
+        undefined
+      >
+    >()
+
+    expect(builder1.zz$pb.middlewares).toEqual([mid, mid2])
+    expect(builder2.zz$pb.middlewares).toEqual([mid, mid2])
+    expect(builder3.zz$pb.middlewares).toEqual([mid, mid2])
+  })
+})
+
+describe('handler method', () => {
+  it('without middlewares', () => {
+    const osw = os.context<{ auth: boolean }>()
+
+    const procedure = osw.handler((input, context, meta) => {
+      expectTypeOf(input).toEqualTypeOf<unknown>()
+      expectTypeOf(context).toEqualTypeOf<{ auth: boolean }>()
+      expectTypeOf(meta).toEqualTypeOf<Meta<unknown>>()
+    })
+
+    expectTypeOf(procedure).toEqualTypeOf<
+      DecoratedProcedure<
+        { auth: boolean },
+        undefined,
+        undefined,
+        undefined,
+        void
+      >
+    >()
+
+    expect(isProcedure(procedure)).toBe(true)
+    expect(procedure.zz$p.middlewares).toBe(undefined)
+  })
+
+  it('with middlewares', () => {
+    const mid = os.middleware(() => {
+      return {
+        context: {
+          userId: 'string',
+        },
+      }
+    })
+
+    const osw = os.context<{ auth: boolean }>().use(mid)
+
+    const procedure = osw.handler((input, context, meta) => {
+      expectTypeOf(input).toEqualTypeOf<unknown>()
+      expectTypeOf(context).toMatchTypeOf<{ auth: boolean }>()
+      expectTypeOf(meta).toEqualTypeOf<Meta<unknown>>()
+    })
+
+    expectTypeOf(procedure).toEqualTypeOf<
+      DecoratedProcedure<
+        { auth: boolean },
+        { userId: string },
+        undefined,
+        undefined,
+        void
+      >
+    >()
+
+    expect(isProcedure(procedure)).toBe(true)
+    expect(procedure.zz$p.middlewares).toEqual([mid])
+  })
+})
+
+test('prefix', () => {
+  const builder = os
+    .context<{ auth: boolean }>()
+    .use(() => {
+      return { context: { userId: '1' } }
+    })
+    .prefix('/api')
+
+  expectTypeOf(builder).toEqualTypeOf<
+    RouterBuilder<{ auth: boolean }, { userId: string }>
+  >()
+
+  expect(builder).instanceOf(RouterBuilder)
+  expect(builder.zz$rb.prefix).toEqual('/api')
+})
+
+test('tags', () => {
+  const builder = os
+    .context<{ auth: boolean }>()
+    .use(() => {
+      return { context: { userId: '1' } }
+    })
+    .tags('user', 'user2')
+
+  expectTypeOf(builder).toEqualTypeOf<
+    RouterBuilder<{ auth: boolean }, { userId: string }>
+  >()
+
+  expect(builder).instanceOf(RouterBuilder)
+  expect(builder.zz$rb.tags).toEqual(['user', 'user2'])
+})