@orpc/server 0.0.0

package/src/router.test.ts

@@ -0,0 +1,142 @@
+import { oc } from '@orpc/contract'
+import { z } from 'zod'
+import { os, type RouterWithContract, toContractRouter } from '.'
+
+it('require procedure match context', () => {
+  const osw = os.context<{ auth: boolean; userId: string }>()
+
+  osw.router({
+    ping: osw.context<{ auth: boolean }>().handler(() => {
+      return { pong: 'ping' }
+    }),
+
+    // @ts-expect-error userId is not match
+    ping2: osw.context<{ userId: number }>().handler(() => {
+      return { name: 'dinwwwh' }
+    }),
+
+    nested: {
+      ping: osw.context<{ auth: boolean }>().handler(() => {
+        return { pong: 'ping' }
+      }),
+
+      // @ts-expect-error userId is not match
+      ping2: osw.context<{ userId: number }>().handler(() => {
+        return { name: 'dinwwwh' }
+      }),
+    },
+  })
+})
+
+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(() => {
+    return 'ping'
+  })
+  const pong = os.contract(pongContract).handler(() => {
+    return 'pong'
+  })
+
+  const contract = oc.router({
+    ping: pingContract,
+    pong: pongContract,
+
+    nested: oc.router({
+      ping: pingContract,
+      pong: pongContract,
+    }),
+  })
+
+  const _1: RouterWithContract<undefined, typeof contract> = {
+    ping,
+    pong,
+
+    nested: {
+      ping,
+      pong,
+    },
+  }
+
+  const _2: RouterWithContract<undefined, typeof contract> = {
+    ping,
+    pong,
+
+    nested: os.contract(contract.nested).router({
+      ping,
+      pong,
+    }),
+  }
+
+  const _3: RouterWithContract<undefined, typeof contract> = {
+    ping,
+    pong,
+
+    // @ts-expect-error missing nested.ping
+    nested: {
+      pong,
+    },
+  }
+
+  const _4: RouterWithContract<undefined, typeof contract> = {
+    ping,
+    pong,
+
+    nested: {
+      ping,
+      // @ts-expect-error nested.pong is mismatch
+      pong: os.handler(() => 'ping'),
+    },
+  }
+
+  // @ts-expect-error missing pong
+  const _5: RouterWithContract<undefined, typeof contract> = {
+    ping,
+
+    nested: {
+      ping,
+      pong,
+    },
+  }
+})
+
+it('toContractRouter', () => {
+  const p1 = oc.input(z.string()).output(z.string())
+  const p2 = oc.output(z.string())
+  const p3 = oc.route({ method: 'GET', path: '/test' })
+
+  const contract = oc.router({
+    p1: p1,
+
+    nested: oc.router({
+      p2: p2,
+    }),
+
+    nested2: {
+      p3: p3,
+    },
+  })
+
+  const osw = os.contract(contract)
+
+  const router = osw.router({
+    p1: osw.p1.handler(() => {
+      return 'dinwwwh'
+    }),
+
+    nested: osw.nested.router({
+      p2: osw.nested.p2.handler(() => {
+        return 'dinwwwh'
+      }),
+    }),
+
+    nested2: {
+      p3: osw.nested2.p3.handler(() => {
+        return 'dinwwwh'
+      }),
+    },
+  })
+
+  expect(toContractRouter(router)).toEqual(contract)
+  expect(toContractRouter(contract)).toEqual(contract)
+})

package/src/router.ts

