@swell/apps-sdk 1.0.151 → 1.0.153

package/dist/index.js

@@ -41,72 +41,6 @@
   var import_keyv = __require("keyv");
   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
-    opts;
-    constructor(store) {
-      this.store = store;
-      this.opts = null;
-      this.namespace = "dummy";
-    }
-    async has(key) {
-      const stream = await this.store.get(key, "stream");
-      if (stream !== null) {
-        await stream.cancel();
-        return true;
-      }
-      return false;
-    }
-    async get(key) {
-      const value = await this.store.get(key);
-      return value !== null ? value : void 0;
-    }
-    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;
-      const prefix = `${this.namespace}:`;
-      do {
-        const response = await this.store.list({
-          prefix,
-          cursor: cursor || void 0
-        });
-        cursor = response.cursor ?? "";
-        complete = response.list_complete;
-        if (response.keys.length > 0) {
-          await Promise.all(
-            response.keys.map((key) => {
-              return this.store.delete(key.name);
-            })
-          );
-        }
-      } while (!complete);
-    }
-    on(_event, _listener) {
-      return this;
-    }
-  };
-
-  // src/utils/index.ts
-  var import_qs = __toESM(__require("qs"), 1);
-  var import_lodash_es3 = __require("lodash-es");
-  var import_json52 = __toESM(__require("json5"), 1);
-
-  // src/resources.ts
-  var import_lodash_es2 = __require("lodash-es");
-
   // src/utils/logger.ts
   var logLevels = {
     error: 0,
@@ -198,6 +132,80 @@
     return (hash >>> 0).toString(16);
   }
 
+  // src/cache/cf-worker-kv-keyv-adapter.ts
+  var CFWorkerKVKeyvAdapter = class {
+    store;
+    namespace;
+    // magically passed in from Keyv
+    opts;
+    constructor(store) {
+      this.store = store;
+      this.opts = null;
+      this.namespace = "dummy";
+    }
+    async has(key) {
+      const stream = await this.store.get(key, "stream");
+      if (stream !== null) {
+        await stream.cancel();
+        return true;
+      }
+      return false;
+    }
+    async get(key) {
+      const trace = createTraceId();
+      logger.debug("[SDK] kv.get", { key, trace });
+      const value = await this.store.get(key);
+      const result = value !== null ? value : void 0;
+      logger.debug(`[SDK] kv.get ${value !== null ? "HIT" : "MISS"}`, {
+        key,
+        trace
+      });
+      return result;
+    }
+    set(key, value, ttl) {
+      if (typeof ttl === "number") {
+        ttl = Math.max(60, ttl / 1e3);
+      }
+      logger.debug("[SDK] kv.set", { key });
+      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;
+      const prefix = `${this.namespace}:`;
+      do {
+        const response = await this.store.list({
+          prefix,
+          cursor: cursor || void 0
+        });
+        cursor = response.cursor ?? "";
+        complete = response.list_complete;
+        if (response.keys.length > 0) {
+          await Promise.all(
+            response.keys.map((key) => {
+              return this.store.delete(key.name);
+            })
+          );
+        }
+      } while (!complete);
+    }
+    on(_event, _listener) {
+      return this;
+    }
+  };
+
+  // src/utils/index.ts
+  var import_qs = __toESM(__require("qs"), 1);
+  var import_lodash_es3 = __require("lodash-es");
+  var import_json52 = __toESM(__require("json5"), 1);
+
+  // src/resources.ts
+  var import_lodash_es2 = __require("lodash-es");
+
   // src/liquid/utils.ts
   var import_liquidjs = __require("liquidjs");
 
@@ -841,6 +849,7 @@
             this._collection,
             this._query,
             this._swell.queryParams,
+            // TODO: consider to exlcude
             this._getterHash
           ],
           getter,
@@ -969,6 +978,7 @@
             this._id,
             this._query,
             this._swell.queryParams,
+            // TODO: consider to exlcude
             this._getterHash
           ],
           getter,
