@orpc/client 0.0.0-next.b15d206 → 0.0.0-next.b2e67f7

package/src/procedure.test.ts

@@ -1,245 +0,0 @@
-import { ORPCError, os } from '@orpc/server'
-import { createFetchHandler } from '@orpc/server/fetch'
-import { z } from 'zod'
-import { createProcedureClient } from './procedure'
-
-describe('createProcedureClient', () => {
-  const schema = z.object({
-    value: z.string(),
-  })
-  const ping = os.input(schema).func((_, __, { path }) => path)
-  const router = os.router({
-    ping,
-    nested: {
-      ping,
-    },
-  })
-  const handler = createFetchHandler({
-    router,
-  })
-  const orpcFetch: typeof fetch = async (...args) => {
-    const request = new Request(...args)
-    const response = await handler({
-      prefix: '/orpc',
-      request,
-      context: {},
-    })
-    return response
-  }
-
-  it('types', () => {
-    const schema = z.object({
-      value: z.string(),
-    })
-    const client = createProcedureClient<
-      typeof schema,
-      undefined,
-      { age: number }
-    >({} as any)
-
-    expectTypeOf(client).toEqualTypeOf<
-      (input: { value: string }) => Promise<{ age: number }>
-    >()
-
-    const client2 = createProcedureClient<
-      undefined,
-      typeof schema,
-      { value: string }
-    >({} as any)
-
-    expectTypeOf(client2).toEqualTypeOf<
-      (input: unknown) => Promise<{ value: string }>
-    >()
-  })
-
-  it('simple', async () => {
-    const client = createProcedureClient({
-      baseURL: 'http://localhost:3000/orpc',
-      fetch: orpcFetch,
-      path: ['ping'],
-    })
-
-    const result = await client({ value: 'hello' })
-
-    expect(result).toEqual(['ping'])
-
-    const client2 = createProcedureClient({
-      baseURL: 'http://localhost:3000/orpc',
-      fetch: orpcFetch,
-      path: ['nested', 'ping'],
-    })
-
-    const result2 = await client2({ value: 'hello' })
-
-    expect(result2).toEqual(['nested', 'ping'])
-  })
-
-  it('on known error', () => {
-    const client = createProcedureClient({
-      baseURL: 'http://localhost:3000/orpc',
-      fetch: orpcFetch,
-      path: ['ping'],
-    })
-
-    expect(client({ value: {} })).rejects.toThrowError(
-      'Validation input failed',
-    )
-  })
-
-  it('on unknown error', () => {
-    const orpcFetch: typeof fetch = async () => {
-      return new Response(JSON.stringify({}), {
-        status: 400,
-        headers: {
-          'Content-Type': 'application/json',
-        },
-      })
-    }
-
-    const client = createProcedureClient({
-      baseURL: 'http://localhost:3000/orpc',
-      fetch: orpcFetch,
-      path: ['ping'],
-    })
-
-    expect(client({ value: 'hello' })).rejects.toThrowError(
-      'Cannot parse response.',
-    )
-  })
-
-  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 = createProcedureClient({
-      path: ['ping'],
-      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({ value: now })).toEqual(now)
-  })
-
-  it('error include data', async () => {
-    const router = os.router({
-      ping: os.func((input) => {
-        throw new ORPCError({
-          code: 'BAD_GATEWAY',
-          data: {
-            value: 'from error',
-          },
-        })
-      }),
-    })
-
-    const handler = createFetchHandler({
-      router,
-    })
-
-    const client = createProcedureClient({
-      path: ['ping'],
-      baseURL: 'http://localhost:3000/orpc',
-      fetch: (...args) => {
-        const request = new Request(...args)
-        return handler({
-          prefix: '/orpc',
-          request,
-          context: {},
-        })
-      },
-    })
-
-    let error: any
-    try {
-      await client(undefined)
-    }
-    catch (e) {
-      error = e
-    }
-
-    expect(error).toBeInstanceOf(ORPCError)
-    expect(error.code).toEqual('BAD_GATEWAY')
-    expect(error.data).toEqual({ value: 'from error' })
-  })
-})
-
-describe('upload file', () => {
-  const router = os.router({
-    signal: os.input(z.instanceof(Blob)).func((input) => {
-      return input
-    }),
-    multiple: os
-      .input(
-        z.object({ first: z.instanceof(Blob), second: z.instanceof(Blob) }),
-      )
-      .func((input) => {
-        return input
-      }),
-  })
-
-  const handler = createFetchHandler({ router })
-
-  const orpcFetch: typeof fetch = async (...args) => {
-    const request = new Request(...args)
-    const response = await handler({
-      prefix: '/orpc',
-      request,
-      context: {},
-    })
-    return response
-  }
-
-  const blob1 = new Blob(['hello'], { type: 'text/plain;charset=utf-8' })
-  const blob2 = new Blob(['"world"'], { type: 'image/png' })
-  const blob3 = new Blob(['unnoq'], { type: 'application/octet-stream' })
-
-  it('single file', async () => {
-    const client = createProcedureClient({
-      baseURL: 'http://localhost:3000/orpc',
-      fetch: orpcFetch,
-      path: ['signal'],
-    })
-
-    const output = await client(blob1)
-
-    expect(output).toBeInstanceOf(Blob)
-    expect(output.type).toBe('text/plain;charset=utf-8')
-    expect(await output.text()).toBe('hello')
-  })
-
-  it('multiple file', async () => {
-    const client = createProcedureClient({
-      baseURL: 'http://localhost:3000/orpc',
-      fetch: orpcFetch,
-      path: ['multiple'],
-    })
-
-    const output = await client({ first: blob3, second: blob2 })
-
-    const file0 = output.first
-    const file1 = output.second
-
-    expect(file0).toBeInstanceOf(Blob)
-    expect(file0.type).toBe('application/octet-stream')
-    expect(await file0.text()).toBe('unnoq')
-
-    expect(file1).toBeInstanceOf(Blob)
-    expect(file1.type).toBe('image/png')
-    expect(await file1.text()).toBe('"world"')
-  })
-})

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
-}