Function createHttpClient

cli/src/http/client.ts:276–348

(opts: ClientOptions)

}

export function createHttpClient(opts: ClientOptions): HttpClient {
  const state = compileState(opts)

  const typedCall = async <T>(method: HttpMethod, path: string, callOpts?: RequestOptions): Promise<T> => {
    const finalOpts: RequestOptions = { ...callOpts, method }
    const built = buildRequest(state, path, finalOpts, true)
    const res = await execute(state, built.request, built.resolved, built.effectiveTimeoutMs, built.userSignal)
    return parseJsonBody<T>(res)
  }

  const rawFetch = (path: string, callOpts?: RequestOptions): Promise<Response> => {
    const finalOpts: RequestOptions = { ...callOpts, method: callOpts?.method ?? 'GET' }
    const built = buildRequest(state, path, finalOpts, false)
    return execute(state, built.request, built.resolved, built.effectiveTimeoutMs, built.userSignal)
  }

  const streamFetch = (path: string, callOpts?: RequestOptions): Promise<Response> => {
    // SSE bodies must not be aborted by a request-level timeout — `0` is the buildRequest
    // sentinel for "no timeout" and also overrides the client default.
    //
    // A stream normally never retries (a mid-stream replay would double-send). When the caller
    // opts into 429 retry, allow a bounded budget: the 429 admission rejection arrives as a plain
    // body before the stream opens, and execute()'s 429 branch is the only path that fires for a
    // POST — shouldRetry still rejects POST for transport / 5xx, so nothing else replays.
    const retryAttempts = callOpts?.retryOnRateLimit === true
      ? (callOpts.retryAttempts ?? RATE_LIMIT_MAX_ATTEMPTS)
      : 0
    const finalOpts: RequestOptions = {
      ...callOpts,
      method: callOpts?.method ?? 'GET',
      retryAttempts,
      timeoutMs: 0,
    }
    const built = buildRequest(state, path, finalOpts, false)
    return execute(state, built.request, built.resolved, built.effectiveTimeoutMs, built.userSignal)
  }

  // Low-level entrypoint for oRPC's OpenAPILink: executes an already-built, absolute-URL
  // Request through the same transport (UA+bearer hooks, retry, timeout, error-map) while
  // skipping joinURL. Policy comes from the client instance defaults — there is no per-call
  // override, so this stays a drop-in for OpenAPILink's `(req, init) => Promise<Response>`.
  // Returns the raw Response for every status; the oRPC fetch wrapper (orpc.ts) inspects the
  // status and raises classifyResponse for non-2xx, so error mapping stays in one place.
  const requestFetch = (req: Request, init?: RequestInit): Promise<Response> => {
    const method = req.method.toUpperCase() as HttpMethod
    const resolved: ResolvedOptions = {
      method,
      headers: req.headers,
      body: undefined,
      timeoutMs: state.defaultTimeoutMs,
      retryAttempts: state.defaultRetryAttempts,
      throwOnError: false,
      retryOnRateLimit: false,
    }
    const userSignal = init?.signal ?? req.signal
    return execute(state, req, resolved, state.defaultTimeoutMs, userSignal)
  }