@orpc/server 0.1.0 → 0.1.1

package/src/procedure-builder.ts

@@ -1,3 +1,5 @@
+import type { MapInputMiddleware, Middleware } from './middleware'
+import type { Context, MergeContext } from './types'
 import {
   type ContractProcedure,
   DecoratedContractProcedure,
@@ -6,14 +8,12 @@ import {
   type SchemaInput,
   type SchemaOutput,
 } from '@orpc/contract'
-import type { MapInputMiddleware, Middleware } from './middleware'
 import {
   type DecoratedProcedure,
-  type ProcedureHandler,
   decorateProcedure,
+  type ProcedureHandler,
 } from './procedure'
 import { ProcedureImplementer } from './procedure-implementer'
-import type { Context, MergeContext } from './types'
 
 export class ProcedureBuilder<
   TContext extends Context,
@@ -75,14 +75,14 @@ export class ProcedureBuilder<
 
   use<
     UExtraContext extends
-      | Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>>
-      | undefined = undefined,
+    | Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>>
+    | undefined = undefined,
   >(
     middleware: Middleware<
       MergeContext<TContext, TExtraContext>,
       UExtraContext,
       SchemaOutput<TInputSchema>,
-      SchemaOutput<TOutputSchema>
+      SchemaInput<TOutputSchema>
     >,
   ): ProcedureImplementer<
     TContext,
@@ -93,15 +93,15 @@ export class ProcedureBuilder<
 
   use<
     UExtraContext extends
-      | Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>>
-      | undefined = undefined,
+    | Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>>
+    | undefined = undefined,
     UMappedInput = unknown,
   >(
     middleware: Middleware<
       MergeContext<TContext, TExtraContext>,
       UExtraContext,
       UMappedInput,
-      SchemaOutput<TOutputSchema>
+      SchemaInput<TOutputSchema>
     >,
     mapInput: MapInputMiddleware<SchemaOutput<TInputSchema>, UMappedInput>,
   ): ProcedureImplementer<
@@ -141,12 +141,12 @@ export class ProcedureBuilder<
       UHandlerOutput
     >,
   ): DecoratedProcedure<
