@reactionary/hcl 0.9.8 → 0.9.12

package/capabilities/profile.capability.js

@@ -0,0 +1,215 @@
+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 {
+  ProfileCapability,
+  ProfileMutationAddShippingAddressSchema,
+  ProfileMutationMakeShippingAddressDefaultSchema,
+  ProfileMutationRemoveShippingAddressSchema,
+  ProfileMutationSetBillingAddressSchema,
+  ProfileMutationUpdateSchema,
+  ProfileMutationUpdateShippingAddressSchema,
+  ProfileQueryByIdSchema,
+  ProfileSchema,
+  Reactionary,
+  error,
+  success
+} from "@reactionary/core";
+import createDebug from "debug";
+const debug = createDebug("reactionary:hcl:profile");
+const BILLING_NICK_NAME = "Billing";
+class HclProfileCapability extends ProfileCapability {
+  config;
+  client;
+  factory;
+  constructor(cache, context, config, client, factory) {
+    super(cache, context);
+    this.config = config;
+    this.client = client;
+    this.factory = factory;
+  }
+  async fetchPerson() {
+    return this.client.callGet(this.personSelfUrl());
+  }
+  async fetchProfile() {
+    const person = await this.fetchPerson();
+    return this.factory.parseProfile(this.context, person);
+  }
+  toWcsContact(address) {
+    const lines = [address.streetAddress, address.streetNumber].filter(Boolean);
+    return {
+      nickName: address.identifier.nickName,
+      firstName: address.firstName,
+      lastName: address.lastName,
+      addressLine: lines.length ? lines : void 0,
+      city: address.city,
+      stateOrProvinceName: address.region,
+      zipCode: address.postalCode,
+      country: address.countryCode
+    };
+  }
+  personSelfUrl() {
+    return `${this.client.transactionBaseUrl}/person/@self`;
+  }
+  updatePersonPayload(email, phone) {
+    return { email1: email, phone1: phone };
+  }
+  personContactListUrl() {
+    return `${this.client.transactionBaseUrl}/person/@self/contact`;
+  }
+  contactUrl(nickName) {
+    return `${this.client.transactionBaseUrl}/person/@self/contact/${encodeURIComponent(nickName)}`;
+  }
+  makeShippingAddressDefaultPayload() {
+    return { primary: "1" };
+  }
+  async getById(_payload) {
+    debug("getById");
+    return success(await this.fetchProfile());
+  }
+  async update(payload) {
+    debug("update %o", payload.identifier);
+    await this.client.callPut(
+      this.personSelfUrl(),
+      this.updatePersonPayload(payload.email, payload.phone)
+    );
+    return success(await this.fetchProfile());
+  }
+  async addShippingAddress(payload) {
+    debug("addShippingAddress %s", payload.address.identifier.nickName);
+    await this.client.callPost(
+      this.personContactListUrl(),
+      this.toWcsContact(payload.address)
+    );
+    return success(await this.fetchProfile());
+  }
+  async updateShippingAddress(payload) {
+    debug("updateShippingAddress %s", payload.address.identifier.nickName);
+    try {
+      await this.client.callPut(
+        this.contactUrl(payload.address.identifier.nickName),
+        this.toWcsContact(payload.address)
+      );
+    } catch (err) {
+      if (err instanceof Error && err.message.includes("404")) {
+        return error({
+          type: "NotFound",
+          identifier: payload.address.identifier
+        });
+      }
+      throw err;
+    }
+    return success(await this.fetchProfile());
+  }
+  async removeShippingAddress(payload) {
+    debug("removeShippingAddress %s", payload.addressIdentifier.nickName);
+    try {
+      await this.client.callDelete(
+        this.contactUrl(payload.addressIdentifier.nickName)
+      );
+    } catch (err) {
+      if (err instanceof Error && err.message.includes("404")) {
+        return error({
+          type: "NotFound",
+          identifier: payload.addressIdentifier
+        });
+      }
+      throw err;
+    }
+    return success(await this.fetchProfile());
+  }
+  async makeShippingAddressDefault(payload) {
+    debug("makeShippingAddressDefault %s", payload.addressIdentifier.nickName);
+    try {
+      await this.client.callPut(
+        this.contactUrl(payload.addressIdentifier.nickName),
+        this.makeShippingAddressDefaultPayload()
+      );
+    } catch (err) {
+      if (err instanceof Error && err.message.includes("404")) {
+        return error({
+          type: "NotFound",
+          identifier: payload.addressIdentifier
+        });
+      }
+      throw err;
+    }
+    return success(await this.fetchProfile());
+  }
+  async setBillingAddress(payload) {
+    debug("setBillingAddress");
+    const person = await this.fetchPerson();
+    const billingContact = (person.contact ?? []).find(
+      (c) => c.nickName === BILLING_NICK_NAME
+    );
+    const contactData = {
+      ...this.toWcsContact(payload.address),
+      nickName: BILLING_NICK_NAME
+    };
+    if (billingContact) {
+      await this.client.callPut(
+        this.contactUrl(BILLING_NICK_NAME),
+        contactData
+      );
+    } else {
+      await this.client.callPost(
+        this.personContactListUrl(),
+        contactData
+      );
+    }
+    return success(await this.fetchProfile());
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: ProfileQueryByIdSchema,
+    outputSchema: ProfileSchema
+  })
+], HclProfileCapability.prototype, "getById", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: ProfileMutationUpdateSchema,
+    outputSchema: ProfileSchema
+  })
+], HclProfileCapability.prototype, "update", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: ProfileMutationAddShippingAddressSchema,
+    outputSchema: ProfileSchema
+  })
+], HclProfileCapability.prototype, "addShippingAddress", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: ProfileMutationUpdateShippingAddressSchema,
+    outputSchema: ProfileSchema
+  })
+], HclProfileCapability.prototype, "updateShippingAddress", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: ProfileMutationRemoveShippingAddressSchema,
+    outputSchema: ProfileSchema
+  })
+], HclProfileCapability.prototype, "removeShippingAddress", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: ProfileMutationMakeShippingAddressDefaultSchema,
+    outputSchema: ProfileSchema
+  })
+], HclProfileCapability.prototype, "makeShippingAddressDefault", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: ProfileMutationSetBillingAddressSchema,
+    outputSchema: ProfileSchema
+  })
+], HclProfileCapability.prototype, "setBillingAddress", 1);
+export {
+  HclProfileCapability
+};