@@ -0,0 +1,69 @@
+import {
+  type ContractProcedure,
+  type ContractRouter,
+  isContractProcedure,
+} from '@orpc/contract'
+import {
+  type DecoratedProcedure,
+  type Procedure,
+  isProcedure,
+} from './procedure'
+import type { Context } from './types'
+
+export interface Router<TContext extends Context> {
+  [k: string]: Procedure<TContext, any, any, any, any> | Router<TContext>
+}
+
+export type HandledRouter<TRouter extends Router<any>> = {
+  [K in keyof TRouter]: TRouter[K] extends Procedure<
+    infer UContext,
+    infer UExtraContext,
+    infer UInputSchema,
+    infer UOutputSchema,
+    infer UHandlerOutput
+  >
+    ? DecoratedProcedure<
+        UContext,
+        UExtraContext,
+        UInputSchema,
+        UOutputSchema,
+        UHandlerOutput
+      >
+    : TRouter[K] extends Router<any>
+      ? HandledRouter<TRouter[K]>
+      : never
+}
+
+export type RouterWithContract<
+  TContext extends Context,
+  TContract extends ContractRouter,
+> = {
+  [K in keyof TContract]: TContract[K] extends ContractProcedure<
+    infer UInputSchema,
+    infer UOutputSchema
+  >
+    ? Procedure<TContext, any, UInputSchema, UOutputSchema, any>
+    : TContract[K] extends ContractRouter
+      ? RouterWithContract<TContext, TContract[K]>
+      : never
+}
+
+export function toContractRouter(
+  router: ContractRouter | Router<any>,
+): ContractRouter {
+  const contract: ContractRouter = {}
+
+  for (const key in router) {
+    const item = router[key]
+
+    if (isContractProcedure(item)) {
+      contract[key] = item
+    } else if (isProcedure(item)) {
+      contract[key] = item.zz$p.contract
+    } else {
+      contract[key] = toContractRouter(item as any)
+    }
+  }
+
+  return contract
+}

package/src/types.test.ts

@@ -0,0 +1,18 @@
+import type { MergeContext } from './types'
+
+test('MergeContext', () => {
+  expectTypeOf<MergeContext<undefined, undefined>>().toEqualTypeOf<undefined>()
+  expectTypeOf<MergeContext<undefined, { foo: string }>>().toEqualTypeOf<{
+    foo: string
+  }>()
+  expectTypeOf<MergeContext<{ foo: string }, undefined>>().toEqualTypeOf<{
+    foo: string
+  }>()
+  expectTypeOf<MergeContext<{ foo: string }, { foo: string }>>().toEqualTypeOf<{
+    foo: string
+  }>()
+  expectTypeOf<MergeContext<{ foo: string }, { bar: string }>>().toMatchTypeOf<{
+    foo: string
+    bar: string
+  }>()
+})

package/src/types.ts

@@ -0,0 +1,28 @@
+import type { WELL_DEFINED_PROCEDURE } from './procedure'
+
+export type Context = Record<string, unknown> | undefined
+
+export type MergeContext<
+  TA extends Context,
+  TB extends Context,
+> = TA extends undefined ? TB : TB extends undefined ? TA : TA & TB
+
+export interface Meta<T> extends Hooks<T> {
+  path: string[]
+  internal: boolean
+  procedure: WELL_DEFINED_PROCEDURE
+}
+
+export type Promisable<T> = T | Promise<T>
+
+export interface UnsubscribeFn {
+  (): void
+}
+
+export interface Hooks<T> {
+  onSuccess: (fn: (output: T) => Promisable<void>) => UnsubscribeFn
+  onError: (fn: (error: unknown) => Promisable<void>) => UnsubscribeFn
+  onFinish: (
+    fn: (output: T | undefined, error: unknown | undefined) => Promisable<void>,
+  ) => UnsubscribeFn
+}

package/src/utils.test.ts

