Function executeEndpointFallback

src/endpoint.ts:111–171

({
  configuredEndpoints,
  getRemoteEndpoints,
  tryEndpoint,
  random = Math.random,
  now = Date.now,
  onFirstFailure,
}: ExecuteEndpointFallbackOptions<T>)

}

export async function executeEndpointFallback<T>({
  configuredEndpoints,
  getRemoteEndpoints,
  tryEndpoint,
  random = Math.random,
  now = Date.now,
  onFirstFailure,
}: ExecuteEndpointFallbackOptions<T>): Promise<EndpointAttemptSuccess<T>> {
  const excludedEndpoints = new Set<string>();
  let candidates = dedupeEndpoints(configuredEndpoints);

  if (!candidates.length) {
    throw new Error('No endpoints configured');
  }

  const firstEndpoint = pickRandomEndpoint(candidates, random);

  try {
    return {
      endpoint: firstEndpoint,
      value: await tryEndpoint(firstEndpoint),
      duration: 0,
    };
  } catch (error) {
    const firstFailure = {
      endpoint: firstEndpoint,
      error: normalizeError(error),
    };
    excludedEndpoints.add(firstEndpoint);
    await onFirstFailure?.(firstFailure);
    let lastError = firstFailure.error;

    while (true) {
      const remoteEndpoints = getRemoteEndpoints
        ? await getRemoteEndpoints().catch(() => [])
        : [];
      candidates = dedupeEndpoints([...candidates, ...remoteEndpoints]).filter(
        endpoint => !excludedEndpoints.has(endpoint),
      );

      if (!candidates.length) {
        throw lastError;
      }

      const { successes, failures } = await selectFastestSuccessfulEndpoint(
        candidates,
        tryEndpoint,
        now,
      );

      if (successes.length) {
        return successes[0];
      }

      for (const failure of failures) {
        excludedEndpoints.add(failure.endpoint);
        lastError = failure.error;
      }