@swell/apps-sdk 1.0.161 → 1.0.163

package/dist/index.cjs

@@ -42,6 +42,7 @@ __export(index_exports, {
   CartResource: () => CartResource,
   CategoriesResource: () => CategoriesResource,
   CategoryResource: () => CategoryResource,
+  DEFAULT_CACHE_RULES: () => DEFAULT_CACHE_RULES,
   DEFAULT_QUERY_PAGE_LIMIT: () => DEFAULT_QUERY_PAGE_LIMIT,
   DeferredShopifyResource: () => DeferredShopifyResource,
   FILE_DATA_INCLUDE_QUERY: () => FILE_DATA_INCLUDE_QUERY,
@@ -7319,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;
@@ -7331,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)
@@ -8440,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(
@@ -8618,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":
@@ -16021,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(
     {
@@ -16354,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();
   }
@@ -16365,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
   });
 }
@@ -16378,7 +16414,7 @@ var SHOPIFY_FORMS = {
     })
   }
 };
-function ShopifyForm(_instance2, form) {
+function ShopifyForm(_instance, form) {
   if (form instanceof ShopifyResource) {
     return form.clone();
   }
@@ -16675,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();
   }
@@ -17887,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,
@@ -20819,12 +20855,7 @@ var SwellTheme3 = class {
         // Default value (always StorefrontResource)
         () => this.fetchCart()
       ),
-      this.fetchSingletonResourceCached(
-        "account",
-        () => this.fetchAccount(),
-        () => null,
-        false
-      )
+      this.fetchAccount()
     ]);
     if (!cart) {
       throw new Error("Failed to fetch cart");
@@ -22462,42 +22493,27 @@ function getResourceQuery(slug, query) {
 
 // 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 };
     }
@@ -22565,31 +22581,27 @@ var HtmlCache = class {
   }
   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,
@@ -22623,14 +22635,13 @@ var HtmlCache = class {
       });
     }
   }
-  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);
@@ -22646,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`
@@ -22741,6 +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"] || ""),
       auth: headers.get("swell-access-token") || "",
       theme: headers.get("swell-theme-version-hash") || "",
       modified: headers.get("swell-cache-modified") || "",
@@ -22763,11 +22775,16 @@ var HtmlCache = class {
       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;
@@ -22783,24 +22800,33 @@ var HtmlCache = class {
   }
   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);
@@ -22808,6 +22834,22 @@ var HtmlCache = class {
     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",
@@ -22976,7 +23018,6 @@ var WorkerCacheBackend = class {
       statusText: entry.statusText,
       headers
     });
-    await cache.delete(request);
     await cache.put(request, response);
   }
   async delete(key) {
@@ -22987,18 +23028,15 @@ var WorkerCacheBackend = class {
 };
 
 // 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);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -23014,6 +23052,7 @@ function getHtmlCache(env) {
   CartResource,
   CategoriesResource,
   CategoryResource,
+  DEFAULT_CACHE_RULES,
   DEFAULT_QUERY_PAGE_LIMIT,
   DeferredShopifyResource,
   FILE_DATA_INCLUDE_QUERY,