@reactionary/hcl 0.9.11 → 0.9.12

package/capabilities/order-search.capability.js

@@ -0,0 +1,79 @@
+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 {
+  OrderSearchCapability,
+  OrderSearchQueryByTermSchema,
+  OrderSearchResultSchema,
+  Reactionary,
+  success
+} from "@reactionary/core";
+import createDebug from "debug";
+const debug = createDebug("reactionary:hcl:order-search");
+const ALL_HISTORY_STATUSES = "C,S,X,R,D,M,G,F";
+function coreStatusToWcs(status) {
+  switch (status) {
+    case "Shipped":
+      return "S";
+    case "Cancelled":
+      return "X,R,D";
+    case "ReleasedToFulfillment":
+      return "M,G,F";
+    case "AwaitingPayment":
+      return "C";
+  }
+}
+class HclOrderSearchCapability extends OrderSearchCapability {
+  config;
+  client;
+  factory;
+  constructor(cache, context, config, client, factory) {
+    super(cache, context);
+    this.config = config;
+    this.client = client;
+    this.factory = factory;
+  }
+  async queryByTerm(payload) {
+    const { pageSize, pageNumber } = payload.search.paginationOptions;
+    const wcsStatuses = payload.search.orderStatus?.length ? payload.search.orderStatus.map(coreStatusToWcs).join(",") : ALL_HISTORY_STATUSES;
+    debug(
+      "queryByTerm statuses=%s page=%d/%d",
+      wcsStatuses,
+      pageNumber,
+      pageSize
+    );
+    const data = await this.client.callGet(
+      this.orderByStatusUrl(wcsStatuses),
+      this.orderByStatusParams(pageSize, (pageNumber - 1) * pageSize)
+    );
+    return success(
+      this.factory.parseOrderSearchResult(this.context, data, payload)
+    );
+  }
+  orderByStatusUrl(statuses) {
+    return `${this.client.transactionBaseUrl}/order/byStatus/${encodeURIComponent(statuses)}`;
+  }
+  orderByStatusParams(maxResults, startIndex) {
+    return new URLSearchParams({
+      maxResults: String(maxResults),
+      startIndex: String(startIndex)
+    });
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: OrderSearchQueryByTermSchema,
+    outputSchema: OrderSearchResultSchema
+  })
+], HclOrderSearchCapability.prototype, "queryByTerm", 1);
+export {
+  HclOrderSearchCapability
+};

package/capabilities/order.capability.js

@@ -0,0 +1,62 @@
+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 {
+  OrderCapability,
+  OrderQueryByIdSchema,
+  OrderSchema,
+  Reactionary,
+  error,
+  success
+} from "@reactionary/core";
+import createDebug from "debug";
+const debug = createDebug("reactionary:hcl:order");
+class HclOrderCapability extends OrderCapability {
+  config;
+  client;
+  factory;
+  constructor(cache, context, config, client, factory) {
+    super(cache, context);
+    this.config = config;
+    this.client = client;
+    this.factory = factory;
+  }
+  async getById(payload) {
+    debug("getById %s", payload.order.key);
+    const data = await this.client.callGet(
+      this.orderUrl(payload.order.key),
+      this.orderParams(),
+      { allowUndefined: true }
+    );
+    if (!data) {
+      return error({
+        type: "NotFound",
+        identifier: payload.order
+      });
+    }
+    return success(this.factory.parseOrder(this.context, data));
+  }
+  orderUrl(orderId) {
+    return `${this.client.transactionBaseUrl}/order/${encodeURIComponent(orderId)}`;
+  }
+  orderParams() {
+    return new URLSearchParams({ profileName: "IBM_getOrderDetailsByOrderId" });
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: OrderQueryByIdSchema,
+    outputSchema: OrderSchema
+  })
+], HclOrderCapability.prototype, "getById", 1);
+export {
+  HclOrderCapability
+};

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/initialize.js