@@ -7197,8 +7207,6 @@
      * This will always return the cached value immediately if exists
      */
     async fetchSWR(key, fetchFn, ttl = DEFAULT_SWR_TTL, isCacheble = true) {
-      const trace = createTraceId();
-      logger.debug("[SDK] Cache fetch start", { key, trace });
       const cacheValue = isCacheble ? await this.client.get(key) : void 0;
       let promise = SWR_PROMISE_MAP.get(key);
       if (promise === void 0) {
@@ -7206,7 +7214,6 @@
           const isNull = value === null || value === void 0;
           if (isCacheble) {
             await this.client.set(key, isNull ? NULL_VALUE : value, ttl);
-            logger.debug("[SDK] Cache update done", { key, trace });
           }
           return value;
         }).finally(() => {
@@ -7218,12 +7225,9 @@
         this.workerCtx.waitUntil(promise);
       }
       if (cacheValue !== void 0) {
-        logger.debug("[SDK] Cache check done", { status: "HIT", key, trace });
         return cacheValue === NULL_VALUE ? null : cacheValue;
       }
-      logger.debug("[SDK] Cache check done", { status: "MISS", key, trace });
       const result = await promise;
-      logger.debug("[SDK] Cache fetch end", { key, trace });
       return result;
     }
     async get(key) {
@@ -7730,6 +7734,384 @@
     }
   };
 
