@swell/apps-sdk 1.0.157 → 1.0.159

package/dist/index.mjs

@@ -139,7 +139,7 @@ var CFWorkerKVKeyvAdapter = class {
     if (typeof ttl === "number") {
       ttl = Math.max(60, ttl / 1e3);
     }
-    logger.debug("[SDK] kv.set", { key });
+    logger.debug("[SDK] kv.set", { key, ttl });
     return this.store.put(key, value, { expirationTtl: ttl });
   }
   async delete(key) {
@@ -718,7 +718,6 @@ var RESOURCE_CLONE_PROPS = Object.freeze([
   "_getResourceObject",
   "_collection",
   "_swell",
-  "_query",
   "_params",
   "_id",
   "_resourceName"
@@ -7282,6 +7281,14 @@ function buildStores2() {
 
 // src/cache/theme-cache.ts
 var TTL = 90 * 24 * 60 * 60 * 1e3;
+var ThemeCache = class extends Cache {
+  constructor(options) {
+    super({
+      ttl: TTL,
+      ...options
+    });
+  }
+};
 
 // src/cache/theme-file-storage.ts
 import bluebird2 from "bluebird";
@@ -7623,139 +7630,29 @@ var MINUTE = 60 * SECOND;
 var HOUR = 60 * MINUTE;
 var DAY = 24 * HOUR;
 var YEAR = 365 * DAY;
-var MAX_TTL = YEAR;
 var SHORT_TTL = 5 * SECOND;
 
-// src/cache/worker-cache-proxy.ts
-var CACHE_NAME = "swell-cache-v011";
-var CACHE_KEY_ORIGIN = "https://cache.swell.store";
-var WorkerCacheProxy = class {
-  swell;
-  constructor(swell) {
-    this.swell = swell;
-  }
-  /**
-   * Reads a JSON value from Worker Cache using a key built from path+query.
-   * Returns null on miss or if running outside of a Worker environment.
-   */
-  async get(path, query, opts) {
-    if (typeof caches === "undefined") {
-      return null;
-    }
-    const { keyUrl } = await this.buildKeyUrl(path, query, opts?.version);
-    try {
-      const cache = await caches.open(CACHE_NAME);
-      const match = await cache.match(keyUrl);
-      if (!match) return null;
-      const data = await match.json();
-      return data;
-    } catch {
-      return null;
-    }
-  }
-  /**
-   * Stores a JSON value in Worker Cache under key built from path+query.
-   * No-ops outside of a Worker environment.
-   */
-  async put(path, query, value, opts) {
-    if (typeof caches === "undefined") {
-      return;
-    }
-    const { keyUrl, hasVersion } = await this.buildKeyUrl(
-      path,
-      query,
-      opts?.version
-    );
-    const ttlMs = hasVersion ? MAX_TTL : SHORT_TTL;
-    try {
-      const cache = await caches.open(CACHE_NAME);
-      const response = new Response(JSON.stringify(value), {
-        headers: {
-          "Content-Type": "application/json",
-          "Cache-Control": `public, max-age=${Math.floor(ttlMs / 1e3)}`
-        }
-      });
-      await cache.put(keyUrl, response);
-      logger.debug("[SDK] cache put done", { keyUrl });
-    } catch {
-    }
-  }
-  /**
-   * Builds a deterministic key URL for Worker Cache from the backend API URL
-   * composed using path and query. Includes tenant and auth isolation and an
-   * optional version segment.
-   */
-  async buildKeyUrl(path, query, explicitVersion) {
-    const apiHost = this.swell.backend?.apiHost;
-    const endpointPath = String(path).startsWith("/") ? String(path).substring(1) : String(path);
-    let queryString = "";
-    if (query && this.swell.backend) {
-      queryString = this.swell.backend.stringifyQuery(query);
-    }
-    const fullUrl = `${apiHost}/${endpointPath}${queryString ? `?${queryString}` : ""}`;
-    const instanceId = this.swell.instanceId || "";
-    const authKey = String(this.swell.swellHeaders?.["swell-auth-key"] || "");
-    const tenantHash = await this.sha256Hex(`${instanceId}|${authKey}`);
-    const version = explicitVersion !== void 0 ? explicitVersion : this.swell.swellHeaders?.["theme-version-hash"] || null;
-    const hasVersion = Boolean(version);
-    const versionHash = hasVersion ? await this.sha256Hex(String(version)) : null;
-    const urlHash = await this.sha256Hex(fullUrl);
-    const keyUrl = versionHash ? `${CACHE_KEY_ORIGIN}/v1/${tenantHash}/${versionHash}/${urlHash}` : `${CACHE_KEY_ORIGIN}/v1/${tenantHash}/${urlHash}`;
-    return { keyUrl, hasVersion };
-  }
-  /**
-   * SHA-256 digest with hex encoding. Requires Worker crypto; callers
-   * should avoid invoking this outside of Worker code paths.
-   */
-  async sha256Hex(input) {
-    if (typeof crypto !== "undefined" && crypto.subtle && crypto.subtle.digest) {
-      const encoder = new TextEncoder();
-      const digest = await crypto.subtle.digest(
-        "SHA-256",
-        encoder.encode(input)
-      );
-      const bytes = new Uint8Array(digest);
-      return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
-    }
-    return md5(input);
-  }
-};
-
 // src/cache/worker-html-cache.ts
-var CACHE_NAME2 = "swell-html-v1";
-var CACHE_KEY_ORIGIN2 = "https://cache.swell.store";
+var CACHE_NAME = "swell-html-v0";
+var CACHE_KEY_ORIGIN = "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
+    DEFAULT: 20,
+    HOME: 20,
+    PRODUCT: 20,
+    COLLECTION: 20,
+    PAGE: 20,
+    BLOG: 20,
+    SWR: 180
   },
   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
+    DEFAULT: 20,
+    HOME: 20,
+    PRODUCT: 20,
+    COLLECTION: 20,
+    PAGE: 20,
+    BLOG: 20,
+    SWR: 180
   }
 };
 var WorkerHtmlCache = class {
@@ -7774,7 +7671,7 @@ var WorkerHtmlCache = class {
       return { found: false, cacheable: false };
     }
     try {
-      const cache = await caches.open(CACHE_NAME2 + this.epoch);
+      const cache = await caches.open(CACHE_NAME + this.epoch);
       const cacheKey = this.buildCacheKey(request);
       const cached = await cache.match(cacheKey);
       if (!cached) {
@@ -7877,7 +7774,7 @@ var WorkerHtmlCache = class {
       return;
     }
     try {
-      const cache = await caches.open(CACHE_NAME2 + this.epoch);
+      const cache = await caches.open(CACHE_NAME + this.epoch);
       const cacheKey = this.buildCacheKey(request);
       await cache.delete(cacheKey);
       const ttl = this.getTTLForRequest(request);
@@ -7937,7 +7834,7 @@ var WorkerHtmlCache = class {
     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}`);
+    const keyUrl = new URL(`${CACHE_KEY_ORIGIN}${cacheKeyPath}`);
     if (normalizedQuery) {
       keyUrl.search = `?${normalizedQuery}`;
     }
@@ -15266,15 +15163,32 @@ function ShopifyBlog(instance, blogCategory) {
   return new ShopifyResource({
     all_tags: allTags,
     articles: deferWith(blogCategory, (blogCategory2) => {
-      return blogCategory2.blogs?._cloneWithCompatibilityResult(
-        (blogs) => {
-          return {
-            results: blogs?.results?.map(
-              (blog) => ShopifyArticle(instance, blog, blogCategory2)
-            )
-          };
+      const { page, limit: limit2 } = instance.swell.queryParams;
+      const categoryBlogs = new SwellStorefrontCollection(
+        instance.swell,
+        "content/blogs",
+        {
+          page,
+          limit: limit2,
+          category_id: blogCategory2.id,
+          expand: "author"
+        },
+        async function() {
+          return this._defaultGetter().call(this);
         }
-      ) || [];
+      );
+      return categoryBlogs._cloneWithCompatibilityResult((blogs) => {
+        return {
+          ...blogs,
+          results: blogs?.results?.map(
+            (blog) => ShopifyArticle(
+              instance,
+              blog,
+              blogCategory2
+            )
+          )
+        };
+      }) || [];
     }),
     articles_count: deferWith(blogCategory.blogs, (blogs) => blogs?.count || 0),
     handle: defer(() => blogCategory.slug),
@@ -20443,7 +20357,8 @@ function getLiquidFS(getThemeConfig, extName) {
 
 // src/theme/theme-loader.ts
 var MAX_INDIVIDUAL_CONFIGS_TO_FETCH = 50;
-var ThemeLoader = class {
+var ThemeLoader = class _ThemeLoader {
+  static cache = null;
   swell;
   configs;
   constructor(swell) {
@@ -20584,24 +20499,14 @@ var ThemeLoader = class {
       limit: 1e3,
       type: "theme",
       fields: "id, name, type, file, file_path, hash"
-      // NO file_data
     };
-    const cache = new WorkerCacheProxy(this.swell);
     const versionHash = this.swell.swellHeaders["theme-version-hash"];
-    try {
-      const cached = await cache.get(
-        "/:themes:configs",
-        query,
-        {
-          version: versionHash || null
-        }
-      );
-      if (cached) {
-        logger.debug("[ThemeLoader] Config metadata cache hit");
-        return cached;
-      }
-    } catch (err) {
-      logger.warn("[ThemeLoader] Cache read failed, fetching from API", err);
+    const cacheKey = this.buildMetadataCacheKey(versionHash, query);
+    const cache = this.getCache();
+    const cached = await cache.get(cacheKey);
+    if (cached) {
+      logger.debug("[ThemeLoader] Config metadata cache hit");
+      return cached;
     }
     logger.debug("[ThemeLoader] Fetching config metadata from API");
     const response = await this.swell.get(
@@ -20609,14 +20514,7 @@ var ThemeLoader = class {
       query
     );
     const configs = response?.results || [];
-    const ctx = this.swell.workerCtx || globalThis.executionContext;
-    if (ctx && typeof ctx.waitUntil === "function") {
-      ctx.waitUntil(
-        cache.put("/:themes:configs", query, configs, {
-          version: versionHash || null
-        })
-      );
-    }
+    await cache.set(cacheKey, configs);
     return configs;
   }
   /**
@@ -20721,6 +20619,25 @@ var ThemeLoader = class {
       preview: swellHeaders["deployment-mode"] === "editor" || swellHeaders["deployment-mode"] === "preview" ? true : { $ne: true }
     };
   }
+  /**
+   * Build cache key with tenant isolation for metadata
+   */
+  buildMetadataCacheKey(version, query) {
+    const args = [this.swell.instanceId, version || "default", query];
+    return `theme_configs:${md5(JSON.stringify(args))}`;
+  }
+  /**
+   * Get or create the theme cache instance
+   */
+  getCache() {
+    if (!_ThemeLoader.cache) {
+      _ThemeLoader.cache = new ThemeCache({
+        kvStore: this.swell.workerEnv?.THEME,
+        workerCtx: this.swell.workerCtx
+      });
+    }
+    return _ThemeLoader.cache;
+  }
 };
 
 // src/globals.ts