@orpc/server 0.2.1 → 0.3.1

package/src/adapters/fetch.ts

@@ -3,6 +3,7 @@
 import type {
   PartialOnUndefinedDeep,
   Promisable,
+  Value,
 } from '@orpc/shared'
 import type { Router } from '../router'
 import {
@@ -16,6 +17,7 @@ import {
   isPlainObject,
   mapValues,
   trim,
+  value,
 } from '@orpc/shared'
 import { ORPCError } from '@orpc/shared/error'
 import {
@@ -91,6 +93,8 @@ export function createFetchHandler<TRouter extends Router<any>>(
       ? new ORPCSerializer()
       : new OpenAPISerializer({ accept })
 
+    const context = await value(requestOptions.context)
+
     const handler = async () => {
       const url = new URL(requestOptions.request.url)
       const pathname = `/${trim(url.pathname.replace(requestOptions.prefix ?? '', ''), '/')}`
@@ -196,9 +200,7 @@ export function createFetchHandler<TRouter extends Router<any>>(
       })()
 
       const caller = createProcedureCaller({
-        context: requestOptions.context,
-        internal: false,
-        validate: true,
+        context,
         procedure,
         path,
       })
@@ -214,7 +216,7 @@ export function createFetchHandler<TRouter extends Router<any>>(
     }
 
     try {
-      return await options.hooks?.(requestOptions.context as any, {
+      return await options.hooks?.(context as any, {
         next: handler,
         response: response => response,
       }) ?? await handler()
@@ -268,7 +270,9 @@ export type FetchHandlerOptions<TRouter extends Router<any>> = {
   /**
    * The context used to handle the request.
    */
-  context: TRouter extends Router<infer UContext> ? UContext : never
+  context: Value<
+    TRouter extends Router<infer UContext> ? UContext : never
+  >
 }>
 
 export interface FetchHandler<TRouter extends Router<any>> {

package/src/builder.test.ts

@@ -74,7 +74,7 @@ describe('use middleware', () => {
           return { postId: '1' }
         },
       )
-      .handler((_, context) => {
+      .func((_, context) => {
         expectTypeOf(context).toMatchTypeOf<{ user: string }>()
       })
   })
@@ -145,7 +145,7 @@ it('router method', () => {
   // Because of the router keyword is special, we can't use instanceof
   expect(osw.router.zz$pi.contract).toEqual(userFindContract)
   expect(
-    osw.router.handler(() => {
+    osw.router.func(() => {
       return { name: '' }
     }),
   ).toSatisfy(isProcedure)
@@ -286,7 +286,7 @@ describe('handler method', () => {
   it('without middlewares', () => {
     const osw = os.context<{ auth: boolean }>()
 
-    const procedure = osw.handler((input, context, meta) => {
+    const procedure = osw.func((input, context, meta) => {
       expectTypeOf(input).toEqualTypeOf<unknown>()
       expectTypeOf(context).toEqualTypeOf<{ auth: boolean }>()
       expectTypeOf(meta).toEqualTypeOf<Meta>()
@@ -317,7 +317,7 @@ describe('handler method', () => {
 
     const osw = os.context<{ auth: boolean }>().use(mid)
 
-    const procedure = osw.handler((input, context, meta) => {
+    const procedure = osw.func((input, context, meta) => {
       expectTypeOf(input).toEqualTypeOf<unknown>()
       expectTypeOf(context).toMatchTypeOf<{ auth: boolean }>()
       expectTypeOf(meta).toEqualTypeOf<Meta>()

package/src/builder.ts

@@ -20,7 +20,7 @@ import {
 import {
   type DecoratedProcedure,
   decorateProcedure,
-  type ProcedureHandler,
+  type ProcedureFunc,
 } from './procedure'
 import { ProcedureBuilder } from './procedure-builder'
 import { ProcedureImplementer } from './procedure-implementer'
@@ -137,20 +137,20 @@ export class Builder<TContext extends Context, TExtraContext extends Context> {
   /**
    * Convert to Procedure
    */
-  handler<UHandlerOutput = undefined>(
-    handler: ProcedureHandler<
+  func<UFuncOutput = undefined>(
+    func: ProcedureFunc<
       TContext,
       TExtraContext,
       undefined,
       undefined,
-      UHandlerOutput
+      UFuncOutput
     >,
   ): DecoratedProcedure<
       TContext,
       TExtraContext,
       undefined,
       undefined,
-      UHandlerOutput
+      UFuncOutput
     > {
     return decorateProcedure({
       zz$p: {
@@ -159,7 +159,7 @@ export class Builder<TContext extends Context, TExtraContext extends Context> {
           InputSchema: undefined,
           OutputSchema: undefined,
         }),
-        handler,
+        func,
       },
     })
   }

package/src/middleware.test.ts

@@ -249,7 +249,7 @@ it('middleware can output', async () => {
       mid2Called = true
       return meta.output('from middleware 2')
     })
-    .handler(() => {
+    .func(() => {
       handlerCalled = true
       return 'from handler'
     })

package/src/procedure-builder.test.ts

@@ -163,7 +163,7 @@ describe('use middleware', () => {
 
 describe('handler', () => {
   it('infer types', () => {
-    const handler = builder.handler((input, context, meta) => {
+    const handler = builder.func((input, context, meta) => {
       expectTypeOf(input).toEqualTypeOf<unknown>()
       expectTypeOf(context).toEqualTypeOf<{ auth: boolean }>()
       expectTypeOf(meta).toEqualTypeOf<Meta>()
@@ -196,7 +196,7 @@ describe('handler', () => {
     const handler = builder
       .use(mid1)
       .use(mid2)
-      .handler((input, context, meta) => {
+      .func((input, context, meta) => {
         expectTypeOf(input).toEqualTypeOf<unknown>()
         expectTypeOf(context).toEqualTypeOf<
           { userId: string } & { auth: boolean }

package/src/procedure-builder.ts

@@ -11,7 +11,7 @@ import {
 import {
   type DecoratedProcedure,
   decorateProcedure,
-  type ProcedureHandler,
+  type ProcedureFunc,
 } from './procedure'
 import { ProcedureImplementer } from './procedure-implementer'
 
@@ -132,26 +132,26 @@ export class ProcedureBuilder<
    * Convert to Procedure
    */
 
-  handler<UHandlerOutput extends SchemaOutput<TOutputSchema>>(
-    handler: ProcedureHandler<
+  func<UFuncOutput extends SchemaOutput<TOutputSchema>>(
+    func: ProcedureFunc<
       TContext,
       TExtraContext,
       TInputSchema,
       TOutputSchema,
-      UHandlerOutput
+      UFuncOutput
     >,
   ): DecoratedProcedure<
       TContext,
       TExtraContext,
       TInputSchema,
       TOutputSchema,
-      UHandlerOutput
+      UFuncOutput
     > {
     return decorateProcedure({
       zz$p: {
         middlewares: this.zz$pb.middlewares,
         contract: this.zz$pb.contract,
-        handler,
+        func,
       },
     })
   }

package/src/procedure-caller.test.ts

@@ -2,17 +2,15 @@ import { z } from 'zod'
 import { createProcedureCaller, os } from '.'
 
 describe('createProcedureCaller', () => {
-  let internal = false
-  let path = ['ping']
-  let context = { auth: true }
+  const path = ['ping']
+  const context = { auth: true }
 
   const osw = os.context<{ auth?: boolean }>()
   const procedure = 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).toBe(internal)
       expect(meta.path).toBe(path)
 
       return input
@@ -34,8 +32,7 @@ describe('createProcedureCaller', () => {
   it('with validate', async () => {
     const caller = createProcedureCaller({
       procedure,
-      context,
-      internal,
+      context: async () => context,
       path,
     })
 
@@ -53,41 +50,14 @@ describe('createProcedureCaller', () => {
     )
   })
 
-  it('without validate', async () => {
-    internal = true
-    path = []
-    context = { auth: false }
-
-    const caller = createProcedureCaller({
-      procedure,
-      context,
-      internal,
-      path,
-      validate: false,
-    })
-
-    expectTypeOf(caller).toMatchTypeOf<
-      (input: { value: number }) => Promise<{
-        value: number
-      }>
-    >()
-
-    expect(await caller({ value: 123 })).toEqual({ value: 123 })
-
-    // @ts-expect-error it's not validate so bellow still works
-    expect(await caller({ value: '123' })).toEqual({ value: '123' })
-  })
-
   it('without validate and schema', () => {
-    const procedure = osw.handler(() => {
+    const procedure = osw.func(() => {
       return { value: true }
     })
 
     const caller = createProcedureCaller({
       procedure,
       context,
-      internal,
-      validate: false,
     })
 
     expectTypeOf(caller).toMatchTypeOf<
@@ -146,7 +116,7 @@ describe('createProcedureCaller', () => {
       .input(z.object({ id: z.string() }))
       .use(mid1)
       .use(mid2)
-      .handler((input, context, meta) => {
+      .func((input, context, meta) => {
         expect(context).toEqual({ userId: '1', auth: false })
 
         expect(ref.value).toBe(2)
@@ -162,4 +132,25 @@ describe('createProcedureCaller', () => {
 
     expect(caller({ id: '1' })).resolves.toEqual('pong')
   })
+
+  it('accept form data', async () => {
+    const ping = osw
+      .input(z.object({ id: z.number() }))
+      .output(z.object({ id: z.number() }))
+      .func((input, context, meta) => {
+        expect(context).toEqual(context)
+
+        return input
+      })
+
+    const caller = createProcedureCaller({
+      procedure: ping,
+      context,
+    })
+
+    const form = new FormData()
+    form.append('id', '1')
+
+    expect(await caller(form)).toEqual({ id: 1 })
+  })
 })

package/src/procedure-caller.ts

@@ -2,84 +2,78 @@ import type { SchemaInput, SchemaOutput } from '@orpc/contract'
 import type { MiddlewareMeta } from './middleware'
 import type { Procedure } from './procedure'
 import type { Context } from './types'
+import { type Value, value } from '@orpc/shared'
 import { ORPCError } from '@orpc/shared/error'
+import { OpenAPIDeserializer } from '@orpc/transformer'
 import { mergeContext } from './utils'
 
 export interface CreateProcedureCallerOptions<
   TProcedure extends Procedure<any, any, any, any, any>,
-  TValidate extends boolean,
 > {
   procedure: TProcedure
 
   /**
    * The context used when calling the procedure.
    */
-  context: TProcedure extends Procedure<infer UContext, any, any, any, any>
-    ? UContext
-    : never
+  context: Value<
+    TProcedure extends Procedure<infer UContext, any, any, any, any>
+      ? UContext
+      : never
+  >
 
   /**
    * This is helpful for logging and analytics.
-   */
-  path?: string[]
-
-  /**
-   * This flag helpful when you want bypass some logics not necessary to internal server calls.
    *
-   * @default true
+   * @internal
    */
-  internal?: boolean
-
-  /**
-   * Indicate whether validate input and output.
-   *
-   * @default true
-   */
-  validate?: TValidate
+  path?: string[]
 }
 
 export type ProcedureCaller<
   TProcedure extends Procedure<any, any, any, any, any>,
-  TValidate extends boolean,
 > = TProcedure extends Procedure<
   any,
   any,
   infer UInputSchema,
   infer UOutputSchema,
-  infer UHandlerOutput
+  infer UFuncOutput
 >
   ? (
-      input: TValidate extends true
-        ? SchemaInput<UInputSchema>
-        : SchemaOutput<UInputSchema>,
+      input: SchemaInput<UInputSchema> | FormData,
     ) => Promise<
-      TValidate extends true
-        ? SchemaOutput<UOutputSchema, UHandlerOutput>
-        : SchemaInput<UOutputSchema, UHandlerOutput>
+      SchemaOutput<UOutputSchema, UFuncOutput>
     >
   : never
 
 export function createProcedureCaller<
   TProcedure extends Procedure<any, any, any, any, any>,
-  TValidate extends boolean = true,
 >(
-  options: CreateProcedureCallerOptions<TProcedure, TValidate>,
-): ProcedureCaller<TProcedure, TValidate> {
-  const internal = options.internal ?? true
+  options: CreateProcedureCallerOptions<TProcedure>,
+): ProcedureCaller<TProcedure> {
   const path = options.path ?? []
   const procedure = options.procedure
-  const validate = options.validate ?? true
 
   const caller = async (input: unknown): Promise<unknown> => {
-    const validInput = (() => {
-      if (!validate)
+    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 validInput = (() => {
       const schema = procedure.zz$p.contract.zz$cp.InputSchema
-      if (!schema)
-        return input
+      if (!schema) {
+        return input_
+      }
 
       try {
-        return schema.parse(input)
+        return schema.parse(input_)
       }
       catch (e) {
         throw new ORPCError({
@@ -92,7 +86,7 @@ export function createProcedureCaller<
 
     const middlewares = procedure.zz$p.middlewares ?? []
     let currentMidIndex = 0
-    let currentContext: Context = options.context
+    let currentContext: Context = await value(options.context)
 
     const next: MiddlewareMeta<unknown>['next'] = async (nextOptions) => {
       const mid = middlewares[currentMidIndex]
@@ -103,17 +97,15 @@ export function createProcedureCaller<
         return await mid(validInput, currentContext, {
           path,
           procedure,
-          internal,
           next,
           output: output => ({ output, context: undefined }),
         })
       }
       else {
         return {
-          output: await await procedure.zz$p.handler(validInput, currentContext, {
+          output: await await procedure.zz$p.func(validInput, currentContext, {
             path,
             procedure,
-            internal,
           }),
           context: currentContext,
         }
@@ -123,11 +115,11 @@ export function createProcedureCaller<
     const output = (await next({})).output
 
     const validOutput = await (async () => {
-      if (!validate)
-        return output
       const schema = procedure.zz$p.contract.zz$cp.OutputSchema
-      if (!schema)
+      if (!schema) {
         return output
+      }
+
       const result = await schema.safeParseAsync(output)
       if (result.error) {
         throw new ORPCError({
@@ -142,5 +134,5 @@ export function createProcedureCaller<
     return validOutput
   }
 
-  return caller as ProcedureCaller<TProcedure, TValidate>
+  return caller as ProcedureCaller<TProcedure>
 }

package/src/procedure-implementer.test.ts

@@ -111,9 +111,9 @@ describe('use middleware', () => {
 
 describe('output schema', () => {
   it('auto infer output schema if output schema is not specified', async () => {
-    const sr = os.handler(() => ({ a: 1 }))
+    const sr = os.func(() => ({ a: 1 }))
 
-    const result = await sr.zz$p.handler({}, undefined, {
+    const result = await sr.zz$p.func({}, undefined, {
       method: 'GET',
       path: '/',
     } as any)
@@ -129,9 +129,9 @@ describe('output schema', () => {
       }),
     })
 
-    const sr = srb1.handler(() => ({ b: 1 }))
+    const sr = srb1.func(() => ({ b: 1 }))
 
-    const result = await sr.zz$p.handler({}, {}, {
+    const result = await sr.zz$p.func({}, {}, {
       method: 'GET',
       path: '/',
     } as any)
@@ -142,7 +142,7 @@ describe('output schema', () => {
 
 describe('handler', () => {
   it('infer types', () => {
-    const handler = implementer1.handler((input, context, meta) => {
+    const handler = implementer1.func((input, context, meta) => {
       expectTypeOf(input).toEqualTypeOf<unknown>()
       expectTypeOf(context).toEqualTypeOf<{ auth: boolean }>()
       expectTypeOf(meta).toEqualTypeOf<Meta>()
@@ -163,7 +163,7 @@ describe('handler', () => {
     >()
     expect(isProcedure(handler)).toBe(true)
 
-    implementer2.handler((input, context, meta) => {
+    implementer2.func((input, context, meta) => {
       expectTypeOf(input).toEqualTypeOf<{ id: string }>()
       expectTypeOf(context).toEqualTypeOf<{ auth: boolean }>()
       expectTypeOf(meta).toEqualTypeOf<Meta>()
@@ -174,7 +174,7 @@ describe('handler', () => {
     })
 
     // @ts-expect-error mismatch output
-    implementer2.handler(() => {})
+    implementer2.func(() => {})
   })
 
   it('combine middlewares', () => {
@@ -193,7 +193,7 @@ describe('handler', () => {
     const handler = implementer2
       .use(mid1)
       .use(mid2)
-      .handler((input, context, meta) => {
+      .func((input, context, meta) => {
         expectTypeOf(input).toEqualTypeOf<{ id: string }>()
         expectTypeOf(context).toEqualTypeOf<
           { auth: boolean } & { userId: string }

package/src/procedure-implementer.ts

@@ -8,7 +8,7 @@ import {
 import {
   type DecoratedProcedure,
   decorateProcedure,
-  type ProcedureHandler,
+  type ProcedureFunc,
 } from './procedure'
 
 export class ProcedureImplementer<
@@ -76,26 +76,26 @@ export class ProcedureImplementer<
     })
   }
 
-  handler<UHandlerOutput extends SchemaOutput<TOutputSchema>>(
-    handler: ProcedureHandler<
+  func<UFuncOutput extends SchemaOutput<TOutputSchema>>(
+    func: ProcedureFunc<
       TContext,
       TExtraContext,
       TInputSchema,
       TOutputSchema,
-      UHandlerOutput
+      UFuncOutput
     >,
   ): DecoratedProcedure<
       TContext,
       TExtraContext,
       TInputSchema,
       TOutputSchema,
-      UHandlerOutput
+      UFuncOutput
     > {
     return decorateProcedure({
       zz$p: {
         middlewares: this.zz$pi.middlewares,
         contract: this.zz$pi.contract,
-        handler,
+        func,
       },
     })
   }