@orpc/server 0.0.0

package/src/procedure-caller.ts

@@ -0,0 +1,165 @@
+import type { SchemaInput, SchemaOutput } from '@orpc/contract'
+import { ORPCError } from '@orpc/shared/error'
+import type { Middleware } from './middleware'
+import type { Procedure } from './procedure'
+import type { Context, Hooks, Meta, Promisable } from './types'
+import { hook, 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
+
+  /**
+   * Helpful hooks to do some logics on specific time.
+   */
+  hooks?: (
+    context: TProcedure extends Procedure<infer UContext, any, any, any, any>
+      ? UContext
+      : never,
+    meta: Meta<unknown>,
+  ) => Promisable<void>
+
+  /**
+   * 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?: boolean
+
+  /**
+   * Indicate whether validate input and output.
+   *
+   * @default true
+   */
+  validate?: TValidate
+}
+
+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
+>
+  ? (
+      input: TValidate extends true
+        ? SchemaInput<UInputSchema>
+        : SchemaOutput<UInputSchema>,
+    ) => Promise<
+      TValidate extends true
+        ? SchemaOutput<UOutputSchema, UHandlerOutput>
+        : SchemaInput<UOutputSchema, UHandlerOutput>
+    >
+  : 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
+  const path = options.path ?? []
+  const procedure = options.procedure
+  const validate = options.validate ?? true
+
+  const caller = async (input: unknown) => {
+    const handler = async (
+      input: unknown,
+      context: Context,
+      partialMeta: Omit<Meta<unknown>, keyof Hooks<unknown>>,
+      middlewares: Middleware<any, any, any, any>[],
+    ): Promise<unknown> => {
+      if (middlewares[0]) {
+        const [middleware, ...rest] = middlewares
+
+        return await hook(async (hooks) => {
+          const mid = await middleware(input, context, {
+            ...partialMeta,
+            ...hooks,
+          })
+          return await handler(
+            input,
+            mergeContext(context, mid?.context),
+            partialMeta,
+            rest,
+          )
+        })
+      }
+
+      return await hook(async (hooks) => {
+        const output = await procedure.zz$p.handler(input, context, {
+          ...partialMeta,
+          ...hooks,
+        })
+
+        const validOutput = await (async () => {
+          if (!validate) return output
+          const schema = procedure.zz$p.contract.zz$cp.OutputSchema
+          if (!schema) return output
+          const result = await schema.safeParseAsync(output)
+          if (result.error)
+            throw new ORPCError({
+              message: 'Validation output failed',
+              code: 'INTERNAL_SERVER_ERROR',
+              cause: result.error,
+            })
+          return result.data
+        })()
+
+        return validOutput
+      })
+    }
+
+    return await hook(async (hooks) => {
+      options.hooks?.(options.context, {
+        ...hooks,
+        path,
+        procedure,
+        internal,
+      })
+
+      const validInput = (() => {
+        if (!validate) return input
+        const schema = procedure.zz$p.contract.zz$cp.InputSchema
+        if (!schema) return input
+
+        try {
+          return schema.parse(input)
+        } catch (e) {
+          throw new ORPCError({
+            message: 'Validation input failed',
+            code: 'BAD_REQUEST',
+            cause: e,
+          })
+        }
+      })()
+
+      return await handler(
+        validInput,
+        options.context,
+        { path, procedure, internal },
+        procedure.zz$p.middlewares ?? [],
+      )
+    })
+  }
+
+  return caller as ProcedureCaller<TProcedure, TValidate>
+}

package/src/procedure-implementer.test.ts

