@swell/apps-sdk 1.0.150 → 1.0.152

package/dist/index.cjs

@@ -66,25 +66,35 @@ __export(index_exports, {
   StorefrontResource: () => StorefrontResource,
   Swell: () => Swell,
   SwellAccount: () => SwellAccount,
+  SwellAddresses: () => SwellAddresses,
   SwellBackendAPI: () => SwellBackendAPI,
   SwellBlog: () => SwellBlog,
   SwellBlogCategory: () => SwellBlogCategory,
   SwellCart: () => SwellCart,
+  SwellCategories: () => SwellCategories,
   SwellCategory: () => SwellCategory,
   SwellError: () => SwellError,
   SwellOrder: () => SwellOrder,
+  SwellOrders: () => SwellOrders,
   SwellPage: () => SwellPage,
+  SwellPredictiveSearch: () => SwellPredictiveSearch,
   SwellProduct: () => SwellProduct,
+  SwellProductRecommendations: () => SwellProductRecommendations,
+  SwellSearch: () => SwellSearch,
   SwellStorefrontCollection: () => SwellStorefrontCollection,
   SwellStorefrontPagination: () => SwellStorefrontPagination,
   SwellStorefrontRecord: () => SwellStorefrontRecord,
   SwellStorefrontResource: () => SwellStorefrontResource,
   SwellStorefrontSingleton: () => SwellStorefrontSingleton,
+  SwellSubscription: () => SwellSubscription,
+  SwellSubscriptions: () => SwellSubscriptions,
   SwellTheme: () => SwellTheme3,
+  SwellVariant: () => SwellVariant,
   ThemeColor: () => ThemeColor,
   ThemeFont: () => ThemeFont,
   ThemeForm: () => ThemeForm,
   ThemeFormErrors: () => ThemeFormErrors,
+  WorkerHtmlCache: () => WorkerHtmlCache,
   adaptShopifyFontData: () => adaptShopifyFontData,
   adaptShopifyFormData: () => adaptShopifyFormData,
   adaptShopifyMenuData: () => adaptShopifyMenuData,
@@ -151,72 +161,6 @@ var import_qs2 = __toESM(require("qs"), 1);
 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,
@@ -308,6 +252,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
+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");
 
@@ -763,18 +781,12 @@ var StorefrontResource = class {
     }
     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);
@@ -857,7 +869,6 @@ function cloneStorefrontResource(input) {
   });
   const clone = new ClonedClass(input._getter);
   clone._params = input._params;
-  clone._transformResult = input._transformResult.bind(clone);
   Object.defineProperty(clone, "_resourceName", {
     value: resourceName
   });
@@ -911,7 +922,11 @@ var SwellStorefrontCollection = class _SwellStorefrontCollection extends SwellSt
   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());
@@ -954,6 +969,7 @@ var SwellStorefrontCollection = class _SwellStorefrontCollection extends SwellSt
           this._collection,
           this._query,
           this._swell.queryParams,
+          // TODO: consider to exlcude
           this._getterHash
         ],
         getter,
@@ -1082,13 +1098,12 @@ var SwellStorefrontRecord = class extends SwellStorefrontResource {
           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);
@@ -7312,8 +7327,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) {
@@ -7321,7 +7334,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(() => {
@@ -7333,12 +7345,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) {
@@ -7845,59 +7854,466 @@ 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 = {
+  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;
+      }
+    );
   }
 };
 
@@ -8057,6 +8473,143 @@ function getSelectedSubscriptionPurchaseOptionPlan(selectedPurchaseOptionType, s
   }
   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) {
@@ -8076,27 +8629,30 @@ function transformSwellVariant(params, product, variant) {
     )
   };
 }
+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 = {
@@ -8109,43 +8665,49 @@ function transformSwellProduct(params, product) {
   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";
@@ -8439,13 +9001,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":
@@ -8492,7 +9060,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;
 }
@@ -15716,11 +16286,9 @@ function getProducts(instance, object, mapper) {
         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) {
@@ -15737,19 +16305,24 @@ function makeProductsCollectionResolve(instance, object, mapper) {
 
 // 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
@@ -16936,13 +17509,12 @@ var ImagesDrop = class extends import_liquidjs7.Drop {
 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 };
@@ -22237,25 +22809,35 @@ function getResourceQuery(slug, query) {
   StorefrontResource,
   Swell,
   SwellAccount,
+  SwellAddresses,
   SwellBackendAPI,
   SwellBlog,
   SwellBlogCategory,
   SwellCart,
+  SwellCategories,
   SwellCategory,
   SwellError,
   SwellOrder,
+  SwellOrders,
   SwellPage,
+  SwellPredictiveSearch,
   SwellProduct,
+  SwellProductRecommendations,
+  SwellSearch,
   SwellStorefrontCollection,
   SwellStorefrontPagination,
   SwellStorefrontRecord,
   SwellStorefrontResource,
   SwellStorefrontSingleton,
+  SwellSubscription,
+  SwellSubscriptions,
   SwellTheme,
+  SwellVariant,
   ThemeColor,
   ThemeFont,
   ThemeForm,
   ThemeFormErrors,
+  WorkerHtmlCache,
   adaptShopifyFontData,
   adaptShopifyFormData,
   adaptShopifyMenuData,