Function cacheBustedFetchFromNetwork

packages/service-worker/worker/src/assets.ts:389–467

* Load a particular asset from the network, accounting for hash validation.

(req: Request)

   * Load a particular asset from the network, accounting for hash validation.
   */
  protected async cacheBustedFetchFromNetwork(req: Request): Promise<Response> {
    const url = this.adapter.normalizeUrl(req.url);

    // If a hash is available for this resource, then compare the fetched version with the
    // canonical hash. Otherwise, the network version will have to be trusted.
    if (this.hashes.has(url)) {
      // It turns out this resource does have a hash. Look it up. Unless the fetched version
      // matches this hash, it's invalid and the whole manifest may need to be thrown out.
      const canonicalHash = this.hashes.get(url)!;

      // Ideally, the resource would be requested with cache-busting to guarantee the SW gets
      // the freshest version. However, doing this would eliminate any chance of the response
      // being in the HTTP cache. Given that the browser has recently actively loaded the page,
      // it's likely that many of the responses the SW needs to cache are in the HTTP cache and
      // are fresh enough to use. In the future, this could be done by setting cacheMode to
      // *only* check the browser cache for a cached version of the resource, when cacheMode is
      // fully supported. For now, the resource is fetched directly, without cache-busting, and
      // if the hash test fails a cache-busted request is tried before concluding that the
      // resource isn't correct. This gives the benefit of acceleration via the HTTP cache
      // without the risk of stale data, at the expense of a duplicate request in the event of
      // a stale response.

      // Fetch the resource from the network (possibly hitting the HTTP cache).
      let response = await this.safeFetch(req);

      // Decide whether a cache-busted request is necessary. A cache-busted request is necessary
      // only if the request was successful but the hash of the retrieved contents does not match
      // the canonical hash from the manifest.
      let makeCacheBustedRequest = response.ok;
      if (makeCacheBustedRequest) {
        // The request was successful. A cache-busted request is only necessary if the hashes
        // don't match.
        // (Make sure to clone the response so it can be used later if it proves to be valid.)
        const fetchedHash = sha1Binary(await response.clone().arrayBuffer());
        makeCacheBustedRequest = fetchedHash !== canonicalHash;
      }

      // Make a cache busted request to the network, if necessary.
      if (makeCacheBustedRequest) {
        // Hash failure, the version that was retrieved under the default URL did not have the
        // hash expected. This could be because the HTTP cache got in the way and returned stale
        // data, or because the version on the server really doesn't match. A cache-busting
        // request will differentiate these two situations.
        // TODO: handle case where the URL has parameters already (unlikely for assets).
        const cacheBustReq = this.newRequestWithMetadata(this.cacheBust(req.url), req);
        response = await this.safeFetch(cacheBustReq);

        // If the response was successful, check the contents against the canonical hash.
        if (response.ok) {
          // Hash the contents.
          // (Make sure to clone the response so it can be used later if it proves to be valid.)
          const cacheBustedHash = sha1Binary(await response.clone().arrayBuffer());

          // If the cache-busted version doesn't match, then the manifest is not an accurate
          // representation of the server's current set of files, and the SW should give up.
          if (canonicalHash !== cacheBustedHash) {
            throw new SwCriticalError(
              `Hash mismatch (cacheBustedFetchFromNetwork): ${req.url}: expected ${canonicalHash}, got ${cacheBustedHash} (after cache busting)`,