@reactionary/hcl 0.9.8 → 0.9.11

package/capabilities/cart.capability.js

@@ -0,0 +1,411 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+import {
+  CartCapability,
+  CartIdentifierSchema,
+  CartMutationApplyCouponSchema,
+  CartMutationChangeCurrencySchema,
+  CartMutationCreateCartSchema,
+  CartMutationDeleteCartSchema,
+  CartMutationItemAddSchema,
+  CartMutationItemQuantityChangeSchema,
+  CartMutationItemRemoveSchema,
+  CartMutationRemoveCouponSchema,
+  CartMutationRenameCartSchema,
+  CartPaginatedSearchResultSchema,
+  CartQueryByIdSchema,
+  CartQueryListSchema,
+  CartSchema,
+  Reactionary,
+  error,
+  success
+} from "@reactionary/core";
+import createDebug from "debug";
+import { HclCartNotFoundError } from "../core/client.js";
+const debug = createDebug("reactionary:hcl:cart");
+class HclCartCapability extends CartCapability {
+  config;
+  client;
+  factory;
+  constructor(cache, context, config, client, factory) {
+    super(cache, context);
+    this.config = config;
+    this.client = client;
+    this.factory = factory;
+  }
+  setPendingOrderUrl(orderId) {
+    return `${this.client.transactionBaseUrl}/cart/${encodeURIComponent(orderId)}/set_pending_order`;
+  }
+  setPendingOrderPayload(orderId) {
+    return { orderId };
+  }
+  /**
+   * Set the specified order as the current pending (@self) order.
+   * After this call, @self endpoints will operate on that orderId.
+   */
+  async fetchSetPendingOrder(orderId) {
+    await this.client.callPost(
+      this.setPendingOrderUrl(orderId),
+      this.setPendingOrderPayload(orderId)
+    );
+  }
+  wcsOrderUrl(orderId) {
+    return `${this.client.transactionBaseUrl}/order/${encodeURIComponent(orderId)}`;
+  }
+  /**
+   * Fetch a specific order by ID directly from the Order API.
+   * Does NOT call set_pending_order — safe to use for read-only access.
+   * Throws HclCartNotFoundError on 404.
+   */
+  async fetchWcsOrder(orderId) {
+    const data = await this.client.callGet(
+      this.wcsOrderUrl(orderId),
+      void 0,
+      { allowUndefined: true }
+    );
+    if (!data)
+      throw new HclCartNotFoundError();
+    return data;
+  }
+  cartUrl() {
+    return `${this.client.transactionBaseUrl}/cart/@self`;
+  }
+  /**
+   * Fetch the raw WCS cart response.
+   * If orderId is provided, uses GET /order/{orderId} directly (no side effects).
+   * Without orderId, falls back to GET /cart/@self (current pending order).
+   * Throws HclCartNotFoundError on 404.
+   */
+  async fetchWcsCart(orderId) {
+    if (orderId) {
+      return this.fetchWcsOrder(orderId);
+    }
+    const data = await this.client.callGet(
+      this.cartUrl(),
+      void 0,
+      { allowUndefined: true }
+    );
+    if (!data)
+      throw new HclCartNotFoundError();
+    return data;
+  }
+  /** Fetch and parse the current cart via the factory. */
+  async fetchCart(orderId) {
+    const data = await this.fetchWcsCart(orderId);
+    return this.factory.parseCart(this.context, data);
+  }
+  addOrderItemUrl(currency) {
+    const qs = currency ? `?currency=${encodeURIComponent(currency)}` : "";
+    return `${this.client.transactionBaseUrl}/cart${qs}`;
+  }
+  addOrderItemPayload(partNumber, quantity) {
+    return {
+      orderItem: [{ partNumber, quantity: String(quantity) }],
+      x_calculateOrder: "1",
+      x_calculationUsage: "-1,-2,-3,-4,-5,-6,-7"
+    };
+  }
+  updateOrderItemUrl() {
+    return `${this.client.transactionBaseUrl}/cart/@self/update_order_item`;
+  }
+  updateOrderItemPayload(orderItemId, quantity) {
+    return {
+      orderItem: [{ orderItemId, quantity: String(quantity) }],
+      x_calculateOrder: "1",
+      x_calculationUsage: "-1,-2,-3,-4,-5,-6,-7"
+    };
+  }
+  deleteOrderItemUrl() {
+    return `${this.client.transactionBaseUrl}/cart/@self/delete_order_item`;
+  }
+  deleteOrderItemPayload(orderItemId) {
+    return {
+      orderItemId,
+      x_calculateOrder: "1",
+      x_calculationUsage: "-1,-2,-3,-4,-5,-6,-7"
+    };
+  }
+  deleteCartUrl(orderId) {
+    return orderId ? `${this.client.transactionBaseUrl}/cart/${encodeURIComponent(orderId)}/cancel_order` : `${this.client.transactionBaseUrl}/cart/@self`;
+  }
+  orderListUrl() {
+    return `${this.client.transactionBaseUrl}/order/byStatus/P`;
+  }
+  createOrderUrl() {
+    return `${this.client.transactionBaseUrl}/cart/create_order`;
+  }
+  createOrderParams(description, currency) {
+    const params = new URLSearchParams();
+    params.set("description", description ?? "");
+    if (currency)
+      params.set("currency", currency);
+    return params;
+  }
+  updateOrderDescriptionUrl() {
+    return `${this.client.transactionBaseUrl}/cart/@self/update_order_item`;
+  }
+  updateOrderDescriptionPayload(description, orderItem) {
+    return {
+      orderDescription: description,
+      orderItem,
+      x_calculateOrder: "1",
+      x_calculationUsage: "-1,-2,-3,-4,-5,-6,-7"
+    };
+  }
+  addPromotionCodeUrl() {
+    return `${this.client.transactionBaseUrl}/cart/@self/assigned_promotion_code`;
+  }
+  addPromotionCodePayload(code) {
+    return { promoCode: code };
+  }
+  removePromotionCodeUrl(code) {
+    return `${this.client.transactionBaseUrl}/cart/@self/assigned_promotion_code/${encodeURIComponent(code)}`;
+  }
+  async getById(payload) {
+    debug("getById %s", payload.cart.key);
+    try {
+      const cart = await this.fetchCart(payload.cart.key || void 0);
+      return success(cart);
+    } catch (err) {
+      if (err instanceof HclCartNotFoundError) {
+        return error({ type: "NotFound", identifier: "" });
+      }
+      throw err;
+    }
+  }
+  async getActiveCartId() {
+    debug("getActiveCartId");
+    try {
+      const data = await this.fetchWcsCart();
+      return success(this.factory.parseCartIdentifier(this.context, data));
+    } catch (err) {
+      if (err instanceof HclCartNotFoundError) {
+        return error({ type: "NotFound", identifier: "" });
+      }
+      throw err;
+    }
+  }
+  async add(payload) {
+    debug(
+      "add %s x%d cart=%s",
+      payload.variant.sku,
+      payload.quantity,
+      payload.cart.key
+    );
+    if (payload.cart.key) {
+      await this.fetchSetPendingOrder(payload.cart.key);
+    }
+    await this.client.callPost(
+      this.addOrderItemUrl(),
+      this.addOrderItemPayload(payload.variant.sku, payload.quantity)
+    );
+    return success(await this.fetchCart(payload.cart.key || void 0));
+  }
+  async remove(payload) {
+    debug("remove orderItemId=%s cart=%s", payload.item.key, payload.cart.key);
+    if (payload.cart.key) {
+      await this.fetchSetPendingOrder(payload.cart.key);
+    }
+    await this.client.callPut(
+      this.deleteOrderItemUrl(),
+      this.deleteOrderItemPayload(payload.item.key)
+    );
+    return success(await this.fetchCart(payload.cart.key || void 0));
+  }
+  async changeQuantity(payload) {
+    debug(
+      "changeQuantity orderItemId=%s qty=%d cart=%s",
+      payload.item.key,
+      payload.quantity,
+      payload.cart.key
+    );
+    if (payload.cart.key) {
+      await this.fetchSetPendingOrder(payload.cart.key);
+    }
+    await this.client.callPut(
+      this.updateOrderItemUrl(),
+      this.updateOrderItemPayload(payload.item.key, payload.quantity)
+    );
+    return success(await this.fetchCart(payload.cart.key || void 0));
+  }
+  async listCarts(payload) {
+    debug("listCarts");
+    const data = await this.client.callGet(
+      this.orderListUrl(),
+      void 0,
+      { allowUndefined: true }
+    );
+    const orderList = data ?? { Order: [] };
+    return success(
+      this.factory.parseCartPaginatedSearchResult(
+        this.context,
+        orderList,
+        payload
+      )
+    );
+  }
+  async createCart(payload) {
+    debug("createCart name=%s", payload.name);
+    const result = await this.client.callPost(
+      `${this.createOrderUrl()}?${this.createOrderParams(payload.name || void 0).toString()}`,
+      {}
+    );
+    if (payload.name) {
+      this.context.session["hcl.cartName"] = payload.name;
+    }
+    return success(await this.fetchCart(result.outOrderId));
+  }
+  async deleteCart(payload) {
+    debug("deleteCart %s", payload.cart.key);
+    await this.client.callDelete(
+      this.deleteCartUrl(payload.cart.key || void 0),
+      {
+        ignore404: true
+      }
+    );
+    return success(void 0);
+  }
+  async renameCart(payload) {
+    debug("renameCart %s -> %s", payload.cart.key, payload.newName);
+    if (payload.cart.key) {
+      await this.fetchSetPendingOrder(payload.cart.key);
+    }
+    const wcsCart = await this.fetchWcsCart();
+    const orderItem = (wcsCart.orderItem ?? []).map((item) => ({
+      orderItemId: item.orderItemId,
+      quantity: item.quantity
+    }));
+    await this.client.callPut(
+      this.updateOrderDescriptionUrl(),
+      this.updateOrderDescriptionPayload(payload.newName, orderItem)
+    );
+    this.context.session["hcl.cartName"] = payload.newName;
+    return success(await this.fetchCart(payload.cart.key || void 0));
+  }
+  async applyCouponCode(payload) {
+    debug("applyCouponCode %s cart=%s", payload.couponCode, payload.cart.key);
+    if (payload.cart.key) {
+      await this.fetchSetPendingOrder(payload.cart.key);
+    }
+    await this.client.callPost(
+      this.addPromotionCodeUrl(),
+      this.addPromotionCodePayload(payload.couponCode)
+    );
+    return success(await this.fetchCart(payload.cart.key || void 0));
+  }
+  async removeCouponCode(payload) {
+    debug("removeCouponCode %s cart=%s", payload.couponCode, payload.cart.key);
+    if (payload.cart.key) {
+      await this.fetchSetPendingOrder(payload.cart.key);
+    }
+    await this.client.callDelete(
+      this.removePromotionCodeUrl(payload.couponCode),
+      {
+        ignore404: true
+      }
+    );
+    return success(await this.fetchCart(payload.cart.key || void 0));
+  }
+  async changeCurrency(payload) {
+    debug("changeCurrency %s cart=%s", payload.newCurrency, payload.cart.key);
+    const oldCart = await this.fetchWcsCart(payload.cart.key || void 0);
+    const oldOrderId = oldCart.orderId;
+    const newOrder = await this.client.callPost(
+      `${this.createOrderUrl()}?${this.createOrderParams(oldCart.orderDescription, payload.newCurrency).toString()}`,
+      {}
+    );
+    await this.fetchSetPendingOrder(newOrder.outOrderId);
+    for (const item of oldCart.orderItem ?? []) {
+      await this.client.callPost(
+        this.addOrderItemUrl(payload.newCurrency),
+        this.addOrderItemPayload(item.partNumber, Number(item.quantity))
+      );
+    }
+    await this.client.callDelete(this.deleteCartUrl(oldOrderId), {
+      ignore404: true
+    });
+    return success(await this.fetchCart(newOrder.outOrderId));
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: CartQueryByIdSchema,
+    outputSchema: CartSchema
+  })
+], HclCartCapability.prototype, "getById", 1);
+__decorateClass([
+  Reactionary({
+    outputSchema: CartIdentifierSchema
+  })
+], HclCartCapability.prototype, "getActiveCartId", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CartMutationItemAddSchema,
+    outputSchema: CartSchema
+  })
+], HclCartCapability.prototype, "add", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CartMutationItemRemoveSchema,
+    outputSchema: CartSchema
+  })
+], HclCartCapability.prototype, "remove", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CartMutationItemQuantityChangeSchema,
+    outputSchema: CartSchema
+  })
+], HclCartCapability.prototype, "changeQuantity", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CartQueryListSchema,
+    outputSchema: CartPaginatedSearchResultSchema
+  })
+], HclCartCapability.prototype, "listCarts", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CartMutationCreateCartSchema,
+    outputSchema: CartSchema
+  })
+], HclCartCapability.prototype, "createCart", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CartMutationDeleteCartSchema
+  })
+], HclCartCapability.prototype, "deleteCart", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CartMutationRenameCartSchema,
+    outputSchema: CartSchema
+  })
+], HclCartCapability.prototype, "renameCart", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CartMutationApplyCouponSchema,
+    outputSchema: CartSchema
+  })
+], HclCartCapability.prototype, "applyCouponCode", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CartMutationRemoveCouponSchema,
+    outputSchema: CartSchema
+  })
+], HclCartCapability.prototype, "removeCouponCode", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CartMutationChangeCurrencySchema,
+    outputSchema: CartSchema
+  })
+], HclCartCapability.prototype, "changeCurrency", 1);
+export {
+  HclCartCapability
+};