-    TContext,
-    TExtraContext,
-    TInputSchema,
-    TOutputSchema,
-    UHandlerOutput
-  > {
+      TContext,
+      TExtraContext,
+      TInputSchema,
+      TOutputSchema,
+      UHandlerOutput
+    > {
     return decorateProcedure({
       zz$p: {
         middlewares: this.zz$pb.middlewares,

package/src/procedure-caller.test.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod'
-import { os, createProcedureCaller } from '.'
+import { createProcedureCaller, os } from '.'
 
 describe('createProcedureCaller', () => {
   let internal = false
@@ -8,8 +8,8 @@ describe('createProcedureCaller', () => {
 
   const osw = os.context<{ auth?: boolean }>()
   const procedure = osw
-    .input(z.object({ value: z.string().transform((v) => Number(v)) }))
-    .output(z.object({ value: z.number().transform((v) => v.toString()) }))
+    .input(z.object({ value: z.string().transform(v => Number(v)) }))
+    .output(z.object({ value: z.number().transform(v => v.toString()) }))
     .handler((input, context, meta) => {
       expect(context).toEqual(context)
       expect(meta.internal).toBe(internal)
@@ -47,7 +47,7 @@ describe('createProcedureCaller', () => {
 
     expect(await caller({ value: '123' })).toEqual({ value: '123' })
 
-    // @ts-expect-error
+    // @ts-expect-error - invalid input
     expect(caller({ value: {} })).rejects.toThrowError(
       'Validation input failed',
     )
@@ -101,44 +101,44 @@ describe('createProcedureCaller', () => {
     const ref = { value: 0 }
 
     const mid1 = vi.fn(
-      osw.middleware((input: { id: string }, context, meta) => {
+      osw.middleware(async (input: { id: string }, context, meta) => {
         expect(input).toEqual({ id: '1' })
 
         expect(ref.value).toBe(0)
         ref.value++
 
-        meta.onSuccess(() => {
-          expect(ref.value).toBe(7)
+        try {
+          const result = await meta.next({
+            context: {
+              userId: '1',
+            },
+          })
+          expect(ref.value).toBe(5)
           ref.value++
-        })
-
-        meta.onFinish(() => {
-          expect(ref.value).toBe(8)
+          return result
+        }
+        finally {
+          expect(ref.value).toBe(6)
           ref.value++
-        })
-
-        return {
-          context: {
-            userId: '1',
-          },
         }
       }),
     )
 
     const mid2 = vi.fn(
-      osw.middleware((input, context, meta) => {
+      osw.middleware(async (input, context, meta) => {
         expect(ref.value).toBe(1)
         ref.value++
 
-        meta.onSuccess(() => {
-          expect(ref.value).toBe(5)
+        try {
+          const result = await meta.next({})
+          expect(ref.value).toBe(3)
           ref.value++
-        })
-
-        meta.onFinish(() => {
-          expect(ref.value).toBe(6)
+          return result
+        }
+        finally {
+          expect(ref.value).toBe(4)
           ref.value++
-        })
+        }
       }),
     )
 
@@ -152,16 +152,6 @@ describe('createProcedureCaller', () => {
         expect(ref.value).toBe(2)
         ref.value++
 
-        meta.onSuccess(() => {
-          expect(ref.value).toBe(3)
-          ref.value++
-        })
-
-        meta.onFinish(() => {
-          expect(ref.value).toBe(4)
-          ref.value++
-        })
-
         return 'pong'
       })
 
@@ -172,39 +162,4 @@ describe('createProcedureCaller', () => {
 
     expect(caller({ id: '1' })).resolves.toEqual('pong')
   })
-
-  it('hooks', async () => {
-    const ref = { value: 0 }
-
-    const caller = createProcedureCaller({
-      procedure: procedure,
-      context: context,
-      internal: internal,
-      path: path,
-      hooks: (context, meta) => {
-        expect(context).toEqual(context)
-        expect(meta.internal).toBe(internal)
-        expect(meta.path).toBe(path)
-        expect(meta.procedure).toBe(procedure)
-
-        expect(ref.value).toBe(0)
-        ref.value++
-
-        meta.onSuccess(() => {
-          expect(ref.value).toBe(1)
-          ref.value++
-        })
-
-        meta.onFinish(() => {
-          expect(ref.value).toBe(2)
-          ref.value++
-
-          throw new Error('foo')
-        })
-      },
-    })
-
-    await expect(caller({ value: '1243' })).rejects.toThrow('foo')
-    expect(ref.value).toBe(3)
-  })
 })

package/src/procedure-caller.ts

@@ -1,9 +1,9 @@
 import type { SchemaInput, SchemaOutput } from '@orpc/contract'
-import { ORPCError } from '@orpc/shared/error'
-import type { Middleware } from './middleware'
+import type { MiddlewareMeta } from './middleware'
 import type { Procedure } from './procedure'
-import type { Context, Hooks, Meta, Promisable } from './types'
-import { hook, mergeContext } from './utils'
+import type { Context } from './types'
+import { ORPCError } from '@orpc/shared/error'
+import { mergeContext } from './utils'
 
 export interface CreateProcedureCallerOptions<
   TProcedure extends Procedure<any, any, any, any, any>,
@@ -18,16 +18,6 @@ export interface CreateProcedureCallerOptions<
     ? UContext
     : never
 
-  /**
-   * Helpful hooks to do some logics on specific time.
-   */
-  hooks?: (
-    context: TProcedure extends Procedure<infer UContext, any, any, any, any>
-      ? UContext
-      : never,
-    meta: Meta<unknown>,
-  ) => Promisable<void>
-
   /**
    * This is helpful for logging and analytics.
    */
@@ -80,85 +70,76 @@ export function createProcedureCaller<
   const procedure = options.procedure
   const validate = options.validate ?? true
 
-  const caller = async (input: unknown) => {
-    const handler = async (
-      input: unknown,
-      context: Context,
-      partialMeta: Omit<Meta<unknown>, keyof Hooks<unknown>>,
-      middlewares: Middleware<any, any, any, any>[],
-    ): Promise<unknown> => {
-      if (middlewares[0]) {
-        const [middleware, ...rest] = middlewares
-
-        return await hook(async (hooks) => {
-          const mid = await middleware(input, context, {
-            ...partialMeta,
-            ...hooks,
-          })
-          return await handler(
-            input,
-            mergeContext(context, mid?.context),
-            partialMeta,
-            rest,
-          )
+  const caller = async (input: unknown): Promise<unknown> => {
+    const validInput = (() => {
+      if (!validate)
+        return input
+      const schema = procedure.zz$p.contract.zz$cp.InputSchema
+      if (!schema)
+        return input
+
+      try {
+        return schema.parse(input)
+      }
+      catch (e) {
+        throw new ORPCError({
+          message: 'Validation input failed',
+          code: 'BAD_REQUEST',
+          cause: e,
         })
       }
-
-      return await hook(async (hooks) => {
-        const output = await procedure.zz$p.handler(input, context, {
-          ...partialMeta,
-          ...hooks,
+    })()
+
+    const middlewares = procedure.zz$p.middlewares ?? []
+    let currentMidIndex = 0
+    let currentContext: Context = options.context
+
+    const next: MiddlewareMeta<unknown>['next'] = async (nextOptions) => {
+      const mid = middlewares[currentMidIndex]
+      currentMidIndex += 1
+      currentContext = mergeContext(currentContext, nextOptions.context)
+
+      if (mid) {
+        return await mid(validInput, currentContext, {
+          path,
+          procedure,
+          internal,
+          next,
+          output: output => ({ output, context: undefined }),
         })
-
-        const validOutput = await (async () => {
-          if (!validate) return output
-          const schema = procedure.zz$p.contract.zz$cp.OutputSchema
-          if (!schema) return output
-          const result = await schema.safeParseAsync(output)
-          if (result.error)
-            throw new ORPCError({
-              message: 'Validation output failed',
-              code: 'INTERNAL_SERVER_ERROR',
-              cause: result.error,
-            })
-          return result.data
-        })()
-
-        return validOutput
-      })
+      }
+      else {
+        return {
+          output: await await procedure.zz$p.handler(validInput, currentContext, {
+            path,
+            procedure,
+            internal,
+          }),
+          context: currentContext,
+        }
+      }
     }
 
-    return await hook(async (hooks) => {
-      options.hooks?.(options.context, {
-        ...hooks,
-        path,
-        procedure,
-        internal,
-      })
-
-      const validInput = (() => {
-        if (!validate) return input
-        const schema = procedure.zz$p.contract.zz$cp.InputSchema
-        if (!schema) return input
-
-        try {
-          return schema.parse(input)
-        } catch (e) {
-          throw new ORPCError({
-            message: 'Validation input failed',
-            code: 'BAD_REQUEST',
-            cause: e,
-          })
-        }
-      })()
-
-      return await handler(
-        validInput,
-        options.context,
-        { path, procedure, internal },
-        procedure.zz$p.middlewares ?? [],
-      )
-    })
+    const output = (await next({})).output
+
+    const validOutput = await (async () => {
+      if (!validate)
+        return output
+      const schema = procedure.zz$p.contract.zz$cp.OutputSchema
+      if (!schema)
+        return output
+      const result = await schema.safeParseAsync(output)
+      if (result.error) {
+        throw new ORPCError({
+          message: 'Validation output failed',
+          code: 'INTERNAL_SERVER_ERROR',
+          cause: result.error,
+        })
+      }
+      return result.data
+    })()
+
+    return validOutput
   }
 
   return caller as ProcedureCaller<TProcedure, TValidate>

package/src/procedure-implementer.test.ts

@@ -1,6 +1,7 @@
+import type { DecoratedProcedure, Meta, MiddlewareMeta } from '.'
 import { DecoratedContractProcedure } from '@orpc/contract'
 import { z } from 'zod'
-import { os, type DecoratedProcedure, type Meta, isProcedure } from '.'
+import { isProcedure, os } from '.'
 import { ProcedureImplementer } from './procedure-implementer'
 
 const p1 = new DecoratedContractProcedure({
@@ -39,20 +40,22 @@ describe('use middleware', () => {
       .use((input, context, meta) => {
         expectTypeOf(input).toEqualTypeOf<unknown>()
         expectTypeOf(context).toEqualTypeOf<{ auth: boolean }>()
-        expectTypeOf(meta).toEqualTypeOf<Meta<unknown>>()
+        expectTypeOf(meta).toEqualTypeOf<MiddlewareMeta<unknown>>()
 
-        return {
+        return meta.next({
           context: {
             userId: '1',
           },
-        }
+        })
       })
       .use((input, context, meta) => {
         expectTypeOf(input).toEqualTypeOf<unknown>()
         expectTypeOf(context).toEqualTypeOf<
           { userId: string } & { auth: boolean }
         >()
-        expectTypeOf(meta).toEqualTypeOf<Meta<unknown>>()
+        expectTypeOf(meta).toEqualTypeOf<MiddlewareMeta<unknown>>()
+
+        return meta.next({})
       })
 
     expectTypeOf(i).toEqualTypeOf<
@@ -72,27 +75,27 @@ describe('use middleware', () => {
     })
 
     implementer2.use(
-      (input: { postId: string }) => {
-        return { context: { a: 'a' } }
+      (input: { postId: string }, _, meta) => {
+        return meta.next({ context: { a: 'a' } })
       },
       // @ts-expect-error mismatch input
-      (input) => ({ postId: 12455 }),
+      input => ({ postId: 12455 }),
     )
 
     implementer2.use(
-      (input: { postId: string }) => {},
-      (input) => ({ postId: '12455' }),
+      (input: { postId: string }, context, meta) => meta.next({}),
+      input => ({ postId: '12455' }),
     )
 
     const i = implementer2.use(
-      (input: { id: number }) => {
-        return {
+      (input: { id: number }, _, meta) => {
+        return meta.next({
           context: {
             userIdd: '1',
           },
-        }
+        })
       },
-      (input) => ({ id: Number.parseInt(input.id) }),
+      input => ({ id: Number.parseInt(input.id) }),
     )
 
     expectTypeOf(i).toEqualTypeOf<
@@ -142,7 +145,7 @@ describe('handler', () => {
     const handler = implementer1.handler((input, context, meta) => {
       expectTypeOf(input).toEqualTypeOf<unknown>()
       expectTypeOf(context).toEqualTypeOf<{ auth: boolean }>()
-      expectTypeOf(meta).toEqualTypeOf<Meta<unknown>>()
+      expectTypeOf(meta).toEqualTypeOf<Meta>()
 
       return {
         name: 'unnoq',
@@ -163,7 +166,7 @@ describe('handler', () => {
     implementer2.handler((input, context, meta) => {
       expectTypeOf(input).toEqualTypeOf<{ id: string }>()
       expectTypeOf(context).toEqualTypeOf<{ auth: boolean }>()
-      expectTypeOf(meta).toEqualTypeOf<Meta<unknown>>()
+      expectTypeOf(meta).toEqualTypeOf<Meta>()
 
       return {
         name: 'unnoq',
@@ -175,15 +178,17 @@ describe('handler', () => {
   })
 
   it('combine middlewares', () => {
-    const mid1 = () => {
-      return {
+    const mid1 = os.middleware((input, context, meta) => {
+      return meta.next({
         context: {
           userId: '1',
         },
-      }
-    }
+      })
+    })
 
-    const mid2 = () => {}
+    const mid2 = os.middleware((input, context, meta) => {
+      return meta.next({ })
+    })
 
     const handler = implementer2
       .use(mid1)
@@ -193,7 +198,7 @@ describe('handler', () => {
         expectTypeOf(context).toEqualTypeOf<
           { auth: boolean } & { userId: string }
         >()
-        expectTypeOf(meta).toEqualTypeOf<Meta<unknown>>()
+        expectTypeOf(meta).toEqualTypeOf<Meta>()
 
         return {
           name: 'unnoq',

package/src/procedure-implementer.ts

@@ -1,16 +1,15 @@
-import type { ContractProcedure, SchemaOutput } from '@orpc/contract'
-import type { Schema } from '@orpc/contract'
+import type { ContractProcedure, Schema, SchemaInput, SchemaOutput } from '@orpc/contract'
+import type { Context, MergeContext } from './types'
 import {
+  decorateMiddleware,
   type MapInputMiddleware,
   type Middleware,
-  decorateMiddleware,
 } from './middleware'
 import {
   type DecoratedProcedure,
-  type ProcedureHandler,
   decorateProcedure,
+  type ProcedureHandler,
 } from './procedure'
-import type { Context, MergeContext } from './types'
 
 export class ProcedureImplementer<
   TContext extends Context,
@@ -27,14 +26,14 @@ export class ProcedureImplementer<
 
   use<
     UExtraContext extends
-      | Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>>
-      | undefined = undefined,
+    | Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>>
+    | undefined = undefined,
   >(
     middleware: Middleware<
       MergeContext<TContext, TExtraContext>,
       UExtraContext,
       SchemaOutput<TInputSchema>,
-      SchemaOutput<TOutputSchema>
+      SchemaInput<TOutputSchema>
     >,
   ): ProcedureImplementer<
     TContext,
@@ -45,15 +44,15 @@ export class ProcedureImplementer<
 
   use<
     UExtraContext extends
-      | Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>>
-      | undefined = undefined,
+    | Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>>
+    | undefined = undefined,
     UMappedInput = unknown,
   >(
     middleware: Middleware<
       MergeContext<TContext, TExtraContext>,
       UExtraContext,
       UMappedInput,
-      SchemaOutput<TOutputSchema>
+      SchemaInput<TOutputSchema>
     >,
     mapInput: MapInputMiddleware<SchemaOutput<TInputSchema>, UMappedInput>,
   ): ProcedureImplementer<
@@ -86,12 +85,12 @@ export class ProcedureImplementer<
       UHandlerOutput
     >,
   ): DecoratedProcedure<
-    TContext,
-    TExtraContext,
-    TInputSchema,
-    TOutputSchema,
-    UHandlerOutput
-  > {
+      TContext,
+      TExtraContext,
+      TInputSchema,
+      TOutputSchema,
+      UHandlerOutput
+    > {
     return decorateProcedure({
       zz$p: {
         middlewares: this.zz$pi.middlewares,