Class ArtifactCrossOriginStorageCache

web/src/artifact_cache.ts:693–772

 * Cache by cross-origin storage extension.
 */
export class ArtifactCrossOriginStorageCache implements ArtifactCacheTemplate {
  private storage: CrossOriginStorage;

  constructor(
    _scope: string,
    storage: CrossOriginStorage = new CrossOriginStorage(),
  ) {
    this.storage = storage;
  }

  async fetchWithCache(
    url: string,
    storetype?: StoreType,
    signal?: AbortSignal,
  ): Promise<any> {
    const cachedResponse = await this.storage.match(url);
    if (cachedResponse !== undefined) {
      return this.responseToStoreType(cachedResponse, storetype);
    }
    await this.addToCache(url, storetype, signal);
    const hydrated = await this.storage.match(url);
    if (hydrated === undefined) {
      throw new Error(`ArtifactCrossOriginStorageCache: failed to hydrate ${url}`);
    }
    return this.responseToStoreType(hydrated, storetype);
  }

  async addToCache(
    url: string,
    _storetype?: StoreType,
    signal?: AbortSignal,
  ): Promise<void> {
    const existing = await this.storage.match(url);
    if (existing !== undefined) {
      return;
    }
    const request = new Request(
      url,
      signal ? { ...DEFAULT_FETCH_OPTIONS, signal } : DEFAULT_FETCH_OPTIONS,
    );
    const response = await fetch(request);
    if (!response.ok) {
      throw new Error(
        `ArtifactCrossOriginStorageCache: Unable to fetch ${url}, received status ${response.status}`,
      );
    }
    await this.storage.put(url, response.clone());
  }

  async hasAllKeys(keys: string[]): Promise<boolean> {
    const results = await Promise.all(
      keys.map(async (key) => {
        const cached = await this.storage.match(key);
        return cached !== undefined;
      }),
    );
    return results.every((result) => result);
  }