@swell/apps-sdk 1.0.138 → 1.0.140

package/dist/index.cjs

@@ -149,31 +149,44 @@ var import_cache_manager = require("cache-manager");
 
 // src/cache/cf-worker-kv-keyv-adapter.ts
 var CFWorkerKVKeyvAdapter = class {
+  store;
   namespace;
   // magically passed in from Keyv
-  store;
+  opts;
   constructor(store) {
     this.store = store;
+    this.opts = null;
     this.namespace = "dummy";
   }
   async has(key) {
-    return this.get(key) !== void 0;
+    const stream = await this.store.get(key, "stream");
+    if (stream !== null) {
+      await stream.cancel();
+      return true;
+    }
+    return false;
   }
   async get(key) {
-    return this.store.get(key);
+    const value = await this.store.get(key);
+    return value !== null ? value : void 0;
   }
-  async set(key, value) {
-    return this.store.put(key, value);
+  set(key, value, ttl) {
+    if (typeof ttl === "number") {
+      ttl = Math.max(60, ttl / 1e3);
+    }
+    return this.store.put(key, value, { expirationTtl: ttl });
   }
   async delete(key) {
     await this.store.delete(key);
+    return true;
   }
   async clear() {
     let cursor = "";
     let complete = false;
-    while (!complete) {
+    const prefix = `${this.namespace}:`;
+    do {
       const response = await this.store.list({
-        prefix: `${this.namespace}:`,
+        prefix,
         cursor: cursor || void 0
       });
       cursor = response.cursor ?? "";
@@ -185,7 +198,10 @@ var CFWorkerKVKeyvAdapter = class {
           })
         );
       }
-    }
+    } while (!complete);
+  }
+  on(_event, _listener) {
+    return this;
   }
 };
 
@@ -7089,23 +7105,25 @@ var Cache = class {
       ...options
     });
   }
