@swell/apps-sdk 1.0.162 → 1.0.164

package/dist/index.cjs

@@ -7320,6 +7320,7 @@ var DEFAULT_OPTIONS = Object.freeze({
 });
 var NULL_VALUE = "__NULL__";
 var SWR_PROMISE_MAP = /* @__PURE__ */ new Map();
+var FETCH_PROMISE_MAP = /* @__PURE__ */ new Map();
 var Cache = class {
   client;
   workerCtx;
@@ -7332,8 +7333,30 @@ var Cache = class {
       ...options
     });
   }
-  async fetch(key, fetchFn, ttl) {
-    return this.client.wrap(key, fetchFn, ttl);
+  /**
+   * Always fetches fresh data and updates cache
+   * Deduplicates concurrent requests with the same key
+   * 
+   * @param key Cache key
+   * @param fetchFn Function to fetch fresh data
+   * @param ttl Time to live in milliseconds (default: DEFAULT_SWR_TTL)
+   * @param isCacheable Whether to store result in cache (default: true)
+   */
+  async fetch(key, fetchFn, ttl = DEFAULT_SWR_TTL, isCacheable = true) {
+    let promise = FETCH_PROMISE_MAP.get(key);
+    if (!promise) {
+      promise = Promise.resolve().then(fetchFn).then(resolveAsyncResources).then(async (value) => {
+        const isNull = value === null || value === void 0;
+        if (isCacheable) {
+          await this.client.set(key, isNull ? NULL_VALUE : value, ttl);
+        }
+        return value;
+      }).finally(() => {
+        FETCH_PROMISE_MAP.delete(key);
+      });
+      FETCH_PROMISE_MAP.set(key, promise);
+    }
+    return await promise;
   }
   /**
    * Fetch cache using SWR (stale-while-revalidate)
@@ -8441,18 +8464,24 @@ var Swell = class _Swell {
     }
     return params;
   }
+  /**
+   * Checks if cache bypass is requested via X-Cache-Bypass header
+   */
+  shouldBypassCache() {
+    return this.headers?.["x-cache-bypass"] === "revalidation";
+  }
   /**
    * Fetches a resource.
    * First attempts to fetch from cache.
    */
   async getCachedResource(key, args, handler, isCacheble = true) {
     const cacheKey = getCacheKey(key, [this.instanceId, args]);
-    return this.getResourceCache().fetchSWR(
-      cacheKey,
-      handler,
-      void 0,
-      isCacheble
-    );
+    const cache = this.getResourceCache();
+    if (this.shouldBypassCache()) {
+      return cache.fetch(cacheKey, handler, void 0, isCacheble);
+    } else {
+      return cache.fetchSWR(cacheKey, handler, void 0, isCacheble);
+    }
   }
   async getAppSettings() {
     const settings = await this.get(
@@ -8619,11 +8648,17 @@ var Swell = class _Swell {
           data,
           opt
         ]);
-        return this.getRequestCache().fetchSWR(key, () => {
+        const cache = this.getRequestCache();
+        const fetchFn = () => {
           const requestUrl = id ? `${url}/${id}` : url;
           logger.debug("[SDK] Cacheable API request", { url: requestUrl, key });
           return storefrontRequest(method, url, id, data, opt);
-        });
+        };
+        if (this.shouldBypassCache()) {
+          return cache.fetch(key, fetchFn);
+        } else {
+          return cache.fetchSWR(key, fetchFn);
+        }
       }
       switch (method) {
         case "delete":
@@ -16022,7 +16057,7 @@ function ShopifyAddress(instance, address, account) {
 function joinAddressLines(...props) {
   return props.filter(Boolean).join("\n");
 }
-function ShopifyCountry(_instance2, countryCode) {
+function ShopifyCountry(_instance, countryCode) {
   const currencyCode = getCurrencyByCountry(countryCode) || "USD";
   return new ShopifyResource(
     {
@@ -16355,7 +16390,7 @@ async function resolveLastOrder(instance, account) {
 }
 
 // src/compatibility/shopify-objects/font.ts
-function ShopifyFont(_instance2, font) {
+function ShopifyFont(_instance, font) {
   if (font instanceof ShopifyResource) {
     return font.clone();
   }
@@ -16366,7 +16401,7 @@ function ShopifyFont(_instance2, font) {
     family: font.family,
     style: font.style,
     "system?": font.system,
-    variants: font.variants.map((variant) => ShopifyFont(_instance2, variant)),
+    variants: font.variants.map((variant) => ShopifyFont(_instance, variant)),
     weight: font.weight
   });
 }
@@ -16379,7 +16414,7 @@ var SHOPIFY_FORMS = {
     })
   }
 };
-function ShopifyForm(_instance2, form) {
+function ShopifyForm(_instance, form) {
   if (form instanceof ShopifyResource) {
     return form.clone();
   }
@@ -16676,7 +16711,7 @@ function ShopifyRecommendations(instance, product) {
 }
 
 // src/compatibility/shopify-objects/page.ts
-function ShopifyPage(_instance2, page) {
+function ShopifyPage(_instance, page) {
   if (page instanceof ShopifyResource) {
     return page.clone();
   }
@@ -17888,7 +17923,7 @@ ${injects.join("\n")}</script>`;
 };
 
 // src/compatibility/shopify-objects/template.ts
-function ShopifyTemplate(_instance2, template) {
+function ShopifyTemplate(_instance, template) {
   return new ShopifyResource(
     {
       directory: template.path,
@@ -22465,9 +22500,7 @@ var DEFAULT_CACHE_RULES = {
     preview: { ttl: 10, swr: 60 * 60 * 24 * 7 }
     // 10s TTL, 1 week SWR
   },
-  pathRules: [
-    { path: "/checkout/*", skip: true }
-  ]
+  pathRules: [{ path: "/checkout/*", skip: true }]
 };
 var HtmlCache = class {
   epoch;
@@ -22557,6 +22590,16 @@ var HtmlCache = class {
       const ttl = this.getTTLForRequest(request);
       const swr = this.getSWRForRequest(request);
       const body = await response.text();
+      if (!body || body.trim().length === 0) {
+        logger.warn(
+          "[SDK Html-cache] put skipped, empty or minimal response body",
+          {
+            trace,
+            bodyLength: body.length
+          }
+        );
+        return;
+      }
       const cacheTimeISO = (/* @__PURE__ */ new Date()).toISOString();
       const headers = this.normalizeHeaders(response.headers);
       const entry = {
@@ -22614,7 +22657,7 @@ var HtmlCache = class {
   }
   buildClientResponse(entry, isStale, age) {
     const headers = new Headers(entry.headers);
-    headers.set("Cache-Control", "public, max-age=0, must-revalidate");
+    headers.set("Cache-Control", "public, max-age=1, must-revalidate");
     headers.set(
       "Cloudflare-CDN-Cache-Control",
       `public, s-maxage=${entry.ttl}, stale-while-revalidate=${entry.swr}, stale-if-error=60`
@@ -22709,7 +22752,7 @@ var HtmlCache = class {
     const accept = headers.get("accept") || "";
     const versionFactors = {
       store: headers.get("swell-storefront-id") || "",
-      app: (headers.get("swell-app-id") || "") + "@" + (swellData["swell-app-version"] || ""),
+      app: (headers.get("swell-app-id") || "") + "@" + (headers.get("host") || ""),
       auth: headers.get("swell-access-token") || "",
       theme: headers.get("swell-theme-version-hash") || "",
       modified: headers.get("swell-cache-modified") || "",
@@ -22975,7 +23018,6 @@ var WorkerCacheBackend = class {
       statusText: entry.statusText,
       headers
     });
-    await cache.delete(request);
     await cache.put(request, response);
   }
   async delete(key) {
@@ -22986,19 +23028,15 @@ var WorkerCacheBackend = class {
 };
 
 // src/cache/html-cache/html-cache-factory.ts
-var _instance = null;
 function getHtmlCache(env, cacheRules) {
   const epoch = env?.HTML_CACHE_EPOCH;
   if (typeof epoch !== "string" || !epoch) return null;
-  if (_instance) return _instance;
   const kv = env?.NAMESPACE;
   const rules = cacheRules || env?.HTML_CACHE_RULES;
   if (env?.HTML_CACHE_BACKEND !== "worker" && kv) {
-    _instance = new HtmlCache(epoch, new KVCacheBackend(kv), rules);
-    return _instance;
+    return new HtmlCache(epoch, new KVCacheBackend(kv), rules);
   }
-  _instance = new HtmlCache(epoch, new WorkerCacheBackend(epoch), rules);
-  return _instance;
+  return new HtmlCache(epoch, new WorkerCacheBackend(epoch), rules);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {