Method handleFetch

packages/service-worker/worker/src/app-version.ts:146–210

(req: Request, event: ExtendableEvent)

  }

  async handleFetch(req: Request, event: ExtendableEvent): Promise<Response | null> {
    // Check the request against each `AssetGroup` in sequence. If an `AssetGroup` can't handle the
    // request,
    // it will return `null`. Thus, the first non-null response is the SW's answer to the request.
    // So reduce
    // the group list, keeping track of a possible response. If there is one, it gets passed
    // through, and if
    // not the next group is consulted to produce a candidate response.
    const asset = await this.assetGroups.reduce(async (potentialResponse, group) => {
      // Wait on the previous potential response. If it's not null, it should just be passed
      // through.
      const resp = await potentialResponse;
      if (resp !== null) {
        return resp;
      }

      // No response has been found yet. Maybe this group will have one.
      return group.handleFetch(req, event);
    }, Promise.resolve<Response | null>(null));

    // The result of the above is the asset response, if there is any, or null otherwise. Return the
    // asset
    // response if there was one. If not, check with the data caching groups.
    if (asset !== null) {
      return asset;
    }

    // Perform the same reduction operation as above, but this time processing
    // the data caching groups.
    const data = await this.dataGroups.reduce(async (potentialResponse, group) => {
      const resp = await potentialResponse;
      if (resp !== null) {
        return resp;
      }

      return group.handleFetch(req, event);
    }, Promise.resolve<Response | null>(null));

    // If the data caching group returned a response, go with it.
    if (data !== null) {
      return data;
    }

    // Next, check if this is a navigation request for a route. Detect circular
    // navigations by checking if the request URL is the same as the index URL.
    if (this.adapter.normalizeUrl(req.url) !== this.indexUrl && this.isNavigationRequest(req)) {
      if (this.manifest.navigationRequestStrategy === 'freshness') {
        // For navigation requests the freshness was configured. The request will always go trough
        // the network and fallback to default `handleFetch` behavior in case of failure.
        try {
          return await this.scope.fetch(req);
        } catch {
          // Navigation request failed - application is likely offline.
          // Proceed forward to the default `handleFetch` behavior, where
          // `indexUrl` will be requested and it should be available in the cache.
        }
      }