@@ -0,0 +1,243 @@
+import { hook, mergeContext } from './utils'
+
+test('mergeContext', () => {
+  expect(mergeContext(undefined, undefined)).toBe(undefined)
+  expect(mergeContext(undefined, { foo: 'bar' })).toEqual({ foo: 'bar' })
+  expect(mergeContext({ foo: 'bar' }, undefined)).toEqual({ foo: 'bar' })
+  expect(mergeContext({ foo: 'bar' }, { foo: 'bar' })).toEqual({ foo: 'bar' })
+  expect(mergeContext({ foo: 'bar' }, { bar: 'bar' })).toEqual({
+    foo: 'bar',
+    bar: 'bar',
+  })
+  expect(mergeContext({ foo: 'bar' }, { bar: 'bar', foo: 'bar1' })).toEqual({
+    foo: 'bar1',
+    bar: 'bar',
+  })
+})
+
+describe('hook', async () => {
+  it('on success', async () => {
+    const onSuccess = vi.fn()
+    const onError = vi.fn()
+    const onFinish = vi.fn()
+
+    await hook(async (hooks) => {
+      hooks.onSuccess(onSuccess)
+      hooks.onError(onError)
+      hooks.onFinish(onFinish)
+
+      return 'foo'
+    })
+
+    expect(onSuccess).toHaveBeenCalledWith('foo')
+    expect(onError).not.toHaveBeenCalled()
+    expect(onFinish).toHaveBeenCalledWith('foo', undefined)
+  })
+
+  it('on failed', async () => {
+    const onSuccess = vi.fn()
+    const onError = vi.fn()
+    const onFinish = vi.fn()
+    const error = new Error('foo')
+
+    try {
+      await hook(async (hooks) => {
+        hooks.onSuccess(onSuccess)
+        hooks.onError(onError)
+        hooks.onFinish(onFinish)
+
+        throw error
+      })
+    } catch (e) {
+      expect(e).toBe(error)
+    }
+
+    expect(onSuccess).not.toHaveBeenCalled()
+    expect(onError).toHaveBeenCalledWith(error)
+    expect(onFinish).toHaveBeenCalledWith(undefined, error)
+  })
+
+  it('throw the last error', async () => {
+    const error = new Error('foo')
+    const error1 = new Error('1')
+    const error2 = new Error('2')
+
+    try {
+      await hook(async (hooks) => {
+        hooks.onSuccess(() => {
+          throw error
+        })
+      })
+    } catch (e) {
+      expect(e).toBe(error)
+    }
+
+    try {
+      await hook(async (hooks) => {
+        hooks.onError(() => {
+          throw error1
+        })
+      })
+    } catch (e) {
+      expect(e).toBe(error1)
+    }
+
+    try {
+      await hook(async (hooks) => {
+        hooks.onFinish(() => {
+          throw error2
+        })
+      })
+    } catch (e) {
+      expect(e).toBe(error2)
+    }
+
+    try {
+      await hook(async (hooks) => {
+        hooks.onError((e) => {
+          expect(e).toBe(error)
+          throw error1
+        })
+        hooks.onFinish((_, error) => {
+          expect(error).toBe(error1)
+          throw error2
+        })
+
+        throw error
+      })
+    } catch (e) {
+      expect(e).toBe(error2)
+    }
+  })
+
+  it('Fist In Last Out', async () => {
+    const ref = { value: 0 }
+    const hooked = hook(async (hooks) => {
+      hooks.onSuccess(() => {
+        expect(ref).toEqual({ value: 2 })
+        ref.value++
+      })
+      hooks.onSuccess(() => {
+        expect(ref).toEqual({ value: 1 })
+        ref.value++
+      })
+      hooks.onSuccess(() => {
+        expect(ref).toEqual({ value: 0 })
+        ref.value++
+      })
+
+      hooks.onFinish(() => {
+        expect(ref).toEqual({ value: 5 })
+        ref.value++
+      })
+      hooks.onFinish(() => {
+        expect(ref).toEqual({ value: 4 })
+        ref.value++
+      })
+      hooks.onFinish(() => {
+        expect(ref).toEqual({ value: 3 })
+        ref.value++
+      })
+    })
+
+    await expect(hooked).resolves.toEqual(undefined)
+    expect(ref).toEqual({ value: 6 })
+  })
+
+  it('Fist In Last Out - onError', async () => {
+    const ref = { value: 0 }
+    const hooked = hook(async (hooks) => {
+      hooks.onError(() => {
+        expect(ref).toEqual({ value: 2 })
+        ref.value++
+      })
+      hooks.onError(() => {
+        expect(ref).toEqual({ value: 1 })
+        ref.value++
+      })
+      hooks.onError(() => {
+        expect(ref).toEqual({ value: 0 })
+        ref.value++
+      })
+
+      hooks.onFinish(() => {
+        expect(ref).toEqual({ value: 5 })
+        ref.value++
+      })
+      hooks.onFinish(() => {
+        expect(ref).toEqual({ value: 4 })
+        ref.value++
+      })
+      hooks.onFinish(() => {
+        expect(ref).toEqual({ value: 3 })
+        ref.value++
+      })
+
+      throw new Error('foo')
+    })
+
+    await expect(hooked).rejects.toThrow('foo')
+    expect(ref).toEqual({ value: 6 })
+  })
+
+  it('ensure run every onSuccess and onFinish even on throw many times', async () => {
+    const error = new Error('foo')
+    const error1 = new Error('1')
+    const error2 = new Error('2')
+
+    const onError = vi.fn(() => {
+      throw error
+    })
+    const onFinish = vi.fn(() => {
+      throw error1
+    })
+
+    try {
+      await hook(async (hooks) => {
+        hooks.onError(onError)
+        hooks.onError(onError)
+        hooks.onError(onError)
+        hooks.onFinish(onFinish)
+        hooks.onFinish(onFinish)
+        hooks.onFinish(onFinish)
+
+        throw error2
+      })
+    } catch (e) {
+      expect(e).toBe(error1)
+    }
+
+    expect(onError).toHaveBeenCalledTimes(3)
+    expect(onFinish).toHaveBeenCalledTimes(3)
+  })
+
+  it('can unsubscribe', async () => {
+    const onSuccess = vi.fn()
+    const onError = vi.fn()
+    const onFinish = vi.fn()
+
+    await hook(async (hooks) => {
+      hooks.onSuccess(onSuccess)()
+      hooks.onSuccess(onSuccess)()
+      hooks.onError(onError)()
+      hooks.onFinish(onFinish)()
+
+      return 'foo'
+    })
+
+    await expect(
+      hook(async (hooks) => {
+        hooks.onSuccess(onSuccess)()
+        hooks.onSuccess(onSuccess)()
+        hooks.onError(onError)()
+        hooks.onFinish(onFinish)()
+
+        throw new Error('foo')
+      }),
+    ).rejects.toThrow('foo')
+
+    expect(onSuccess).not.toHaveBeenCalled()
+    expect(onError).not.toHaveBeenCalled()
+    expect(onFinish).not.toHaveBeenCalled()
+  })
+})