@@ -1,7 +1,10 @@
 import {
   CategoryPaginatedResultSchema,
   IdentitySchema,
-  ProductSchema
+  OrderSchema,
+  OrderSearchResultSchema,
+  ProductSchema,
+  ProfileSchema
 } from "@reactionary/core";
 import { HclCategorySchema } from "../schema/category.schema.js";
 import {
@@ -20,9 +23,12 @@ import {
   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";
@@ -32,6 +38,9 @@ import { HclProductSearchCapability } from "../capabilities/product-search.capab
 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,
@@ -195,6 +204,54 @@ function withHclCapabilities(configuration, capabilities) {
         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/factories/index.js

@@ -6,3 +6,6 @@ export * from "./product-search/product-search.factory.js";
 export * from "./price/price.factory.js";
 export * from "./inventory/inventory.factory.js";
 export * from "./identity/identity.factory.js";
+export * from "./profile/profile.factory.js";
+export * from "./order/order.factory.js";
+export * from "./order-search/order-search.factory.js";

package/factories/order/order.factory.js

@@ -0,0 +1,124 @@
+function mapWcsOrderStatus(status) {
+  switch (status) {
+    case "S":
+      return "Shipped";
+    case "X":
+    case "R":
+    case "D":
+      return "Cancelled";
+    case "M":
+    case "G":
+    case "F":
+      return "ReleasedToFulfillment";
+    default:
+      return "AwaitingPayment";
+  }
+}
+class HclOrderFactory {
+  orderSchema;
+  constructor(orderSchema) {
+    this.orderSchema = orderSchema;
+  }
+  parseOrder(context, data) {
+    const currency = data.grandTotalCurrency ?? data.totalProductPriceCurrency ?? "USD";
+    const orderStatus = mapWcsOrderStatus(data.orderStatus ?? "");
+    const inventoryStatus = orderStatus === "Shipped" ? "Allocated" : "NotAllocated";
+    const userId = { userId: data.buyerId ?? "" };
+    const result = {
+      identifier: { key: data.orderId },
+      userId,
+      items: (data.orderItem ?? []).map(
+        (item) => this.parseOrderItem(context, item, currency)
+      ),
+      price: this.parseCostBreakdown(context, data, currency),
+      orderStatus,
+      inventoryStatus,
+      paymentInstructions: (data.paymentInstruction ?? []).map(
+        (pi) => this.parsePaymentInstruction(context, pi, currency)
+      ),
+      shippingAddress: data.x_shippingAddress ? {
+        identifier: {
+          nickName: data.x_shippingAddress.nickName ?? ""
+        },
+        firstName: data.x_shippingAddress.firstName ?? "",
+        lastName: data.x_shippingAddress.lastName ?? "",
+        streetAddress: data.x_shippingAddress.addressLine?.[0] ?? data.x_shippingAddress.address1 ?? "",
+        streetNumber: data.x_shippingAddress.addressLine?.[1] ?? "",
+        city: data.x_shippingAddress.city ?? "",
+        region: data.x_shippingAddress.state ?? "",
+        postalCode: data.x_shippingAddress.zipCode ?? "",
+        countryCode: data.x_shippingAddress.country ?? ""
+      } : void 0,
+      billingAddress: data.x_billingAddress ? {
+        identifier: {
+          nickName: data.x_billingAddress.nickName ?? ""
+        },
+        firstName: data.x_billingAddress.firstName ?? "",
+        lastName: data.x_billingAddress.lastName ?? "",
+        streetAddress: data.x_billingAddress.addressLine?.[0] ?? data.x_billingAddress.address1 ?? "",
+        streetNumber: data.x_billingAddress.addressLine?.[1] ?? "",
+        city: data.x_billingAddress.city ?? "",
+        region: data.x_billingAddress.state ?? "",
+        postalCode: data.x_billingAddress.zipCode ?? "",
+        countryCode: data.x_billingAddress.country ?? ""
+      } : void 0
+    };
+    return this.orderSchema.parse(result);
+  }
+  parseOrderItem(_context, item, defaultCurrency) {
+    const currency = item.currency ?? defaultCurrency;
+    const price = {
+      unitPrice: { value: Number(item.unitPrice), currency },
+      totalPrice: { value: Number(item.orderItemPrice), currency },
+      unitDiscount: { value: 0, currency },
+      totalDiscount: { value: 0, currency }
+    };
+    return {
+      identifier: { key: item.orderItemId },
+      variant: { sku: item.partNumber },
+      quantity: Number(item.quantity),
+      price,
+      inventoryStatus: "Allocated"
+    };
+  }
+  parseCostBreakdown(_context, data, currency) {
+    return {
+      grandTotal: { value: Number(data.grandTotal ?? "0"), currency },
+      totalProductPrice: {
+        value: Number(data.totalProductPrice ?? "0"),
+        currency
+      },
+      totalShipping: {
+        value: Number(data.totalShippingCharge ?? "0"),
+        currency
+      },
+      totalTax: { value: Number(data.totalSalesTax ?? "0"), currency },
+      totalDiscount: {
+        value: Math.abs(Number(data.totalAdjustment ?? "0")),
+        currency
+      },
+      totalSurcharge: { value: 0, currency }
+    };
+  }
+  parsePaymentInstruction(_context, pi, defaultCurrency) {
+    const currency = pi.currency ?? defaultCurrency;
+    const paymentMethod = {
+      method: pi.payMethodId,
+      name: pi.piDescription ?? pi.payMethodId,
+      paymentProcessor: pi.payMethodId
+    };
+    return {
+      identifier: { key: pi.piId },
+      amount: { value: Number(pi.piAmount ?? "0"), currency },
+      paymentMethod,
+      protocolData: (pi.protocolData ?? []).map((pd) => ({
+        key: pd.name,
+        value: pd.value
+      })),
+      status: "pending"
+    };
+  }
+}
+export {
+  HclOrderFactory
+};

package/factories/order-search/order-search.factory.js

@@ -0,0 +1,59 @@
+function mapWcsOrderStatus(status) {
+  switch (status) {
+    case "S":
+      return "Shipped";
+    case "X":
+    case "R":
+    case "D":
+      return "Cancelled";
+    case "M":
+    case "G":
+    case "F":
+      return "ReleasedToFulfillment";
+    default:
+      return "AwaitingPayment";
+  }
+}
+class HclOrderSearchFactory {
+  orderSearchResultSchema;
+  constructor(orderSearchResultSchema) {
+    this.orderSearchResultSchema = orderSearchResultSchema;
+  }
+  parseOrderSearchResult(context, data, query) {
+    const items = (data.Order ?? []).map(
+      (o) => this.parseOrderSearchResultItem(context, o)
+    );
+    const totalCount = Number(data.recordSetTotal ?? items.length);
+    const { pageSize, pageNumber } = query.search.paginationOptions;
+    const result = {
+      identifier: { ...query.search },
+      items,
+      totalCount,
+      pageSize,
+      pageNumber,
+      totalPages: Math.ceil(totalCount / Math.max(1, pageSize))
+    };
+    return this.orderSearchResultSchema.parse(result);
+  }
+  parseOrderSearchResultItem(_context, item) {
+    const orderStatus = mapWcsOrderStatus(item.orderStatus ?? "");
+    const inventoryStatus = orderStatus === "Shipped" ? "Allocated" : "NotAllocated";
+    const userId = { userId: item.buyerId ?? "" };
+    const totalAmount = {
+      value: Number(item.grandTotal ?? "0"),
+      currency: item.grandTotalCurrency ?? "USD"
+    };
+    return {
+      identifier: { key: item.orderId },
+      userId,
+      customerName: "",
+      orderDate: item.lastUpdateDate ?? "",
+      orderStatus,
+      inventoryStatus,
+      totalAmount
+    };
+  }
+}
+export {
+  HclOrderSearchFactory
+};

package/factories/profile/profile.factory.js

@@ -0,0 +1,49 @@
+const BILLING_NICK_NAME = "Billing";
+class HclProfileFactory {
+  profileSchema;
+  constructor(profileSchema) {
+    this.profileSchema = profileSchema;
+  }
+  parseProfile(context, data) {
+    const contacts = data.contact ?? [];
+    const billingContact = contacts.find(
+      (c) => c.nickName === BILLING_NICK_NAME
+    );
+    const shippingContacts = contacts.filter(
+      (c) => c.nickName !== BILLING_NICK_NAME
+    );
+    const defaultShipping = shippingContacts.find((c) => c.primary === "1") ?? shippingContacts[0];
+    const alternates = shippingContacts.filter((c) => c !== defaultShipping);
+    const result = {
+      identifier: { userId: data.userId },
+      email: data.email1 ?? data.logonId ?? "",
+      phone: data.phone1 ?? "",
+      emailVerified: false,
+      phoneVerified: false,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      billingAddress: billingContact ? this.parseAddress(context, billingContact) : void 0,
+      shippingAddress: defaultShipping ? this.parseAddress(context, defaultShipping) : void 0,
+      alternateShippingAddresses: alternates.map(
+        (c) => this.parseAddress(context, c)
+      )
+    };
+    return this.profileSchema.parse(result);
+  }
+  parseAddress(_context, contact) {
+    return {
+      identifier: { nickName: contact.nickName },
+      firstName: contact.firstName ?? "",
+      lastName: contact.lastName ?? "",
+      streetAddress: contact.addressLine?.[0] ?? contact.address1 ?? "",
+      streetNumber: contact.addressLine?.[1] ?? "",
+      city: contact.city ?? "",
+      region: contact.stateOrProvinceName ?? "",
+      postalCode: contact.zipCode ?? "",
+      countryCode: contact.country ?? ""
+    };
+  }
+}
+export {
+  HclProfileFactory
+};

package/index.js

@@ -14,3 +14,6 @@ export * from "./capabilities/product-search.capability.js";
 export * from "./capabilities/price.capability.js";
 export * from "./capabilities/inventory.capability.js";
 export * from "./capabilities/identity.capability.js";
+export * from "./capabilities/profile.capability.js";
+export * from "./capabilities/order.capability.js";
+export * from "./capabilities/order-search.capability.js";

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@reactionary/hcl",
-  "version": "0.9.11",
+  "version": "0.9.12",
   "type": "module",
   "main": "./index.js",
   "types": "./src/index.d.ts",
   "dependencies": {
-    "@reactionary/core": "0.9.11",
+    "@reactionary/core": "0.9.12",
     "debug": "^4.4.3",
     "zod": "4.1.9"
   },

package/schema/capabilities.schema.js

@@ -13,7 +13,10 @@ const HclCapabilitiesSchema = CapabilitiesSchema.pick({
   price: true,
   inventory: true,
   identity: true,
-  productSearch: true
+  productSearch: true,
+  profile: true,
+  order: true,
+  orderSearch: true
 }).extend({
   cart: OverridableCapabilitySchema.optional(),
   checkout: OverridableCapabilitySchema.optional(),
@@ -22,7 +25,10 @@ const HclCapabilitiesSchema = CapabilitiesSchema.pick({
   price: OverridableCapabilitySchema.optional(),
   inventory: OverridableCapabilitySchema.optional(),
   identity: OverridableCapabilitySchema.optional(),
-  productSearch: OverridableCapabilitySchema.optional()
+  productSearch: OverridableCapabilitySchema.optional(),
+  profile: OverridableCapabilitySchema.optional(),
+  order: OverridableCapabilitySchema.optional(),
+  orderSearch: OverridableCapabilitySchema.optional()
 }).partial();
 export {
   HclCapabilitiesSchema

package/src/capabilities/order-search.capability.d.ts

@@ -0,0 +1,13 @@
+import { type Cache, OrderSearchCapability, type OrderSearchFactory, type OrderSearchFactoryOutput, type OrderSearchFactoryWithOutput, type OrderSearchQueryByTerm, type RequestContext, type Result } from '@reactionary/core';
+import type { HclConfiguration } from '../schema/configuration.schema.js';
+import type { HclClient } from '../core/client.js';
+import type { HclOrderSearchFactory } from '../factories/order-search/order-search.factory.js';
+export declare class HclOrderSearchCapability<TFactory extends OrderSearchFactory = HclOrderSearchFactory> extends OrderSearchCapability<OrderSearchFactoryOutput<TFactory>> {
+    protected config: HclConfiguration;
+    protected client: HclClient;
+    protected factory: OrderSearchFactoryWithOutput<TFactory>;
+    constructor(cache: Cache, context: RequestContext, config: HclConfiguration, client: HclClient, factory: OrderSearchFactoryWithOutput<TFactory>);
+    queryByTerm(payload: OrderSearchQueryByTerm): Promise<Result<OrderSearchFactoryOutput<TFactory>>>;
+    protected orderByStatusUrl(statuses: string): string;
+    protected orderByStatusParams(maxResults: number, startIndex: number): URLSearchParams;
+}

package/src/capabilities/order.capability.d.ts

@@ -0,0 +1,13 @@
+import { type Cache, type NotFoundError, OrderCapability, type OrderFactory, type OrderFactoryOutput, type OrderFactoryWithOutput, type OrderQueryById, type RequestContext, type Result } from '@reactionary/core';
+import type { HclConfiguration } from '../schema/configuration.schema.js';
+import type { HclClient } from '../core/client.js';
+import type { HclOrderFactory } from '../factories/order/order.factory.js';
+export declare class HclOrderCapability<TFactory extends OrderFactory = HclOrderFactory> extends OrderCapability<OrderFactoryOutput<TFactory>> {
+    protected config: HclConfiguration;
+    protected client: HclClient;
+    protected factory: OrderFactoryWithOutput<TFactory>;
+    constructor(cache: Cache, context: RequestContext, config: HclConfiguration, client: HclClient, factory: OrderFactoryWithOutput<TFactory>);
+    getById(payload: OrderQueryById): Promise<Result<OrderFactoryOutput<TFactory>, NotFoundError>>;
+    protected orderUrl(orderId: string): string;
+    protected orderParams(): URLSearchParams;
+}

package/src/capabilities/profile.capability.d.ts

@@ -0,0 +1,31 @@
+import { type Address, type Cache, type NotFoundError, ProfileCapability, type ProfileFactory, type ProfileFactoryOutput, type ProfileFactoryWithOutput, type ProfileMutationAddShippingAddress, type ProfileMutationMakeShippingAddressDefault, type ProfileMutationRemoveShippingAddress, type ProfileMutationSetBillingAddress, type ProfileMutationUpdate, type ProfileMutationUpdateShippingAddress, type ProfileQuerySelf, type RequestContext, type Result } from '@reactionary/core';
+import type { HclConfiguration } from '../schema/configuration.schema.js';
+import type { HclClient } from '../core/client.js';
+import type { HclProfileFactory } from '../factories/profile/profile.factory.js';
+import type { HclPersonResponse, HclWcsPersonContact } from '../schema/hcl.schema.js';
+export declare class HclProfileCapability<TFactory extends ProfileFactory = HclProfileFactory> extends ProfileCapability<ProfileFactoryOutput<TFactory>> {
+    protected config: HclConfiguration;
+    protected client: HclClient;
+    protected factory: ProfileFactoryWithOutput<TFactory>;
+    constructor(cache: Cache, context: RequestContext, config: HclConfiguration, client: HclClient, factory: ProfileFactoryWithOutput<TFactory>);
+    protected fetchPerson(): Promise<HclPersonResponse>;
+    protected fetchProfile(): Promise<ProfileFactoryOutput<TFactory>>;
+    protected toWcsContact(address: Address): Partial<HclWcsPersonContact>;
+    protected personSelfUrl(): string;
+    protected updatePersonPayload(email?: string, phone?: string): {
+        email1?: string;
+        phone1?: string;
+    };
+    protected personContactListUrl(): string;
+    protected contactUrl(nickName: string): string;
+    protected makeShippingAddressDefaultPayload(): {
+        primary: string;
+    };
+    getById(_payload: ProfileQuerySelf): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>>;
+    update(payload: ProfileMutationUpdate): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>>;
+    addShippingAddress(payload: ProfileMutationAddShippingAddress): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>>;
+    updateShippingAddress(payload: ProfileMutationUpdateShippingAddress): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>>;
+    removeShippingAddress(payload: ProfileMutationRemoveShippingAddress): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>>;
+    makeShippingAddressDefault(payload: ProfileMutationMakeShippingAddressDefault): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>>;
+    setBillingAddress(payload: ProfileMutationSetBillingAddress): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>>;
+}

package/src/core/initialize.types.d.ts

@@ -8,7 +8,10 @@ import type { HclProductSearchCapability } from '../capabilities/product-search.
 import type { HclPriceCapability } from '../capabilities/price.capability.js';
 import type { HclInventoryCapability } from '../capabilities/inventory.capability.js';
 import type { HclIdentityCapability } from '../capabilities/identity.capability.js';
-type OverridableCapabilityKey = 'product' | 'productSearch' | 'cart' | 'checkout' | 'category' | 'price' | 'inventory' | 'identity';
+import type { HclProfileCapability } from '../capabilities/profile.capability.js';
+import type { HclOrderCapability } from '../capabilities/order.capability.js';
+import type { HclOrderSearchCapability } from '../capabilities/order-search.capability.js';
+type OverridableCapabilityKey = 'product' | 'productSearch' | 'cart' | 'checkout' | 'category' | 'price' | 'inventory' | 'identity' | 'profile' | 'order' | 'orderSearch';
 type EnabledCapability<TCapability> = TCapability extends {
     enabled: true;
 } ? true : false;
@@ -28,6 +31,9 @@ type DefaultCapabilityMap = {
     price: HclPriceCapability;
     inventory: HclInventoryCapability;
     identity: HclIdentityCapability;
+    profile: HclProfileCapability;
+    order: HclOrderCapability;
+    orderSearch: HclOrderSearchCapability;
 };
 type CapabilityImplementationMap<T extends HclCapabilities> = {
     [K in OverridableCapabilityKey]: ExtractCapabilityImplementation<T[K], DefaultCapabilityMap[K]>;

package/src/factories/index.d.ts

@@ -6,3 +6,6 @@ export * from './product-search/product-search.factory.js';
 export * from './price/price.factory.js';
 export * from './inventory/inventory.factory.js';
 export * from './identity/identity.factory.js';
+export * from './profile/profile.factory.js';
+export * from './order/order.factory.js';
+export * from './order-search/order-search.factory.js';

package/src/factories/order/order.factory.d.ts

@@ -0,0 +1,11 @@
+import type { AnyOrderSchema, CostBreakDown, Currency, OrderFactory, OrderItem, OrderSchema, PaymentInstruction, RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+import type { HclWcsOrderDetailResponse, HclWcsOrderItem, HclWcsPaymentInstruction } from '../../schema/hcl.schema.js';
+export declare class HclOrderFactory<TOrderSchema extends AnyOrderSchema = typeof OrderSchema> implements OrderFactory<TOrderSchema> {
+    readonly orderSchema: TOrderSchema;
+    constructor(orderSchema: TOrderSchema);
+    parseOrder(context: RequestContext, data: HclWcsOrderDetailResponse): z.output<TOrderSchema>;
+    protected parseOrderItem(_context: RequestContext, item: HclWcsOrderItem, defaultCurrency: Currency): OrderItem;
+    protected parseCostBreakdown(_context: RequestContext, data: HclWcsOrderDetailResponse, currency: Currency): CostBreakDown;
+    protected parsePaymentInstruction(_context: RequestContext, pi: HclWcsPaymentInstruction, defaultCurrency: Currency): PaymentInstruction;
+}

package/src/factories/order-search/order-search.factory.d.ts

@@ -0,0 +1,9 @@
+import type { AnyOrderSearchResultSchema, OrderSearchFactory, OrderSearchQueryByTerm, OrderSearchResultItem, OrderSearchResultSchema, RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+import type { HclWcsCartResponse, HclWcsOrderListResponse } from '../../schema/hcl.schema.js';
+export declare class HclOrderSearchFactory<TOrderSearchResultSchema extends AnyOrderSearchResultSchema = typeof OrderSearchResultSchema> implements OrderSearchFactory<TOrderSearchResultSchema> {
+    readonly orderSearchResultSchema: TOrderSearchResultSchema;
+    constructor(orderSearchResultSchema: TOrderSearchResultSchema);
+    parseOrderSearchResult(context: RequestContext, data: HclWcsOrderListResponse, query: OrderSearchQueryByTerm): z.output<TOrderSearchResultSchema>;
+    protected parseOrderSearchResultItem(_context: RequestContext, item: HclWcsCartResponse): OrderSearchResultItem;
+}

package/src/factories/profile/profile.factory.d.ts

@@ -0,0 +1,9 @@
+import type { Address, AnyProfileSchema, ProfileFactory, ProfileSchema, RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+import type { HclPersonResponse, HclWcsPersonContact } from '../../schema/hcl.schema.js';
+export declare class HclProfileFactory<TProfileSchema extends AnyProfileSchema = typeof ProfileSchema> implements ProfileFactory<TProfileSchema> {
+    readonly profileSchema: TProfileSchema;
+    constructor(profileSchema: TProfileSchema);
+    parseProfile(context: RequestContext, data: HclPersonResponse): z.output<TProfileSchema>;
+    protected parseAddress(_context: RequestContext, contact: HclWcsPersonContact): Address;
+}

package/src/index.d.ts

@@ -14,3 +14,6 @@ export * from './capabilities/product-search.capability.js';
 export * from './capabilities/price.capability.js';
 export * from './capabilities/inventory.capability.js';
 export * from './capabilities/identity.capability.js';
+export * from './capabilities/profile.capability.js';
+export * from './capabilities/order.capability.js';
+export * from './capabilities/order-search.capability.js';

package/src/schema/capabilities.schema.d.ts

@@ -1,4 +1,4 @@
-import type { Cache, RequestContext, CartFactory, CartFactoryWithOutput, CartCapability, CategoryFactory, CategoryFactoryWithOutput, CategoryCapability, CheckoutFactory, CheckoutFactoryWithOutput, CheckoutCapability, IdentityFactory, IdentityFactoryWithOutput, IdentityCapability, InventoryFactory, InventoryFactoryWithOutput, InventoryCapability, PriceFactory, PriceFactoryWithOutput, PriceCapability, ProductFactory, ProductFactoryWithOutput, ProductCapability, ProductSearchFactory, ProductSearchFactoryWithOutput, ProductSearchCapability } from '@reactionary/core';
+import type { Cache, RequestContext, CartFactory, CartFactoryWithOutput, CartCapability, CategoryFactory, CategoryFactoryWithOutput, CategoryCapability, CheckoutFactory, CheckoutFactoryWithOutput, CheckoutCapability, IdentityFactory, IdentityFactoryWithOutput, IdentityCapability, InventoryFactory, InventoryFactoryWithOutput, InventoryCapability, OrderFactory, OrderFactoryWithOutput, OrderCapability, OrderSearchFactory, OrderSearchFactoryWithOutput, OrderSearchCapability, PriceFactory, PriceFactoryWithOutput, PriceCapability, ProductFactory, ProductFactoryWithOutput, ProductCapability, ProductSearchFactory, ProductSearchFactoryWithOutput, ProductSearchCapability, ProfileFactory, ProfileFactoryWithOutput, ProfileCapability } from '@reactionary/core';
 import type { HclConfiguration } from './configuration.schema.js';
 import type { HclClient } from '../core/client.js';
 import * as z from 'zod';
@@ -43,6 +43,21 @@ export declare const HclCapabilitiesSchema: z.ZodObject<{
         factory: z.ZodOptional<z.ZodUnknown>;
         capability: z.ZodOptional<z.ZodUnknown>;
     }, z.core.$loose>>>;
+    profile: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+    order: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+    orderSearch: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
 }, z.core.$loose>;
 export type HclCapabilities = z.infer<typeof HclCapabilitiesSchema>;
 export interface HclCapabilityFactoryArgs {
@@ -67,3 +82,6 @@ export type HclPriceCapabilityConfig = HclCapabilityConfig<PriceFactoryWithOutpu
 export type HclProductCapabilityConfig = HclCapabilityConfig<ProductFactoryWithOutput<ProductFactory>, ProductCapability>;
 export type HclProductSearchCapabilityConfig = HclCapabilityConfig<ProductSearchFactoryWithOutput<ProductSearchFactory>, ProductSearchCapability>;
 export type HclIdentityCapabilityConfig = HclCapabilityConfig<IdentityFactoryWithOutput<IdentityFactory>, IdentityCapability>;
+export type HclProfileCapabilityConfig = HclCapabilityConfig<ProfileFactoryWithOutput<ProfileFactory>, ProfileCapability>;
+export type HclOrderCapabilityConfig = HclCapabilityConfig<OrderFactoryWithOutput<OrderFactory>, OrderCapability>;
+export type HclOrderSearchCapabilityConfig = HclCapabilityConfig<OrderSearchFactoryWithOutput<OrderSearchFactory>, OrderSearchCapability>;

package/src/schema/hcl.schema.d.ts

@@ -427,6 +427,31 @@ export interface HclWcsIdentityResponse {
     personalizationID?: string;
     resourceName?: string;
 }
+/**
+ * A single entry in a WCS person address book (contact list).
+ * Returned as part of the GET /person/@self response (contact[] field)
+ * and used for POST/PUT /person/@self/contact operations.
+ */
+export interface HclWcsPersonContact {
+    /** Unique identifier / display name for this address (e.g. 'Home', 'Work', 'Billing'). */
+    nickName: string;
+    firstName?: string;
+    lastName?: string;
+    /** Street address lines. Index 0 = street, index 1 = apartment / second line. */
+    addressLine?: string[];
+    /** Alternative single-field address (some WCS endpoint variants). */
+    address1?: string;
+    city?: string;
+    stateOrProvinceName?: string;
+    zipCode?: string;
+    /** ISO country code, e.g. 'US'. */
+    country?: string;
+    phone1?: string;
+    email1?: string;
+    /** '1' marks this as the default / primary shipping address. */
+    primary?: string;
+    addressType?: string;
+}
 /**
  * Response from GET /wcs/resources/store/{storeId}/person/@self.
  * Only the fields we use are typed; the full WCS schema has many more.
@@ -439,9 +464,12 @@ export interface HclPersonResponse {
     email1?: string;
     firstName?: string;
     lastName?: string;
+    phone1?: string;
     resourceName?: string;
     /** Organization ID. `-2000` indicates the default anonymous org. */
     orgizationId?: string;
+    /** Address book entries embedded in the person/@self response. */
+    contact?: HclWcsPersonContact[];
 }
 /** A single order item embedded in a WCS cart/@self response. */
 export interface HclWcsOrderItem {
@@ -631,3 +659,38 @@ export interface HclWcsCreateOrderResponse {
     redirecturl?: string;
     viewTaskName?: string;
 }
+/**
+ * A full order as returned by GET /wcs/resources/store/{storeId}/order/{orderId}.
+ * Extends the cart response shape with the `placedDate` field that is only
+ * present on placed (non-active) orders.
+ */
+export interface HclWcsOrderDetailResponse extends HclWcsCartResponse {
+    /** Date/time when the order was placed, e.g. '2024-01-15T10:30:00.000Z'. */
+    placedDate?: string;
+}
+/**
+ * A single summary entry in a GET /wcs/resources/store/{storeId}/order/@history response.
+ * Contains only the fields available in the history list; use getById for full detail.
+ */
+export interface HclWcsOrderHistoryItem {
+    orderId: string;
+    /** WCS order status code, e.g. 'P', 'M', 'S', 'X'. */
+    status: string;
+    placedDate?: string;
+    grandTotal?: string;
+    grandTotalCurrency?: string;
+    totalProductPrice?: string;
+    orderDescription?: string;
+    buyerDistinguishedName?: string;
+}
+/**
+ * Top-level response from GET /wcs/resources/store/{storeId}/order/@history.
+ * Returns a paginated list of the buyer's past orders.
+ */
+export interface HclWcsOrderHistoryResponse {
+    Order?: HclWcsOrderHistoryItem[];
+    recordSetTotal?: string;
+    recordSetCount?: string;
+    recordSetStartNumber?: string;
+    recordSetComplete?: string;
+}

package/src/test/test-utils.d.ts

@@ -5,12 +5,15 @@ export declare function createHclClient(contextOverrides?: Partial<RequestContex
     product?: true | undefined;
     productSearch?: true | undefined;
     price?: false | undefined;
+    order?: false | undefined;
     cart?: false | undefined;
     checkout?: false | undefined;
     identity?: false | undefined;
+    profile?: false | undefined;
     inventory?: false | undefined;
     category?: true | undefined;
-}>, "product" | "productSearch" | "price" | "cart" | "checkout" | "identity" | "inventory" | "category"> & {
+    orderSearch?: false | undefined;
+}>, "product" | "productSearch" | "price" | "order" | "cart" | "checkout" | "identity" | "profile" | "inventory" | "category" | "orderSearch"> & {
     product: import("../index.js").HclProductCapability<import("../index.js").HclProductFactory<import("zod").ZodObject<{
         identifier: import("zod").ZodObject<{
             key: import("zod").ZodString;