@swell/apps-sdk 1.0.139 → 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
@@ -18924,28 +18943,30 @@ var ThemeLoader = class _ThemeLoader {
    * Fetches a theme config by file path.
    */
   async fetchThemeConfig(filePath) {
-    const themeConfig = this.configs.get(filePath);
-    if (themeConfig !== void 0) {
-      return themeConfig;
+    const config = this.configs.get(filePath);
+    if (config !== void 0) {
+      return config;
     }
     const hash = this.manifest?.get(filePath);
     if (!hash) {
       return null;
     }
     const cache = this.getCache();
-    let config = await cache.get(`config:${hash}`);
-    if (config) {
-      const themeId = this.getThemeId();
-      if (themeId && config.file?.url) {
-        const fileUrl = await cache.get(
-          `file:${themeId}:${config.hash}`
-        );
-        if (fileUrl) {
-          config = { ...config, file: { ...config.file, url: fileUrl } };
-        }
+    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 }
+        };
       }
-      this.configs.set(filePath, config);
-      return config;
+      this.configs.set(filePath, config2);
+      return config2;
     }
     return this.fetchThemeConfigsFromSourceByPath(filePath, hash);
   }
@@ -18994,18 +19015,20 @@ var ThemeLoader = class _ThemeLoader {
     await Promise2.map(
       manifest.values(),
       async (configHash) => {
-        let config = await cache.get(`config:${configHash}`);
-        if (!config) {
+        const [themeConfig, fileUrl] = await Promise2.all([
+          cache.get(`config:${configHash}`),
+          themeId ? cache.get(`file:${themeId}:${configHash}`) : void 0
+        ]);
+        if (!themeConfig) {
           configHashesUnresolved.push(configHash);
           return;
         }
-        if (themeId && config.file?.url) {
-          const fileUrl = await cache.get(
-            `file:${themeId}:${configHash}`
-          );
-          if (fileUrl) {
-            config = { ...config, file: { ...config.file, url: fileUrl } };
-          }
+        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);
@@ -19389,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) {
@@ -19418,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;