package/src/utils.ts

@@ -0,0 +1,95 @@
+import type { Context, Hooks, MergeContext, Promisable } from './types'
+
+export function mergeContext<A extends Context, B extends Context>(
+  a: A,
+  b: B,
+): MergeContext<A, B> {
+  if (!a) return b as any
+  if (!b) return a as any
+
+  return {
+    ...a,
+    ...b,
+  } as any
+}
+
+export async function hook<T>(
+  fn: (hooks: Hooks<T>) => Promisable<T>,
+): Promise<T> {
+  const onSuccessFns: ((output: T) => Promisable<void>)[] = []
+  const onErrorFns: ((error: unknown) => Promisable<void>)[] = []
+  const onFinishFns: ((
+    output: T | undefined,
+    error: unknown | undefined,
+  ) => Promisable<void>)[] = []
+
+  const hooks: Hooks<T> = {
+    onSuccess(fn) {
+      onSuccessFns.unshift(fn)
+
+      return () => {
+        const index = onSuccessFns.indexOf(fn)
+        if (index !== -1) onSuccessFns.splice(index, 1)
+      }
+    },
+
+    onError(fn) {
+      onErrorFns.unshift(fn)
+
+      return () => {
+        const index = onErrorFns.indexOf(fn)
+        if (index !== -1) onErrorFns.splice(index, 1)
+      }
+    },
+
+    onFinish(fn) {
+      onFinishFns.unshift(fn)
+
+      return () => {
+        const index = onFinishFns.indexOf(fn)
+        if (index !== -1) onFinishFns.splice(index, 1)
+      }
+    },
+  }
+
+  let error: unknown = undefined
+  let output: T | undefined = undefined
+
+  try {
+    output = await fn(hooks)
+
+    for (const onSuccessFn of onSuccessFns) {
+      await onSuccessFn(output)
+    }
+
+    return output
+  } catch (e) {
+    error = e
+
+    for (const onErrorFn of onErrorFns) {
+      try {
+        await onErrorFn(error)
+      } catch (e) {
+        error = e
+      }
+    }
+
+    throw error
+  } finally {
+    let hasNewError = false
+
+    for (const onFinishFn of onFinishFns) {
+      try {
+        await onFinishFn(output, error)
+      } catch (e) {
+        error = e
+        hasNewError = true
+      }
+    }
+
+    if (hasNewError) {
+      // biome-ignore lint/correctness/noUnsafeFinally: this behavior is expected
+      throw error
+    }
+  }
+}