@orpc/server 0.10.0-beta.1 → 0.11.0

package/src/adapters/fetch.ts

@@ -1,290 +0,0 @@
-/// <reference lib="dom" />
-
-import type {
-  PartialOnUndefinedDeep,
-  Promisable,
-  Value,
-} from '@orpc/shared'
-import type { Router } from '../router'
-import {
-  type HTTPPath,
-  ORPC_HEADER,
-  ORPC_HEADER_VALUE,
-  standardizeHTTPPath,
-} from '@orpc/contract'
-import {
-  get,
-  isPlainObject,
-  mapValues,
-  trim,
-  value,
-} from '@orpc/shared'
-import { ORPCError } from '@orpc/shared/error'
-import {
-  OpenAPIDeserializer,
-  OpenAPISerializer,
-  ORPCDeserializer,
-  ORPCSerializer,
-  zodCoerce,
-} from '@orpc/transformer'
-import { LinearRouter } from 'hono/router/linear-router'
-import { RegExpRouter } from 'hono/router/reg-exp-router'
-import { isProcedure, type WELL_DEFINED_PROCEDURE } from '../procedure'
-import { createProcedureCaller } from '../procedure-caller'
-
-export interface FetchHandlerHooks {
-  next: () => Promise<Response>
-  response: (response: Response) => Response
-}
-
-export interface CreateFetchHandlerOptions<TRouter extends Router<any>> {
-  router: TRouter
-
-  /**
-   * Hooks for executing logics on lifecycle events.
-   */
-  hooks?: (
-    context: TRouter extends Router<infer UContext> ? UContext : never,
-    hooks: FetchHandlerHooks,
-  ) => Promisable<Response>
-
-  /**
-   * 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 })
-
-    const context = await value(requestOptions.context)
-
-    const handler = async () => {
-      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> | undefined
-
-      if (isORPCTransformer) {
-        path = trim(pathname, '/').split('/').map(decodeURIComponent)
-        const val = get(options.router, path)
-
-        if (isProcedure(val)) {
-          procedure = val
-        }
-      }
-      else {
-        const customMethod
-            = requestOptions.request.method === 'POST'
-              ? url.searchParams.get('method')?.toUpperCase()
-              : undefined
-        const method = customMethod || requestOptions.request.method
-
-        const [matches, params_] = routing.match(method, pathname)
-
-        const [match] = matches.sort((a, b) => {
-          return Object.keys(a[1]).length - Object.keys(b[1]).length
-        })
-
-        if (match) {
-          path = match[0][0]
-          procedure = match[0][1]
-
-          if (params_) {
-            params = mapValues(
-              (match as any)[1]!,
-              v => params_[v as number]!,
-            )
-          }
-          else {
-            params = match[1] as Record<string, string>
-          }
-        }
-
-        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 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) {
-          return input_
-        }
-
-        const coercedParams = procedure.zz$p.contract.zz$cp.InputSchema
-          ? (zodCoerce(
-              procedure.zz$p.contract.zz$cp.InputSchema,
-              { ...params },
-              {
-                bracketNotation: true,
-              },
-            ) as object)
-          : params
-
-        if (!isPlainObject(input_)) {
-          return coercedParams
-        }
-
-        return {
-          ...coercedParams,
-          ...input_,
-        }
-      })()
-
-      const caller = createProcedureCaller({
-        context,
-        procedure,
-        path,
-      })
-
-      const output = await caller(input)
-
-      const { body, headers } = serializer.serialize(output)
-
-      return new Response(body, {
-        status: 200,
-        headers,
-      })
-    }
-
-    try {
-      return await options.hooks?.(context as any, {
-        next: handler,
-        response: response => response,
-      }) ?? await handler()
-    }
-    catch (e) {
-      const error = toORPCError(e)
-
-      try {
-        const { body, headers } = serializer.serialize(error.toJSON())
-
-        return new Response(body, {
-          status: error.status,
-          headers,
-        })
-      }
-      catch (e) {
-        const error = toORPCError(e)
-
-        // fallback to OpenAPI serializer (without accept) when expected serializer has failed
-        const { body, headers } = new OpenAPISerializer().serialize(
-          error.toJSON(),
-        )
-
-        return new Response(body, {
-          status: error.status,
-          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: Value<
-    TRouter extends Router<infer UContext> ? UContext : never
-  >
-}>
-
-export interface FetchHandler<TRouter extends Router<any>> {
-  (options: FetchHandlerOptions<TRouter>): Promise<Response>
-}
-
-function toORPCError(e: unknown): ORPCError<any, any> {
-  return e instanceof ORPCError
-    ? e
-    : new ORPCError({
-      code: 'INTERNAL_SERVER_ERROR',
-      message: 'Internal server error',
-      cause: e,
-    })
-}

package/src/builder.test.ts

@@ -1,371 +0,0 @@
-import type {
-  Builder,
-  DecoratedMiddleware,
-  DecoratedProcedure,
-  Meta,
-  MiddlewareMeta,
-} from '.'
-import { oc } from '@orpc/contract'
-import { z } from 'zod'
-import {
-  isProcedure,
-  os,
-  ProcedureBuilder,
-  ProcedureImplementer,
-  RouterImplementer,
-} from '.'
-import { RouterBuilder } from './router-builder'
-
-it('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<MiddlewareMeta<unknown>>()
-
-      return meta.next({})
-    })
-  })
-
-  it('can map context', () => {
-    osw
-      .use((_, __, meta) => {
-        return meta.next({ context: { userId: '1' } })
-      })
-      .use((_, context, meta) => {
-        expectTypeOf(context).toMatchTypeOf<Context & { userId: string }>()
-
-        return meta.next({})
-      })
-  })
-
-  it('can map input', () => {
-    osw
-      // @ts-expect-error mismatch input
-      .use((input: { postId: string }) => {})
-      .use(
-        (input: { postId: string }, _, meta) => {
-          return meta.next({ context: { user: '1' } })
-        },
-        (input) => {
-          expectTypeOf(input).toEqualTypeOf<unknown>()
-          return { postId: '1' }
-        },
-      )
-      .func((_, 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<MiddlewareMeta<any>>()
-
-        return meta.next({ })
-      })
-
-    expectTypeOf(mid).toEqualTypeOf<
-      DecoratedMiddleware<{ auth: boolean }, undefined, unknown, any>
-    >()
-  })
-
-  it('map context', () => {
-    const mid = os.context<{ auth: boolean }>().middleware((_, __, meta) => {
-      return meta.next({ context: { userId: '1' } })
-    })
-
-    expectTypeOf(mid).toEqualTypeOf<
-      DecoratedMiddleware<
-        { auth: boolean },
-        { userId: string },
-        unknown,
-        any
-      >
-    >()
-  })
-})
-
-it('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.func(() => {
-      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: '' }
-
-  it('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,
-        },
-      },
-    })
-  })
-
-  it('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,
-        },
-      },
-    })
-  })
-
-  it('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'],
-        },
-      },
-    })
-  })
-
-  it('with middlewares', () => {
-    const mid = os.middleware((_, __, meta) => {
-      return meta.next({
-        context: {
-          userId: 'string',
-        },
-      })
-    })
-
-    const mid2 = os.middleware((_, __, meta) => {
-      return meta.next({
-        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.func((input, context, meta) => {
-      expectTypeOf(input).toEqualTypeOf<unknown>()
-      expectTypeOf(context).toEqualTypeOf<{ auth: boolean }>()
-      expectTypeOf(meta).toEqualTypeOf<Meta>()
-    })
-
-    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((_, __, meta) => {
-      return meta.next({
-        context: {
-          userId: 'string',
-        },
-      })
-    })
-
-    const osw = os.context<{ auth: boolean }>().use(mid)
-
-    const procedure = osw.func((input, context, meta) => {
-      expectTypeOf(input).toEqualTypeOf<unknown>()
-      expectTypeOf(context).toMatchTypeOf<{ auth: boolean }>()
-      expectTypeOf(meta).toEqualTypeOf<Meta>()
-    })
-
-    expectTypeOf(procedure).toEqualTypeOf<
-      DecoratedProcedure<
-        { auth: boolean },
-        { userId: string },
-        undefined,
-        undefined,
-        void
-      >
-    >()
-
-    expect(isProcedure(procedure)).toBe(true)
-    expect(procedure.zz$p.middlewares).toEqual([mid])
-  })
-})
-
-it('prefix', () => {
-  const builder = os
-    .context<{ auth: boolean }>()
-    .use((_, __, meta) => {
-      return meta.next({ context: { userId: '1' } })
-    })
-    .prefix('/api')
-
-  expectTypeOf(builder).toEqualTypeOf<
-    RouterBuilder<{ auth: boolean }, { userId: string }>
-  >()
-
-  expect(builder).instanceOf(RouterBuilder)
-  expect(builder.zz$rb.prefix).toEqual('/api')
-})
-
-it('tags', () => {
-  const builder = os
-    .context<{ auth: boolean }>()
-    .use((_, __, meta) => {
-      return meta.next({ 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'])
-})