Method fetch

client/js/src/internal/apiService/apiService.ts:276–406

(
        request: { method: string; url: string; signal?: AbortSignal },
        callback: () => Promise<Response>,
        {
            attempt,
            previousError,
        }: {
            attempt: number;
            previousError?: unknown;
        } = {
            attempt: 0,
        },
    )

    // u=5 for background (e.g., upload, download)
    // u=7 for optional (e.g., metrics, telemetry)
    private async fetch(
        request: { method: string; url: string; signal?: AbortSignal },
        callback: () => Promise<Response>,
        {
            attempt,
            previousError,
        }: {
            attempt: number;
            previousError?: unknown;
        } = {
            attempt: 0,
        },
    ): Promise<Response> {
        if (request.signal?.aborted) {
            throw new AbortError(c('Error').t`Request aborted`);
        }

        if (attempt > 0) {
            this.logger.debug(`${request.method} ${request.url}: retry ${attempt}`);
        } else {
            this.logger.debug(`${request.method} ${request.url}`);
        }

        if (this.hasReachedServerErrorLimit) {
            this.logger.warn('Server errors limit reached');
            throw new ServerError(c('Error').t`Too many server errors, please try again later`);
        }
        if (this.hasReachedTooManyRequestsErrorLimit) {
            this.logger.warn('Too many requests limit reached');
            throw new RateLimitedError(c('Error').t`Too many server requests, please try again later`);
        }

        const start = Date.now();

        let response;
        try {
            response = await callback();
        } catch (error: unknown) {
            if (error instanceof Error) {
                if (error.name === 'AbortError') {
                    this.logger.debug(`${request.method} ${request.url}: Aborted`);
                    throw new AbortError(c('Error').t`Request aborted`);
                }

                if (error.name === 'OfflineError') {
                    this.offlineErrorHappened();
                    this.logger.info(`${request.method} ${request.url}: Offline error, retrying`);
                    await waitSeconds(OFFLINE_RETRY_DELAY_SECONDS);
                    return this.fetch(request, callback, { attempt: attempt + 1, previousError: error });
                }

                if (error.name === 'TimeoutError' && attempt + 1 < MAX_TIMEOUT_ERROR_RETRY_ATTEMPTS) {
                    this.logger.warn(`${request.method} ${request.url}: Timeout error, retrying`);
                    await waitSeconds(SERVER_ERROR_RETRY_DELAY_SECONDS);
                    return this.fetch(request, callback, { attempt: attempt + 1, previousError: error });
                }

                if (isNetworkError(error) && attempt + 1 < MAX_NETWORK_ERROR_RETRY_ATTEMPTS) {