Function fetchForConnectionEffect

packages/runtime/src/connection-effect-fetch.ts:34–85

(
  fetchFn: ConnectionEffectFetch | undefined,
  input: string | URL,
  init: ProxiedFetchInit = {},
)

}

export async function fetchForConnectionEffect(
  fetchFn: ConnectionEffectFetch | undefined,
  input: string | URL,
  init: ProxiedFetchInit = {},
): Promise<ConnectionEffectResponse> {
  const { timeoutMs = 15_000, signal, ...requestInit } = init;
  const controller = new AbortController();
  let timedOut = false;
  let timer: ReturnType<typeof setTimeout> | undefined;

  const abortFromCaller = () => {
    if (isTimeoutReason(signal?.reason)) timedOut = true;
    controller.abort(signal?.reason);
  };
  if (signal) {
    if (signal.aborted) abortFromCaller();
    else signal.addEventListener('abort', abortFromCaller, { once: true });
  }
  if (timeoutMs > 0) {
    timer = setTimeout(() => {
      timedOut = true;
      controller.abort(new ConnectionEffectFetchError('timeout'));
    }, timeoutMs);
  }

  try {
    // Own the timeout above both transports so it remains active until the
    // response body is consumed or cancelled. proxiedFetch's native timeout
    // ends at headers because it also serves streaming callers.
    const response = fetchFn
      ? await fetchFn(input, {
          ...requestInit,
          signal: controller.signal,
        } as RequestInit)
      : await proxiedFetch(input.toString(), {
          ...requestInit,
          signal: controller.signal,
          timeoutMs: 0,
        });
    return manageConnectionEffectResponse(response, {
      didTimeOut: () => timedOut,
      finish: () => {
        if (timer) clearTimeout(timer);
        signal?.removeEventListener('abort', abortFromCaller);
      },
    });
  } catch (error) {
    if (timer) clearTimeout(timer);
    signal?.removeEventListener('abort', abortFromCaller);
    throw connectionEffectFetchFailure(error, timedOut);
  }
}

function manageConnectionEffectResponse(
  response: Response,