+  // src/cache/worker-html-cache.ts
+  var CACHE_NAME2 = "swell-html-v1";
+  var CACHE_KEY_ORIGIN2 = "https://cache.swell.store";
+  var TTL_CONFIG = {
+    LIVE: {
+      DEFAULT: 300,
+      // 5 minutes
+      HOME: 300,
+      // 5 minutes
+      PRODUCT: 600,
+      // 10 minutes
+      COLLECTION: 900,
+      // 15 minutes
+      PAGE: 3600,
+      // 1 hour
+      BLOG: 1800,
+      // 30 minutes
+      SWR: 3600
+      // 1 hour stale-while-revalidate
+    },
+    PREVIEW: {
+      DEFAULT: 5,
+      // 1 minute - faster updates in preview
+      HOME: 5,
+      // 1 minute
+      PRODUCT: 5,
+      // 2 minutes
+      COLLECTION: 5,
+      // 3 minutes
+      PAGE: 5,
+      // 5 minutes
+      BLOG: 5,
+      // 5 minutes
+      SWR: 600
+      // 10 minutes stale-while-revalidate
+    }
+  };
+  var WorkerHtmlCache = class {
+    epoch;
+    constructor(epoch) {
+      this.epoch = epoch;
+    }
+    async get(request) {
+      const trace = createTraceId();
+      if (request.method !== "GET") {
+        logger.debug("[SDK Html-cache] non-cacheable", { trace });
+        return { found: false, cacheable: false };
+      }
+      if (!this.isCacheable(request)) {
+        logger.debug("[SDK Html-cache] non-cacheable", { trace });
+        return { found: false, cacheable: false };
+      }
+      try {
+        const cache = await caches.open(CACHE_NAME2 + this.epoch);
+        const cacheKey = this.buildCacheKey(request);
+        const cached = await cache.match(cacheKey);
+        if (!cached) {
+          logger.debug("[SDK Html-cache] cacheable, MISS", { trace });
+          return { found: false, cacheable: true };
+        }
+        const age = this.getResponseAge(cached);
+        const ttl = parseInt(cached.headers.get("X-Original-TTL") || "") || this.getTTLForRequest(request);
+        const swr = parseInt(cached.headers.get("X-Original-SWR") || "") || this.getSWRForRequest(request);
+        const isStale = age >= ttl;
+        const isExpired = age >= ttl + swr;
+        if (!isExpired) {
+          logger.debug("[SDK Html-cache] cacheable, HIT", {
+            stale: isStale,
+            age,
+            trace
+          });
+          const clientResponse = this.buildClientResponse(
+            cached,
+            ttl,
+            swr,
+            isStale,
+            age
+          );
+          return {
+            found: true,
+            stale: isStale,
+            response: clientResponse,
+            cacheable: true,
+            age: Math.floor(age)
+          };
+        }
+        logger.debug("[SDK Html-cache] cacheable, hit, expired", { trace });
+        return { found: false, cacheable: true };
+      } catch (_) {
+        logger.warn("[SDK Html-cache] no get support", { trace });
+        return null;
+      }
+    }
+    // 304 support
+    async getWithConditionals(request) {
+      const result = await this.get(request);
+      if (!result?.found || result.stale) {
+        return result;
+      }
+      const ifModifiedSince = request.headers.get("If-Modified-Since");
+      const ifNoneMatch = request.headers.get("If-None-Match");
+      if ((ifModifiedSince || ifNoneMatch) && result.response) {
+        const lastModified = result.response.headers.get("Last-Modified");
+        const etag = result.response.headers.get("ETag");
+        if (this.checkNotModified(ifModifiedSince, ifNoneMatch, lastModified, etag)) {
+          result.notModified = true;
+          result.conditional304 = new Response(null, {
+            status: 304,
+            headers: {
+              "Last-Modified": lastModified || "",
+              ETag: etag || "",
+              "Cache-Control": result.response.headers.get("Cache-Control") || "",
+              "Cloudflare-CDN-Cache-Control": result.response.headers.get("Cloudflare-CDN-Cache-Control") || "",
+              "X-Cache-Status": "HIT-304"
+            }
+          });
+        }
+      }
+      return result;
+    }
+    checkNotModified(ifModifiedSince, ifNoneMatch, lastModified, etag) {
+      if (ifNoneMatch && etag) {
+        return ifNoneMatch === etag;
+      }
+      if (ifModifiedSince && lastModified) {
+        const ifModDate = new Date(ifModifiedSince);
+        const lastModDate = new Date(lastModified);
+        return !isNaN(ifModDate.getTime()) && !isNaN(lastModDate.getTime()) && ifModDate >= lastModDate;
+      }
+      return false;
+    }
+    createRevalidationRequest(request) {
+      const headers = new Headers(request.headers);
+      headers.set("X-Cache-Bypass", "revalidation");
+      headers.delete("If-None-Match");
+      headers.delete("If-Modified-Since");
+      headers.delete("Cache-Control");
+      headers.delete("Pragma");
+      return new Request(request.url, {
+        method: "GET",
+        headers
+      });
+    }
+    async put(request, response) {
+      const trace = createTraceId();
+      if (request.method !== "GET" || !response.ok) {
+        logger.debug("[SDK Html-cache] put skipped", { trace });
+        return;
+      }
+      if (!this.isCacheable(request) || !this.isResponseCacheable(response)) {
+        logger.debug("[SDK Html-cache] put skipped, non-cacheable", {
+          trace
+        });
+        return;
+      }
+      try {
+        const cache = await caches.open(CACHE_NAME2 + this.epoch);
+        const cacheKey = this.buildCacheKey(request);
+        await cache.delete(cacheKey);
+        const ttl = this.getTTLForRequest(request);
+        const swr = this.getSWRForRequest(request);
+        const headers = new Headers(response.headers);
+        const existingCacheControl = response.headers.get("Cache-Control");
+        if (!existingCacheControl || existingCacheControl === "public") {
+          const internalMaxAge = ttl + swr;
+          headers.set("Cache-Control", `public, max-age=${internalMaxAge}`);
+        }
+        const cacheTime = (/* @__PURE__ */ new Date()).toISOString();
+        headers.set("X-Cache-Time", cacheTime);
+        headers.set("X-Original-TTL", ttl.toString());
+        headers.set("X-Original-SWR", swr.toString());
+        if (!headers.get("Last-Modified")) {
+          headers.set("Last-Modified", new Date(cacheTime).toUTCString());
+        }
+        const cacheableResponse = new Response(response.body, {
+          status: response.status,
+          statusText: response.statusText,
+          headers
+        });
+        await cache.put(cacheKey, cacheableResponse);
+        logger.debug("[SDK Html-cache] put done", { trace });
+      } catch (_) {
+        logger.warn("[SDK Html-cache] no put support", { trace });
+      }
+    }
+    buildClientResponse(cachedResponse, ttl, swr, isStale, age) {
+      const headers = new Headers(cachedResponse.headers);
+      headers.set(
+        "Cache-Control",
+        `public, max-age=${ttl}, stale-while-revalidate=${swr}`
+      );
+      headers.set(
+        "Cloudflare-CDN-Cache-Control",
+        `public, s-maxage=${ttl}, stale-while-revalidate=${swr}, stale-if-error=60`
+      );
+      const cacheTime = headers.get("X-Cache-Time");
+      if (cacheTime) {
+        const lastModified = new Date(cacheTime).toUTCString();
+        headers.set("Last-Modified", lastModified);
+      }
+      headers.set("X-Cache-Status", isStale ? "STALE" : "HIT");
+      headers.set("X-Cache-Age", Math.floor(age).toString());
+      headers.delete("X-Original-TTL");
+      headers.delete("X-Original-SWR");
+      headers.delete("X-Cache-Time");
+      return new Response(cachedResponse.body, {
+        status: cachedResponse.status,
+        statusText: cachedResponse.statusText,
+        headers
+      });
+    }
+    buildCacheKey(request) {
+      const url = new URL(request.url);
+      const versionHash = this.generateVersionHash(request.headers);
+      const normalizedQuery = this.normalizeSearchParams(url.searchParams);
+      const cacheKeyPath = `${versionHash}${url.pathname}`;
+      const keyUrl = new URL(`${CACHE_KEY_ORIGIN2}${cacheKeyPath}`);
+      if (normalizedQuery) {
+        keyUrl.search = `?${normalizedQuery}`;
+      }
+      const sanitizedHeaders = this.sanitizeHeaders(request.headers);
+      return new Request(keyUrl.toString(), {
+        method: "GET",
+        headers: sanitizedHeaders
+      });
+    }
+    sanitizeHeaders(originalHeaders) {
+      const CACHE_RELEVANT_HEADERS = [
+        // Content negotiation (affects response format)
+        "accept",
+        "accept-language"
+      ];
+      const sanitized = new Headers();
+      CACHE_RELEVANT_HEADERS.forEach((header) => {
+        const value = originalHeaders.get(header);
+        if (value) {
+          sanitized.set(header, value);
+        }
+      });
+      return sanitized;
+    }
+    generateVersionHash(headers) {
+      const swellData = this.extractSwellData(headers);
+      const versionFactors = {
+        store: headers.get("swell-storefront-id") || "",
+        auth: headers.get("swell-access-token") || "",
+        theme: headers.get("swell-theme-version-hash") || "",
+        modified: headers.get("swell-cache-modified") || "",
+        currency: swellData["swell-currency"] || "USD",
+        locale: headers.get("x-locale") || headers.get("accept-language")?.split(",")[0] || "default",
+        context: headers.get("swell-storefront-context"),
+        epoch: this.epoch
+      };
+      return md5(JSON.stringify(versionFactors));
+    }
+    extractSwellData(headers) {
+      const cookie = headers.get("cookie");
+      if (!cookie) return {};
+      const swellDataMatch = cookie.match(/swell-data=([^;]+)/);
+      if (!swellDataMatch) return {};
+      try {
+        const parsed = JSON.parse(decodeURIComponent(swellDataMatch[1]));
+        if (typeof parsed === "object" && parsed !== null) {
+          return parsed;
+        }
+        return {};
+      } catch {
+        return {};
+      }
+    }
+    isCacheable(request) {
+      const url = new URL(request.url);
+      const headers = request.headers;
+      if (headers.get("swell-deployment-mode") === "editor") {
+        return false;
+      }
+      const skipPaths = ["/checkout"];
+      if (skipPaths.some((path) => url.pathname.startsWith(path))) {
+        return false;
+      }
+      if (headers.get("cache-control")?.includes("no-cache")) {
+        return false;
+      }
+      return true;
+    }
+    isResponseCacheable(response) {
+      const contentType = response.headers.get("content-type");
+      if (!contentType?.includes("text/html")) {
+        return false;
+      }
+      if (response.headers.get("set-cookie")) {
+        return false;
+      }
+      const cacheControl = response.headers.get("cache-control");
+      if (cacheControl?.includes("no-store") || cacheControl?.includes("private")) {
+        return false;
+      }
+      return true;
+    }
+    getDeploymentMode(headers) {
+      const mode = headers.get("swell-deployment-mode");
+      if (mode === "preview" || mode === "editor") {
+        return mode;
+      }
+      return "live";
+    }
+    getTTLForRequest(request) {
+      const url = new URL(request.url);
+      const path = url.pathname;
+      const mode = this.getDeploymentMode(request.headers);
+      if (mode === "editor") {
+        return 0;
+      }
+      const config = mode === "preview" ? TTL_CONFIG.PREVIEW : TTL_CONFIG.LIVE;
+      if (path === "/") {
+        return config.HOME;
+      }
+      if (path.startsWith("/products/")) {
+        return config.PRODUCT;
+      }
+      if (path.startsWith("/categories/")) {
+        return config.COLLECTION;
+      }
+      if (path.startsWith("/pages/")) {
+        return config.PAGE;
+      }
+      if (path.startsWith("/blogs/")) {
+        return config.BLOG;
+      }
+      return config.DEFAULT;
+    }
+    getSWRForRequest(request) {
+      const mode = this.getDeploymentMode(request.headers);
+      if (mode === "editor") {
+        return 0;
+      }
+      return mode === "preview" ? TTL_CONFIG.PREVIEW.SWR : TTL_CONFIG.LIVE.SWR;
+    }
+    getResponseAge(response) {
+      const cacheTime = response.headers.get("X-Cache-Time");
+      if (!cacheTime) {
+        return Infinity;
+      }
+      const cacheDate = new Date(cacheTime);
+      if (isNaN(cacheDate.getTime())) {
+        return Infinity;
+      }
+      const age = (Date.now() - cacheDate.getTime()) / 1e3;
+      return Math.max(0, age);
+    }
+    normalizeSearchParams(searchParams) {
+      const ignoredParams = [
+        "utm_source",
+        "utm_medium",
+        "utm_campaign",
+        "utm_content",
+        "utm_term",
+        "fbclid",
+        "gclid",
+        "gbraid",
+        "wbraid",
+        "ref",
+        "source",
+        "mc_cid",
+        "mc_eid"
+      ];
+      const relevantParams = [];
+      searchParams.forEach((value, key) => {
+        if (!ignoredParams.includes(key)) {
+          relevantParams.push(
+            `${encodeURIComponent(key)}=${encodeURIComponent(value)}`
+          );
+        }
+      });
+      return relevantParams.sort().join("&");
+    }
+  };
+
   // src/resources/addresses.ts
   var SwellAddresses = class extends SwellStorefrontCollection {
     constructor(swell, query) {
@@ -8557,13 +8939,19 @@
       const storefrontRequest = storefront.request;
       return (method, url, id, data, opt) => {
         if (this.isStorefrontRequestCacheable(method, url, opt)) {
-          return this.getRequestCache().fetchSWR(
-            getCacheKey("request", [this.instanceId, method, url, id, data, opt]),
-            () => {
-              logger.info("[SDK] Storefront request", { method, url, id, data });
-              return storefrontRequest(method, url, id, data, opt);
-            }
-          );
+          const key = getCacheKey("request", [
+            this.instanceId,
+            method,
+            url,
+            id,
+            data,
+            opt
+          ]);
+          return this.getRequestCache().fetchSWR(key, () => {
+            const requestUrl = id ? `${url}/${id}` : url;
+            logger.debug("[SDK] Cacheable API request", { url: requestUrl, key });
+            return storefrontRequest(method, url, id, data, opt);
+          });
         }
         switch (method) {
           case "delete":
@@ -8610,7 +8998,9 @@
   };
   function getCacheKey(key, args) {
     if (Array.isArray(args) && args.length > 0) {
-      return `${key}_${md5(JSON.stringify(args))}`;
+      const fullKey = `${key}_${md5(JSON.stringify(args))}`;
+      logger.debug(`[SDK] make cache key: ${fullKey}`);
+      return fullKey;
     }
     return key;
   }