@reactionary/hcl 0.9.11 → 0.9.13

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,13 @@
 import {
   CategoryPaginatedResultSchema,
   IdentitySchema,
-  ProductSchema
+  OrderSchema,
+  OrderSearchResultSchema,
+  PersonalizationProfileSchema,
+  ProductAssociationSchema,
+  ProductRecommendationSchema,
+  ProductSchema,
+  ProfileSchema
 } from "@reactionary/core";
 import { HclCategorySchema } from "../schema/category.schema.js";
 import {
@@ -20,9 +26,15 @@ import {
   HclCheckoutFactory,
   HclIdentityFactory,
   HclInventoryFactory,
+  HclOrderFactory,
+  HclOrderSearchFactory,
+  HclPersonalizationProfileFactory,
   HclPriceFactory,
+  HclProductAssociationsFactory,
   HclProductFactory,
-  HclProductSearchFactory
+  HclProductRecommendationsFactory,
+  HclProductSearchFactory,
+  HclProfileFactory
 } from "../factories/index.js";
 import { HclCartCapability } from "../capabilities/cart.capability.js";
 import { HclCheckoutCapability } from "../capabilities/checkout.capability.js";
@@ -32,6 +44,13 @@ 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 { HclAnalyticsCapability } from "../capabilities/analytics.capability.js";
+import { HclProductAssociationsCapability } from "../capabilities/product-associations.capability.js";
+import { HclProductRecommendationsCapability } from "../capabilities/product-recommendations.capability.js";
+import { HclPersonalizationProfileCapability } from "../capabilities/personalization-profile.capability.js";
 import {
   CartIdentifierSchema,
   CartPaginatedSearchResultSchema,
@@ -195,6 +214,121 @@ 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
+      );
+    }
+    if (caps.analytics?.enabled) {
+      const analyticsCap = capabilities.analytics;
+      if (analyticsCap?.capability) {
+        client.analytics = analyticsCap.capability(
+          buildCapabilityArgs(void 0)
+        );
+      } else {
+        client.analytics = new HclAnalyticsCapability(
+          cache,
+          context,
+          config,
+          hclClient
+        );
+      }
+    }
+    if (caps.productAssociations?.enabled) {
+      client.productAssociations = resolveCapabilityWithFactory(
+        capabilities.productAssociations,
+        {
+          factory: new HclProductAssociationsFactory(ProductAssociationSchema),
+          capability: (args) => new HclProductAssociationsCapability(
+            args.cache,
+            args.context,
+            args.config,
+            args.hclClient,
+            args.factory
+          )
+        },
+        buildCapabilityArgs
+      );
+    }
+    if (caps.productRecommendations?.enabled) {
+      client.productRecommendations = resolveCapabilityWithFactory(
+        capabilities.productRecommendations,
+        {
+          factory: new HclProductRecommendationsFactory(
+            ProductRecommendationSchema
+          ),
+          capability: (args) => new HclProductRecommendationsCapability(
+            args.cache,
+            args.context,
+            args.config,
+            args.hclClient,
+            args.factory
+          )
+        },
+        buildCapabilityArgs
+      );
+    }
+    if (caps.personalizationProfile?.enabled) {
+      client.personalizationProfile = resolveCapabilityWithFactory(
+        capabilities.personalizationProfile,
+        {
+          factory: new HclPersonalizationProfileFactory(
+            PersonalizationProfileSchema
+          ),
+          capability: (args) => new HclPersonalizationProfileCapability(
+            args.cache,
+            args.context,
+            args.config,
+            args.hclClient,
+            args.factory
+          )
+        },
+        buildCapabilityArgs
+      );
+    }
     return client;
   };
 }

package/factories/index.js

@@ -6,3 +6,9 @@ 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";
+export * from "./product-associations/product-associations.factory.js";
+export * from "./product-recommendations/product-recommendations.factory.js";
+export * from "./personalization-profile/personalization-profile.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/personalization-profile/personalization-profile.factory.js

@@ -0,0 +1,16 @@
+class HclPersonalizationProfileFactory {
+  personalizationProfileSchema;
+  constructor(personalizationProfileSchema) {
+    this.personalizationProfileSchema = personalizationProfileSchema;
+  }
+  parsePersonalizationProfile(_context, data) {
+    return this.personalizationProfileSchema.parse({
+      identifier: { key: data.personalizationId },
+      segments: data.segments,
+      blurb: ""
+    });
+  }
+}
+export {
+  HclPersonalizationProfileFactory
+};

package/factories/product-associations/product-associations.factory.js

@@ -0,0 +1,16 @@
+class HclProductAssociationsFactory {
+  productAssociationSchema;
+  constructor(productAssociationSchema) {
+    this.productAssociationSchema = productAssociationSchema;
+  }
+  parseAssociation(_context, data) {
+    return this.productAssociationSchema.parse({
+      associationIdentifier: { key: data.partNumber },
+      associationReturnType: "idOnly",
+      product: { key: data.partNumber }
+    });
+  }
+}
+export {
+  HclProductAssociationsFactory
+};

package/factories/product-recommendations/product-recommendations.factory.js

@@ -0,0 +1,17 @@
+class HclProductRecommendationsFactory {
+  productRecommendationSchema;
+  constructor(productRecommendationSchema) {
+    this.productRecommendationSchema = productRecommendationSchema;
+  }
+  parseRecommendation(_context, data) {
+    const key = data.activityData.partNumber ?? data.activityData.contentId ?? "";
+    return this.productRecommendationSchema.parse({
+      recommendationIdentifier: { key, algorithm: data.algorithm },
+      recommendationReturnType: "idOnly",
+      product: { key }
+    });
+  }
+}
+export {
+  HclProductRecommendationsFactory
+};

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,10 @@ 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";
+export * from "./capabilities/analytics.capability.js";
+export * from "./capabilities/product-associations.capability.js";
+export * from "./capabilities/product-recommendations.capability.js";
+export * from "./capabilities/personalization-profile.capability.js";