feat(server)!: middleware can run both before/after validation step

packages/openapi/src/adapters/fetch/openapi-handler.test.ts

@@ -216,6 +216,8 @@ describe.each(hono)('openAPIHandler: %s', (_, HonoConstructor) => {
           errorMap: undefined,
         }),
         handler: vi.fn(),
+        postMiddlewares: [],
+        preMiddlewares: [],
       }),
     }
 
@@ -241,6 +243,8 @@ describe.each(hono)('openAPIHandler: %s', (_, HonoConstructor) => {
           errorMap: undefined,
         }),
         handler: vi.fn(),
+        postMiddlewares: [],
+        preMiddlewares: [],
       }),
     }
 

packages/server/src/adapters/fetch/orpc-handler.test.ts

@@ -17,6 +17,8 @@ describe('rpcHandler', () => {
       errorMap: undefined,
     }),
     handler: vi.fn(),
+    postMiddlewares: [],
+    preMiddlewares: [],
   })
   const pong = new Procedure({
     contract: new ContractProcedure({
@@ -25,6 +27,8 @@ describe('rpcHandler', () => {
       errorMap: undefined,
     }),
     handler: vi.fn(),
+    postMiddlewares: [],
+    preMiddlewares: [],
   })
 
   const router = {

packages/server/src/builder.test-d.ts

@@ -1,3 +1,4 @@
+import type { Builder } from './builder'
 import type { ChainableImplementer } from './implementer-chainable'
 import type { DecoratedLazy } from './lazy-decorated'
 import type { Middleware, MiddlewareOutputFn } from './middleware'
@@ -9,11 +10,10 @@ import type { AdaptedRouter, RouterBuilder } from './router-builder'
 import type { WELL_CONTEXT } from './types'
 import { oc } from '@orpc/contract'
 import { z } from 'zod'
-import { Builder } from './builder'
 
 const schema = z.object({ val: z.string().transform(v => Number.parseInt(v)) })
 
-const builder = new Builder<{ auth: boolean }, { db: string }>({})
+const builder = {} as Builder<{ auth: boolean }, { db: string }>
 
 describe('self chainable', () => {
   it('define context', () => {

packages/server/src/builder.test.ts

@@ -34,11 +34,12 @@ describe('self chainable', () => {
     expect(applied).not.toBe(builder)
     expect(applied).toBeInstanceOf(Builder)
 
-    expect(applied['~orpc'].middlewares).toEqual(undefined)
+    expect(applied['~orpc'].middlewares).toEqual([])
   })
 
   it('use middleware', () => {
     const builder = new Builder({
+      middlewares: [],
     })
 
     const mid1 = vi.fn()
@@ -111,7 +112,7 @@ describe('to DecoratedProcedure', () => {
     const result = builder.handler(fn)
 
     expect(result).toSatisfy(isProcedure)
-    expect(result['~orpc'].middlewares).toEqual([mid])
+    expect(result['~orpc'].preMiddlewares).toEqual([mid])
     expect(result['~orpc'].handler).toBe(fn)
   })
 })

packages/server/src/builder.ts

@@ -14,7 +14,7 @@ import { DecoratedProcedure } from './procedure-decorated'
 import { RouterBuilder } from './router-builder'
 
 export interface BuilderDef<TContext extends Context, TExtraContext extends Context> {
-  middlewares?: Middleware<MergeContext<TContext, TExtraContext>, Partial<TExtraContext> | undefined, unknown, any, Record<string, unknown>>[]
+  middlewares: Middleware<MergeContext<TContext, TExtraContext>, Partial<TExtraContext> | undefined, unknown, any, Record<string, unknown>>[]
 }
 
 export class Builder<TContext extends Context, TExtraContext extends Context> {
@@ -26,7 +26,9 @@ export class Builder<TContext extends Context, TExtraContext extends Context> {
   }
 
   context<UContext extends Context = WELL_CONTEXT>(): Builder<UContext, undefined> {
-    return new Builder({})
+    return new Builder({
+      middlewares: [],
+    })
   }
 
   use<U extends Context & Partial<MergeContext<TContext, TExtraContext>> | undefined = undefined>(
@@ -40,7 +42,7 @@ export class Builder<TContext extends Context, TExtraContext extends Context> {
   ): Builder<TContext, MergeContext<TExtraContext, U>> {
     return new Builder({
       ...this['~orpc'],
-      middlewares: [...(this['~orpc'].middlewares ?? []), middleware as any],
+      middlewares: [...this['~orpc'].middlewares, middleware as any],
     })
   }
 
@@ -123,7 +125,8 @@ export class Builder<TContext extends Context, TExtraContext extends Context> {
     handler: ProcedureHandler<TContext, TExtraContext, undefined, undefined, UFuncOutput, undefined>,
   ): DecoratedProcedure<TContext, TExtraContext, undefined, undefined, UFuncOutput, undefined> {
     return new DecoratedProcedure({
-      middlewares: this['~orpc'].middlewares,
+      preMiddlewares: this['~orpc'].middlewares,
+      postMiddlewares: [],
       contract: new ContractProcedure({
         InputSchema: undefined,
         OutputSchema: undefined,

packages/server/src/implementer-chainable.test.ts

@@ -27,7 +27,7 @@ describe('createChainableImplementer', () => {
     const implementer = createChainableImplementer(ping, [mid1, mid2])
 
     expect(implementer).toBeInstanceOf(ProcedureImplementer)
-    expect(implementer['~orpc'].middlewares).toEqual([mid1, mid2])
+    expect(implementer['~orpc'].preMiddlewares).toEqual([mid1, mid2])
     expect(implementer['~orpc'].contract).toBe(ping)
   })
 
@@ -38,22 +38,22 @@ describe('createChainableImplementer', () => {
     expect(implementer.use(mid3)['~orpc'].contract).toBe(contract)
 
     expect(implementer.ping).toBeInstanceOf(ProcedureImplementer)
-    expect(implementer.ping['~orpc'].middlewares).toEqual([mid1, mid2])
+    expect(implementer.ping['~orpc'].preMiddlewares).toEqual([mid1, mid2])
     expect(implementer.ping['~orpc'].contract).toBe(ping)
 
     expect(implementer.pong).toBeInstanceOf(ProcedureImplementer)
-    expect(implementer.pong['~orpc'].middlewares).toEqual([mid1, mid2])
+    expect(implementer.pong['~orpc'].preMiddlewares).toEqual([mid1, mid2])
     expect(implementer.pong['~orpc'].contract).toBe(pong)
 
     expect(implementer.nested.use(mid3)['~orpc'].middlewares).toEqual([mid1, mid2, mid3])
     expect(implementer.nested.use(mid3)['~orpc'].contract).toBe(contract.nested)
 
     expect(implementer.nested.ping).toBeInstanceOf(ProcedureImplementer)
-    expect(implementer.nested.ping['~orpc'].middlewares).toEqual([mid1, mid2])
+    expect(implementer.nested.ping['~orpc'].preMiddlewares).toEqual([mid1, mid2])
     expect(implementer.nested.ping['~orpc'].contract).toBe(contract.nested.ping)
 
     expect(implementer.nested.pong).toBeInstanceOf(ProcedureImplementer)
-    expect(implementer.nested.pong['~orpc'].middlewares).toEqual([mid1, mid2])
+    expect(implementer.nested.pong['~orpc'].preMiddlewares).toEqual([mid1, mid2])
     expect(implementer.nested.pong['~orpc'].contract).toBe(contract.nested.pong)
   })
 
@@ -82,7 +82,8 @@ describe('createChainableImplementer', () => {
 
       expect(implementer.use).toBeTypeOf('function')
       expect(implementer.use.use(mid3)).toBeInstanceOf(ProcedureImplementer)
-      expect(implementer.use.use(mid3)['~orpc'].middlewares).toEqual([mid1, mid2, mid3])
+      expect(implementer.use.use(mid3)['~orpc'].preMiddlewares).toEqual([mid1, mid2])
+      expect(implementer.use.use(mid3)['~orpc'].postMiddlewares).toEqual([mid3])
       expect(implementer.use['~orpc'].contract).toBe(ping)
 
       expect(implementer.router).toBeTypeOf('function')
@@ -92,17 +93,20 @@ describe('createChainableImplementer', () => {
 
       expect(implementer.router.router).toBeTypeOf('function')
       expect(implementer.router.router.use(mid3)).toBeInstanceOf(ProcedureImplementer)
-      expect(implementer.router.router.use(mid3)['~orpc'].middlewares).toEqual([mid1, mid2, mid3])
+      expect(implementer.router.router.use(mid3)['~orpc'].preMiddlewares).toEqual([mid1, mid2])
+      expect(implementer.router.router.use(mid3)['~orpc'].postMiddlewares).toEqual([mid3])
       expect(implementer.router.router['~orpc'].contract).toBe(contract.router.router)
 
       expect(implementer.router.use).toBeTypeOf('function')
       expect(implementer.router.use.use(mid3)).toBeInstanceOf(ProcedureImplementer)
-      expect(implementer.router.use.use(mid3)['~orpc'].middlewares).toEqual([mid1, mid2, mid3])
+      expect(implementer.router.use.use(mid3)['~orpc'].preMiddlewares).toEqual([mid1, mid2])
+      expect(implementer.router.use.use(mid3)['~orpc'].postMiddlewares).toEqual([mid3])
       expect(implementer.router.use['~orpc'].contract).toBe(contract.router.use)
 
       expect(implementer['~orpc'].use).toBeTypeOf('function')
       expect(implementer['~orpc'].use.use(mid3)).toBeInstanceOf(ProcedureImplementer)
-      expect(implementer['~orpc'].use.use(mid3)['~orpc'].middlewares).toEqual([mid1, mid2, mid3])
+      expect(implementer['~orpc'].use.use(mid3)['~orpc'].preMiddlewares).toEqual([mid1, mid2])
+      expect(implementer['~orpc'].use.use(mid3)['~orpc'].postMiddlewares).toEqual([mid3])
       expect(implementer['~orpc'].use['~orpc'].contract).toBe(contract.router.use)
     })
 

packages/server/src/implementer-chainable.ts

@@ -21,12 +21,13 @@ export function createChainableImplementer<
   TContract extends ContractRouter = any,
 >(
   contract: TContract,
-  middlewares?: Middleware<MergeContext<TContext, TExtraContext>, Partial<TExtraContext> | undefined, unknown, any, Record<string, unknown>>[],
+  middlewares: Middleware<MergeContext<TContext, TExtraContext>, Partial<TExtraContext> | undefined, unknown, any, Record<string, unknown>>[] = [],
 ): ChainableImplementer<TContext, TExtraContext, TContract> {
   if (isContractProcedure(contract)) {
     const implementer = new ProcedureImplementer({
       contract,
-      middlewares,
+      preMiddlewares: middlewares,
+      postMiddlewares: [],
     })
 
     return implementer as any

packages/server/src/index.ts

@@ -23,4 +23,6 @@ export * from './types'
 export * from './utils'
 export { configGlobal, fallbackToGlobalConfig, isDefinedError, ORPCError, safe } from '@orpc/contract'
 
-export const os = new Builder<WELL_CONTEXT, undefined>({})
+export const os = new Builder<WELL_CONTEXT, undefined>({
+  middlewares: [],
+})

packages/server/src/lazy-decorated.test.ts

@@ -18,7 +18,8 @@ describe('decorated lazy', () => {
       errorMap: undefined,
     }),
     handler: vi.fn(),
-    middlewares: [],
+    preMiddlewares: [],
+    postMiddlewares: [],
   })
 
   const lazyPing = lazy(() => Promise.resolve({ default: ping }))

packages/server/src/lazy-utils.test.ts

@@ -11,6 +11,8 @@ describe('createLazyProcedureFormAnyLazy', () => {
       errorMap: undefined,
     }),
     handler: vi.fn(),
+    postMiddlewares: [],
+    preMiddlewares: [],
   })
 
   it('return a Lazy<ANY_PROCEDURE>', async () => {

packages/server/src/lazy.test.ts

@@ -10,7 +10,8 @@ const procedure = new Procedure<WELL_CONTEXT, undefined, undefined, undefined, u
     errorMap: undefined,
   }),
   handler: vi.fn(),
-  middlewares: [],
+  preMiddlewares: [],
+  postMiddlewares: [],
 })
 
 const router = { procedure }

packages/server/src/middleware.ts

@@ -54,3 +54,7 @@ export interface MapInputMiddleware<TInput, TMappedInput> {
 }
 
 export type ANY_MAP_INPUT_MIDDLEWARE = MapInputMiddleware<any, any>
+
+export function middlewareOutputFn<TOutput>(output: TOutput): MiddlewareResult<undefined, TOutput> {
+  return { output, context: undefined }
+}

packages/server/src/procedure-builder.test.ts

@@ -93,7 +93,8 @@ describe('to ProcedureImplementer', () => {
     const implementer = builder.use(mid)
 
     expect(implementer).toBeInstanceOf(ProcedureImplementer)
-    expect(implementer['~orpc'].middlewares).toEqual([baseMid, mid])
+    expect(implementer['~orpc'].preMiddlewares).toEqual([baseMid])
+    expect(implementer['~orpc'].postMiddlewares).toEqual([mid])
     expect(implementer['~orpc'].contract['~orpc'].InputSchema).toEqual(baseSchema)
     expect(implementer['~orpc'].contract['~orpc'].OutputSchema).toEqual(baseSchema)
     expect(implementer['~orpc'].contract['~orpc'].errorMap).toEqual(baseErrors)
@@ -105,15 +106,16 @@ describe('to ProcedureImplementer', () => {
 
     const implementer = builder.use(mid, map_input)
     expect(implementer).toBeInstanceOf(ProcedureImplementer)
-    expect(implementer['~orpc'].middlewares).toEqual([baseMid, expect.any(Function)])
+    expect(implementer['~orpc'].preMiddlewares).toEqual([baseMid])
+    expect(implementer['~orpc'].postMiddlewares).toEqual([expect.any(Function)])
     expect(implementer['~orpc'].contract['~orpc'].InputSchema).toEqual(baseSchema)
     expect(implementer['~orpc'].contract['~orpc'].OutputSchema).toEqual(baseSchema)
     expect(implementer['~orpc'].contract['~orpc'].errorMap).toEqual(baseErrors)
 
     map_input.mockReturnValueOnce('__input__')
     mid.mockReturnValueOnce('__mid__')
 
-    expect((implementer as any)['~orpc'].middlewares[1]({}, 'input', '__output__')).toBe('__mid__')
+    expect((implementer as any)['~orpc'].postMiddlewares[0]({}, 'input', '__output__')).toBe('__mid__')
 
     expect(map_input).toBeCalledTimes(1)
     expect(map_input).toBeCalledWith('input')
@@ -131,7 +133,7 @@ describe('to DecoratedProcedure', () => {
     expect(procedure).toSatisfy(isProcedure)
 
     expect(procedure['~orpc'].handler).toBe(handler)
-    expect(procedure['~orpc'].middlewares).toEqual([baseMid])
+    expect(procedure['~orpc'].preMiddlewares).toEqual([baseMid])
     expect(procedure['~orpc'].contract['~orpc'].InputSchema).toEqual(baseSchema)
     expect(procedure['~orpc'].contract['~orpc'].OutputSchema).toEqual(baseSchema)
     expect(procedure['~orpc'].contract['~orpc'].errorMap).toEqual(baseErrors)

packages/server/src/procedure-builder.ts

@@ -26,7 +26,7 @@ export interface ProcedureBuilderDef<
   TErrorMap extends ErrorMap,
 > {
   contract: ContractProcedure<TInputSchema, TOutputSchema, TErrorMap>
-  middlewares?: Middleware<MergeContext<TContext, TExtraContext>, Partial<TExtraContext> | undefined, unknown, any, Record<string, unknown>>[]
+  middlewares: Middleware<MergeContext<TContext, TExtraContext>, Partial<TExtraContext> | undefined, unknown, any, Record<string, unknown>>[]
 }
 
 export class ProcedureBuilder<
@@ -130,21 +130,24 @@ export class ProcedureBuilder<
     if (!mapInput) {
       return new ProcedureImplementer({
         contract: this['~orpc'].contract,
-        middlewares: this['~orpc'].middlewares,
+        preMiddlewares: this['~orpc'].middlewares,
+        postMiddlewares: [],
       }).use(middleware)
     }
 
     return new ProcedureImplementer({
       contract: this['~orpc'].contract,
-      middlewares: this['~orpc'].middlewares,
+      preMiddlewares: this['~orpc'].middlewares,
+      postMiddlewares: [],
     }).use(middleware, mapInput)
   }
 
   handler<UFuncOutput extends SchemaInput<TOutputSchema>>(
     handler: ProcedureHandler<TContext, TExtraContext, TInputSchema, TOutputSchema, UFuncOutput, TErrorMap>,
   ): DecoratedProcedure<TContext, TExtraContext, TInputSchema, TOutputSchema, UFuncOutput, TErrorMap> {
     return new DecoratedProcedure({
-      middlewares: this['~orpc'].middlewares,
+      preMiddlewares: this['~orpc'].middlewares,
+      postMiddlewares: [],
       contract: this['~orpc'].contract,
       handler,
     })