@orpc/server 0.2.1 → 0.3.0

package/src/procedure.test.ts

@@ -18,7 +18,7 @@ it('isProcedure', () => {
             InputSchema: undefined,
             OutputSchema: undefined,
           }),
-          handler: () => {},
+          func: () => {},
         }),
       ),
     ),
@@ -29,7 +29,7 @@ it('isProcedure', () => {
         InputSchema: undefined,
         OutputSchema: undefined,
       }),
-      handler: () => {},
+      func: () => {},
     },
   }).toSatisfy(isProcedure)
 
@@ -57,7 +57,7 @@ it('isProcedure', () => {
 
 describe('route method', () => {
   it('sets route options correctly', () => {
-    const p = os.context<{ auth: boolean }>().handler(() => {
+    const p = os.context<{ auth: boolean }>().func(() => {
       return 'test'
     })
 
@@ -69,11 +69,11 @@ describe('route method', () => {
 
   it('preserves existing context and handler', () => {
     const handler = () => 'test'
-    const p = os.context<{ auth: boolean }>().handler(handler)
+    const p = os.context<{ auth: boolean }>().func(handler)
 
     const p2 = p.route({ path: '/test' })
 
-    expect(p2.zz$p.handler).toBe(handler)
+    expect(p2.zz$p.func).toBe(handler)
     // Context type is preserved through the route method
     expectTypeOf(p2).toEqualTypeOf<
       DecoratedProcedure<
@@ -90,7 +90,7 @@ describe('route method', () => {
     const p = os
       .context<{ auth: boolean }>()
       .route({ path: '/api', method: 'POST' })
-      .handler(() => 'test')
+      .func(() => 'test')
 
     const p2 = p.prefix('/v1')
 
@@ -105,7 +105,7 @@ describe('route method', () => {
       .context<{ auth: boolean }>()
       .route({ path: '/test' })
       .use(mid)
-      .handler((input, context) => {
+      .func((input, context) => {
         expectTypeOf(context).toEqualTypeOf<
           { auth: boolean } & { userId: string }
         >()
@@ -120,7 +120,7 @@ describe('route method', () => {
     const p = os
       .context<{ auth: boolean }>()
       .route({ path: '/test1', method: 'GET' })
-      .handler(() => 'test')
+      .func(() => 'test')
 
     const p2 = p.route({ path: '/test2', method: 'POST' })
 
@@ -136,7 +136,7 @@ describe('route method', () => {
       .input(inputSchema)
       .output(outputSchema)
       .route({ path: '/test' })
-      .handler((input) => {
+      .func((input) => {
         expectTypeOf(input).toEqualTypeOf<{ id: number }>()
         return 'test'
       })
@@ -157,7 +157,7 @@ describe('route method', () => {
 })
 
 it('prefix method', () => {
-  const p = os.context<{ auth: boolean }>().handler(() => {
+  const p = os.context<{ auth: boolean }>().func(() => {
     return 'unnoq'
   })
 
@@ -168,7 +168,7 @@ it('prefix method', () => {
   const p3 = os
     .context<{ auth: boolean }>()
     .route({ path: '/test1' })
-    .handler(() => {
+    .func(() => {
       return 'unnoq'
     })
 
@@ -183,7 +183,7 @@ describe('use middleware', () => {
       .use((_, __, meta) => {
         return meta.next({ context: { postId: 'string' } })
       })
-      .handler(() => {
+      .func(() => {
         return 'unnoq'
       })
 
@@ -251,7 +251,7 @@ describe('use middleware', () => {
     const mid2 = vi.fn()
     const mid3 = vi.fn()
 
-    const p1 = os.use(mid1).handler(() => 'unnoq')
+    const p1 = os.use(mid1).func(() => 'unnoq')
     const p2 = p1.use(mid2).use(mid3)
 
     expect(p2.zz$p.middlewares).toEqual([mid3, mid2, mid1])
@@ -260,12 +260,12 @@ describe('use middleware', () => {
 
 describe('server action', () => {
   it('only accept undefined context', () => {
-    expectTypeOf(os.handler(() => {})).toMatchTypeOf<(...args: any[]) => any>()
+    expectTypeOf(os.func(() => {})).toMatchTypeOf<(...args: any[]) => any>()
     expectTypeOf(
-      os.context<{ auth: boolean } | undefined>().handler(() => {}),
+      os.context<{ auth: boolean } | undefined>().func(() => {}),
     ).toMatchTypeOf<(...args: any[]) => any>()
     expectTypeOf(
-      os.context<{ auth: boolean }>().handler(() => {}),
+      os.context<{ auth: boolean }>().func(() => {}),
     ).not.toMatchTypeOf<(...args: any[]) => any>()
   })
 
@@ -273,13 +273,13 @@ describe('server action', () => {
     const p = os
       .input(z.object({ id: z.number() }))
       .output(z.string())
-      .handler(() => 'string')
+      .func(() => 'string')
 
     expectTypeOf(p).toMatchTypeOf<
       (input: { id: number } | FormData) => Promise<string>
     >()
 
-    const p2 = os.input(z.object({ id: z.number() })).handler(() => 12333)
+    const p2 = os.input(z.object({ id: z.number() })).func(() => 12333)
 
     expectTypeOf(p2).toMatchTypeOf<
       (input: { id: number } | FormData) => Promise<number>
@@ -289,7 +289,7 @@ describe('server action', () => {
   it('works with input', async () => {
     const p = os
       .input(z.object({ id: z.number(), date: z.date() }))
-      .handler(async (input, context) => {
+      .func(async (input, context) => {
         expect(context).toBe(undefined)
         return input
       })
@@ -303,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)
+      .func(async input => input)
 
     const form = new FormData()
     form.append('id', '123')

package/src/procedure.ts

@@ -1,4 +1,5 @@
 import type { Promisable } from '@orpc/shared'
+import type { ProcedureCaller } from './procedure-caller'
 import type { Context, MergeContext, Meta } from './types'
 import {
   type ContractProcedure,
@@ -10,7 +11,6 @@ import {
   type SchemaInput,
   type SchemaOutput,
 } from '@orpc/contract'
-import { OpenAPIDeserializer } from '@orpc/transformer'
 import {
   decorateMiddleware,
   type MapInputMiddleware,
@@ -23,18 +23,18 @@ export class Procedure<
   TExtraContext extends Context,
   TInputSchema extends Schema,
   TOutputSchema extends Schema,
-  THandlerOutput extends SchemaOutput<TOutputSchema>,
+  TFuncOutput extends SchemaOutput<TOutputSchema>,
 > {
   constructor(
     public zz$p: {
       middlewares?: Middleware<any, any, any, any>[]
       contract: ContractProcedure<TInputSchema, TOutputSchema>
-      handler: ProcedureHandler<
+      func: ProcedureFunc<
         TContext,
         TExtraContext,
         TInputSchema,
         TOutputSchema,
-        THandlerOutput
+        TFuncOutput
       >
     },
   ) {}
@@ -45,13 +45,13 @@ export type DecoratedProcedure<
   TExtraContext extends Context,
   TInputSchema extends Schema,
   TOutputSchema extends Schema,
-  THandlerOutput extends SchemaOutput<TOutputSchema>,
+  TFuncOutput extends SchemaOutput<TOutputSchema>,
 > = Procedure<
   TContext,
   TExtraContext,
   TInputSchema,
   TOutputSchema,
-  THandlerOutput
+  TFuncOutput
 > & {
   prefix: (
     prefix: HTTPPath,
@@ -60,7 +60,7 @@ export type DecoratedProcedure<
     TExtraContext,
     TInputSchema,
     TOutputSchema,
-    THandlerOutput
+    TFuncOutput
   >
 
   route: (
@@ -70,7 +70,7 @@ export type DecoratedProcedure<
     TExtraContext,
     TInputSchema,
     TOutputSchema,
-    THandlerOutput
+    TFuncOutput
   >
 
   use: (<
@@ -82,14 +82,14 @@ export type DecoratedProcedure<
       MergeContext<TContext, TExtraContext>,
       UExtraContext,
       SchemaOutput<TInputSchema>,
-      SchemaInput<TOutputSchema, THandlerOutput>
+      SchemaInput<TOutputSchema, TFuncOutput>
     >,
   ) => DecoratedProcedure<
     TContext,
     MergeContext<TExtraContext, UExtraContext>,
     TInputSchema,
     TOutputSchema,
-    THandlerOutput
+    TFuncOutput
   >) & (<
     UExtraContext extends
     | Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>>
@@ -100,10 +100,10 @@ export type DecoratedProcedure<
       MergeContext<TContext, TExtraContext>,
       UExtraContext,
       UMappedInput,
-      SchemaInput<TOutputSchema, THandlerOutput>
+      SchemaInput<TOutputSchema, TFuncOutput>
     >,
     mapInput: MapInputMiddleware<
-      SchemaOutput<TInputSchema, THandlerOutput>,
+      SchemaOutput<TInputSchema, TFuncOutput>,
       UMappedInput
     >,
   ) => DecoratedProcedure<
@@ -111,15 +111,19 @@ export type DecoratedProcedure<
     MergeContext<TExtraContext, UExtraContext>,
     TInputSchema,
     TOutputSchema,
-    THandlerOutput
+    TFuncOutput
   >)
 } & (undefined extends TContext
-  ? (
-      input: SchemaInput<TInputSchema> | FormData,
-    ) => Promise<SchemaOutput<TOutputSchema, THandlerOutput>>
+  ? ProcedureCaller<Procedure<
+    TContext,
+    TExtraContext,
+    TInputSchema,
+    TOutputSchema,
+    TFuncOutput
+  >>
   : unknown)
 
-export interface ProcedureHandler<
+export interface ProcedureFunc<
   TContext extends Context,
   TExtraContext extends Context,
   TInputSchema extends Schema,
@@ -140,49 +144,30 @@ export function decorateProcedure<
   TExtraContext extends Context,
   TInputSchema extends Schema,
   TOutputSchema extends Schema,
-  THandlerOutput extends SchemaOutput<TOutputSchema>,
+  TFuncOutput extends SchemaOutput<TOutputSchema>,
 >(
   procedure: Procedure<
     TContext,
     TExtraContext,
     TInputSchema,
     TOutputSchema,
-    THandlerOutput
+    TFuncOutput
   >,
 ): DecoratedProcedure<
     TContext,
     TExtraContext,
     TInputSchema,
     TOutputSchema,
-    THandlerOutput
+    TFuncOutput
   > {
   if (DECORATED_PROCEDURE_SYMBOL in procedure) {
     return procedure as any
   }
 
-  const serverAction = async (input: unknown): Promise<SchemaOutput<TOutputSchema, THandlerOutput>> => {
-    const input_ = (() => {
-      if (!(input instanceof FormData))
-        return input
-
-      const transformer = new OpenAPIDeserializer({
-        schema: procedure.zz$p.contract.zz$cp.InputSchema,
-      })
-
-      return transformer.deserializeAsFormData(input)
-    })()
-
-    const procedureCaller = createProcedureCaller({
-      procedure,
-      context: undefined as any,
-      internal: false,
-      validate: true,
-    })
-
-    return await procedureCaller(input_ as any)
-  }
-
-  return Object.assign(serverAction, {
+  return Object.assign(createProcedureCaller({
+    procedure,
+    context: undefined as any,
+  }), {
     [DECORATED_PROCEDURE_SYMBOL]: true,
     zz$p: procedure.zz$p,
 
@@ -246,7 +231,7 @@ export function isProcedure(item: unknown): item is WELL_DEFINED_PROCEDURE {
     && 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'
+    && 'func' in item.zz$p
+    && typeof item.zz$p.func === 'function'
   )
 }

package/src/router-builder.test.ts

@@ -6,10 +6,10 @@ import { RouterBuilder } from './router-builder'
 const builder = new RouterBuilder<undefined, undefined>({})
 const ping = os
   .route({ method: 'GET', path: '/ping', tags: ['ping'] })
-  .handler(() => 'ping')
+  .func(() => 'ping')
 const pong = os
   .output(z.object({ id: z.string() }))
-  .handler(() => ({ id: '123' }))
+  .func(() => ({ id: '123' }))
 
 describe('prefix', () => {
   it('chainable prefix', () => {
@@ -80,7 +80,7 @@ describe('middleware', () => {
         InputSchema: undefined,
         OutputSchema: undefined,
       }),
-      handler: () => {},
+      func: () => {},
     })
 
     const decorated = decorateProcedure({
@@ -89,7 +89,7 @@ describe('middleware', () => {
           InputSchema: undefined,
           OutputSchema: undefined,
         }),
-        handler: () => {},
+        func: () => {},
       },
     })
 

package/src/router-caller.test.ts

@@ -2,24 +2,22 @@ import { z } from 'zod'
 import { createRouterCaller, os } from '.'
 
 describe('createRouterCaller', () => {
-  let internal = false
-  let context = { auth: true }
+  const internal = false
+  const context = { auth: true }
 
   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()) }))
-    .handler((input, context, meta) => {
+    .func((input, context, meta) => {
       expect(context).toEqual(context)
-      expect(meta.internal).toEqual(internal)
 
       return input
     })
 
-  const pong = osw.handler((_, context, meta) => {
+  const pong = osw.func((_, context, meta) => {
     expect(context).toEqual(context)
-    expect(meta.internal).toBe(internal)
 
     return { value: true }
   })
@@ -50,7 +48,6 @@ describe('createRouterCaller', () => {
     const caller = createRouterCaller({
       router,
       context,
-      internal,
     })
 
     expectTypeOf(caller.ping).toMatchTypeOf<
@@ -98,52 +95,8 @@ describe('createRouterCaller', () => {
     )
   })
 
-  it('without validate', () => {
-    internal = true
-    context = { auth: false }
-
-    const caller = createRouterCaller({
-      router,
-      context,
-      internal,
-      validate: false,
-    })
-
-    expectTypeOf(caller.ping).toMatchTypeOf<
-      (input: { value: number }) => Promise<{
-        value: number
-      }>
-    >()
-
-    expectTypeOf(caller.pong).toMatchTypeOf<
-      (input: unknown) => Promise<{
-        value: boolean
-      }>
-    >()
-
-    expectTypeOf(caller.nested.ping).toMatchTypeOf<
-      (input: { value: number }) => Promise<{
-        value: number
-      }>
-    >()
-
-    expectTypeOf(caller.nested.pong).toMatchTypeOf<
-      (input: unknown) => Promise<{
-        value: boolean
-      }>
-    >()
-
-    expect(caller.ping({ value: 123 })).resolves.toEqual({ value: 123 })
-    expect(caller.pong({ value: 123 })).resolves.toEqual({ value: true })
-    expect(caller.nested.ping({ value: 123 })).resolves.toEqual({ value: 123 })
-    expect(caller.nested.pong({ value: 123 })).resolves.toEqual({ value: true })
-
-    // @ts-expect-error it's not validate so bellow still works
-    expect(caller.ping({ value: '123' })).resolves.toEqual({ value: '123' })
-  })
-
   it('path', () => {
-    const ping = osw.handler((_, __, { path }) => {
+    const ping = osw.func((_, __, { path }) => {
       return path
     })
 

package/src/router-caller.ts

@@ -1,59 +1,43 @@
-import type {} from '@orpc/contract'
+import type { PromisableValue } from '@orpc/shared'
 import type { Router } from './router'
 import { isProcedure, type Procedure } from './procedure'
 import { createProcedureCaller, type ProcedureCaller } from './procedure-caller'
 
 export interface CreateRouterCallerOptions<
   TRouter extends Router<any>,
-  TValidate extends boolean,
 > {
   router: TRouter
 
   /**
    * The context used when calling the procedure.
    */
-  context: TRouter extends Router<infer UContext> ? UContext : never
+  context: PromisableValue<
+    TRouter extends Router<infer UContext> ? UContext : never
+  >
 
   /**
    * This is helpful for logging and analytics.
-   */
-  basePath?: string[]
-
-  /**
-   * This flag helpful when you want bypass some logics not necessary to internal server calls.
-   *
-   * @default true
-   */
-  internal?: boolean
-
-  /**
-   * Indicate whether validate input and output.
    *
-   * @default true
+   * @internal
    */
-  validate?: TValidate
+  basePath?: string[]
 }
 
 export type RouterCaller<
   TRouter extends Router<any>,
-  TValidate extends boolean,
 > = {
   [K in keyof TRouter]: TRouter[K] extends Procedure<any, any, any, any, any>
-    ? ProcedureCaller<TRouter[K], TValidate>
+    ? ProcedureCaller<TRouter[K]>
     : TRouter[K] extends Router<any>
-      ? RouterCaller<TRouter[K], TValidate>
+      ? RouterCaller<TRouter[K]>
       : never
 }
 
 export function createRouterCaller<
   TRouter extends Router<any>,
-  TValidate extends boolean = true,
 >(
-  options: CreateRouterCallerOptions<TRouter, TValidate>,
-): RouterCaller<TRouter, TValidate> {
-  const internal = options.internal ?? true
-  const validate = options.validate ?? true
-
+  options: CreateRouterCallerOptions<TRouter>,
+): RouterCaller<TRouter> {
   const caller: Record<string, unknown> = {}
 
   for (const key in options.router) {
@@ -65,8 +49,6 @@ export function createRouterCaller<
         procedure: item,
         context: options.context as any,
         path,
-        internal,
-        validate,
       })
     }
     else {
@@ -74,11 +56,9 @@ export function createRouterCaller<
         router: item as any,
         context: options.context,
         basePath: path,
-        internal,
-        validate,
       })
     }
   }
 
-  return caller as RouterCaller<TRouter, TValidate>
+  return caller as RouterCaller<TRouter>
 }

package/src/router-implementer.test.ts

@@ -17,15 +17,15 @@ const cr = oc.router({
 
 const osw = os.context<{ auth: boolean }>().contract(cr)
 
-const p1 = osw.p1.handler(() => {
+const p1 = osw.p1.func(() => {
   return 'unnoq'
 })
 
-const p2 = osw.nested.p2.handler(() => {
+const p2 = osw.nested.p2.func(() => {
   return 'unnoq'
 })
 
-const p3 = osw.nested2.p3.handler(() => {
+const p3 = osw.nested2.p3.func(() => {
   return 'unnoq'
 })
 
@@ -37,7 +37,7 @@ it('required all procedure match', () => {
   implementer.router({
     p1,
     nested: {
-      p2: os.contract(cp2).handler(() => ''),
+      p2: os.contract(cp2).func(() => ''),
     },
     nested2: {
       p3,
@@ -47,7 +47,7 @@ it('required all procedure match', () => {
   expect(() => {
     implementer.router({
       // @ts-expect-error p1 is mismatch
-      p1: os.handler(() => {}),
+      p1: os.func(() => {}),
       nested: {
         p2,
       },
@@ -76,7 +76,7 @@ it('required all procedure match', () => {
       p1: os
         .input(z.string())
         .output(z.string())
-        .handler(() => 'unnoq'),
+        .func(() => 'unnoq'),
       nested: {
         p2,
       },

package/src/router.test-d.ts

@@ -6,11 +6,11 @@ const router = os.router({
   ping: os
     .input(z.object({ ping: z.string().transform(() => 1) }))
     .output(z.object({ pong: z.number().transform(() => '1') }))
-    .handler(() => ({ pong: 1 })),
+    .func(() => ({ pong: 1 })),
   user: {
     find: os
       .input(z.object({ find: z.number().transform(() => '1') }))
-      .handler(() => ({ user: { id: 1 } }))
+      .func(() => ({ user: { id: 1 } }))
     ,
   },
 })

package/src/router.test.ts

@@ -6,22 +6,22 @@ it('require procedure match context', () => {
   const osw = os.context<{ auth: boolean, userId: string }>()
 
   osw.router({
-    ping: osw.context<{ auth: boolean }>().handler(() => {
+    ping: osw.context<{ auth: boolean }>().func(() => {
       return { pong: 'ping' }
     }),
 
     // @ts-expect-error userId is not match
-    ping2: osw.context<{ userId: number }>().handler(() => {
+    ping2: osw.context<{ userId: number }>().func(() => {
       return { name: 'unnoq' }
     }),
 
     nested: {
-      ping: osw.context<{ auth: boolean }>().handler(() => {
+      ping: osw.context<{ auth: boolean }>().func(() => {
         return { pong: 'ping' }
       }),
 
       // @ts-expect-error userId is not match
-      ping2: osw.context<{ userId: number }>().handler(() => {
+      ping2: osw.context<{ userId: number }>().func(() => {
         return { name: 'unnoq' }
       }),
     },
@@ -31,10 +31,10 @@ it('require procedure match context', () => {
 it('require match contract', () => {
   const pingContract = oc.route({ method: 'GET', path: '/ping' })
   const pongContract = oc.input(z.string()).output(z.string())
-  const ping = os.contract(pingContract).handler(() => {
+  const ping = os.contract(pingContract).func(() => {
     return 'ping'
   })
-  const pong = os.contract(pongContract).handler(() => {
+  const pong = os.contract(pongContract).func(() => {
     return 'pong'
   })
 
@@ -85,7 +85,7 @@ it('require match contract', () => {
     nested: {
       ping,
       // @ts-expect-error nested.pong is mismatch
-      pong: os.handler(() => 'ping'),
+      pong: os.func(() => 'ping'),
     },
   }
 
@@ -120,18 +120,18 @@ it('toContractRouter', () => {
   const osw = os.contract(contract)
 
   const router = osw.router({
-    p1: osw.p1.handler(() => {
+    p1: osw.p1.func(() => {
       return 'unnoq'
     }),
 
     nested: osw.nested.router({
-      p2: osw.nested.p2.handler(() => {
+      p2: osw.nested.p2.func(() => {
         return 'unnoq'
       }),
     }),
 
     nested2: {
-      p3: osw.nested2.p3.handler(() => {
+      p3: osw.nested2.p3.func(() => {
         return 'unnoq'
       }),
     },