@orpc/client 1.0.1 → 1.0.3

package/src/router.test.ts

@@ -1,148 +0,0 @@
-import { oc } from '@orpc/contract'
-import { os } from '@orpc/server'
-import { createFetchHandler } from '@orpc/server/fetch'
-import { z } from 'zod'
-import { createRouterClient } from './router'
-
-describe('createRouterClient', () => {
-  const schema = z.object({
-    value: z.string(),
-  })
-  const ping = os.input(schema).handler((_, __, { path }) => path)
-  const router = os.router({
-    ping,
-    nested: {
-      unique: ping,
-    },
-  })
-  const handler = createFetchHandler({
-    router,
-  })
-  const orpcFetch: typeof fetch = async (...args) => {
-    const request = new Request(...args)
-    return await handler({
-      prefix: '/orpc',
-      request,
-      context: {},
-    })
-  }
-
-  it('types with contract router', () => {
-    const schema = z.object({
-      value: z.string(),
-    })
-
-    const ping = oc.input(schema)
-    const pong = oc.output(schema)
-    const peng = oc.route({})
-    const router = oc.router({
-      ping,
-      pong,
-      peng,
-      nested: {
-        unique: ping,
-      },
-    })
-
-    const client = createRouterClient<typeof router>({} as any)
-
-    expectTypeOf(client.ping).toEqualTypeOf<
-      (input: { value: string }) => Promise<unknown>
-    >()
-    expectTypeOf(client.pong).toEqualTypeOf<
-      (input: unknown) => Promise<{ value: string }>
-    >()
-    expectTypeOf(client.peng).toEqualTypeOf<
-      (input: unknown) => Promise<unknown>
-    >()
-
-    expectTypeOf(client.nested.unique).toEqualTypeOf<
-      (input: { value: string }) => Promise<unknown>
-    >()
-  })
-
-  it('types with router', () => {
-    const schema = z.object({
-      value: z.string(),
-    })
-    const ping = os.input(schema).handler(() => '')
-    const pong = os.output(schema).handler(() => ({ value: 'string' }))
-    const peng = os.route({}).handler(() => ({ age: 1244 }))
-
-    const router = os.router({
-      ping,
-      pong,
-      peng,
-      nested: {
-        unique: ping,
-      },
-    })
-
-    const client = createRouterClient<typeof router>({} as any)
-
-    expectTypeOf(client.ping).toEqualTypeOf<
-      (input: { value: string }) => Promise<string>
-    >()
-    expectTypeOf(client.pong).toEqualTypeOf<
-      (input: unknown) => Promise<{ value: string }>
-    >()
-    expectTypeOf(client.peng).toEqualTypeOf<
-      (input: unknown) => Promise<{ age: number }>
-    >()
-    expectTypeOf(client.nested.unique).toEqualTypeOf<
-      (input: { value: string }) => Promise<string>
-    >()
-  })
-
-  it('simple', async () => {
-    const client = createRouterClient<typeof router>({
-      baseURL: 'http://localhost:3000/orpc',
-      fetch: orpcFetch,
-    })
-
-    const result = await client.ping({ value: 'hello' })
-    expect(result).toEqual(['ping'])
-
-    const result2 = await client.nested.unique({ value: 'hello' })
-    expect(result2).toEqual(['nested', 'unique'])
-  })
-
-  it('on error', () => {
-    const client = createRouterClient<typeof router>({
-      baseURL: 'http://localhost:3000/orpc',
-      fetch: orpcFetch,
-    })
-
-    // @ts-expect-error - invalid input
-    expect(client.ping({ value: {} })).rejects.toThrowError(
-      'Validation input failed',
-    )
-  })
-
-  it('transformer', async () => {
-    const router = os.router({
-      ping: os
-        .input(z.object({ value: z.date() }))
-        .handler(input => input.value),
-    })
-
-    const handler = createFetchHandler({
-      router,
-    })
-
-    const client = createRouterClient<typeof router>({
-      baseURL: 'http://localhost:3000/orpc',
-      fetch: (...args) => {
-        const request = new Request(...args)
-        return handler({
-          prefix: '/orpc',
-          request,
-          context: {},
-        })
-      },
-    })
-
-    const now = new Date()
-    expect(await client.ping({ value: now })).toEqual(now)
-  })
-})

package/src/router.ts

@@ -1,96 +0,0 @@
-/// <reference lib="dom" />
-
-import type {
-  ContractProcedure,
-  ContractRouter,
-  SchemaOutput,
-} from '@orpc/contract'
-import type { Procedure, Router } from '@orpc/server'
-import type { Promisable } from '@orpc/shared'
-import { createProcedureClient, type ProcedureClient } from './procedure'
-
-export type RouterClientWithContractRouter<TRouter extends ContractRouter> = {
-  [K in keyof TRouter]: TRouter[K] extends ContractProcedure<
-    infer UInputSchema,
-    infer UOutputSchema
-  >
-    ? ProcedureClient<UInputSchema, UOutputSchema, SchemaOutput<UOutputSchema>>
-    : TRouter[K] extends ContractRouter
-      ? RouterClientWithContractRouter<TRouter[K]>
-      : never
-}
-
-export type RouterClientWithRouter<TRouter extends Router<any>> = {
-  [K in keyof TRouter]: TRouter[K] extends Procedure<
-    any,
-    any,
-    infer UInputSchema,
-    infer UOutputSchema,
-    infer UHandlerOutput
-  >
-    ? ProcedureClient<UInputSchema, UOutputSchema, UHandlerOutput>
-    : TRouter[K] extends Router<any>
-      ? RouterClientWithRouter<TRouter[K]>
-      : never
-}
-
-export interface CreateRouterClientOptions {
-  /**
-   * The base url of the server.
-   */
-  baseURL: string
-
-  /**
-   * The fetch function used to make the request.
-   * @default global fetch
-   */
-  fetch?: typeof fetch
-
-  /**
-   * The headers used to make the request.
-   * Invoked before the request is made.
-   */
-  headers?: (input: unknown) => Promisable<Headers | Record<string, string>>
-
-  /**
-   * This used for internal purpose only.
-   *
-   * @internal
-   */
-  path?: string[]
-}
-
-export function createRouterClient<
-  TRouter extends Router<any> | ContractRouter,
->(
-  options: CreateRouterClientOptions,
-): TRouter extends Router<any>
-    ? RouterClientWithRouter<TRouter>
-    : TRouter extends ContractRouter
-      ? RouterClientWithContractRouter<TRouter>
-      : never {
-  const path = options?.path ?? []
-
-  const client = new Proxy(
-    createProcedureClient({
-      baseURL: options.baseURL,
-      fetch: options.fetch,
-      headers: options.headers,
-      path,
-    }),
-    {
-      get(target, key) {
-        if (typeof key !== 'string') {
-          return Reflect.get(target, key)
-        }
-
-        return createRouterClient({
-          ...options,
-          path: [...path, key],
-        })
-      },
-    },
-  )
-
-  return client as any
-}