@swell/apps-sdk 1.0.150 → 1.0.152

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");
 
@@ -653,18 +661,12 @@
       }
       return instance[prop];
     }
-    // add additional properties to the loaded result
-    _transformResult(result) {
-      return result;
-    }
     async _get(..._args) {
       if (this._getter) {
         const getter = this._getter.bind(
           this
         );
         return Promise.resolve().then(getter).then((result) => {
-          return this._transformResult(result);
-        }).then((result) => {
           this._result = result ?? null;
           if (result) {
             Object.assign(this, result);
@@ -747,7 +749,6 @@
     });
     const clone = new ClonedClass(input._getter);
     clone._params = input._params;
-    clone._transformResult = input._transformResult.bind(clone);
     Object.defineProperty(clone, "_resourceName", {
       value: resourceName
     });
@@ -801,7 +802,11 @@
     limit = DEFAULT_QUERY_PAGE_LIMIT;
     name;
     constructor(swell, collection, query = {}, getter) {
-      super(swell, collection, getter);
+      super(
+        swell,
+        collection,
+        getter
+      );
       this._query = this._initQuery(query);
       if (!getter) {
         this._setGetter(this._defaultGetter());
@@ -844,6 +849,7 @@
             this._collection,
             this._query,
             this._swell.queryParams,
+            // TODO: consider to exlcude
             this._getterHash
           ],
           getter,
@@ -972,13 +978,12 @@
             this._id,
             this._query,
             this._swell.queryParams,
+            // TODO: consider to exlcude
             this._getterHash
           ],
           getter,
           isResourceCacheble(this._collection)
         ).then((result) => {
-          return this._transformResult(result);
-        }).then((result) => {
           this._result = result;
           if (result) {
             Object.assign(this, result);
@@ -7202,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) {
@@ -7211,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(() => {
@@ -7223,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) {
@@ -7735,59 +7734,466 @@
     }
   };
 
+  // src/cache/worker-html-cache.ts
+  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
+  };
+  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") || "") || TTL_CONFIG.DEFAULT_SWR;
+        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;
+      }
+    }
+    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);
+        const ttl = this.getTTLForRequest(request);
+        const swr = TTL_CONFIG.DEFAULT_SWR;
+        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());
+        headers.set("X-Original-TTL", ttl.toString());
+        headers.set("X-Original-SWR", swr.toString());
+        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 });
+      }
+    }
+    /**
+     * 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("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");
+      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);
+      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
+      });
+    }
+    /**
+     * 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"
+      ];
+      const sanitized = new Headers();
+      CACHE_RELEVANT_HEADERS.forEach((header) => {
+        const value = originalHeaders.get(header);
+        if (value) {
+          sanitized.set(header, value);
+        }
+      });
+      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") || "",
+        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));
+    }
+    /**
+     * Extract swell-data from cookies
+     */
+    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;
+      }
+      const cacheControl = response.headers.get("cache-control");
+      if (cacheControl?.includes("no-store") || cacheControl?.includes("private")) {
+        return false;
+      }
+      return true;
+    }
+    getTTLForRequest(request) {
+      const url = new URL(request.url);
+      const path = url.pathname;
+      if (path === "/") {
+        return TTL_CONFIG.HOME;
+      }
+      if (path.startsWith("/products/")) {
+        return TTL_CONFIG.PRODUCT;
+      }
+      if (path.startsWith("/categories/")) {
+        return TTL_CONFIG.COLLECTION;
+      }
+      if (path.startsWith("/pages/")) {
+        return TTL_CONFIG.PAGE;
+      }
+      if (path.startsWith("/blogs/")) {
+        return TTL_CONFIG.BLOG;
+      }
+      return TTL_CONFIG.DEFAULT;
+    }
+    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);
+    }
+    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",
+        "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) {
+      const { page, limit: limit2 } = swell.queryParams;
+      super(swell, "accounts:addresses", { page, limit: limit2, ...query }, function() {
+        return this._swell.storefront.account.listAddresses(
+          this._query
+        );
+      });
+    }
+  };
+
+  // src/resources/orders.ts
+  var SwellOrders = class extends SwellStorefrontCollection {
+    constructor(swell, query) {
+      const { page, limit: limit2 } = swell.queryParams;
+      super(swell, "accounts:orders", { page, limit: limit2, ...query }, function() {
+        return this._swell.storefront.account.listOrders(this._query);
+      });
+    }
+  };
+
+  // src/resources/subscriptions.ts
+  var SwellSubscriptions = class extends SwellStorefrontCollection {
+    constructor(swell, query) {
+      const { page, limit: limit2 } = swell.queryParams;
+      super(
+        swell,
+        "accounts:subscriptions",
+        { page, limit: limit2, ...query },
+        function() {
+          return this._swell.storefront.subscriptions.list(
+            this._query
+          );
+        }
+      );
+    }
+  };
+
   // src/resources/account.ts
   var SwellAccount = class extends SwellStorefrontSingleton {
-    constructor(swell, getter) {
-      super(swell, "account", getter);
+    constructor(swell) {
+      super(swell, "account", async function() {
+        const account = await this._defaultGetter().call(this);
+        if (!account) {
+          return null;
+        }
+        account.addresses = new SwellAddresses(
+          this._swell
+        );
+        account.orders = new SwellOrders(
+          this._swell
+        );
+        account.subscriptions = new SwellSubscriptions(
+          this._swell
+        );
+        return account;
+      });
       return this._getProxy();
     }
   };
 
   // src/resources/blog_category.ts
   var SwellBlogCategory = class extends SwellStorefrontRecord {
-    constructor(swell, id, query = {}, getter) {
-      super(swell, "content/blog-categories", id, query, getter);
+    constructor(swell, id, query) {
+      super(swell, "content/blog-categories", id, query, async function() {
+        const category = await this._defaultGetter().call(this);
+        if (!category) {
+          return null;
+        }
+        category.blogs = new SwellStorefrontCollection(
+          this._swell,
+          "content/blogs",
+          {
+            category_id: category.id,
+            expand: "author"
+          }
+        );
+        return category;
+      });
       return this._getProxy();
     }
   };
 
   // src/resources/blog.ts
   var SwellBlog = class extends SwellStorefrontRecord {
-    constructor(swell, id, query = {}, getter) {
-      super(swell, "content/blogs", id, query, getter);
+    constructor(swell, blogId, categoryId, query) {
+      super(swell, "content/blogs", blogId, query, async function() {
+        this._query = { ...this._query, expand: "author" };
+        const blog = await this._defaultGetter().call(this);
+        if (!blog) {
+          return null;
+        }
+        if (categoryId) {
+          blog.category = new SwellStorefrontRecord(
+            this._swell,
+            "content/blog-categories",
+            categoryId
+          );
+        }
+        return blog;
+      });
       return this._getProxy();
     }
   };
 
   // src/resources/cart.ts
   var SwellCart = class extends SwellStorefrontSingleton {
-    constructor(swell, getter) {
-      super(swell, "cart", getter);
-      return this._getProxy();
-    }
-  };
-
-  // src/resources/category.ts
-  var SwellCategory = class extends SwellStorefrontRecord {
-    constructor(swell, id, query = {}, getter) {
-      super(swell, "categories", id, query, getter);
-      return this._getProxy();
-    }
-  };
-
-  // src/resources/order.ts
-  var SwellOrder = class extends SwellStorefrontRecord {
-    constructor(swell, id, query = {}, getter) {
-      super(swell, "orders", id, query, getter);
+    constructor(swell) {
+      super(swell, "cart");
       return this._getProxy();
     }
   };
 
-  // src/resources/page.ts
-  var SwellPage = class extends SwellStorefrontRecord {
-    constructor(swell, id, query = {}, getter) {
-      super(swell, "content/pages", id, query, getter);
-      return this._getProxy();
+  // src/resources/categories.ts
+  var SwellCategories = class extends SwellStorefrontCollection {
+    constructor(swell, query) {
+      super(
+        swell,
+        "categories",
+        {
+          limit: 100,
+          top_id: null,
+          ...query
+        },
+        async function() {
+          const categories = await this._defaultGetter().call(this);
+          if (!categories) {
+            return null;
+          }
+          for (const category of categories.results) {
+            category.products = new SwellStorefrontCollection(
+              this._swell,
+              "products",
+              { category: category.id }
+            );
+          }
+          return categories;
+        }
+      );
     }
   };
 
@@ -7947,6 +8353,143 @@
     }
     return selectedPlan || subscriptionPurchaseOption.plans[0];
   }
+  var SORT_OPTIONS = Object.freeze([
+    { value: "", name: "Featured" },
+    { value: "popularity", name: "Popularity", query: "popularity desc" },
+    { value: "price_asc", name: "Price, low to high", query: "price asc" },
+    { value: "price_desc", name: "Price, high to low", query: "price desc" },
+    { value: "date_asc", name: "Date, old to new", query: "date asc" },
+    { value: "date_desc", name: "Date, new to old", query: "date desc" },
+    { value: "name_asc", name: "Product name, A-Z", query: "name asc" },
+    { value: "name_desc", name: "Product name, Z-A", query: "name desc" }
+  ]);
+  async function getProductFilters(swell, productQuery) {
+    const sortBy = swell.queryParams.sort || "";
+    const filterQuery = productQueryWithFilters(swell, productQuery);
+    return {
+      filter_options: await getProductFiltersByQuery(swell, filterQuery),
+      sort: SORT_OPTIONS.find((option) => option.value === sortBy)?.value,
+      sort_options: [...SORT_OPTIONS]
+    };
+  }
+  async function getProductFiltersByQuery(swell, query = {}) {
+    const filters2 = await swell.get("/products/:filters", {
+      ...query,
+      sort: void 0
+    }) || [];
+    if (!Array.isArray(filters2)) {
+      throw new Error("Product filters must be an array");
+    }
+    for (const filter of filters2) {
+      filter.param_name = `filter_${filter.id}`;
+      if (Array.isArray(filter.options)) {
+        filter.active_options = [];
+        filter.inactive_options = [];
+        for (const option of filter.options) {
+          const queryValue = swell.queryParams[filter.param_name];
+          option.active = Array.isArray(queryValue) ? queryValue.includes(option.value) : queryValue === option.value;
+          const list = option.active ? filter.active_options : filter.inactive_options;
+          list.push(option);
+        }
+      }
+    }
+    return filters2;
+  }
+  function productQueryWithFilters(swell, query) {
+    const filters2 = Object.keys(swell.queryParams).reduce(
+      (acc, key) => {
+        if (key.startsWith("filter_")) {
+          const qkey = key.replace("filter_", "");
+          const value = swell.queryParams[key];
+          if (typeof value === "object" && value !== null && !Array.isArray(value) && (value.gte !== void 0 || value.lte !== void 0)) {
+            acc[qkey] = [value.gte || 0, value.lte || void 0];
+          } else {
+            acc[qkey] = value;
+          }
+        }
+        return acc;
+      },
+      {}
+    );
+    const sortBy = swell.queryParams.sort || "";
+    return {
+      sort: SORT_OPTIONS.find((option) => option.value === sortBy)?.query || void 0,
+      $filters: filters2,
+      ...query
+    };
+  }
+
+  // src/resources/category.ts
+  var SwellCategory = class extends SwellStorefrontRecord {
+    constructor(swell, id, query) {
+      super(swell, "categories", id, query, async function() {
+        let category = await this._defaultGetter().call(this);
+        if (!category && this._id === "all") {
+          category = {
+            name: "Products",
+            id: "all",
+            slug: "all",
+            filter_options: [],
+            sort_options: []
+          };
+        }
+        if (!category) {
+          return null;
+        }
+        const productFilters = await getProductFilters(
+          this._swell,
+          category.id !== "all" ? { category: category.id, $variants: true } : { $variants: true }
+        );
+        Object.assign(category, productFilters);
+        return category;
+      });
+      return this._getProxy();
+    }
+  };
+
+  // src/resources/order.ts
+  var SwellOrder = class extends SwellStorefrontRecord {
+    constructor(swell, id, query) {
+      super(swell, "accounts:orders", id, query, function() {
+        return this._swell.storefront.account.getOrder(this._id);
+      });
+      return this._getProxy();
+    }
+  };
+
+  // src/resources/page.ts
+  var SwellPage = class extends SwellStorefrontRecord {
+    constructor(swell, id, query) {
+      super(swell, "content/pages", id, query);
+      return this._getProxy();
+    }
+  };
+
+  // src/resources/predictive_search.ts
+  var SwellPredictiveSearch = class extends StorefrontResource {
+    constructor(swell, query) {
+      super(async function() {
+        const performed = String(query || "").length > 0;
+        let products;
+        if (performed) {
+          products = new SwellStorefrontCollection(
+            swell,
+            "products",
+            {
+              search: query,
+              limit: 10
+            }
+          );
+          await products.resolve();
+        }
+        return {
+          query,
+          performed,
+          products
+        };
+      });
+    }
+  };
 
   // src/resources/variant.ts
   function transformSwellVariant(params, product, variant) {
@@ -7966,27 +8509,30 @@
       )
     };
   }
+  var SwellVariant = class extends SwellStorefrontRecord {
+    product;
+    constructor(swell, product, id, query) {
+      super(swell, "products:variants", id, query, async function() {
+        const variant = await this._swell.get(
+          "/products:variants/{id}",
+          { id: this._id }
+        );
+        return variant ?? null;
+      });
+      this.product = product;
+    }
+  };
 
   // src/resources/product.ts
-  var SORT_OPTIONS = [
-    { value: "", name: "Featured" },
-    { value: "popularity", name: "Popularity", query: "popularity desc" },
-    { value: "price_asc", name: "Price, low to high", query: "price asc" },
-    { value: "price_desc", name: "Price, high to low", query: "price desc" },
-    { value: "date_asc", name: "Date, old to new", query: "date asc" },
-    { value: "date_desc", name: "Date, new to old", query: "date desc" },
-    { value: "name_asc", name: "Product name, A-Z", query: "name asc" },
-    { value: "name_desc", name: "Product name, Z-A", query: "name desc" }
-  ];
   function transformSwellProduct(params, product) {
     if (!product) {
-      return product;
+      return null;
     }
     const newProduct = {
       ...product,
       // add swell properties there
       selected_option_values: getSelectedVariantOptionValues(product, params),
-      purchase_options: getPurchaseOptions(product, params)
+      purchase_options: getPurchaseOptions(product, params) ?? void 0
     };
     if (Array.isArray(newProduct.variants?.results)) {
       newProduct.variants = {
@@ -7999,43 +8545,49 @@
     return newProduct;
   }
   var SwellProduct = class extends SwellStorefrontRecord {
-    _params;
-    constructor(swell, id, query = {}, getter) {
-      super(swell, "products", id, query, getter);
-      this._params = swell.queryParams;
+    constructor(swell, id, query) {
+      const params = swell.queryParams;
+      super(swell, "products", id, query, async function() {
+        const result = await this._defaultGetter().call(this);
+        return transformSwellProduct(params, result);
+      });
       return this._getProxy();
     }
-    // add swell properties to the resolved object
-    _transformResult(result) {
-      const res = transformSwellProduct(
-        this._params,
-        result
-      );
-      return res;
+  };
+
+  // src/resources/product_recommendations.ts
+  var SwellProductRecommendations = class extends SwellProduct {
+    constructor(swell, id, query) {
+      super(swell, id, { ...query, $recommendations: true });
+    }
+  };
+
+  // src/resources/search.ts
+  var SwellSearch = class extends StorefrontResource {
+    constructor(swell, query) {
+      super(async () => {
+        const performed = String(query || "").length > 0;
+        const productFilters = await getProductFilters(
+          swell,
+          performed ? { search: query } : void 0
+        );
+        return {
+          query,
+          performed,
+          ...productFilters
+        };
+      });
+    }
+  };
+
+  // src/resources/subscription.ts
+  var SwellSubscription = class extends SwellStorefrontRecord {
+    constructor(swell, id, query) {
+      super(swell, "accounts:subscriptions", id, query, function() {
+        return this._swell.storefront.subscriptions.get(this._id, this._query);
+      });
     }
   };
-  function productQueryWithFilters(swell, query = {}) {
-    const sortBy = swell.queryParams.sort || "";
-    const filters2 = Object.entries(swell.queryParams).reduce(
-      (acc, [key, value]) => {
-        if (key.startsWith("filter_")) {
-          const qkey = key.replace("filter_", "");
-          if (value?.gte !== void 0 || value?.lte !== void 0) {
-            acc[qkey] = [value.gte || 0, value.lte || void 0];
-          } else {
-            acc[qkey] = value;
-          }
-        }
-        return acc;
-      },
-      {}
-    );
-    return {
-      sort: SORT_OPTIONS.find((option) => option.value === sortBy)?.query || void 0,
-      $filters: filters2,
-      ...query
-    };
-  }
 
   // src/api.ts
   var DEFAULT_API_HOST = "https://api.schema.io";
@@ -8329,13 +8881,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":
@@ -8382,7 +8940,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;
   }
@@ -15606,11 +16166,9 @@ ${formattedMessage}`;
           return this._defaultGetter().call(this);
         }
       );
-      return products._cloneWithCompatibilityResult(
-        (products2) => {
-          return { ...products2, results: products2.results.map(mapper) };
-        }
-      );
+      return products._cloneWithCompatibilityResult((products2) => {
+        return { ...products2, results: products2.results.map(mapper) };
+      });
     });
   }
   function makeProductsCollectionResolve(instance, object, mapper) {
@@ -15627,19 +16185,24 @@ ${formattedMessage}`;
 
   // src/compatibility/shopify-objects/collections.ts
   function ShopifyCollections(instance, categories) {
-    return new SwellStorefrontCollection(instance.swell, categories._collection, categories._query, async () => {
-      const results = (await categories.results)?.map((category) => {
-        return ShopifyCollection(instance, category);
-      });
-      return {
-        page: categories.page ?? 1,
-        count: categories.count ?? 0,
-        results: results ?? [],
-        page_count: categories.page_count ?? 0,
-        limit: categories.limit,
-        pages: categories.pages ?? {}
-      };
-    });
+    return new SwellStorefrontCollection(
+      instance.swell,
+      categories._collection,
+      categories._query,
+      async () => {
+        const results = (await categories.results)?.map((category) => {
+          return ShopifyCollection(instance, category);
+        });
+        return {
+          page: categories.page ?? 1,
+          count: categories.count ?? 0,
+          results: results ?? [],
+          page_count: categories.page_count ?? 0,
+          limit: categories.limit,
+          pages: categories.pages ?? {}
+        };
+      }
+    );
   }
 
   // src/compatibility/shopify-objects/address.ts
@@ -16826,13 +17389,12 @@ ${formattedMessage}`;
   var SwellImage = class extends StorefrontResource {
     constructor(swell, name) {
       super(async () => {
-        const files = await swell.get("/:files", {
+        const file = await swell.get("/:files/:last", {
           private: { $ne: true },
           content_type: { $regex: "^image/" },
           filename: name
         });
-        const file = files?.results[0] ?? null;
-        if (file === null) {
+        if (!file) {
           return null;
         }
         return { file };