@orpc/server 0.1.0 → 0.1.2

package/src/adapters/fetch.ts

@@ -1,5 +1,10 @@
 /// <reference lib="dom" />
 
+import type {
+  PartialOnUndefinedDeep,
+  Promisable,
+} from '@orpc/shared'
+import type { Router } from '../router'
 import {
   type HTTPPath,
   ORPC_HEADER,
@@ -7,7 +12,6 @@ import {
   standardizeHTTPPath,
 } from '@orpc/contract'
 import {
-  type PartialOnUndefinedDeep,
   get,
   isPlainObject,
   mapValues,
@@ -15,27 +19,32 @@ import {
 } from '@orpc/shared'
 import { ORPCError } from '@orpc/shared/error'
 import {
-  ORPCDeserializer,
-  ORPCSerializer,
   OpenAPIDeserializer,
   OpenAPISerializer,
+  ORPCDeserializer,
+  ORPCSerializer,
   zodCoerce,
 } 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 { isProcedure, type WELL_DEFINED_PROCEDURE } from '../procedure'
 import { createProcedureCaller } from '../procedure-caller'
-import type { Router } from '../router'
-import type { Meta, Promisable } from '../types'
-import { hook } from '../utils'
+
+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,
-    meta: Meta<unknown>,
-  ) => Promisable<void>
+    hooks: FetchHandlerHooks,
+  ) => Promisable<Response>
 
   /**
    * It will help improve the cold start time. But it will increase the performance.
@@ -64,7 +73,8 @@ export function createFetchHandler<TRouter extends Router<any>>(
 
           routing.add(method, path, [currentPath, item])
         }
-      } else {
+      }
+      else {
         addRouteRecursively(item, currentPath)
       }
     }
@@ -73,143 +83,143 @@ export function createFetchHandler<TRouter extends Router<any>>(
   addRouteRecursively(options.router, [])
 
   return async (requestOptions) => {
-    const isORPCTransformer =
-      requestOptions.request.headers.get(ORPC_HEADER) === ORPC_HEADER_VALUE
+    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 ?? '', ''), '/')}`
+    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
+      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 (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'
+        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 method = customMethod || requestOptions.request.method
 
-          const [matches, params_] = routing.match(method, pathname)
+        const [matches, params_] = routing.match(method, pathname)
 
-          const [match] = matches.sort((a, b) => {
-            return Object.keys(a[1]).length - Object.keys(b[1]).length
-          })
+        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 (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 (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)
+        if (!path || !procedure) {
+          path = trim(pathname, '/').split('/').map(decodeURIComponent)
 
-            const val = get(options.router, path)
+          const val = get(options.router, path)
 
-            if (isProcedure(val)) {
-              procedure = val
-            }
+          if (isProcedure(val)) {
+            procedure = val
           }
         }
+      }
 
-        if (!path || !procedure) {
-          throw new ORPCError({ code: 'NOT_FOUND', message: 'Not found' })
-        }
+      if (!path || !procedure) {
+        throw new ORPCError({ code: 'NOT_FOUND', message: 'Not found' })
+      }
 
-        const meta: Meta<unknown> = {
-          ...hooks,
-          procedure,
-          path: path,
-          internal: false,
-        }
+      const deserializer = isORPCTransformer
+        ? new ORPCDeserializer()
+        : new OpenAPIDeserializer({
+          schema: procedure.zz$p.contract.zz$cp.InputSchema,
+        })
 
-        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:
+      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,
-            })
-          }
-        })()
+            cause: e,
+          })
+        }
+      })()
 
-        const input = (() => {
-          if (!params || Object.keys(params).length === 0) {
-            return input_
-          }
+      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
-          }
+        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: requestOptions.context,
-          internal: false,
-          validate: true,
-          procedure,
-          path,
-        })
+        return {
+          ...coercedParams,
+          ...input_,
+        }
+      })()
+
+      const caller = createProcedureCaller({
+        context: requestOptions.context,
+        internal: false,
+        validate: true,
+        procedure,
+        path,
+      })
 
-        const output = await caller(input)
+      const output = await caller(input)
 
-        const { body, headers } = serializer.serialize(output)
+      const { body, headers } = serializer.serialize(output)
 
-        return new Response(body, {
-          status: 200,
-          headers,
-        })
+      return new Response(body, {
+        status: 200,
+        headers,
       })
-    } catch (e) {
+    }
+
+    try {
+      return await options.hooks?.(requestOptions.context as any, {
+        next: handler,
+        response: response => response,
+      }) ?? await handler()
+    }
+    catch (e) {
       const error = toORPCError(e)
 
       try {
@@ -217,9 +227,10 @@ export function createFetchHandler<TRouter extends Router<any>>(
 
         return new Response(body, {
           status: error.status,
-          headers: headers,
+          headers,
         })
-      } catch (e) {
+      }
+      catch (e) {
         const error = toORPCError(e)
 
         // fallback to OpenAPI serializer (without accept) when expected serializer has failed
@@ -229,7 +240,7 @@ export function createFetchHandler<TRouter extends Router<any>>(
 
         return new Response(body, {
           status: error.status,
-          headers: headers,
+          headers,
         })
       }
     }
@@ -268,8 +279,8 @@ function toORPCError(e: unknown): ORPCError<any, any> {
   return e instanceof ORPCError
     ? e
     : new ORPCError({
-        code: 'INTERNAL_SERVER_ERROR',
-        message: 'Internal server error',
-        cause: e,
-      })
+      code: 'INTERNAL_SERVER_ERROR',
+      message: 'Internal server error',
+      cause: e,
+    })
 }

package/src/builder.test.ts

@@ -1,19 +1,22 @@
+import type {
+  Builder,
+  DecoratedMiddleware,
+  DecoratedProcedure,
+  Meta,
+  MiddlewareMeta,
+} from '.'
 import { oc } from '@orpc/contract'
 import { z } from 'zod'
 import {
+  isProcedure,
   os,
-  type Builder,
-  type DecoratedMiddleware,
-  type DecoratedProcedure,
-  type Meta,
   ProcedureBuilder,
   ProcedureImplementer,
   RouterImplementer,
-  isProcedure,
 } from '.'
 import { RouterBuilder } from './router-builder'
 
-test('context method', () => {
+it('context method', () => {
   expectTypeOf<
     typeof os extends Builder<infer TContext, any> ? TContext : never
   >().toEqualTypeOf<undefined | Record<string, unknown>>()
@@ -40,17 +43,21 @@ describe('use middleware', () => {
     osw.use((input, context, meta) => {
       expectTypeOf(input).toEqualTypeOf<unknown>()
       expectTypeOf(context).toEqualTypeOf<Context>()
-      expectTypeOf(meta).toEqualTypeOf<Meta<unknown>>()
+      expectTypeOf(meta).toEqualTypeOf<MiddlewareMeta<unknown>>()
+
+      return meta.next({})
     })
   })
 
   it('can map context', () => {
     osw
-      .use(() => {
-        return { context: { userId: '1' } }
+      .use((_, __, meta) => {
+        return meta.next({ context: { userId: '1' } })
       })
-      .use((_, context) => {
+      .use((_, context, meta) => {
         expectTypeOf(context).toMatchTypeOf<Context & { userId: string }>()
+
+        return meta.next({})
       })
   })
 
@@ -59,8 +66,8 @@ describe('use middleware', () => {
       // @ts-expect-error mismatch input
       .use((input: { postId: string }) => {})
       .use(
-        (input: { postId: string }) => {
-          return { context: { user: '1' } }
+        (input: { postId: string }, _, meta) => {
+          return meta.next({ context: { user: '1' } })
         },
         (input) => {
           expectTypeOf(input).toEqualTypeOf<unknown>()
@@ -80,17 +87,19 @@ describe('create middleware', () => {
       .middleware((input, context, meta) => {
         expectTypeOf(input).toEqualTypeOf<unknown>()
         expectTypeOf(context).toEqualTypeOf<{ auth: boolean }>()
-        expectTypeOf(meta).toEqualTypeOf<Meta<unknown>>()
+        expectTypeOf(meta).toEqualTypeOf<MiddlewareMeta<any>>()
+
+        return meta.next({ })
       })
 
     expectTypeOf(mid).toEqualTypeOf<
-      DecoratedMiddleware<{ auth: boolean }, undefined, unknown, unknown>
+      DecoratedMiddleware<{ auth: boolean }, undefined, unknown, any>
     >()
   })
 
   it('map context', () => {
-    const mid = os.context<{ auth: boolean }>().middleware(() => {
-      return { context: { userId: '1' } }
+    const mid = os.context<{ auth: boolean }>().middleware((_, __, meta) => {
+      return meta.next({ context: { userId: '1' } })
     })
 
     expectTypeOf(mid).toEqualTypeOf<
@@ -98,13 +107,13 @@ describe('create middleware', () => {
         { auth: boolean },
         { userId: string },
         unknown,
-        unknown
+        any
       >
     >()
   })
 })
 
-test('router method', () => {
+it('router method', () => {
   const pingContract = oc.input(z.string()).output(z.string())
   const userFindContract = oc
     .input(z.object({ id: z.string() }))
@@ -149,7 +158,7 @@ describe('define procedure builder', () => {
   const schema2 = z.object({ a: z.string() })
   const example2 = { a: '' }
 
-  test('input method', () => {
+  it('input method', () => {
     const builder = osw.input(schema1, example1)
 
     expectTypeOf(builder).toEqualTypeOf<
@@ -168,7 +177,7 @@ describe('define procedure builder', () => {
     })
   })
 
-  test('output method', () => {
+  it('output method', () => {
     const builder = osw.output(schema2, example2)
 
     expectTypeOf(builder).toEqualTypeOf<
@@ -187,7 +196,7 @@ describe('define procedure builder', () => {
     })
   })
 
-  test('route method', () => {
+  it('route method', () => {
     const builder = osw.route({
       method: 'GET',
       path: '/test',
@@ -217,21 +226,21 @@ describe('define procedure builder', () => {
     })
   })
 
-  test('with middlewares', () => {
-    const mid = os.middleware(() => {
-      return {
+  it('with middlewares', () => {
+    const mid = os.middleware((_, __, meta) => {
+      return meta.next({
         context: {
           userId: 'string',
         },
-      }
+      })
     })
 
-    const mid2 = os.middleware(() => {
-      return {
+    const mid2 = os.middleware((_, __, meta) => {
+      return meta.next({
         context: {
           mid2: true,
         },
-      }
+      })
     })
 
     const osw = os.context<{ auth: boolean }>().use(mid).use(mid2)
@@ -280,7 +289,7 @@ describe('handler method', () => {
     const procedure = osw.handler((input, context, meta) => {
       expectTypeOf(input).toEqualTypeOf<unknown>()
       expectTypeOf(context).toEqualTypeOf<{ auth: boolean }>()
-      expectTypeOf(meta).toEqualTypeOf<Meta<unknown>>()
+      expectTypeOf(meta).toEqualTypeOf<Meta>()
     })
 
     expectTypeOf(procedure).toEqualTypeOf<
@@ -298,12 +307,12 @@ describe('handler method', () => {
   })
 
   it('with middlewares', () => {
-    const mid = os.middleware(() => {
-      return {
+    const mid = os.middleware((_, __, meta) => {
+      return meta.next({
         context: {
           userId: 'string',
         },
-      }
+      })
     })
 
     const osw = os.context<{ auth: boolean }>().use(mid)
@@ -311,7 +320,7 @@ describe('handler method', () => {
     const procedure = osw.handler((input, context, meta) => {
       expectTypeOf(input).toEqualTypeOf<unknown>()
       expectTypeOf(context).toMatchTypeOf<{ auth: boolean }>()
-      expectTypeOf(meta).toEqualTypeOf<Meta<unknown>>()
+      expectTypeOf(meta).toEqualTypeOf<Meta>()
     })
 
     expectTypeOf(procedure).toEqualTypeOf<
@@ -329,11 +338,11 @@ describe('handler method', () => {
   })
 })
 
-test('prefix', () => {
+it('prefix', () => {
   const builder = os
     .context<{ auth: boolean }>()
-    .use(() => {
-      return { context: { userId: '1' } }
+    .use((_, __, meta) => {
+      return meta.next({ context: { userId: '1' } })
     })
     .prefix('/api')
 
@@ -345,11 +354,11 @@ test('prefix', () => {
   expect(builder.zz$rb.prefix).toEqual('/api')
 })
 
-test('tags', () => {
+it('tags', () => {
   const builder = os
     .context<{ auth: boolean }>()
-    .use(() => {
-      return { context: { userId: '1' } }
+    .use((_, __, meta) => {
+      return meta.next({ context: { userId: '1' } })
     })
     .tags('user', 'user2')