@swell/apps-sdk 1.0.151 → 1.0.153

package/dist/index.mjs

@@ -14,72 +14,6 @@ import {
   createCache
 } from "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
-import qs from "qs";
-import { cloneDeep as cloneDeep3, reduce } from "lodash-es";
-import JSON52 from "json5";
-
-// src/resources.ts
-import { cloneDeep as cloneDeep2 } from "lodash-es";
-
 // src/utils/logger.ts
 var logLevels = {
   error: 0,
@@ -171,6 +105,80 @@ function createTraceId(data) {
   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
+import qs from "qs";
+import { cloneDeep as cloneDeep3, reduce } from "lodash-es";
+import JSON52 from "json5";
+
+// src/resources.ts
+import { cloneDeep as cloneDeep2 } from "lodash-es";
+
 // src/liquid/utils.ts
 import { Drop } from "liquidjs";
 
@@ -814,6 +822,7 @@ var SwellStorefrontCollection = class _SwellStorefrontCollection extends SwellSt
           this._collection,
           this._query,
           this._swell.queryParams,
+          // TODO: consider to exlcude
           this._getterHash
         ],
         getter,
@@ -942,6 +951,7 @@ var SwellStorefrontRecord = class extends SwellStorefrontResource {
           this._id,
           this._query,
           this._swell.queryParams,
+          // TODO: consider to exlcude
           this._getterHash
         ],
         getter,
@@ -7170,8 +7180,6 @@ var Cache = class {
    * 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) {
@@ -7179,7 +7187,6 @@ var Cache = class {
         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(() => {
@@ -7191,12 +7198,9 @@ var Cache = class {
       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) {
@@ -7703,6 +7707,384 @@ var WorkerCacheProxy = class {
   }
 };
 
+// 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) {
@@ -8530,13 +8912,19 @@ var Swell = class _Swell {
     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":
@@ -8583,7 +8971,9 @@ var Swell = class _Swell {
 };
 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;
 }
@@ -22365,6 +22755,7 @@ export {
   ThemeFont,
   ThemeForm,
   ThemeFormErrors,
+  WorkerHtmlCache,
   adaptShopifyFontData,
   adaptShopifyFormData,
   adaptShopifyMenuData,