package/core/client.js

@@ -1,120 +1,111 @@
+import { getLocaleParams } from "./locale-params.js";
+import {
+  SESSION_KEY_PERSONALIZATION_ID,
+  SESSION_KEY_WC_TOKEN,
+  SESSION_KEY_WC_TRUSTED_TOKEN
+} from "./session-keys.js";
+class HclCartNotFoundError extends Error {
+  constructor() {
+    super("No active cart found");
+    this.name = "HclCartNotFoundError";
+  }
+}
 class HclClient {
-  constructor(config) {
+  constructor(config, context) {
     this.config = config;
-    const origin = (config.searchApiUrl ?? config.apiUrl).replace(/\/+$/, "");
-    const apiPath = "/search/resources/api/v2";
-    this.baseUrl = `${origin}${apiPath}`;
+    this.context = context;
+    const origin = config.apiUrl.replace(/\/+$/, "");
+    const searchOrigin = (config.searchApiUrl ?? config.apiUrl).replace(/\/+$/, "");
+    this.catalogBaseUrl = `${searchOrigin}/search/resources`;
+    this.transactionBaseUrl = `${origin}/wcs/resources/store/${config.storeId}`;
   }
-  baseUrl;
-  async findProducts(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.langId)
-      params.set("langId", query.langId);
-    if (query.currency)
-      params.set("currency", query.currency);
-    if (query.categoryId)
-      params.set("categoryId", query.categoryId);
-    if (query.searchTerm)
-      params.set("searchTerm", query.searchTerm);
-    if (query.contractId)
-      params.set("contractId", query.contractId);
-    if (query.profileName)
-      params.set("profileName", query.profileName);
-    if (query.limit !== void 0)
-      params.set("limit", String(query.limit));
-    if (query.offset !== void 0)
-      params.set("offset", String(query.offset));
-    if (query.checkEntitlement !== void 0) {
-      params.set("checkEntitlement", String(query.checkEntitlement));
-    }
-    for (const id of query.id ?? []) {
-      params.append("id", id);
-    }
-    for (const partNumber of query.partNumber ?? []) {
-      params.append("partNumber", partNumber);
-    }
-    for (const facet of query.facets ?? []) {
-      params.append("facet", facet);
-    }
-    const url = `${this.baseUrl}/products?${params.toString()}`;
-    const response = await fetch(url, {
+  /** Base URL for the Query Service (catalog / search). */
+  catalogBaseUrl;
+  /** Base URL for the Transaction Service (WCS REST). */
+  transactionBaseUrl;
+  async callGet(url, params, opts) {
+    const merged = this.buildParams(params);
+    const query = merged.toString() ? `?${merged.toString()}` : "";
+    const response = await fetch(`${url}${query}`, {
       method: "GET",
-      headers: { Accept: "application/json" }
+      headers: this.buildHeaders()
     });
+    if (opts?.allowUndefined && response.status === 404)
+      return void 0;
     if (!response.ok) {
       throw new Error(
-        `HCL API error ${response.status} ${response.statusText} for URL: ${url}`
+        `HCL GET ${url} error ${response.status} ${response.statusText}`
       );
     }
     return response.json();
   }
-  /**
-   * Resolve a URL slug to an HCL token (product partNumber, category ID, etc.).
-   * Calls GET /api/v2/urls?storeId=X&identifier=<slug>
-   * Returns undefined when the slug is not found (404).
-   */
-  async resolveSlug(slug, langId) {
-    const params = new URLSearchParams();
-    params.set("storeId", this.config.storeId);
-    params.append("identifier", slug);
-    if (langId)
-      params.set("langId", langId);
-    const url = `${this.baseUrl}/urls?${params.toString()}`;
+  async callPost(url, body = {}) {
     const response = await fetch(url, {
-      method: "GET",
-      headers: { Accept: "application/json" }
+      method: "POST",
+      headers: { ...this.buildHeaders(), "Content-Type": "application/json" },
+      body: JSON.stringify(body)
     });
-    if (response.status === 404)
-      return void 0;
     if (!response.ok) {
+      const text = await response.text();
       throw new Error(
-        `HCL URL resolve error ${response.status} ${response.statusText} for URL: ${url}`
+        `HCL POST ${url} error ${response.status} ${response.statusText}: ${text}`
       );
     }
-    const data = await response.json();
-    return data.contents?.[0];
+    return response.json();
   }
-  /**
-   * Query categories from the HCL Commerce Query Service.
-   * Calls GET /api/v2/categories with the given query parameters.
-   */
-  async findCategories(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.langId)
-      params.set("langId", query.langId);
-    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);
-    }
-    const url = `${this.baseUrl}/categories?${params.toString()}`;
+  async callPut(url, body) {
     const response = await fetch(url, {
-      method: "GET",
-      headers: { Accept: "application/json" }
+      method: "PUT",
+      headers: { ...this.buildHeaders(), "Content-Type": "application/json" },
+      body: JSON.stringify(body)
     });
     if (!response.ok) {
+      const text = await response.text();
       throw new Error(
-        `HCL API error ${response.status} ${response.statusText} for URL: ${url}`
+        `HCL PUT ${url} error ${response.status} ${response.statusText}: ${text}`
       );
     }
     return response.json();
   }
+  async callDelete(url, opts) {
+    const response = await fetch(url, {
+      method: "DELETE",
+      headers: this.buildHeaders()
+    });
+    if (!response.ok && !(opts?.ignore404 && response.status === 404)) {
+      throw new Error(
+        `HCL DELETE ${url} error ${response.status} ${response.statusText}`
+      );
+    }
+  }
+  /**
+   * Merges caller-supplied params with locale defaults (langId, currency)
+   * derived from the request context. Caller-supplied values always win.
+   */
+  buildParams(params) {
+    const merged = new URLSearchParams(params);
+    const { langId, currency } = getLocaleParams(this.config, this.context);
+    if (langId && !merged.has("langId"))
+      merged.set("langId", langId);
+    if (currency && !merged.has("currency"))
+      merged.set("currency", currency);
+    return merged;
+  }
+  buildHeaders() {
+    const headers = { Accept: "application/json" };
+    const token = this.context.session[SESSION_KEY_WC_TOKEN];
+    const trustedToken = this.context.session[SESSION_KEY_WC_TRUSTED_TOKEN];
+    const personalizationId = this.context.session[SESSION_KEY_PERSONALIZATION_ID];
+    if (token)
+      headers["WCToken"] = token;
+    if (trustedToken)
+      headers["WCTrustedToken"] = trustedToken;
+    if (personalizationId)
+      headers["WCPersonalization"] = personalizationId;
+    return headers;
+  }
 }
 export {
+  HclCartNotFoundError,
   HclClient
 };

package/core/initialize.js

@@ -1,6 +1,10 @@
 import {
   CategoryPaginatedResultSchema,
-  ProductSchema
+  IdentitySchema,
+  OrderSchema,
+  OrderSearchResultSchema,
+  ProductSchema,
+  ProfileSchema
 } from "@reactionary/core";
 import { HclCategorySchema } from "../schema/category.schema.js";
 import {
@@ -14,20 +18,46 @@ import {
 } from "./initialize.types.js";
 import { HclClient } from "./client.js";
 import {
+  HclCartFactory,
   HclCategoryFactory,
+  HclCheckoutFactory,
+  HclIdentityFactory,
+  HclInventoryFactory,
+  HclOrderFactory,
+  HclOrderSearchFactory,
+  HclPriceFactory,
   HclProductFactory,
-  HclProductSearchFactory
+  HclProductSearchFactory,
+  HclProfileFactory
 } from "../factories/index.js";
+import { HclCartCapability } from "../capabilities/cart.capability.js";
+import { HclCheckoutCapability } from "../capabilities/checkout.capability.js";
 import { HclProductCapability } from "../capabilities/product.capability.js";
 import { HclCategoryCapability } from "../capabilities/category.capability.js";
 import { HclProductSearchCapability } from "../capabilities/product-search.capability.js";
-import { ProductSearchResultSchema } from "@reactionary/core";
+import { HclPriceCapability } from "../capabilities/price.capability.js";
+import { HclInventoryCapability } from "../capabilities/inventory.capability.js";
+import { HclIdentityCapability } from "../capabilities/identity.capability.js";
+import { HclProfileCapability } from "../capabilities/profile.capability.js";
+import { HclOrderCapability } from "../capabilities/order.capability.js";
+import { HclOrderSearchCapability } from "../capabilities/order-search.capability.js";
+import {
+  CartIdentifierSchema,
+  CartPaginatedSearchResultSchema,
+  CartSchema,
+  CheckoutSchema,
+  InventorySchema,
+  PaymentMethodSchema,
+  PriceSchema,
+  ProductSearchResultSchema,
+  ShippingMethodSchema
+} from "@reactionary/core";
 function withHclCapabilities(configuration, capabilities) {
   return (cache, context) => {
     const client = {};
     const config = HclConfigurationSchema.parse(configuration);
     const caps = HclCapabilitiesSchema.parse(capabilities);
-    const hclClient = new HclClient(config);
+    const hclClient = new HclClient(config, context);
     const buildCapabilityArgs = (factory) => ({
       cache,
       context,
@@ -35,9 +65,48 @@ function withHclCapabilities(configuration, capabilities) {
       hclClient,
       factory
     });
+    if (caps.cart?.enabled) {
+      client.cart = resolveCapabilityWithFactory(
+        capabilities.cart,
+        {
+          factory: new HclCartFactory(
+            CartSchema,
+            CartIdentifierSchema,
+            CartPaginatedSearchResultSchema
+          ),
+          capability: (args) => new HclCartCapability(
+            args.cache,
+            args.context,
+            args.config,
+            args.hclClient,
+            args.factory
+          )
+        },
+        buildCapabilityArgs
+      );
+    }
+    if (caps.checkout?.enabled) {
+      client.checkout = resolveCapabilityWithFactory(
+        capabilities.checkout,
+        {
+          factory: new HclCheckoutFactory(
+            CheckoutSchema,
+            ShippingMethodSchema,
+            PaymentMethodSchema
+          ),
+          capability: (args) => new HclCheckoutCapability(
+            args.cache,
+            args.context,
+            args.config,
+            args.hclClient,
+            args.factory
+          )
+        },
+        buildCapabilityArgs
+      );
+    }
     if (caps.product?.enabled) {
       client.product = resolveCapabilityWithFactory(
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         capabilities.product,
         {
           factory: new HclProductFactory(ProductSchema),
@@ -54,7 +123,6 @@ function withHclCapabilities(configuration, capabilities) {
     }
     if (caps.category?.enabled) {
       client.category = resolveCapabilityWithFactory(
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         capabilities.category,
         {
           factory: new HclCategoryFactory(
@@ -74,7 +142,6 @@ function withHclCapabilities(configuration, capabilities) {
     }
     if (caps.productSearch?.enabled) {
       client.productSearch = resolveCapabilityWithFactory(
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         capabilities.productSearch,
         {
           factory: new HclProductSearchFactory(ProductSearchResultSchema),
@@ -89,6 +156,102 @@ function withHclCapabilities(configuration, capabilities) {
         buildCapabilityArgs
       );
     }
+    if (caps.price?.enabled) {
+      client.price = resolveCapabilityWithFactory(
+        capabilities.price,
+        {
+          factory: new HclPriceFactory(PriceSchema),
+          capability: (args) => new HclPriceCapability(
+            args.cache,
+            args.context,
+            args.config,
+            args.hclClient,
+            args.factory
+          )
+        },
+        buildCapabilityArgs
+      );
+    }
+    if (caps.inventory?.enabled) {
+      client.inventory = resolveCapabilityWithFactory(
+        capabilities.inventory,
+        {
+          factory: new HclInventoryFactory(InventorySchema),
+          capability: (args) => new HclInventoryCapability(
+            args.cache,
+            args.context,
+            args.config,
+            args.hclClient,
+            args.factory
+          )
+        },
+        buildCapabilityArgs
+      );
+    }
+    if (caps.identity?.enabled) {
+      client.identity = resolveCapabilityWithFactory(
+        capabilities.identity,
+        {
+          factory: new HclIdentityFactory(IdentitySchema),
+          capability: (args) => new HclIdentityCapability(
+            args.cache,
+            args.context,
+            args.config,
+            args.hclClient,
+            args.factory
+          )
+        },
+        buildCapabilityArgs
+      );
+    }
+    if (caps.profile?.enabled) {
+      client.profile = resolveCapabilityWithFactory(
+        capabilities.profile,
+        {
+          factory: new HclProfileFactory(ProfileSchema),
+          capability: (args) => new HclProfileCapability(
+            args.cache,
+            args.context,
+            args.config,
+            args.hclClient,
+            args.factory
+          )
+        },
+        buildCapabilityArgs
+      );
+    }
+    if (caps.order?.enabled) {
+      client.order = resolveCapabilityWithFactory(
+        capabilities.order,
+        {
+          factory: new HclOrderFactory(OrderSchema),
+          capability: (args) => new HclOrderCapability(
+            args.cache,
+            args.context,
+            args.config,
+            args.hclClient,
+            args.factory
+          )
+        },
+        buildCapabilityArgs
+      );
+    }
+    if (caps.orderSearch?.enabled) {
+      client.orderSearch = resolveCapabilityWithFactory(
+        capabilities.orderSearch,
+        {
+          factory: new HclOrderSearchFactory(OrderSearchResultSchema),
+          capability: (args) => new HclOrderSearchCapability(
+            args.cache,
+            args.context,
+            args.config,
+            args.hclClient,
+            args.factory
+          )
+        },
+        buildCapabilityArgs
+      );
+    }
     return client;
   };
 }

package/core/session-keys.js

@@ -0,0 +1,14 @@
+const SESSION_KEY_WC_TOKEN = "hcl.WCToken";
+const SESSION_KEY_WC_TRUSTED_TOKEN = "hcl.WCTrustedToken";
+const SESSION_KEY_USER_ID = "hcl.userId";
+const SESSION_KEY_IDENTITY_TYPE = "hcl.identityType";
+const SESSION_KEY_PERSONALIZATION_ID = "hcl.personalizationID";
+const SESSION_KEY_PRICE_RULE_ID = "hcl.priceRuleId";
+export {
+  SESSION_KEY_IDENTITY_TYPE,
+  SESSION_KEY_PERSONALIZATION_ID,
+  SESSION_KEY_PRICE_RULE_ID,
+  SESSION_KEY_USER_ID,
+  SESSION_KEY_WC_TOKEN,
+  SESSION_KEY_WC_TRUSTED_TOKEN
+};