@orpc/server 0.1.0 → 0.1.1

package/src/procedure.test.ts

@@ -1,11 +1,12 @@
+import type { MiddlewareMeta } from '.'
 import { ContractProcedure, DecoratedContractProcedure } from '@orpc/contract'
 import { z } from 'zod'
-import { os, type Meta } from '.'
+import { os } from '.'
 import {
   type DecoratedProcedure,
-  Procedure,
   decorateProcedure,
   isProcedure,
+  Procedure,
 } from './procedure'
 
 it('isProcedure', () => {
@@ -98,7 +99,7 @@ describe('route method', () => {
   })
 
   it('works with middleware', () => {
-    const mid = vi.fn(() => ({ context: { userId: '1' } }))
+    const mid = os.middleware((_, __, meta) => meta.next({ context: { userId: '1' } }))
 
     const p = os
       .context<{ auth: boolean }>()
@@ -155,7 +156,7 @@ describe('route method', () => {
   })
 })
 
-test('prefix method', () => {
+it('prefix method', () => {
   const p = os.context<{ auth: boolean }>().handler(() => {
     return 'unnoq'
   })
@@ -179,8 +180,8 @@ describe('use middleware', () => {
   it('infer types', () => {
     const p1 = os
       .context<{ auth: boolean }>()
-      .use(() => {
-        return { context: { postId: 'string' } }
+      .use((_, __, meta) => {
+        return meta.next({ context: { postId: 'string' } })
       })
       .handler(() => {
         return 'unnoq'
@@ -192,20 +193,22 @@ describe('use middleware', () => {
         expectTypeOf(context).toEqualTypeOf<
           { auth: boolean } & { postId: string }
         >()
-        expectTypeOf(meta).toEqualTypeOf<Meta<string>>()
+        expectTypeOf(meta).toEqualTypeOf<MiddlewareMeta<string>>()
 
-        return {
+        return meta.next({
           context: {
             userId: '1',
           },
-        }
+        })
       })
       .use((input, context, meta) => {
         expectTypeOf(input).toEqualTypeOf<unknown>()
         expectTypeOf(context).toEqualTypeOf<
           { userId: string } & { postId: string } & { auth: boolean }
         >()
-        expectTypeOf(meta).toEqualTypeOf<Meta<string>>()
+        expectTypeOf(meta).toEqualTypeOf<MiddlewareMeta<string>>()
+
+        return meta.next({})
       })
 
     expectTypeOf(p2).toEqualTypeOf<
@@ -220,7 +223,9 @@ describe('use middleware', () => {
   })
 
   it('can map input', () => {
-    const mid = (input: { id: number }) => {}
+    const mid = os.middleware((input: { id: number }, __, meta) => {
+      return meta.next({})
+    })
 
     os.input(z.object({ postId: z.number() })).use(mid, (input) => {
       expectTypeOf(input).toEqualTypeOf<{ postId: number }>()
@@ -298,7 +303,7 @@ describe('server action', () => {
   it('can deserialize form data', async () => {
     const p = os
       .input(z.object({ id: z.number(), nested: z.object({ date: z.date() }) }))
-      .handler(async (input) => input)
+      .handler(async input => input)
 
     const form = new FormData()
     form.append('id', '123')

package/src/procedure.ts

@@ -1,20 +1,22 @@
+import type { Promisable } from '@orpc/shared'
+import type { Context, MergeContext, Meta } from './types'
 import {
   type ContractProcedure,
   DecoratedContractProcedure,
   type HTTPPath,
+  isContractProcedure,
+  type RouteOptions,
+  type Schema,
   type SchemaInput,
   type SchemaOutput,
-  isContractProcedure,
 } from '@orpc/contract'
-import type { RouteOptions, Schema } from '@orpc/contract'
 import { OpenAPIDeserializer } from '@orpc/transformer'
 import {
+  decorateMiddleware,
   type MapInputMiddleware,
   type Middleware,
-  decorateMiddleware,
 } from './middleware'
 import { createProcedureCaller } from './procedure-caller'
-import type { Context, MergeContext, Meta, Promisable } from './types'
 
 export class Procedure<
   TContext extends Context,
@@ -51,9 +53,9 @@ export type DecoratedProcedure<
   TOutputSchema,
   THandlerOutput
 > & {
-  prefix(
+  prefix: (
     prefix: HTTPPath,
-  ): DecoratedProcedure<
+  ) => DecoratedProcedure<
     TContext,
     TExtraContext,
     TInputSchema,
@@ -61,9 +63,9 @@ export type DecoratedProcedure<
     THandlerOutput
   >
 
-  route(
+  route: (
     opts: RouteOptions,
-  ): DecoratedProcedure<
+  ) => DecoratedProcedure<
     TContext,
     TExtraContext,
     TInputSchema,
@@ -71,54 +73,51 @@ export type DecoratedProcedure<
     THandlerOutput
   >
 
-  use<
+  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, THandlerOutput>
+      SchemaInput<TOutputSchema, THandlerOutput>
     >,
-  ): DecoratedProcedure<
+  ) => DecoratedProcedure<
     TContext,
     MergeContext<TExtraContext, UExtraContext>,
     TInputSchema,
     TOutputSchema,
     THandlerOutput
-  >
-
-  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, THandlerOutput>
+      SchemaInput<TOutputSchema, THandlerOutput>
     >,
     mapInput: MapInputMiddleware<
       SchemaOutput<TInputSchema, THandlerOutput>,
       UMappedInput
     >,
-  ): DecoratedProcedure<
+  ) => DecoratedProcedure<
     TContext,
     MergeContext<TExtraContext, UExtraContext>,
     TInputSchema,
     TOutputSchema,
     THandlerOutput
-  >
+  >)
 } & (undefined extends TContext
-    ? (
-        input: SchemaInput<TInputSchema> | FormData,
-      ) => Promise<SchemaOutput<TOutputSchema, THandlerOutput>>
-    : // biome-ignore lint/complexity/noBannedTypes: {} seem has no side-effect on this case
-      {})
+  ? (
+      input: SchemaInput<TInputSchema> | FormData,
+    ) => Promise<SchemaOutput<TOutputSchema, THandlerOutput>>
+  : unknown)
 
 export interface ProcedureHandler<
   TContext extends Context,
@@ -130,7 +129,7 @@ export interface ProcedureHandler<
   (
     input: SchemaOutput<TInputSchema>,
     context: MergeContext<TContext, TExtraContext>,
-    meta: Meta<unknown>,
+    meta: Meta,
   ): Promisable<SchemaInput<TOutputSchema, TOutput>>
 }
 
@@ -151,19 +150,20 @@ export function decorateProcedure<
     THandlerOutput
   >,
 ): DecoratedProcedure<
-  TContext,
-  TExtraContext,
-  TInputSchema,
-  TOutputSchema,
-  THandlerOutput
-> {
+    TContext,
+    TExtraContext,
+    TInputSchema,
+    TOutputSchema,
+    THandlerOutput
+  > {
   if (DECORATED_PROCEDURE_SYMBOL in procedure) {
     return procedure as any
   }
 
-  const serverAction = async (input: unknown) => {
+  const serverAction = async (input: unknown): Promise<SchemaOutput<TOutputSchema, THandlerOutput>> => {
     const input_ = (() => {
-      if (!(input instanceof FormData)) return input
+      if (!(input instanceof FormData))
+        return input
 
       const transformer = new OpenAPIDeserializer({
         schema: procedure.zz$p.contract.zz$cp.InputSchema,
@@ -235,17 +235,18 @@ export type WELL_DEFINED_PROCEDURE = Procedure<
 >
 
 export function isProcedure(item: unknown): item is WELL_DEFINED_PROCEDURE {
-  if (item instanceof Procedure) return true
+  if (item instanceof Procedure)
+    return true
 
   return (
-    (typeof item === 'object' || typeof item === 'function') &&
-    item !== null &&
-    'zz$p' in item &&
-    typeof item.zz$p === 'object' &&
-    item.zz$p !== null &&
-    'contract' in item.zz$p &&
-    isContractProcedure(item.zz$p.contract) &&
-    'handler' in item.zz$p &&
-    typeof item.zz$p.handler === 'function'
+    (typeof item === 'object' || typeof item === 'function')
+    && item !== null
+    && 'zz$p' in item
+    && typeof item.zz$p === 'object'
+    && item.zz$p !== null
+    && 'contract' in item.zz$p
+    && isContractProcedure(item.zz$p.contract)
+    && 'handler' in item.zz$p
+    && typeof item.zz$p.handler === 'function'
   )
 }

package/src/router-builder.test.ts

@@ -1,6 +1,6 @@
 import { ContractProcedure } from '@orpc/contract'
 import { z } from 'zod'
-import { os, Procedure, decorateProcedure, isProcedure } from '.'
+import { decorateProcedure, isProcedure, os, Procedure } from '.'
 import { RouterBuilder } from './router-builder'
 
 const builder = new RouterBuilder<undefined, undefined>({})
@@ -22,7 +22,7 @@ describe('prefix', () => {
     const router = builder
       .prefix('/api')
       .prefix('/users')
-      .router({ ping: ping, pong })
+      .router({ ping, pong })
 
     expect(router.ping.zz$p.contract.zz$cp.path).toEqual('/api/users/ping')
     expect(router.pong.zz$p.contract.zz$cp.path).toEqual(undefined)
@@ -43,7 +43,7 @@ describe('tags', () => {
     const router = builder
       .tags('api')
       .tags('users')
-      .router({ ping: ping, pong })
+      .router({ ping, pong })
 
     expect(router.ping.zz$p.contract.zz$cp.tags).toEqual([
       'ping',
@@ -68,7 +68,7 @@ describe('middleware', () => {
   })
 
   it('router', () => {
-    const router = builder.use(mid1).use(mid2).router({ ping: ping, pong })
+    const router = builder.use(mid1).use(mid2).router({ ping, pong })
 
     expect(router.ping.zz$p.middlewares).toEqual([mid1, mid2])
     expect(router.pong.zz$p.middlewares).toEqual([mid1, mid2])

package/src/router-builder.ts

@@ -1,12 +1,12 @@
+import type { HandledRouter, Router } from './router'
+import type { Context, MergeContext } from './types'
 import { DecoratedContractProcedure, type HTTPPath } from '@orpc/contract'
 import {
+  decorateMiddleware,
   type MapInputMiddleware,
   type Middleware,
-  decorateMiddleware,
 } from './middleware'
 import { decorateProcedure, isProcedure } from './procedure'
-import type { HandledRouter, Router } from './router'
-import type { Context, MergeContext } from './types'
 
 export class RouterBuilder<
   TContext extends Context,
@@ -28,7 +28,8 @@ export class RouterBuilder<
   }
 
   tags(...tags: string[]): RouterBuilder<TContext, TExtraContext> {
-    if (!tags.length) return this
+    if (!tags.length)
+      return this
 
     return new RouterBuilder({
       ...this.zz$rb,
@@ -38,8 +39,8 @@ export class RouterBuilder<
 
   use<
     UExtraContext extends
-      | Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>>
-      | undefined = undefined,
+    | Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>>
+    | undefined = undefined,
   >(
     middleware: Middleware<
       MergeContext<TContext, TExtraContext>,
@@ -51,8 +52,8 @@ export class RouterBuilder<
 
   use<
     UExtraContext extends
-      | Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>>
-      | undefined = undefined,
+    | Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>>
+    | undefined = undefined,
     UMappedInput = unknown,
   >(
     middleware: Middleware<
@@ -93,7 +94,7 @@ export class RouterBuilder<
         const middlewares = [
           ...builderMiddlewares,
           ...itemMiddlewares.filter(
-            (item) => !builderMiddlewares.includes(item),
+            item => !builderMiddlewares.includes(item),
           ),
         ]
 
@@ -110,7 +111,8 @@ export class RouterBuilder<
             middlewares,
           },
         })
-      } else {
+      }
+      else {
         handled[key] = this.router(item as any)
       }
     }

package/src/router-caller.test.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod'
-import { os, createRouterCaller } from '.'
+import { createRouterCaller, os } from '.'
 
 describe('createRouterCaller', () => {
   let internal = false
@@ -8,8 +8,8 @@ describe('createRouterCaller', () => {
   const osw = os.context<{ auth?: boolean }>()
 
   const ping = 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).toEqual(internal)
@@ -87,12 +87,12 @@ describe('createRouterCaller', () => {
       value: true,
     })
 
-    // @ts-expect-error
+    // @ts-expect-error - invalid input
     expect(caller.ping({ value: new Date('2023-01-01') })).rejects.toThrowError(
       'Validation input failed',
     )
 
-    // @ts-expect-error
+    // @ts-expect-error - invalid input
     expect(caller.nested.ping({ value: true })).rejects.toThrowError(
       'Validation input failed',
     )
@@ -158,7 +158,7 @@ describe('createRouterCaller', () => {
     })
 
     const caller = createRouterCaller({
-      router: router,
+      router,
       context,
     })
 

package/src/router-caller.ts

@@ -1,9 +1,7 @@
 import type {} from '@orpc/contract'
-import { type Procedure, isProcedure } from './procedure'
-import { type ProcedureCaller, createProcedureCaller } from './procedure-caller'
 import type { Router } from './router'
-import type { Meta, Promisable } from './types'
-import {} from './utils'
+import { isProcedure, type Procedure } from './procedure'
+import { createProcedureCaller, type ProcedureCaller } from './procedure-caller'
 
 export interface CreateRouterCallerOptions<
   TRouter extends Router<any>,
@@ -16,14 +14,6 @@ export interface CreateRouterCallerOptions<
    */
   context: TRouter extends Router<infer UContext> ? UContext : never
 
-  /**
-   * Helpful hooks to do some logics on specific time.
-   */
-  hooks?: (
-    context: TRouter extends Router<infer UContext> ? UContext : never,
-    meta: Meta<unknown>,
-  ) => Promisable<void>
-
   /**
    * This is helpful for logging and analytics.
    */
@@ -74,16 +64,15 @@ export function createRouterCaller<
       caller[key] = createProcedureCaller({
         procedure: item,
         context: options.context as any,
-        hooks: options.hooks as any,
-        path: path,
+        path,
         internal,
         validate,
       })
-    } else {
+    }
+    else {
       caller[key] = createRouterCaller({
         router: item as any,
         context: options.context,
-        hooks: options.hooks,
         basePath: path,
         internal,
         validate,

package/src/router-implementer.test.ts

@@ -35,12 +35,12 @@ it('required all procedure match', () => {
   })
 
   implementer.router({
-    p1: p1,
+    p1,
     nested: {
       p2: os.contract(cp2).handler(() => ''),
     },
     nested2: {
-      p3: p3,
+      p3,
     },
   })
 
@@ -49,10 +49,10 @@ it('required all procedure match', () => {
       // @ts-expect-error p1 is mismatch
       p1: os.handler(() => {}),
       nested: {
-        p2: p2,
+        p2,
       },
       nested2: {
-        p3: p3,
+        p3,
       },
     })
   }).toThrowError('Mismatch implementation for procedure at [p1]')
@@ -62,10 +62,10 @@ it('required all procedure match', () => {
       // @ts-expect-error p1 is mismatch
       p1: osw,
       nested: {
-        p2: p2,
+        p2,
       },
       nested2: {
-        p3: p3,
+        p3,
       },
     })
   }).toThrowError('Mismatch implementation for procedure at [p1]')
@@ -78,10 +78,10 @@ it('required all procedure match', () => {
         .output(z.string())
         .handler(() => 'unnoq'),
       nested: {
-        p2: p2,
+        p2,
       },
       nested2: {
-        p3: p3,
+        p3,
       },
     })
   }).toThrowError('Mismatch implementation for procedure at [p1]')
@@ -93,9 +93,9 @@ it('required all procedure match', () => {
 
   expect(() => {
     implementer.router({
-      p1: p1,
+      p1,
       nested: {
-        p2: p2,
+        p2,
       },
       // @ts-expect-error missing p3
       nested2: {},
@@ -104,9 +104,9 @@ it('required all procedure match', () => {
 
   expect(() => {
     implementer.router({
-      p1: p1,
+      p1,
       nested: {
-        p2: p2,
+        p2,
       },
       nested2: {
         p3: p3.prefix('/test'),

package/src/router-implementer.ts

@@ -1,13 +1,13 @@
+import type { Middleware } from './middleware'
+import type { RouterWithContract } from './router'
+import type { Context } from './types'
 import {
   type ContractProcedure,
   type ContractRouter,
   isContractProcedure,
 } from '@orpc/contract'
-import type { Middleware } from './middleware'
 import { isProcedure } from './procedure'
 import { ProcedureImplementer } from './procedure-implementer'
-import type { RouterWithContract } from './router'
-import type { Context } from './types'
 
 export class RouterImplementer<
   TContext extends Context,
@@ -61,7 +61,8 @@ export function chainRouterImplementer<
         contract: item,
         middlewares,
       })
-    } else {
+    }
+    else {
       result[key] = chainRouterImplementer(item as ContractRouter, middlewares)
     }
   }
@@ -94,12 +95,14 @@ export function assertRouterImplementation(
             `Mismatch implementation for procedure at [${currentPath.join('.')}]`,
           )
         }
-      } else {
+      }
+      else {
         throw new Error(
           `Mismatch implementation for procedure at [${currentPath.join('.')}]`,
         )
       }
-    } else {
+    }
+    else {
       assertRouterImplementation(
         contractItem as ContractRouter,
         routerItem as any,

package/src/router.test.ts

@@ -3,7 +3,7 @@ import { z } from 'zod'
 import { os, type RouterWithContract, toContractRouter } from '.'
 
 it('require procedure match context', () => {
-  const osw = os.context<{ auth: boolean; userId: string }>()
+  const osw = os.context<{ auth: boolean, userId: string }>()
 
   osw.router({
     ping: osw.context<{ auth: boolean }>().handler(() => {
@@ -106,14 +106,14 @@ it('toContractRouter', () => {
   const p3 = oc.route({ method: 'GET', path: '/test' })
 
   const contract = oc.router({
-    p1: p1,
+    p1,
 
     nested: oc.router({
-      p2: p2,
+      p2,
     }),
 
     nested2: {
-      p3: p3,
+      p3,
     },
   })
 

package/src/router.ts

@@ -1,3 +1,4 @@
+import type { Context } from './types'
 import {
   type ContractProcedure,
   type ContractRouter,
@@ -5,10 +6,9 @@ import {
 } from '@orpc/contract'
 import {
   type DecoratedProcedure,
-  type Procedure,
   isProcedure,
+  type Procedure,
 } from './procedure'
-import type { Context } from './types'
 
 export interface Router<TContext extends Context> {
   [k: string]: Procedure<TContext, any, any, any, any> | Router<TContext>
@@ -23,12 +23,12 @@ export type HandledRouter<TRouter extends Router<any>> = {
     infer UHandlerOutput
   >
     ? DecoratedProcedure<
-        UContext,
-        UExtraContext,
-        UInputSchema,
-        UOutputSchema,
-        UHandlerOutput
-      >
+      UContext,
+      UExtraContext,
+      UInputSchema,
+      UOutputSchema,
+      UHandlerOutput
+    >
     : TRouter[K] extends Router<any>
       ? HandledRouter<TRouter[K]>
       : never
@@ -58,9 +58,11 @@ export function toContractRouter(
 
     if (isContractProcedure(item)) {
       contract[key] = item
-    } else if (isProcedure(item)) {
+    }
+    else if (isProcedure(item)) {
       contract[key] = item.zz$p.contract
-    } else {
+    }
+    else {
       contract[key] = toContractRouter(item as any)
     }
   }

package/src/types.test.ts

@@ -1,6 +1,6 @@
 import type { MergeContext } from './types'
 
-test('MergeContext', () => {
+it('mergeContext', () => {
   expectTypeOf<MergeContext<undefined, undefined>>().toEqualTypeOf<undefined>()
   expectTypeOf<MergeContext<undefined, { foo: string }>>().toEqualTypeOf<{
     foo: string