@@ -0,0 +1,215 @@
+import { DecoratedContractProcedure } from '@orpc/contract'
+import { z } from 'zod'
+import { os, type DecoratedProcedure, type Meta, isProcedure } from '.'
+import { ProcedureImplementer } from './procedure-implementer'
+
+const p1 = new DecoratedContractProcedure({
+  InputSchema: undefined,
+  OutputSchema: undefined,
+  method: undefined,
+  path: undefined,
+})
+const implementer1 = new ProcedureImplementer<
+  { auth: boolean },
+  undefined,
+  undefined,
+  undefined
+>({ contract: p1 })
+
+const schema1 = z.object({ id: z.string() })
+const schema2 = z.object({ name: z.string() })
+
+const p2 = new DecoratedContractProcedure({
+  InputSchema: schema1,
+  OutputSchema: schema2,
+  method: 'GET',
+  path: '/test',
+})
+
+const implementer2 = new ProcedureImplementer<
+  { auth: boolean },
+  undefined,
+  typeof schema1,
+  typeof schema2
+>({ contract: p2 })
+
+describe('use middleware', () => {
+  it('infer types', () => {
+    const i = implementer1
+      .use((input, context, meta) => {
+        expectTypeOf(input).toEqualTypeOf<unknown>()
+        expectTypeOf(context).toEqualTypeOf<{ auth: boolean }>()
+        expectTypeOf(meta).toEqualTypeOf<Meta<unknown>>()
+
+        return {
+          context: {
+            userId: '1',
+          },
+        }
+      })
+      .use((input, context, meta) => {
+        expectTypeOf(input).toEqualTypeOf<unknown>()
+        expectTypeOf(context).toEqualTypeOf<
+          { userId: string } & { auth: boolean }
+        >()
+        expectTypeOf(meta).toEqualTypeOf<Meta<unknown>>()
+      })
+
+    expectTypeOf(i).toEqualTypeOf<
+      ProcedureImplementer<
+        { auth: boolean },
+        { userId: string },
+        undefined,
+        undefined
+      >
+    >()
+  })
+
+  it('map middleware input', () => {
+    // @ts-expect-error mismatch input
+    implementer2.use((input: { postId: string }) => {
+      return { context: { a: 'a' } }
+    })
+
+    implementer2.use(
+      (input: { postId: string }) => {
+        return { context: { a: 'a' } }
+      },
+      // @ts-expect-error mismatch input
+      (input) => ({ postId: 12455 }),
+    )
+
+    implementer2.use(
+      (input: { postId: string }) => {},
+      (input) => ({ postId: '12455' }),
+    )
+
+    const i = implementer2.use(
+      (input: { id: number }) => {
+        return {
+          context: {
+            userIdd: '1',
+          },
+        }
+      },
+      (input) => ({ id: Number.parseInt(input.id) }),
+    )
+
+    expectTypeOf(i).toEqualTypeOf<
+      ProcedureImplementer<
+        { auth: boolean },
+        { userIdd: string },
+        typeof schema1,
+        typeof schema2
+      >
+    >()
+  })
+})
+
+describe('output schema', () => {
+  it('auto infer output schema if output schema is not specified', async () => {
+    const sr = os.handler(() => ({ a: 1 }))
+
+    const result = await sr.zz$p.handler({}, undefined, {
+      method: 'GET',
+      path: '/',
+    } as any)
+
+    expectTypeOf(result).toEqualTypeOf<{ a: number }>()
+  })
+
+  it('not infer output schema if output schema is specified', async () => {
+    const srb1 = new ProcedureImplementer({
+      contract: new DecoratedContractProcedure({
+        OutputSchema: z.unknown(),
+        InputSchema: undefined,
+      }),
+    })
+
+    const sr = srb1.handler(() => ({ b: 1 }))
+
+    const result = await sr.zz$p.handler({}, {}, {
+      method: 'GET',
+      path: '/',
+    } as any)
+
+    expectTypeOf(result).toEqualTypeOf<unknown>()
+  })
+})
+
+describe('handler', () => {
+  it('infer types', () => {
+    const handler = implementer1.handler((input, context, meta) => {
+      expectTypeOf(input).toEqualTypeOf<unknown>()
+      expectTypeOf(context).toEqualTypeOf<{ auth: boolean }>()
+      expectTypeOf(meta).toEqualTypeOf<Meta<unknown>>()
+
+      return {
+        name: 'dinwwwh',
+      }
+    })
+
+    expectTypeOf(handler).toEqualTypeOf<
+      DecoratedProcedure<
+        { auth: boolean },
+        undefined,
+        undefined,
+        undefined,
+        { name: string }
+      >
+    >()
+    expect(isProcedure(handler)).toBe(true)
+
+    implementer2.handler((input, context, meta) => {
+      expectTypeOf(input).toEqualTypeOf<{ id: string }>()
+      expectTypeOf(context).toEqualTypeOf<{ auth: boolean }>()
+      expectTypeOf(meta).toEqualTypeOf<Meta<unknown>>()
+
+      return {
+        name: 'dinwwwh',
+      }
+    })
+
+    // @ts-expect-error mismatch output
+    implementer2.handler(() => {})
+  })
+
+  it('combine middlewares', () => {
+    const mid1 = () => {
+      return {
+        context: {
+          userId: '1',
+        },
+      }
+    }
+
+    const mid2 = () => {}
+
+    const handler = implementer2
+      .use(mid1)
+      .use(mid2)
+      .handler((input, context, meta) => {
+        expectTypeOf(input).toEqualTypeOf<{ id: string }>()
+        expectTypeOf(context).toEqualTypeOf<
+          { auth: boolean } & { userId: string }
+        >()
+        expectTypeOf(meta).toEqualTypeOf<Meta<unknown>>()
+
+        return {
+          name: 'dinwwwh',
+        }
+      })
+
+    expectTypeOf(handler).toEqualTypeOf<
+      DecoratedProcedure<
+        { auth: boolean },
+        { userId: string },
+        typeof schema1,
+        typeof schema2,
+        { name: string }
+      >
+    >()
+
+    expect(handler.zz$p.middlewares).toEqual([mid1, mid2])
+  })
+})

