@orpc/client 0.0.0-next.83ec2e8 → 0.0.0-next.84e58e0

package/src/procedure.ts

@@ -1,108 +0,0 @@
-/// <reference lib="dom" />
-/// <reference lib="dom.iterable" />
-
-import type { Promisable } from '@orpc/shared'
-import {
-  ORPC_HEADER,
-  ORPC_HEADER_VALUE,
-  type Schema,
-  type SchemaInput,
-  type SchemaOutput,
-} from '@orpc/contract'
-import { trim } from '@orpc/shared'
-import { ORPCError } from '@orpc/shared/error'
-import { ORPCDeserializer, ORPCSerializer } from '@orpc/transformer'
-
-export interface ProcedureClient<
-  TInputSchema extends Schema,
-  TOutputSchema extends Schema,
-  TFuncOutput extends SchemaOutput<TOutputSchema>,
-> {
-  (
-    input: SchemaInput<TInputSchema>,
-  ): Promise<SchemaOutput<TOutputSchema, TFuncOutput>>
-}
-
-export interface CreateProcedureClientOptions {
-  /**
-   * 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>>
-
-  /**
-   * The path of the procedure on server.
-   */
-  path: string[]
-}
-
-export function createProcedureClient<
-  TInputSchema extends Schema,
-  TOutputSchema extends Schema,
-  TFuncOutput extends SchemaOutput<TOutputSchema>,
->(
-  options: CreateProcedureClientOptions,
-): ProcedureClient<TInputSchema, TOutputSchema, TFuncOutput> {
-  const serializer = new ORPCSerializer()
-  const deserializer = new ORPCDeserializer()
-
-  const client = async (input: unknown): Promise<unknown> => {
-    const fetch_ = options.fetch ?? fetch
-    const url = `${trim(options.baseURL, '/')}/${options.path.map(encodeURIComponent).join('/')}`
-    let headers = await options.headers?.(input)
-    headers = headers instanceof Headers ? headers : new Headers(headers)
-
-    const { body, headers: headers_ } = serializer.serialize(input)
-
-    for (const [key, value] of headers_.entries()) {
-      headers.set(key, value)
-    }
-
-    headers.set(ORPC_HEADER, ORPC_HEADER_VALUE)
-
-    const response = await fetch_(url, {
-      method: 'POST',
-      headers,
-      body,
-    })
-
-    const json = await (async () => {
-      try {
-        return await deserializer.deserialize(response)
-      }
-      catch (e) {
-        throw new ORPCError({
-          code: 'INTERNAL_SERVER_ERROR',
-          message: 'Cannot parse response.',
-          cause: e,
-        })
-      }
-    })()
-
-    if (!response.ok) {
-      throw (
-        ORPCError.fromJSON(json)
-        ?? new ORPCError({
-          status: response.status,
-          code: 'INTERNAL_SERVER_ERROR',
-          message: 'Internal server error',
-        })
-      )
-    }
-
-    return json
-  }
-
-  return client as any
-}

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).func((_, __, { 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).func(() => '')
-    const pong = os.output(schema).func(() => ({ value: 'string' }))
-    const peng = os.route({}).func(() => ({ 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() }))
-        .func(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 UFuncOutput
-  >
-    ? ProcedureClient<UInputSchema, UOutputSchema, UFuncOutput>
-    : 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
-}