@orpc/server 0.1.0 → 0.1.2

package/src/builder.ts

@@ -1,34 +1,34 @@
+import type { IsEqual } from '@orpc/shared'
+import type { HandledRouter, Router } from './router'
+import type { Context, MergeContext } from './types'
 import {
   ContractProcedure,
   type ContractRouter,
   type HTTPPath,
+  isContractProcedure,
   type RouteOptions,
   type Schema,
   type SchemaInput,
   type SchemaOutput,
-  isContractProcedure,
 } from '@orpc/contract'
-import type { IsEqual } from '@orpc/shared'
 import {
   type DecoratedMiddleware,
+  decorateMiddleware,
   type MapInputMiddleware,
   type Middleware,
-  decorateMiddleware,
 } from './middleware'
 import {
   type DecoratedProcedure,
-  type ProcedureHandler,
   decorateProcedure,
+  type ProcedureHandler,
 } from './procedure'
 import { ProcedureBuilder } from './procedure-builder'
 import { ProcedureImplementer } from './procedure-implementer'
-import type { HandledRouter, Router } from './router'
 import { RouterBuilder } from './router-builder'
 import {
   type ChainedRouterImplementer,
   chainRouterImplementer,
 } from './router-implementer'
-import type { Context, MergeContext } from './types'
 
 export class Builder<TContext extends Context, TExtraContext extends Context> {
   constructor(
@@ -49,8 +49,8 @@ export class Builder<TContext extends Context, TExtraContext extends Context> {
 
   use<
     UExtraContext extends
-      | Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>>
-      | undefined = undefined,
+    | Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>>
+    | undefined = undefined,
   >(
     middleware: Middleware<
       MergeContext<TContext, TExtraContext>,
@@ -62,8 +62,8 @@ export class Builder<TContext extends Context, TExtraContext extends Context> {
 
   use<
     UExtraContext extends
-      | Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>>
-      | undefined = undefined,
+    | Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>>
+    | undefined = undefined,
     UMappedInput = unknown,
   >(
     middleware: Middleware<
@@ -146,12 +146,12 @@ export class Builder<TContext extends Context, TExtraContext extends Context> {
       UHandlerOutput
     >,
   ): DecoratedProcedure<
-    TContext,
-    TExtraContext,
-    undefined,
-    undefined,
-    UHandlerOutput
-  > {
+      TContext,
+      TExtraContext,
+      undefined,
+      undefined,
+      UHandlerOutput
+    > {
     return decorateProcedure({
       zz$p: {
         middlewares: this.zz$b.middlewares,
@@ -171,13 +171,13 @@ export class Builder<TContext extends Context, TExtraContext extends Context> {
   contract<UContract extends ContractProcedure<any, any> | ContractRouter>(
     contract: UContract,
   ): UContract extends ContractProcedure<
-    infer UInputSchema,
-    infer UOutputSchema
-  >
-    ? ProcedureImplementer<TContext, TExtraContext, UInputSchema, UOutputSchema>
-    : UContract extends ContractRouter
-      ? ChainedRouterImplementer<TContext, UContract, TExtraContext>
-      : never {
+      infer UInputSchema,
+      infer UOutputSchema
+    >
+      ? ProcedureImplementer<TContext, TExtraContext, UInputSchema, UOutputSchema>
+      : UContract extends ContractRouter
+        ? ChainedRouterImplementer<TContext, UContract, TExtraContext>
+        : never {
     if (isContractProcedure(contract)) {
       return new ProcedureImplementer({
         contract,
@@ -195,19 +195,21 @@ export class Builder<TContext extends Context, TExtraContext extends Context> {
    * Create ExtendedMiddleware
    */
 
-  middleware<UExtraContext extends Context = undefined, TInput = unknown>(
+  // TODO: TOutput always any, infer not work at all, because TOutput used inside middleware params,
+  // solution (maybe): create new generic for .output() method
+  middleware<UExtraContext extends Context = undefined, TInput = unknown, TOutput = any>(
     middleware: Middleware<
       MergeContext<TContext, TExtraContext>,
       UExtraContext,
       TInput,
-      unknown
+      TOutput
     >,
   ): DecoratedMiddleware<
-    MergeContext<TContext, TExtraContext>,
-    UExtraContext,
-    TInput,
-    unknown
-  > {
+      MergeContext<TContext, TExtraContext>,
+      UExtraContext,
+      TInput,
+      TOutput
+    > {
     return decorateMiddleware(middleware)
   }
 

package/src/index.ts

@@ -1,16 +1,16 @@
 import { Builder } from './builder'
 
 export * from './builder'
-export * from '@orpc/shared/error'
 export * from './middleware'
 export * from './procedure'
-export * from './procedure-caller'
 export * from './procedure-builder'
+export * from './procedure-caller'
 export * from './procedure-implementer'
 export * from './router'
 export * from './router-caller'
 export * from './router-implementer'
 export * from './types'
 export * from './utils'
+export * from '@orpc/shared/error'
 
 export const os = new Builder<undefined | Record<string, unknown>, undefined>()

package/src/middleware.test.ts

@@ -1,9 +1,6 @@
-import {
-  type DecoratedMiddleware,
-  type Middleware,
-  decorateMiddleware,
-} from './middleware'
-import type { Meta } from './types'
+import type { DecoratedMiddleware, Middleware, MiddlewareMeta } from './middleware'
+import { os } from '.'
+import { decorateMiddleware } from './middleware'
 
 describe('middleware', () => {
   it('just a function', () => {
@@ -15,13 +12,9 @@ describe('middleware', () => {
     > = (input, context, meta) => {
       expectTypeOf(input).toEqualTypeOf<unknown>()
       expectTypeOf(context).toEqualTypeOf<{ auth: boolean }>()
-      expectTypeOf(meta).toEqualTypeOf<Meta<unknown>>()
+      expectTypeOf(meta).toEqualTypeOf<MiddlewareMeta< unknown>>()
 
-      return {
-        context: {
-          userId: '1',
-        },
-      }
+      return meta.next({ context: { userId: '1' } })
     }
   })
 
@@ -34,16 +27,12 @@ describe('middleware', () => {
     > = (input, context, meta) => {
       expectTypeOf(input).toEqualTypeOf<unknown>()
       expectTypeOf(context).toEqualTypeOf<{ auth: boolean }>()
-      expectTypeOf(meta).toEqualTypeOf<Meta<unknown>>()
+      expectTypeOf(meta).toEqualTypeOf<MiddlewareMeta< unknown>>()
 
-      return {
-        context: {
-          userId: '1',
-        },
-      }
+      return meta.next({ context: { userId: '1' } })
     }
 
-    // @ts-expect-error mid is not return extra context
+    // @ts-expect-error mid must call next
     const mid2: Middleware<
       { auth: boolean },
       { userId: string },
@@ -52,7 +41,7 @@ describe('middleware', () => {
     > = (input, context, meta) => {
       expectTypeOf(input).toEqualTypeOf<unknown>()
       expectTypeOf(context).toEqualTypeOf<{ auth: boolean }>()
-      expectTypeOf(meta).toEqualTypeOf<Meta<unknown>>()
+      expectTypeOf(meta).toEqualTypeOf<MiddlewareMeta< unknown>>()
     }
 
     // @ts-expect-error mid return invalid context
@@ -64,42 +53,13 @@ describe('middleware', () => {
     > = (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: {
           valid: false,
         },
-      }
-    }
-  })
-
-  it('not allow return if has no extra context', () => {
-    const mid: Middleware<{ auth: boolean }, undefined, unknown, unknown> = (
-      input,
-      context,
-      meta,
-    ) => {
-      expectTypeOf(input).toEqualTypeOf<unknown>()
-      expectTypeOf(context).toEqualTypeOf<{ auth: boolean }>()
-      expectTypeOf(meta).toEqualTypeOf<Meta<unknown>>()
-    }
-
-    // @ts-expect-error mid2 is not return extra context
-    const mid2: Middleware<{ auth: boolean }, undefined, unknown, unknown> = (
-      input,
-      context,
-      meta,
-    ) => {
-      expectTypeOf(input).toEqualTypeOf<unknown>()
-      expectTypeOf(context).toEqualTypeOf<{ auth: boolean }>()
-      expectTypeOf(meta).toEqualTypeOf<Meta<unknown>>()
-
-      return {
-        context: {
-          userId: '1',
-        },
-      }
+      })
     }
   })
 })
@@ -114,13 +74,13 @@ describe('decorateMiddleware', () => {
     >((input, context, meta) => {
       expectTypeOf(input).toEqualTypeOf<{ id: string }>()
       expectTypeOf(context).toEqualTypeOf<{ auth: boolean }>()
-      expectTypeOf(meta).toEqualTypeOf<Meta<{ name: string }>>()
+      expectTypeOf(meta).toEqualTypeOf<MiddlewareMeta<{ name: string }>>()
 
-      return {
+      return meta.next({
         context: {
           userId: '1',
         },
-      }
+      })
     })
 
     expectTypeOf(mid).toEqualTypeOf<
@@ -148,16 +108,16 @@ describe('decorateMiddleware', () => {
       undefined,
       { id: string },
       { name: string }
-    >(() => {}).concat((input, context, meta) => {
+    >((_, __, meta) => meta.next({})).concat(async (input, context, meta) => {
       expectTypeOf(input).toEqualTypeOf<{ id: string }>()
       expectTypeOf(context).toEqualTypeOf<{ auth: boolean }>()
-      expectTypeOf(meta).toEqualTypeOf<Meta<{ name: string }>>()
+      expectTypeOf(meta).toEqualTypeOf<MiddlewareMeta<{ name: string }>>()
 
-      return {
+      return meta.next({
         context: {
           userId: '1',
         },
-      }
+      })
     })
 
     expectTypeOf(mid).toEqualTypeOf<
@@ -176,9 +136,9 @@ describe('decorateMiddleware', () => {
       undefined,
       unknown,
       unknown
-    >(() => {})
-      .concat((input: { id: string }) => {})
-      .concat((input: { status: string }) => {})
+    >((_, __, meta) => meta.next({}))
+      .concat((input: { id: string }, _, meta) => meta.next({}))
+      .concat((input: { status: string }, _, meta) => meta.next({}))
 
     expectTypeOf(mid).toEqualTypeOf<
       DecoratedMiddleware<
@@ -190,20 +150,20 @@ describe('decorateMiddleware', () => {
     >()
 
     // MID2 isn't usable because input type is wrong
-    const mid2 = mid.concat((input: { id: number }) => {})
+    const mid2 = mid.concat((input: { id: number }, _, meta) => meta.next({}))
     expectTypeOf(mid2).toMatchTypeOf<
       DecoratedMiddleware<
         { auth: boolean },
         undefined,
-        { id: never; status: string },
+        { id: never, status: string },
         unknown
       >
     >()
   })
 
   it('concat: deep copy', () => {
-    const middleware = decorateMiddleware(() => {})
-    const mid2 = middleware.concat(() => {})
+    const middleware = decorateMiddleware((_, __, meta) => meta.next({}))
+    const mid2 = middleware.concat((_, __, meta) => meta.next({}))
     expect(mid2).not.toBe(middleware)
   })
 
@@ -213,13 +173,11 @@ describe('decorateMiddleware', () => {
       undefined,
       unknown,
       unknown
-    >(() => {})
+    >((_, __, meta) => meta.next({}))
 
     const mid2 = middleware.concat(
-      (input: { postId: number }) => {
-        return { context: { a: 'a' } }
-      },
-      (input) => ({ postId: 12455 }),
+      (input: { postId: number }, _, meta) => meta.next({ context: { a: 'a' } }),
+      input => ({ postId: 12455 }),
     )
 
     // mid2 input is unknown, because it's map input does not expect anything
@@ -229,9 +187,11 @@ describe('decorateMiddleware', () => {
 
     const fn = vi.fn()
     const mid3 = middleware.concat(
-      (input: { postId: string }) => {
+      (input: { postId: string }, _, meta) => {
         fn()
         expect(input).toEqual({ postId: '123' })
+
+        return meta.next({})
       },
       (input: { postId: number }) => {
         fn()
@@ -242,7 +202,7 @@ describe('decorateMiddleware', () => {
       },
     )
 
-    await mid3({ postId: 123 }, {} as any, {} as any)
+    await mid3({ postId: 123 }, {} as any, { next: () => {} } as any)
     expect(fn).toHaveBeenCalledTimes(2)
 
     // INPUT now follow expect types from map not from middleware
@@ -277,3 +237,24 @@ describe('decorateMiddleware', () => {
     expect(fn).toHaveBeenCalledWith({ id: '1' }, undefined, {})
   })
 })
+
+it('middleware can output', async () => {
+  let mid2Called = false
+  let handlerCalled = false
+  const ping = os
+    .use((input, ctx, meta) => {
+      return meta.output('from middleware')
+    })
+    .use((input, ctx, meta) => {
+      mid2Called = true
+      return meta.output('from middleware 2')
+    })
+    .handler(() => {
+      handlerCalled = true
+      return 'from handler'
+    })
+
+  expect(await ping(undefined)).toBe('from middleware')
+  expect(mid2Called).toBeFalsy()
+  expect(handlerCalled).toBeFalsy()
+})

package/src/middleware.ts

@@ -1,6 +1,21 @@
-import type { Context, MergeContext, Meta, Promisable } from './types'
+import type { Promisable } from '@orpc/shared'
+import type { Context, MergeContext, Meta } from './types'
 import { mergeContext } from './utils'
 
+export type MiddlewareResult<TExtraContext extends Context, TOutput> = Promisable<{
+  output: TOutput
+  context: TExtraContext
+}>
+
+export interface MiddlewareMeta<
+  TOutput,
+> extends Meta {
+  next: <UExtraContext extends Context = undefined>(
+    options: UExtraContext extends undefined ? { context?: UExtraContext } : { context: UExtraContext }
+  ) => MiddlewareResult<UExtraContext, TOutput>
+  output: <UOutput>(output: UOutput) => MiddlewareResult<undefined, UOutput>
+}
+
 export interface Middleware<
   TContext extends Context,
   TExtraContext extends Context,
@@ -10,9 +25,9 @@ export interface Middleware<
   (
     input: TInput,
     context: TContext,
-    meta: Meta<TOutput>,
+    meta: MiddlewareMeta<TOutput>,
   ): Promisable<
-    TExtraContext extends undefined ? void : { context: TExtraContext }
+    MiddlewareResult<TExtraContext, TOutput>
   >
 }
 
@@ -26,22 +41,23 @@ export interface DecoratedMiddleware<
   TInput,
   TOutput,
 > extends Middleware<TContext, TExtraContext, TInput, TOutput> {
-  concat<UExtraContext extends Context = undefined, UInput = TInput>(
+  concat: (<
+    UExtraContext extends Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>> | undefined = undefined,
+    UInput = TInput,
+  >(
     middleware: Middleware<
       MergeContext<TContext, TExtraContext>,
       UExtraContext,
       UInput & TInput,
       TOutput
     >,
-  ): DecoratedMiddleware<
+  ) => DecoratedMiddleware<
     TContext,
     MergeContext<TExtraContext, UExtraContext>,
     TInput & UInput,
     TOutput
-  >
-
-  concat<
-    UExtraContext extends Context = undefined,
+  >) & (<
+    UExtraContext extends Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>> | undefined = undefined,
     UInput = TInput,
     UMappedInput = unknown,
   >(
@@ -52,16 +68,16 @@ export interface DecoratedMiddleware<
       TOutput
     >,
     mapInput: MapInputMiddleware<UInput, UMappedInput>,
-  ): DecoratedMiddleware<
+  ) => DecoratedMiddleware<
     TContext,
     MergeContext<TExtraContext, UExtraContext>,
     TInput & UInput,
     TOutput
-  >
+  >)
 
-  mapInput<UInput = unknown>(
+  mapInput: <UInput = unknown>(
     map: MapInputMiddleware<UInput, TInput>,
-  ): DecoratedMiddleware<TContext, TExtraContext, UInput, TOutput>
+  ) => DecoratedMiddleware<TContext, TExtraContext, UInput, TOutput>
 }
 
 const decoratedMiddlewareSymbol = Symbol('🔒decoratedMiddleware')
@@ -81,7 +97,7 @@ export function decorateMiddleware<
   const concat = (
     concatMiddleware: Middleware<any, any, any, any>,
     mapInput?: MapInputMiddleware<any, any>,
-  ) => {
+  ): Middleware<any, any, any, any> => {
     const concatMiddleware_ = mapInput
       ? decorateMiddleware(concatMiddleware).mapInput(mapInput)
       : concatMiddleware
@@ -91,15 +107,16 @@ export function decorateMiddleware<
       const context_ = context as any
       const meta_ = meta as any
 
-      const m1 = await middleware(input_, context_, meta_, ...rest)
-      const m2 = await concatMiddleware_(
-        input_,
-        mergeContext(context_, m1?.context),
-        meta_,
-        ...rest,
-      )
+      const next: MiddlewareMeta<any>['next'] = async (options) => {
+        return concatMiddleware_(input_, mergeContext(context_, options.context), meta_, ...rest)
+      }
+
+      const m1 = await middleware(input_, context_, {
+        ...meta_,
+        next,
+      }, ...rest)
 
-      return { context: mergeContext(m1?.context, m2?.context) }
+      return m1
     })
   }
 

package/src/procedure-builder.test.ts

@@ -1,9 +1,11 @@
+import type { MiddlewareMeta } from './middleware'
+import type { ProcedureImplementer } from './procedure-implementer'
+import type { Meta } from './types'
 import { ContractProcedure } from '@orpc/contract'
 import { z } from 'zod'
+import { os } from '.'
 import { type DecoratedProcedure, isProcedure } from './procedure'
 import { ProcedureBuilder } from './procedure-builder'
-import type { ProcedureImplementer } from './procedure-implementer'
-import type { Meta } from './types'
 
 const schema1 = z.object({ id: z.string() })
 const example1 = { id: '1' }
@@ -90,20 +92,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(implementer).toEqualTypeOf<
@@ -123,27 +127,27 @@ describe('use middleware', () => {
     })
 
     builder.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 }),
     )
 
     builder.use(
-      (input: { postId: string }) => {},
-      (input) => ({ postId: '12455' }),
+      (input: { postId: string }, context, meta) => meta.next({}),
+      input => ({ postId: '12455' }),
     )
 
     const implementer = builder.input(schema1).use(
-      (input: { id: number }) => {
-        return {
+      (input: { id: number }, _, meta) => {
+        return meta.next({
           context: {
             userId555: '1',
           },
-        }
+        })
       },
-      (input) => ({ id: Number.parseInt(input.id) }),
+      input => ({ id: Number.parseInt(input.id) }),
     )
 
     expectTypeOf(implementer).toEqualTypeOf<
@@ -162,7 +166,7 @@ describe('handler', () => {
     const handler = builder.handler((input, context, meta) => {
       expectTypeOf(input).toEqualTypeOf<unknown>()
       expectTypeOf(context).toEqualTypeOf<{ auth: boolean }>()
-      expectTypeOf(meta).toEqualTypeOf<Meta<unknown>>()
+      expectTypeOf(meta).toEqualTypeOf<Meta>()
     })
 
     expectTypeOf(handler).toEqualTypeOf<
@@ -179,15 +183,15 @@ 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((_, __, meta) => meta.next({}))
 
     const handler = builder
       .use(mid1)
@@ -197,7 +201,7 @@ describe('handler', () => {
         expectTypeOf(context).toEqualTypeOf<
           { userId: string } & { auth: boolean }
         >()
-        expectTypeOf(meta).toEqualTypeOf<Meta<unknown>>()
+        expectTypeOf(meta).toEqualTypeOf<Meta>()
 
         return {
           name: 'unnoq',