test(server): add missing builder & middleware tests (#226)

dinwwwh · web-flow · commit cc8802c89e50 · 2025-03-11T20:08:25.000+07:00
&lt;!-- This is an auto-generated comment: release notes by coderabbit.ai
--&gt;

## Summary by CodeRabbit

- **New Features**
- Introduced a dedicated input mapping method for configuring
middleware, enhancing API flexibility.

- **Refactor**
- Simplified middleware chaining by refining type handling and
streamlining input parameters.

- **Tests**
- Expanded and reorganized test coverage for middleware functionality
and route handling, ensuring robust error detection and improved
reliability.

&lt;!-- end of auto-generated comment: release notes by coderabbit.ai --&gt;
diff --git a/packages/server/src/builder-variants.test-d.ts b/packages/server/src/builder-variants.test-d.ts
@@ -1046,6 +1046,44 @@ describe('RouterBuilder', () => {
     expectTypeOf<keyof typeof builder>().toEqualTypeOf<keyof typeof expected>()
   })
 
+  it('.use', () => {
+    const applied = builder.use(({ context, next, path, procedure, errors, signal }, input, output) => {
+      expectTypeOf(input).toEqualTypeOf<unknown>()
+      expectTypeOf(context).toEqualTypeOf<CurrentContext>()
+      expectTypeOf(path).toEqualTypeOf<readonly string[]>()
+      expectTypeOf(procedure).toEqualTypeOf<
+        Procedure<Context, Context, AnySchema, AnySchema, ErrorMap, BaseMeta>
+      >()
+      expectTypeOf(output).toEqualTypeOf<MiddlewareOutputFn<unknown>>()
+      expectTypeOf(errors).toEqualTypeOf<ORPCErrorConstructorMap<typeof baseErrorMap>>()
+      expectTypeOf(signal).toEqualTypeOf<undefined | InstanceType<typeof AbortSignal>>()
+
+      return next({
+        context: {
+          extra: true,
+        },
+      })
+    })
+
+    expectTypeOf(applied).toEqualTypeOf<
+      RouterBuilder<
+        InitialContext,
+        CurrentContext & { extra: boolean },
+        typeof baseErrorMap,
+        BaseMeta
+      >
+    >()
+
+    // @ts-expect-error --- conflict context
+    builder.use(({ next }) => next({ context: { db: 123 } }))
+    // conflict but not detected
+    expectTypeOf(builder.use(({ next }) => next({ context: { db: undefined } }))).toMatchTypeOf<never>()
+    // @ts-expect-error --- input is not match
+    builder.use(({ next }, input: 'invalid') => next({}))
+    // @ts-expect-error --- output is not match
+    builder.use(({ next }, input, output: MiddlewareOutputFn<'invalid'>) => next({}))
+  })
+
   it('.prefix', () => {
     expectTypeOf(builder.prefix('/test')).toEqualTypeOf<
       RouterBuilder<InitialContext, CurrentContext, typeof baseErrorMap, BaseMeta>
diff --git a/packages/server/src/builder.test.ts b/packages/server/src/builder.test.ts
@@ -143,15 +143,35 @@ describe('builder', () => {
     })
   })
 
-  it('.use', () => {
-    const mid2 = vi.fn()
-    const applied = builder.use(mid2)
+  describe('.use', () => {
+    it('without map input', () => {
+      const mid2 = vi.fn()
+      const applied = builder.use(mid2)
 
-    expect(applied).instanceOf(Builder)
-    expect(applied).not.toBe(builder)
-    expect(applied['~orpc']).toEqual({
-      ...def,
-      middlewares: [mid, mid2],
+      expect(applied).instanceOf(Builder)
+      expect(applied).not.toBe(builder)
+      expect(applied['~orpc']).toEqual({
+        ...def,
+        middlewares: [mid, mid2],
+      })
+    })
+
+    it('with map input', () => {
+      const mid2 = vi.fn()
+      const map2 = vi.fn()
+
+      decorateMiddlewareSpy.mockImplementationOnce(mid => ({
+        mapInput: (map: any) => [mid, map] as any,
+      }) as any)
+
+      const applied = builder.use(mid2, map2)
+
+      expect(applied).instanceOf(Builder)
+      expect(applied).not.toBe(builder)
+      expect(applied['~orpc']).toEqual({
+        ...def,
+        middlewares: [mid, [mid2, map2]],
+      })
     })
   })
 
diff --git a/packages/server/src/middleware-decorated.test-d.ts b/packages/server/src/middleware-decorated.test-d.ts
@@ -1,8 +1,11 @@
+import type { AnySchema, ErrorMap } from '@orpc/contract'
 import type { baseErrorMap, BaseMeta } from '../../contract/tests/shared'
 import type { CurrentContext } from '../tests/shared'
+import type { Context, MergedContext } from './context'
 import type { ORPCErrorConstructorMap } from './error'
-import type { Middleware } from './middleware'
+import type { Middleware, MiddlewareOutputFn } from './middleware'
 import type { DecoratedMiddleware } from './middleware-decorated'
+import type { Procedure } from './procedure'
 
 const decorated = {} as DecoratedMiddleware<
   CurrentContext,
@@ -40,56 +43,92 @@ describe('DecoratedMiddleware', () => {
         BaseMeta
       >
     >()
+
+    // @ts-expect-error - invalid map input return
+    decorated.mapInput((input: 'input') => ({ input: 123 }))
   })
 
   describe('.concat', () => {
     it('without map input', () => {
-      const mapped = decorated.concat(
-        ({ next }, input: { input2: string }) => next({ context: { extra2: true } }),
-      )
+      const applied = decorated.concat(({ context, next, path, procedure, errors, signal }, input, output) => {
+        expectTypeOf(input).toEqualTypeOf<{ input: string }>()
+        expectTypeOf(context).toEqualTypeOf<CurrentContext & { extra: boolean }>()
+        expectTypeOf(path).toEqualTypeOf<readonly string[]>()
+        expectTypeOf(procedure).toEqualTypeOf<
+          Procedure<Context, Context, AnySchema, AnySchema, ErrorMap, BaseMeta>
+        >()
+        expectTypeOf(output).toEqualTypeOf<MiddlewareOutputFn<{ output: number }>>()
+        expectTypeOf(errors).toEqualTypeOf<ORPCErrorConstructorMap<typeof baseErrorMap>>()
+        expectTypeOf(signal).toEqualTypeOf<undefined | AbortSignal>()
+
+        return next({
+          context: {
+            extra2: true,
+          },
+        })
+      })
 
-      expectTypeOf(mapped).toEqualTypeOf<
+      expectTypeOf(applied).toEqualTypeOf<
         DecoratedMiddleware<
           CurrentContext,
-          { extra: boolean } & { extra2: boolean },
-          { input: string } & { input2: string },
+          MergedContext<{ extra: boolean }, { extra2: boolean }>,
+          { input: string },
           { output: number },
           ORPCErrorConstructorMap<typeof baseErrorMap>,
           BaseMeta
         >
       >()
 
-      decorated.concat(
-        // @ts-expect-error - conflict context
-        ({ next }) => next({ context: { extra: 'invalid' } }),
-      )
+      // @ts-expect-error --- conflict context
+      decorated.concat(({ next }) => next({ context: { extra: 'invalid' } }))
+      // @ts-expect-error --- output is not match
+      decorated.concat(({ next }, input, output: MiddlewareOutputFn<'invalid'>) => next({}))
     })
 
     it('with map input', () => {
-      const mapped = decorated.concat(
-        ({ next }, input) => {
-          expectTypeOf(input).toEqualTypeOf<{ input: { input2: string } }>()
-          return next({ context: { extra2: true } })
-        },
-        (input: { input2: string }) => ({ input }),
-      )
+      const applied = decorated.concat(({ context, next, path, procedure, errors, signal }, input: { mapped: boolean }, output) => {
+        expectTypeOf(input).toEqualTypeOf<{ mapped: boolean }>()
+        expectTypeOf(context).toEqualTypeOf<CurrentContext & { extra: boolean }>()
+        expectTypeOf(path).toEqualTypeOf<readonly string[]>()
+        expectTypeOf(procedure).toEqualTypeOf<
+          Procedure<Context, Context, AnySchema, AnySchema, ErrorMap, BaseMeta>
+        >()
+        expectTypeOf(output).toEqualTypeOf<MiddlewareOutputFn<{ output: number }>>()
+        expectTypeOf(errors).toEqualTypeOf<ORPCErrorConstructorMap<typeof baseErrorMap>>()
+        expectTypeOf(signal).toEqualTypeOf<undefined | AbortSignal>()
+
+        return next({
+          context: {
+            extra2: true,
+          },
+        })
+      }, (input) => {
+        expectTypeOf(input).toEqualTypeOf<{ input: string }>()
 
-      expectTypeOf(mapped).toEqualTypeOf<
+        return { mapped: true }
+      })
+
+      expectTypeOf(applied).toEqualTypeOf<
         DecoratedMiddleware<
           CurrentContext,
-          { extra: boolean } & { extra2: boolean },
-          { input: string } & { input2: string },
+          MergedContext<{ extra: boolean }, { extra2: boolean }>,
+          { input: string },
           { output: number },
           ORPCErrorConstructorMap<typeof baseErrorMap>,
           BaseMeta
         >
       >()
 
       decorated.concat(
-        // @ts-expect-error - conflict context
-        ({ next }) => next({ context: { extra: 'invalid' } }),
-        input => ({ mapped: input }),
+        ({ context, next, path, procedure, errors, signal }, input: { mapped: boolean }, output) => next(),
+        // @ts-expect-error --- invalid map input
+        input => ({ invalid: true }),
       )
+
+      // @ts-expect-error --- conflict context
+      decorated.concat(({ next }) => next({ context: { extra: 'invalid' } }), input => ({ mapped: true }))
+      // @ts-expect-error --- output is not match
+      decorated.concat(({ next }, input, output: MiddlewareOutputFn<'invalid'>) => next({}), input => ({ mapped: true }))
     })
   })
 })
diff --git a/packages/server/src/middleware-decorated.test.ts b/packages/server/src/middleware-decorated.test.ts
@@ -1,19 +1,25 @@
+import { baseErrorMap } from '../../contract/tests/shared'
 import { decorateMiddleware } from './middleware-decorated'
 
+beforeEach(() => {
+  vi.clearAllMocks()
+})
+
 describe('decorateMiddleware', () => {
-  it('just a function', () => {
+  it('just a copied function', () => {
     const fn = vi.fn()
     const decorated = decorateMiddleware(fn) as any
 
     fn.mockReturnValueOnce('__mocked__')
 
+    expect(decorated).not.toBe(fn)
     expect(decorated('input')).toBe('__mocked__')
     expect(fn).toHaveBeenCalledTimes(1)
     expect(fn).toHaveBeenCalledWith('input')
   })
 
-  it('can map input', () => {
-    const fn = vi.fn()
+  it('.mapInput', () => {
+    const fn = Object.assign(vi.fn(), { '~orpcErrorMap': baseErrorMap })
     const map = vi.fn()
     const decorated = decorateMiddleware(fn).mapInput(map) as any
 
@@ -29,64 +35,61 @@ describe('decorateMiddleware', () => {
     expect(fn).toHaveBeenCalledWith({}, '__input__')
   })
 
-  it('can concat', async () => {
+  describe('.concat', () => {
     const fn = vi.fn()
     const fn2 = vi.fn()
     const next = vi.fn()
 
-    const decorated = decorateMiddleware((options, input, output) => {
+    const mid1 = vi.fn((options, input, output) => {
       fn(options, input, output)
       return options.next({ context: { auth: 1, mid1: true } })
-    }).concat((options, input, output) => {
+    })
+
+    const mid2 = vi.fn((options, input, output) => {
       fn2(options, input, output)
       return options.next({ context: { auth: 2, mid2: true } })
-    }) as any
+    })
 
-    next.mockReturnValueOnce('__mocked__')
-    const outputFn = vi.fn()
-    const signal = AbortSignal.timeout(100)
-    expect((await decorated({ next, context: { origin: true }, signal }, 'input', outputFn))).toBe('__mocked__')
+    it('without map input', async () => {
+      const decorated = decorateMiddleware(mid1).concat(mid2) as any
 
-    expect(fn).toHaveBeenCalledTimes(1)
-    expect(fn).toHaveBeenCalledWith({ next: expect.any(Function), context: { origin: true }, signal }, 'input', outputFn)
+      next.mockReturnValueOnce('__mocked__')
+      const outputFn = vi.fn()
+      const signal = AbortSignal.timeout(100)
+      expect((await decorated({ next, context: { origin: true }, signal }, 'input', outputFn))).toBe('__mocked__')
 
-    expect(fn2).toHaveBeenCalledTimes(1)
-    expect(fn2).toHaveBeenCalledWith({ next: expect.any(Function), context: { origin: true, auth: 1, mid1: true }, signal }, 'input', outputFn)
+      expect(fn).toHaveBeenCalledTimes(1)
+      expect(fn).toHaveBeenCalledWith({ next: expect.any(Function), context: { origin: true }, signal }, 'input', outputFn)
 
-    expect(next).toHaveBeenCalledTimes(1)
-    expect(next).toHaveBeenCalledWith({ context: { auth: 2, mid2: true, mid1: true } })
-  })
+      expect(fn2).toHaveBeenCalledTimes(1)
+      expect(fn2).toHaveBeenCalledWith({ next: expect.any(Function), context: { origin: true, auth: 1, mid1: true }, signal }, 'input', outputFn)
 
-  it('can concat with map input', async () => {
-    const fn = vi.fn()
-    const fn2 = vi.fn()
-    const map = vi.fn()
-    const next = vi.fn()
+      expect(next).toHaveBeenCalledTimes(1)
+      expect(next).toHaveBeenCalledWith({ context: { auth: 2, mid2: true, mid1: true } })
+    })
 
-    const decorated = decorateMiddleware((options, input, output) => {
-      fn(options, input, output)
-      return options.next({ context: { auth: true } })
-    }).concat((options, input, output) => {
-      fn2(options, input, output)
-      return options.next({})
-    }, map) as any
+    it('with map input', async () => {
+      const map = vi.fn()
 
-    map.mockReturnValueOnce({ name: 'input' })
-    next.mockReturnValueOnce('__mocked__')
+      const decorated = decorateMiddleware(mid1).concat(mid2, map) as any
 
-    const outputFn = vi.fn()
-    expect((await decorated({ next }, 'input', outputFn))).toBe('__mocked__')
+      map.mockReturnValueOnce({ name: 'input' })
+      next.mockReturnValueOnce('__mocked__')
 
-    expect(fn).toHaveBeenCalledTimes(1)
-    expect(fn).toHaveBeenCalledWith({ next: expect.any(Function) }, 'input', outputFn)
+      const outputFn = vi.fn()
+      expect((await decorated({ next }, 'input', outputFn))).toBe('__mocked__')
 
-    expect(map).toHaveBeenCalledTimes(1)
-    expect(map).toHaveBeenCalledWith('input')
+      expect(fn).toHaveBeenCalledTimes(1)
+      expect(fn).toHaveBeenCalledWith({ next: expect.any(Function) }, 'input', outputFn)
+
+      expect(map).toHaveBeenCalledTimes(1)
+      expect(map).toHaveBeenCalledWith('input')
 
-    expect(fn2).toHaveBeenCalledTimes(1)
-    expect(fn2).toHaveBeenCalledWith({ context: { auth: true }, next: expect.any(Function) }, { name: 'input' }, outputFn)
+      expect(fn2).toHaveBeenCalledTimes(1)
+      expect(fn2).toHaveBeenCalledWith({ context: { auth: 1, mid1: true }, next: expect.any(Function) }, { name: 'input' }, outputFn)
 
-    expect(next).toHaveBeenCalledTimes(1)
-    expect(next).toHaveBeenCalledWith({ context: { auth: true } })
+      expect(next).toHaveBeenCalledTimes(1)
+      expect(next).toHaveBeenCalledWith({ context: { auth: 2, mid1: true, mid2: true } })
+    })
   })
 })
diff --git a/packages/server/src/middleware-decorated.ts b/packages/server/src/middleware-decorated.ts
