Function zodfetch

packages/trigger-sdk/src/apiClient.ts:976–1049

(
  schema: TResponseSchema,
  url: string,
  requestInit?: RequestInit,
  options?: {
    errorMessage?: string;
    optional?: TOptional;
  },
  retryCount = 0
)

}

async function zodfetch<TResponseSchema extends z.ZodTypeAny, TOptional extends boolean = false>(
  schema: TResponseSchema,
  url: string,
  requestInit?: RequestInit,
  options?: {
    errorMessage?: string;
    optional?: TOptional;
  },
  retryCount = 0
): Promise<
  TOptional extends true ? z.infer<TResponseSchema> | undefined : z.infer<TResponseSchema>
> {
  try {
    const response = await fetch(url, requestInitWithCache(requestInit));

    if (
      (!requestInit || requestInit.method === "GET") &&
      response.status === 404 &&
      options?.optional
    ) {
      // @ts-ignore
      return;
    }

    //rate limit, so we want to reschedule
    if (response.status === 429) {
      //unix timestamp in milliseconds
      const retryAfter = response.headers.get("x-ratelimit-reset");
      if (retryAfter) {
        throw new AutoYieldRateLimitError(parseInt(retryAfter));
      }
    }

    if (response.status >= 400 && response.status < 500) {
      const body = await response.json();

      throw new Error(body.error);
    }

    if (response.status >= 500 && retryCount < MAX_RETRIES) {
      // retry with exponential backoff and jitter
      const delay = exponentialBackoff(retryCount + 1);

      await new Promise((resolve) => setTimeout(resolve, delay));

      return zodfetch(schema, url, requestInit, options, retryCount + 1);
    }

    if (response.status !== 200) {
      throw new Error(
        options?.errorMessage ?? `Failed to fetch ${url}, got status code ${response.status}`
      );
    }

    const jsonBody = await response.json();

    return schema.parse(jsonBody);
  } catch (error) {