@swell/apps-sdk 1.0.152 → 1.0.153

package/dist/index.cjs

@@ -7858,20 +7858,38 @@ var WorkerCacheProxy = class {
 var CACHE_NAME2 = "swell-html-v1";
 var CACHE_KEY_ORIGIN2 = "https://cache.swell.store";
 var TTL_CONFIG = {
-  DEFAULT: 300,
-  // 5 minutes
-  DEFAULT_SWR: 3600,
-  // 1 hour stale-while-revalidate
-  HOME: 300,
-  // 5 minutes
-  PRODUCT: 600,
-  // 10 minutes
-  COLLECTION: 900,
-  // 15 minutes
-  PAGE: 3600,
-  // 1 hour
-  BLOG: 1800
-  // 30 minutes
+  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;
@@ -7898,7 +7916,7 @@ var WorkerHtmlCache = class {
       }
       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") || "") || TTL_CONFIG.DEFAULT_SWR;
+      const swr = parseInt(cached.headers.get("X-Original-SWR") || "") || this.getSWRForRequest(request);
       const isStale = age >= ttl;
       const isExpired = age >= ttl + swr;
       if (!isExpired) {
@@ -7929,6 +7947,56 @@ var WorkerHtmlCache = class {
       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) {
@@ -7944,17 +8012,22 @@ var WorkerHtmlCache = class {
     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 = TTL_CONFIG.DEFAULT_SWR;
+      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}`);
       }
-      headers.set("X-Cache-Time", (/* @__PURE__ */ new Date()).toISOString());
+      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,
@@ -7966,28 +8039,32 @@ var WorkerHtmlCache = class {
       logger.warn("[SDK Html-cache] no put support", { trace });
     }
   }
-  /**
-   * Build client response with correct headers
-   */
   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
     });
   }
-  /**
-   * Build cache key from request using two-level structure
-   */
   buildCacheKey(request) {
     const url = new URL(request.url);
     const versionHash = this.generateVersionHash(request.headers);
@@ -8003,22 +8080,11 @@ var WorkerHtmlCache = class {
       headers: sanitizedHeaders
     });
   }
-  /**
-   * Sanitize headers for cache operations - minimal whitelist approach
-   */
   sanitizeHeaders(originalHeaders) {
     const CACHE_RELEVANT_HEADERS = [
       // Content negotiation (affects response format)
       "accept",
-      "accept-encoding",
-      "accept-language",
-      // Cache control directives from client/proxy
-      "cache-control",
-      "pragma",
-      // Legacy cache control
-      // Conditional request headers (for 304 responses)
-      "if-none-match",
-      "if-modified-since"
+      "accept-language"
     ];
     const sanitized = new Headers();
     CACHE_RELEVANT_HEADERS.forEach((header) => {
@@ -8029,15 +8095,13 @@ var WorkerHtmlCache = class {
     });
     return sanitized;
   }
-  /**
-   * Generate version hash from headers and cookies
-   */
   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"),
@@ -8045,9 +8109,6 @@ var WorkerHtmlCache = class {
     };
     return md5(JSON.stringify(versionFactors));
   }
-  /**
-   * Extract swell-data from cookies
-   */
   extractSwellData(headers) {
     const cookie = headers.get("cookie");
     if (!cookie) return {};
@@ -8083,31 +8144,53 @@ var WorkerHtmlCache = class {
     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 TTL_CONFIG.HOME;
+      return config.HOME;
     }
     if (path.startsWith("/products/")) {
-      return TTL_CONFIG.PRODUCT;
+      return config.PRODUCT;
     }
     if (path.startsWith("/categories/")) {
-      return TTL_CONFIG.COLLECTION;
+      return config.COLLECTION;
     }
     if (path.startsWith("/pages/")) {
-      return TTL_CONFIG.PAGE;
+      return config.PAGE;
     }
     if (path.startsWith("/blogs/")) {
-      return TTL_CONFIG.BLOG;
+      return config.BLOG;
+    }
+    return config.DEFAULT;
+  }
+  getSWRForRequest(request) {
+    const mode = this.getDeploymentMode(request.headers);
+    if (mode === "editor") {
+      return 0;
     }
-    return TTL_CONFIG.DEFAULT;
+    return mode === "preview" ? TTL_CONFIG.PREVIEW.SWR : TTL_CONFIG.LIVE.SWR;
   }
   getResponseAge(response) {
     const cacheTime = response.headers.get("X-Cache-Time");
@@ -8121,31 +8204,6 @@ var WorkerHtmlCache = class {
     const age = (Date.now() - cacheDate.getTime()) / 1e3;
     return Math.max(0, age);
   }
-  getMaxAge(response) {
-    const cacheControl = response.headers.get("Cache-Control");
-    if (!cacheControl) {
-      return TTL_CONFIG.DEFAULT;
-    }
-    const maxAgeMatch = cacheControl.match(/max-age=(\d+)/);
-    if (maxAgeMatch) {
-      return parseInt(maxAgeMatch[1], 10);
-    }
-    return TTL_CONFIG.DEFAULT;
-  }
-  getStaleWindow(response) {
-    const cacheControl = response.headers.get("Cache-Control");
-    if (!cacheControl) {
-      return TTL_CONFIG.DEFAULT_SWR;
-    }
-    const swrMatch = cacheControl.match(/stale-while-revalidate=(\d+)/);
-    if (swrMatch) {
-      return parseInt(swrMatch[1], 10);
-    }
-    return TTL_CONFIG.DEFAULT_SWR;
-  }
-  /**
-   * Normalize search params for cache key
-   */
   normalizeSearchParams(searchParams) {
     const ignoredParams = [
       "utm_source",