package/src/procedure-implementer.ts

@@ -0,0 +1,103 @@
+import type { ContractProcedure, SchemaOutput } from '@orpc/contract'
+import type { Schema } from '@orpc/contract'
+import {
+  type MapInputMiddleware,
+  type Middleware,
+  decorateMiddleware,
+} from './middleware'
+import {
+  type DecoratedProcedure,
+  type ProcedureHandler,
+  decorateProcedure,
+} from './procedure'
+import type { Context, MergeContext } from './types'
+
+export class ProcedureImplementer<
+  TContext extends Context,
+  TExtraContext extends Context,
+  TInputSchema extends Schema,
+  TOutputSchema extends Schema,
+> {
+  constructor(
+    public zz$pi: {
+      contract: ContractProcedure<TInputSchema, TOutputSchema>
+      middlewares?: Middleware<any, any, any, any>[]
+    },
+  ) {}
+
+  use<
+    UExtraContext extends
+      | Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>>
+      | undefined = undefined,
+  >(
+    middleware: Middleware<
+      MergeContext<TContext, TExtraContext>,
+      UExtraContext,
+      SchemaOutput<TInputSchema>,
+      SchemaOutput<TOutputSchema>
+    >,
+  ): ProcedureImplementer<
+    TContext,
+    MergeContext<TExtraContext, UExtraContext>,
+    TInputSchema,
+    TOutputSchema
+  >
+
+  use<
+    UExtraContext extends
+      | Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>>
+      | undefined = undefined,
+    UMappedInput = unknown,
+  >(
+    middleware: Middleware<
+      MergeContext<TContext, TExtraContext>,
+      UExtraContext,
+      UMappedInput,
+      SchemaOutput<TOutputSchema>
+    >,
+    mapInput: MapInputMiddleware<SchemaOutput<TInputSchema>, UMappedInput>,
+  ): ProcedureImplementer<
+    TContext,
+    MergeContext<TExtraContext, UExtraContext>,
+    TInputSchema,
+    TOutputSchema
+  >
+
+  use(
+    middleware: Middleware<any, any, any, any>,
+    mapInput?: MapInputMiddleware<any, any>,
+  ): ProcedureImplementer<any, any, any, any> {
+    const middleware_ = mapInput
+      ? decorateMiddleware(middleware).mapInput(mapInput)
+      : middleware
+
+    return new ProcedureImplementer({
+      ...this.zz$pi,
+      middlewares: [...(this.zz$pi.middlewares ?? []), middleware_],
+    })
+  }
+
+  handler<UHandlerOutput extends SchemaOutput<TOutputSchema>>(
+    handler: ProcedureHandler<
+      TContext,
+      TExtraContext,
+      TInputSchema,
+      TOutputSchema,
+      UHandlerOutput
+    >,
+  ): DecoratedProcedure<
+    TContext,
+    TExtraContext,
+    TInputSchema,
+    TOutputSchema,
+    UHandlerOutput
+  > {
+    return decorateProcedure({
+      zz$p: {
+        middlewares: this.zz$pi.middlewares,
+        contract: this.zz$pi.contract,
+        handler,
+      },
+    })
+  }
+}