@swell/apps-sdk 1.0.161 → 1.0.163

package/dist/index.js

@@ -7199,6 +7199,7 @@
   });
   var NULL_VALUE = "__NULL__";
   var SWR_PROMISE_MAP = /* @__PURE__ */ new Map();
+  var FETCH_PROMISE_MAP = /* @__PURE__ */ new Map();
   var Cache = class {
     client;
     workerCtx;
@@ -7211,8 +7212,30 @@
         ...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)
@@ -8320,18 +8343,24 @@
       }
       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(
@@ -8498,11 +8527,17 @@
             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":
@@ -15901,7 +15936,7 @@ ${formattedMessage}`;
   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(
       {
@@ -16234,7 +16269,7 @@ ${formattedMessage}`;
   }
 
   // src/compatibility/shopify-objects/font.ts
-  function ShopifyFont(_instance2, font) {
+  function ShopifyFont(_instance, font) {
     if (font instanceof ShopifyResource) {
       return font.clone();
     }
@@ -16245,7 +16280,7 @@ ${formattedMessage}`;
       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
     });
   }
@@ -16258,7 +16293,7 @@ ${formattedMessage}`;
       })
     }
   };
-  function ShopifyForm(_instance2, form) {
+  function ShopifyForm(_instance, form) {
     if (form instanceof ShopifyResource) {
       return form.clone();
     }
@@ -16555,7 +16590,7 @@ ${formattedMessage}`;
   }
 
   // src/compatibility/shopify-objects/page.ts
-  function ShopifyPage(_instance2, page) {
+  function ShopifyPage(_instance, page) {
     if (page instanceof ShopifyResource) {
       return page.clone();
     }
@@ -17767,7 +17802,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,
@@ -20699,12 +20734,7 @@ ${injects.join("\n")}<\/script>`;
           // Default value (always StorefrontResource)
           () => this.fetchCart()
         ),
-        this.fetchSingletonResourceCached(
-          "account",
-          () => this.fetchAccount(),
-          () => null,
-          false
-        )
+        this.fetchAccount()
       ]);
       if (!cart) {
         throw new Error("Failed to fetch cart");
@@ -22342,42 +22372,27 @@ ${this.shopifyCompatibility.getContentForHeader()}`;
 
   // src/cache/html-cache/html-cache.ts
   var CACHE_KEY_ORIGIN = "https://cache.swell.store";
-  var TTL_CONFIG = {
-    LIVE: {
-      DEFAULT: 20,
-      HOME: 20,
-      PRODUCT: 20,
-      COLLECTION: 20,
-      PAGE: 20,
-      BLOG: 20,
-      SWR: 60 * 60 * 24 * 7
-      // 1 week
-    },
-    PREVIEW: {
-      DEFAULT: 10,
-      HOME: 10,
-      PRODUCT: 10,
-      COLLECTION: 10,
-      PAGE: 10,
-      BLOG: 10,
-      SWR: 60 * 60 * 24 * 7
-      // 1 week
-    }
+  var DEFAULT_CACHE_RULES = {
+    defaults: {
+      live: { ttl: 20, swr: 60 * 60 * 24 * 7 },
+      // 20s TTL, 1 week SWR
+      preview: { ttl: 10, swr: 60 * 60 * 24 * 7 }
+      // 10s TTL, 1 week SWR
+    },
+    pathRules: [{ path: "/checkout/*", skip: true }]
   };
   var HtmlCache = class {
     epoch;
     backend;
-    constructor(epoch, backend) {
+    cacheRules;
+    constructor(epoch, backend, cacheRules = DEFAULT_CACHE_RULES) {
       this.epoch = epoch;
       this.backend = backend;
+      this.cacheRules = cacheRules;
     }
     async get(request) {
       const trace = createTraceId();
-      if (request.method !== "GET") {
-        logger.debug("[SDK Html-cache] non-cacheable method", { trace });
-        return { found: false, cacheable: false };
-      }
-      if (!this.isCacheable(request)) {
+      if (!this.canReadFromCache(request)) {
         logger.debug("[SDK Html-cache] non-cacheable request", { trace });
         return { found: false, cacheable: false };
       }
@@ -22445,31 +22460,27 @@ ${this.shopifyCompatibility.getContentForHeader()}`;
     }
     async put(request, response) {
       const trace = createTraceId();
-      if (request.method !== "GET" || !response.ok) {
-        logger.debug("[SDK Html-cache] put skipped, invalid method or response", {
-          trace
-        });
-        return;
-      }
-      if (!this.isCacheable(request) || !this.isResponseCacheable(response)) {
+      if (!this.canWriteToCache(request, response)) {
         logger.debug("[SDK Html-cache] put skipped, non-cacheable", { trace });
         return;
       }
       try {
-        let lowercaseHeaders2 = function(headers2) {
-          const out = {};
-          headers2.forEach((value, key) => {
-            out[key.toLowerCase()] = value;
-          });
-          return out;
-        };
-        var lowercaseHeaders = lowercaseHeaders2;
         const cacheKey = this.buildCacheKey(request);
         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 = lowercaseHeaders2(response.headers);
+        const headers = this.normalizeHeaders(response.headers);
         const entry = {
           status: response.status,
           statusText: response.statusText,
@@ -22503,14 +22514,13 @@ ${this.shopifyCompatibility.getContentForHeader()}`;
         });
       }
     }
-    isReadCacheCandidate(request) {
-      const m = request.method.toUpperCase();
-      return (m === "GET" || m === "HEAD") && this.isCacheable(request);
+    canReadFromCache(request) {
+      const method = request.method.toUpperCase();
+      return (method === "GET" || method === "HEAD") && this.isRequestCacheable(request);
     }
-    isWriteCacheCandidate(request, response) {
-      if (request.method.toUpperCase() !== "GET") return false;
-      if (!this.isCacheable(request)) return false;
-      return this.isResponseCacheable(response);
+    canWriteToCache(request, response) {
+      const method = request.method.toUpperCase();
+      return method === "GET" && response.ok && this.isRequestCacheable(request) && this.isResponseCacheable(response);
     }
     createRevalidationRequest(request) {
       const headers = new Headers(request.headers);
@@ -22526,7 +22536,7 @@ ${this.shopifyCompatibility.getContentForHeader()}`;
     }
     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`
@@ -22621,6 +22631,7 @@ ${this.shopifyCompatibility.getContentForHeader()}`;
       const accept = headers.get("accept") || "";
       const versionFactors = {
         store: headers.get("swell-storefront-id") || "",
+        app: (headers.get("swell-app-id") || "") + "@" + (swellData["swell-app-version"] || ""),
         auth: headers.get("swell-access-token") || "",
         theme: headers.get("swell-theme-version-hash") || "",
         modified: headers.get("swell-cache-modified") || "",
@@ -22643,11 +22654,16 @@ ${this.shopifyCompatibility.getContentForHeader()}`;
         return {};
       }
     }
-    isCacheable(request) {
+    isRequestCacheable(request) {
       const url = new URL(request.url);
       if (request.headers.get("swell-deployment-mode") === "editor") return false;
-      const skipPaths = ["/checkout"];
-      if (skipPaths.some((path) => url.pathname.startsWith(path))) return false;
+      if (this.cacheRules.pathRules) {
+        for (const rule of this.cacheRules.pathRules) {
+          if (this.pathMatches(rule.path, url.pathname) && rule.skip) {
+            return false;
+          }
+        }
+      }
       if (request.headers.get("cache-control")?.includes("no-cache"))
         return false;
       return true;
@@ -22663,24 +22679,33 @@ ${this.shopifyCompatibility.getContentForHeader()}`;
     }
     getDeploymentMode(headers) {
       const mode = headers.get("swell-deployment-mode");
-      return mode === "preview" || mode === "editor" ? mode : "live";
+      return mode === "preview" ? "preview" : "live";
     }
     getTTLForRequest(request) {
       const url = new URL(request.url);
       const mode = this.getDeploymentMode(request.headers);
-      if (mode === "editor") return 0;
-      const config = mode === "preview" ? TTL_CONFIG.PREVIEW : TTL_CONFIG.LIVE;
-      if (url.pathname === "/") return config.HOME;
-      if (url.pathname.startsWith("/products/")) return config.PRODUCT;
-      if (url.pathname.startsWith("/categories/")) return config.COLLECTION;
-      if (url.pathname.startsWith("/pages/")) return config.PAGE;
-      if (url.pathname.startsWith("/blogs/")) return config.BLOG;
-      return config.DEFAULT;
+      if (this.cacheRules.pathRules) {
+        for (const rule of this.cacheRules.pathRules) {
+          if (this.pathMatches(rule.path, url.pathname) && rule.ttl !== void 0) {
+            return rule.ttl;
+          }
+        }
+      }
+      const defaults = this.cacheRules.defaults?.[mode];
+      return defaults?.ttl ?? DEFAULT_CACHE_RULES.defaults[mode].ttl;
     }
     getSWRForRequest(request) {
+      const url = new URL(request.url);
       const mode = this.getDeploymentMode(request.headers);
-      if (mode === "editor") return 0;
-      return mode === "preview" ? TTL_CONFIG.PREVIEW.SWR : TTL_CONFIG.LIVE.SWR;
+      if (this.cacheRules.pathRules) {
+        for (const rule of this.cacheRules.pathRules) {
+          if (this.pathMatches(rule.path, url.pathname) && rule.swr !== void 0) {
+            return rule.swr;
+          }
+        }
+      }
+      const defaults = this.cacheRules.defaults?.[mode];
+      return defaults?.swr ?? DEFAULT_CACHE_RULES.defaults[mode].swr;
     }
     getEntryAge(entry) {
       const t = Date.parse(entry.cacheTimeISO);
@@ -22688,6 +22713,22 @@ ${this.shopifyCompatibility.getContentForHeader()}`;
       const age = (Date.now() - t) / 1e3;
       return age < 0 ? 0 : age;
     }
+    /**
+     * Converts wildcard pattern to regex and tests against path.
+     * - * matches any characters except /
+     * - ** matches any characters including /
+     */
+    pathMatches(pattern, path) {
+      const regex = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "___DOUBLE_STAR___").replace(/\*/g, "[^/]*").replace(/___DOUBLE_STAR___/g, ".*");
+      return new RegExp(`^${regex}$`).test(path);
+    }
+    normalizeHeaders(headers) {
+      const normalized = {};
+      headers.forEach((value, key) => {
+        normalized[key.toLowerCase()] = value;
+      });
+      return normalized;
+    }
     normalizeSearchParams(searchParams) {
       const ignoredParams = [
         "utm_source",
@@ -22856,7 +22897,6 @@ ${this.shopifyCompatibility.getContentForHeader()}`;
         statusText: entry.statusText,
         headers
       });
-      await cache.delete(request);
       await cache.put(request, response);
     }
     async delete(key) {
@@ -22867,18 +22907,15 @@ ${this.shopifyCompatibility.getContentForHeader()}`;
   };
 
   // src/cache/html-cache/html-cache-factory.ts
-  var _instance = null;
-  function getHtmlCache(env) {
+  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));
-      return _instance;
+      return new HtmlCache(epoch, new KVCacheBackend(kv), rules);
     }
-    _instance = new HtmlCache(epoch, new WorkerCacheBackend(epoch));
-    return _instance;
+    return new HtmlCache(epoch, new WorkerCacheBackend(epoch), rules);
   }
 })();
 //# sourceMappingURL=index.js.map