-  async fetch(key, fetchFn) {
-    return this.client.wrap(key, fetchFn);
+  async fetch(key, fetchFn, ttl) {
+    return this.client.wrap(key, fetchFn, ttl);
   }
-  // Fetch cache using SWR (stale-while-revalidate)
-  // This will always return the cached value immediately if exists
+  /**
+   * Fetch cache using SWR (stale-while-revalidate)
+   *
+   * This will always return the cached value immediately if exists
+   */
   async fetchSWR(key, fetchFn, ttl = DEFAULT_SWR_TTL) {
     const cacheValue = await this.client.get(key);
-    const promiseValue = Promise.resolve().then(() => fetchFn()).then(async (value) => {
+    const promiseValue = Promise.resolve().then(fetchFn).then(resolveAsyncResources).then(async (value) => {
       const isNull = value === null || value === void 0;
-      const valueResolved = await resolveAsyncResources(value);
-      await this.client.set(key, isNull ? NULL_VALUE : valueResolved, ttl);
+      await this.client.set(key, isNull ? NULL_VALUE : value, ttl);
       return value;
     });
     if (this.workerCtx?.waitUntil) {
       this.workerCtx.waitUntil(promiseValue);
     }
-    if (cacheValue !== null) {
+    if (cacheValue !== void 0) {
       return cacheValue === NULL_VALUE ? null : cacheValue;
     }
     const result = await promiseValue;
@@ -7122,8 +7140,9 @@ var Cache = class {
   }
   /**
    * Flushes the entire cache.
-   * WARNING: If the cache store is shared among many cache clients,
-   *          this will flush entries for other clients.
+   *
+   * __WARNING__: If the cache store is shared among many cache clients,
+   *              this will flush entries for other clients.
    */
   async flushAll() {
     await this.client.clear();
@@ -7166,7 +7185,7 @@ var ResourceCache = class extends Cache {
 function buildStores2() {
   return [
     new import_keyv2.Keyv({
-      // Disabling serialization allows for pure memo-ization of class instances
+      // Disabling serialization allows for pure memoization of class instances
       // at the tradeoff of no support for compression.
       serialize: void 0,
       deserialize: void 0
@@ -18236,10 +18255,10 @@ var svgs = {
     src: "https://cdn.swell.store/schema/685ef581b79e3e0012cf3222/fba884c7fe8122c472e130355fb52db7/collection-6.png"
   },
   "lifestyle-1": {
-    src: "https://cdn.swell.store/schema/685ef58bb79e3e0012cf3256/1da0da57ea80d90038fcf6b100a16fe6/lifestyle-1.png"
+    src: "https://cdn.swell.store/schema/6870eddc1657130012643fc6/1777bcff40736610093833ef858b5936/lifestyle-1.png"
   },
   "lifestyle-2": {
-    src: "https://cdn.swell.store/schema/685ef58cb79e3e0012cf3259/f963448f1a6f4d6588fcd283b5c00c7c/lifestyle-2.png"
+    src: "https://cdn.swell.store/schema/6870eddc1657130012643fcb/4d29197e3fa0b6d8255c1b7770f8dc12/lifestyle-2.png"
   },
   "product-apparel-1": {
     src: "https://cdn.swell.store/schema/685ef58eb79e3e0012cf3276/37c3c973a01287a580ab9db2e05dd36d/product-apparel-1.png"
@@ -18837,12 +18856,11 @@ var ThemeLoader = class _ThemeLoader {
     this.configPaths = [];
   }
   async init(themeConfigs) {
-    const { swellHeaders } = this.swell;
     if (themeConfigs) {
       this.setConfigs(themeConfigs);
       return;
     }
-    if (!swellHeaders["theme-id"]) {
+    if (!this.getThemeId()) {
       return;
     }
     await this.fetchManifest();
@@ -18881,25 +18899,45 @@ var ThemeLoader = class _ThemeLoader {
    */
   setConfigs(themeConfigs) {
     this.configs = new Map(themeConfigs);
+    this.manifest = /* @__PURE__ */ new Map();
+    for (const { file_path, hash } of this.configs.values()) {
+      this.manifest.set(file_path, hash);
+    }
     this.configPaths = Array.from(this.configs.keys());
-    this.manifest = this.configPaths.reduce((manifest, path) => {
-      manifest[path] = this.configs.get(path)?.hash;
-      return manifest;
-    }, {});
   }
   /**
    * Preloads a theme version and configs. This is used to optimize initial theme load.
    */
-  async preloadTheme(version, configs) {
+  async preloadTheme(payload) {
+    const { version, configs } = payload;
     console.log(
       `ThemeLoader.preloadTheme${version?.hash ? ` - manifest: ${version.hash}` : ""}${configs?.length ? ` - configs: ${configs.length}` : ""}`
     );
-    await Promise2.all([
-      version && this.cacheManifest(version),
-      configs && Promise2.map(configs, (config) => this.cacheThemeConfig(config), {
-        concurrency: 10
-      })
-    ]);
+    const promises = [];
+    if (version) {
+      promises.push(this.cacheManifest(version));
+    }
+    if (configs) {
+      const themeId = this.getThemeId();
+      promises.push(
+        Promise2.map(
+          configs,
+          async (config) => {
+            const promises2 = [
+              this.cacheThemeConfig(config)
+            ];
+            if (themeId && config.file?.url) {
+              promises2.push(
+                this.cacheThemeFileUrl(themeId, config.hash, config.file.url)
+              );
+            }
+            await Promise2.all(promises2);
+          },
+          { concurrency: 10 }
+        )
+      );
+    }
+    await Promise2.all(promises);
   }
   /**
    * Fetches a theme config by file path.
@@ -18909,18 +18947,28 @@ var ThemeLoader = class _ThemeLoader {
     if (config !== void 0) {
       return config;
     }
-    const hash = this.manifest?.[filePath];
-    if (hash) {
-      const config2 = await this.getCache().get(
-        `config:${hash}`
-      );
-      if (config2) {
-        this.configs.set(filePath, config2);
-        return config2;
+    const hash = this.manifest?.get(filePath);
+    if (!hash) {
+      return null;
+    }
+    const cache = this.getCache();
+    const themeId = this.getThemeId();
+    const [themeConfig, fileUrl] = await Promise2.all([
+      cache.get(`config:${hash}`),
+      themeId ? cache.get(`file:${themeId}:${hash}`) : void 0
+    ]);
+    if (themeConfig) {
+      let config2 = themeConfig;
+      if (fileUrl && themeConfig.file?.url) {
+        config2 = {
+          ...themeConfig,
+          file: { ...themeConfig.file, url: fileUrl }
+        };
       }
-      return this.fetchThemeConfigsFromSourceByPath(filePath, hash);
+      this.configs.set(filePath, config2);
+      return config2;
     }
-    return null;
+    return this.fetchThemeConfigsFromSourceByPath(filePath, hash);
   }
   async fetchThemeConfigsByPath(pathPrefix, pathSuffix) {
     const paths = this.configPaths.filter(
@@ -18929,9 +18977,7 @@ var ThemeLoader = class _ThemeLoader {
     const configs = await Promise2.map(
       paths,
       (path) => this.fetchThemeConfig(path),
-      {
-        concurrency: 10
-      }
+      { concurrency: 10 }
     );
     return configs.filter((config) => config !== null);
   }
@@ -18964,17 +19010,28 @@ var ThemeLoader = class _ThemeLoader {
     }
     const configHashesUnresolved = [];
     const configsByHash = /* @__PURE__ */ new Map();
+    const themeId = this.getThemeId();
+    const cache = this.getCache();
     await Promise2.map(
-      Object.values(manifest),
-      (configHash) => {
-        return this.getCache().get(`config:${configHash}`).then((config) => {
-          if (config) {
-            configsByHash.set(config.hash, config);
-            this.configs.set(config.file_path, config);
-          } else {
-            configHashesUnresolved.push(configHash);
-          }
-        });
+      manifest.values(),
+      async (configHash) => {
+        const [themeConfig, fileUrl] = await Promise2.all([
+          cache.get(`config:${configHash}`),
+          themeId ? cache.get(`file:${themeId}:${configHash}`) : void 0
+        ]);
+        if (!themeConfig) {
+          configHashesUnresolved.push(configHash);
+          return;
+        }
+        let config = themeConfig;
+        if (fileUrl && themeConfig.file?.url) {
+          config = {
+            ...themeConfig,
+            file: { ...themeConfig.file, url: fileUrl }
+          };
+        }
+        configsByHash.set(config.hash, config);
+        this.configs.set(config.file_path, config);
       },
       { concurrency: 10 }
     );
@@ -18989,9 +19046,19 @@ var ThemeLoader = class _ThemeLoader {
         configsByHash.set(config.hash, config);
         this.configs.set(config.file_path, config);
       }
-      await Promise2.map(newConfigs, (config) => this.cacheThemeConfig(config), {
-        concurrency: 10
-      });
+      await Promise2.map(
+        newConfigs,
+        async (config) => {
+          const promises = [this.cacheThemeConfig(config)];
+          if (themeId && config.file?.url) {
+            promises.push(
+              this.cacheThemeFileUrl(themeId, config.hash, config.file.url)
+            );
+          }
+          await Promise2.all(promises);
+        },
+        { concurrency: 10 }
+      );
     }
     return Array.from(configsByHash.values());
   }
@@ -19011,6 +19078,12 @@ var ThemeLoader = class _ThemeLoader {
       await this.getCache().set(`config:${config.hash}`, config);
     }
   }
+  /**
+   * Caches a CDN file url by config hash.
+   */
+  async cacheThemeFileUrl(themeId, configHash, fileUrl) {
+    await this.getCache().set(`file:${themeId}:${configHash}`, fileUrl);
+  }
   /**
    * Fetches the manifest (set of config hashes) for a theme version.
    */
@@ -19034,8 +19107,10 @@ var ThemeLoader = class _ThemeLoader {
         manifest = themeVersion.manifest;
       }
     }
-    this.manifest = manifest;
-    this.configPaths = Object.keys(manifest || {});
+    if (manifest) {
+      this.manifest = new Map(Object.entries(manifest));
+      this.configPaths = [...this.manifest.keys()];
+    }
     return this.manifest;
   }
   /**
@@ -19053,7 +19128,7 @@ var ThemeLoader = class _ThemeLoader {
       "/:themes:configs",
       {
         ...this.themeVersionQueryFilter(),
-        ...fetchAll ? {} : { hash: { $in: configHashes } },
+        ...fetchAll ? void 0 : { hash: { $in: configHashes } },
         // TODO: paginate to support more than 1000 configs
         limit: 1e3,
         type: "theme",
@@ -19089,10 +19164,20 @@ var ThemeLoader = class _ThemeLoader {
       if (hash) {
         config.hash = hash;
       }
-      await this.cacheThemeConfig(config);
+      const themeId = this.getThemeId();
+      const promises = [this.cacheThemeConfig(config)];
+      if (themeId && config.file?.url) {
+        promises.push(
+          this.cacheThemeFileUrl(themeId, config.hash, config.file.url)
+        );
+      }
+      await Promise2.all(promises);
     }
     return config ?? null;
   }
+  getThemeId() {
+    return this.swell.swellHeaders["theme-id"];
+  }
   /**
    * Generates a Swell API query filter for this theme version.
    */
@@ -19327,13 +19412,15 @@ var SwellTheme3 = class {
     const [cart, account] = await Promise.all([
       this.fetchSingletonResourceCached(
         "cart",
+        // The cached cart may be null, but we need the StorefrontResource
         () => this.fetchCart(),
-        {}
+        // Default value (always StorefrontResource)
+        () => this.fetchCart()
       ),
       this.fetchSingletonResourceCached(
         "account",
         () => this.fetchAccount(),
-        null
+        () => null
       )
     ]);
     if (!cart) {
@@ -19356,13 +19443,14 @@ var SwellTheme3 = class {
   async fetchSingletonResourceCached(key, handler, defaultValue) {
     const cacheKey = this.swell.storefront.session.getCookie();
     if (!cacheKey) {
-      return defaultValue;
+      return defaultValue();
     }
-    return this.swell.getCachedResource(
+    const result = await this.swell.getCachedResource(
       `${key}-${cacheKey}`,
       [],
-      () => handler()
+      handler
     );
+    return result ?? defaultValue();
   }
   async fetchCart() {
     const CartResource = this.resources?.singletons?.cart;
@@ -19703,8 +19791,8 @@ var SwellTheme3 = class {
   /**
    * Preloads updated theme configs. Used to optimize initial theme load.
    */
-  async preloadThemeConfigs(version, configs) {
-    await this.themeLoader.preloadTheme(version, configs);
+  async preloadThemeConfigs(payload) {
+    await this.themeLoader.preloadTheme(payload);
   }
   getPageConfigPath(pageId, altTemplate) {
     if (this.shopifyCompatibility) {