package/capabilities/category.capability.js

@@ -23,7 +23,6 @@ import {
   success
 } from "@reactionary/core";
 import * as z from "zod";
-import { getLocaleParams } from "../core/locale-params.js";
 class HclCategoryCapability extends CategoryCapability {
   constructor(cache, context, config, client, factory) {
     super(cache, context);
@@ -32,11 +31,10 @@ class HclCategoryCapability extends CategoryCapability {
     this.factory = factory;
   }
   async getById(payload) {
-    const { langId } = getLocaleParams(this.config, this.context);
-    const response = await this.client.findCategories({
-      identifier: [payload.id.key],
-      langId
-    });
+    const response = await this.client.callGet(
+      this.getByIdUrl(payload),
+      this.getByIdPayload(payload)
+    );
     const data = response.contents?.[0];
     if (!data) {
       return error({ type: "NotFound", identifier: payload.id });
@@ -44,20 +42,22 @@ class HclCategoryCapability extends CategoryCapability {
     return success(this.factory.parseCategory(this.context, data));
   }
   async getBySlug(payload) {
-    const { langId } = getLocaleParams(this.config, this.context);
-    const token = await this.client.resolveSlug(payload.slug, langId);
+    const urlResponse = await this.client.callGet(
+      this.urlsUrl(),
+      this.urlsParams(payload.slug),
+      { allowUndefined: true }
+    );
+    const token = urlResponse?.contents?.[0];
     if (!token || token.tokenName !== "CategoryToken" || !token.tokenExternalValue) {
       return error({
         type: "NotFound",
         identifier: payload.slug
       });
     }
-    const response = await this.client.findCategories({
-      // tokenExternalValue is the external identifier (e.g. "LivingRoom").
-      // Use identifier= param so the key returned by the factory is consistent.
-      identifier: [token.tokenExternalValue],
-      langId
-    });
+    const response = await this.client.callGet(
+      this.getBySlugUrl(token),
+      this.getBySlugPayload(token)
+    );
     const data = response.contents?.[0];
     if (!data) {
       return error({
@@ -68,11 +68,10 @@ class HclCategoryCapability extends CategoryCapability {
     return success(this.factory.parseCategory(this.context, data));
   }
   async getBreadcrumbPathToCategory(payload) {
-    const { langId } = getLocaleParams(this.config, this.context);
-    const leafResponse = await this.client.findCategories({
-      identifier: [payload.id.key],
-      langId
-    });
+    const leafResponse = await this.client.callGet(
+      this.getBreadcrumbLeafUrl(payload),
+      this.getBreadcrumbLeafPayload(payload)
+    );
     const leafData = leafResponse.contents?.[0];
     if (!leafData) {
       return success([]);
@@ -80,7 +79,10 @@ class HclCategoryCapability extends CategoryCapability {
     const parentId = leafData.parentCatalogGroupID;
     const pathSegments = (typeof parentId === "string" ? parentId : parentId?.[0] ?? "").split("/").filter(Boolean);
     const ancestorIds = pathSegments.slice(0, -1);
-    const ancestorsResp = ancestorIds.length > 0 ? await this.client.findCategories({ id: ancestorIds, langId }) : { contents: [] };
+    const ancestorsResp = ancestorIds.length > 0 ? await this.client.callGet(
+      this.getBreadcrumbAncestorsUrl(ancestorIds),
+      this.getBreadcrumbAncestorsPayload(ancestorIds)
+    ) : { contents: [] };
     const byUniqueId = new Map(
       (ancestorsResp.contents ?? []).map((c) => [c.uniqueID, c])
     );
@@ -95,11 +97,10 @@ class HclCategoryCapability extends CategoryCapability {
     return success(path);
   }
   async findChildCategories(payload) {
-    const { langId } = getLocaleParams(this.config, this.context);
-    const parentResp = await this.client.findCategories({
-      identifier: [payload.parentId.key],
-      langId
-    });
+    const parentResp = await this.client.callGet(
+      this.findChildCategoriesParentUrl(payload),
+      this.findChildCategoriesParentPayload(payload)
+    );
     const parentUniqueId = parentResp.contents?.[0]?.uniqueID;
     if (!parentUniqueId) {
       return error({
@@ -107,11 +108,10 @@ class HclCategoryCapability extends CategoryCapability {
         identifier: payload.parentId
       });
     }
-    const response = await this.client.findCategories({
-      parentCategoryId: parentUniqueId,
-      depthAndLimit: "1,0",
-      langId
-    });
+    const response = await this.client.callGet(
+      this.findChildCategoriesUrl(parentUniqueId),
+      this.findChildCategoriesPayload(parentUniqueId)
+    );
     const items = response.contents ?? [];
     const paginated = this.factory.parseCategoryPaginatedResult(
       this.context,
@@ -121,11 +121,10 @@ class HclCategoryCapability extends CategoryCapability {
     return success(paginated);
   }
   async findTopCategories(payload) {
-    const { langId } = getLocaleParams(this.config, this.context);
-    const response = await this.client.findCategories({
-      depthAndLimit: "1,0",
-      langId
-    });
+    const response = await this.client.callGet(
+      this.findTopCategoriesUrl(payload),
+      this.findTopCategoriesPayload()
+    );
     const items = response.contents ?? [];
     const paginated = this.factory.parseCategoryPaginatedResult(
       this.context,
@@ -134,6 +133,83 @@ class HclCategoryCapability extends CategoryCapability {
     );
     return success(paginated);
   }
+  getByIdUrl(_payload) {
+    return this.categoriesUrl();
+  }
+  getBySlugUrl(_token) {
+    return this.categoriesUrl();
+  }
+  getBreadcrumbLeafUrl(_payload) {
+    return this.categoriesUrl();
+  }
+  getBreadcrumbAncestorsUrl(_ancestorIds) {
+    return this.categoriesUrl();
+  }
+  findChildCategoriesParentUrl(_payload) {
+    return this.categoriesUrl();
+  }
+  findChildCategoriesUrl(_parentUniqueId) {
+    return this.categoriesUrl();
+  }
+  findTopCategoriesUrl(_payload) {
+    return this.categoriesUrl();
+  }
+  getByIdPayload(payload) {
+    return this.categoriesParams({ identifier: [payload.id.key] });
+  }
+  // tokenValue is the numeric uniqueID; tokenExternalValue is the string identifier
+  // which the categories API rejects with 400 when used as an id= parameter.
+  getBySlugPayload(token) {
+    return this.categoriesParams({ id: [token.tokenValue] });
+  }
+  getBreadcrumbLeafPayload(payload) {
+    return this.categoriesParams({ identifier: [payload.id.key] });
+  }
+  getBreadcrumbAncestorsPayload(ancestorIds) {
+    return this.categoriesParams({ id: ancestorIds });
+  }
+  findChildCategoriesParentPayload(payload) {
+    return this.categoriesParams({ identifier: [payload.parentId.key] });
+  }
+  findChildCategoriesPayload(parentUniqueId) {
+    return this.categoriesParams({
+      parentCategoryId: parentUniqueId,
+      depthAndLimit: "1,0"
+    });
+  }
+  findTopCategoriesPayload() {
+    return this.categoriesParams({ depthAndLimit: "1,0" });
+  }
+  categoriesUrl() {
+    return `${this.client.catalogBaseUrl}/api/v2/categories`;
+  }
+  categoriesParams(query) {
+    const params = new URLSearchParams();
+    params.set("storeId", query.storeId ?? this.config.storeId);
+    const catalogId = query.catalogId ?? this.config.catalogId;
+    if (catalogId)
+      params.set("catalogId", catalogId);
+    if (query.parentCategoryId)
+      params.set("parentCategoryId", query.parentCategoryId);
+    if (query.depthAndLimit)
+      params.set("depthAndLimit", query.depthAndLimit);
+    if (query.profileName)
+      params.set("profileName", query.profileName);
+    for (const id of query.id ?? [])
+      params.append("id", id);
+    for (const identifier of query.identifier ?? [])
+      params.append("identifier", identifier);
+    return params;
+  }
+  urlsUrl() {
+    return `${this.client.catalogBaseUrl}/api/v2/urls`;
+  }
+  urlsParams(slug) {
+    const params = new URLSearchParams();
+    params.set("storeId", this.config.storeId);
+    params.append("identifier", slug);
+    return params;
+  }
 }
 __decorateClass([
   Reactionary({