@reactionary/hcl 0.9.12 → 0.9.14

package/capabilities/product-recommendations.capability.js

@@ -0,0 +1,143 @@
+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 {
+  ProductRecommendationsCapability,
+  ProductRecommendationsQuerySchema,
+  ProductRecommendationsByCollectionQuerySchema,
+  Reactionary,
+  success
+} from "@reactionary/core";
+class HclProductRecommendationsCapability extends ProductRecommendationsCapability {
+  constructor(cache, context, config, client, factory) {
+    super(cache, context);
+    this.config = config;
+    this.client = client;
+    this.factory = factory;
+  }
+  getRecommendations(...args) {
+    return super.getRecommendations(...args);
+  }
+  async getCollection(query) {
+    const params = {
+      productId: query.sourceProduct?.[0]?.key,
+      categoryId: query.sourceCategory?.key,
+      count: String(query.numberOfRecommendations)
+    };
+    const recommendations = await this.fetchEspot(
+      query.collectionName,
+      query.collectionName,
+      params
+    );
+    return success(recommendations.slice(0, query.numberOfRecommendations));
+  }
+  async getFrequentlyBoughtTogetherRecommendations(query) {
+    return this.fetchEspot(
+      this.config.espotNames.frequentlyBoughtTogether,
+      "frequentlyBoughtTogether",
+      {
+        productId: query.sourceProduct.key,
+        count: String(query.numberOfRecommendations)
+      }
+    );
+  }
+  async getSimilarProductsRecommendations(query) {
+    return this.fetchEspot(this.config.espotNames.similar, "similar", {
+      productId: query.sourceProduct.key,
+      count: String(query.numberOfRecommendations)
+    });
+  }
+  async getRelatedProductsRecommendations(query) {
+    return this.fetchEspot(this.config.espotNames.related, "related", {
+      productId: query.sourceProduct.key,
+      count: String(query.numberOfRecommendations)
+    });
+  }
+  async getTrendingInCategoryRecommendations(query) {
+    return this.fetchEspot(
+      this.config.espotNames.trendingInCategory,
+      "trendingInCategory",
+      {
+        categoryId: query.sourceCategory.key,
+        count: String(query.numberOfRecommendations)
+      }
+    );
+  }
+  async getPopularProductsRecommendations(query) {
+    return this.fetchEspot(this.config.espotNames.popular, "popular", {
+      count: String(query.numberOfRecommendations)
+    });
+  }
+  async getTopPicksProductsRecommendations(query) {
+    return this.fetchEspot(this.config.espotNames.topPicks, "topPicks", {
+      count: String(query.numberOfRecommendations)
+    });
+  }
+  async getAlsoViewedProductsRecommendations(query) {
+    return this.fetchEspot(this.config.espotNames.alsoViewed, "alsoViewed", {
+      productId: query.sourceProduct.key,
+      count: String(query.numberOfRecommendations)
+    });
+  }
+  /**
+   * Calls an HCL marketing spot (espot) by name and maps its catalog entry
+   * activity data to `ProductRecommendation[]` using the factory.
+   *
+   * Returns an empty array when the espot is not found (404) or returns no
+   * catalog entry data — allowing teams to configure only the espots they need.
+   */
+  async fetchEspot(name, algorithm, params = {}) {
+    const response = await this.client.callGet(
+      this.getEspotUrl(name),
+      this.getEspotParams(params),
+      { allowUndefined: true }
+    );
+    if (!response) {
+      return [];
+    }
+    const activities = response.MarketingSpotData?.[0]?.baseMarketingSpotActivityData ?? [];
+    return activities.filter(
+      (a) => a.baseMarketingSpotDataType === "CatalogEntry" || a.baseMarketingSpotDataType === "CatalogEntryId"
+    ).map(
+      (a) => this.factory.parseRecommendation(this.context, {
+        activityData: a,
+        algorithm
+      })
+    ).filter((r) => r.product.key !== "");
+  }
+  getEspotUrl(name) {
+    return `${this.client.transactionBaseUrl}/espot/${encodeURIComponent(name)}`;
+  }
+  getEspotParams(params) {
+    const searchParams = new URLSearchParams();
+    const count = params["count"];
+    if (count)
+      searchParams.set("DM_DisplayProducts", count);
+    if (params["productId"])
+      searchParams.set("productId", params["productId"]);
+    if (params["categoryId"])
+      searchParams.set("categoryId", params["categoryId"]);
+    return searchParams;
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: ProductRecommendationsQuerySchema
+  })
+], HclProductRecommendationsCapability.prototype, "getRecommendations", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: ProductRecommendationsByCollectionQuerySchema
+  })
+], HclProductRecommendationsCapability.prototype, "getCollection", 1);
+export {
+  HclProductRecommendationsCapability
+};

package/capabilities/store.capability.js

@@ -0,0 +1,72 @@
+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 {
+  Reactionary,
+  StoreCapability,
+  StoreQueryByProximitySchema,
+  StoreSchema,
+  success
+} from "@reactionary/core";
+import * as z from "zod";
+import createDebug from "debug";
+const debug = createDebug("reactionary:hcl:store");
+class HclStoreCapability extends StoreCapability {
+  config;
+  client;
+  factory;
+  constructor(cache, context, config, client, factory) {
+    super(cache, context);
+    this.config = config;
+    this.client = client;
+    this.factory = factory;
+  }
+  async queryByProximity(payload) {
+    debug(
+      "queryByProximity lat=%d lon=%d dist=%d",
+      payload.latitude,
+      payload.longitude,
+      payload.distance
+    );
+    const response = await this.client.callGet(
+      this.getStoreLocatorUrl(payload),
+      this.getStoreLocatorParams(payload),
+      { allowUndefined: true }
+    );
+    const stores = (response?.PhysicalStore ?? []).map(
+      (store) => this.factory.parseStore(this.context, store)
+    );
+    return success(stores);
+  }
+  // ---------------------------------------------------------------------------
+  // Extension points
+  // ---------------------------------------------------------------------------
+  getStoreLocatorUrl(payload) {
+    return `${this.client.transactionBaseUrl}/storelocator/latitude/${payload.latitude}/longitude/${payload.longitude}`;
+  }
+  getStoreLocatorParams(payload) {
+    const params = new URLSearchParams();
+    params.set("maxItems", String(payload.limit));
+    params.set("radius", String(payload.distance));
+    params.set("radiusUOM", "km");
+    params.set("siteLevelStoreSearch", "false");
+    return params;
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: StoreQueryByProximitySchema,
+    outputSchema: z.array(StoreSchema)
+  })
+], HclStoreCapability.prototype, "queryByProximity", 1);
+export {
+  HclStoreCapability
+};

package/core/initialize.js

@@ -1,10 +1,20 @@
 import {
   CategoryPaginatedResultSchema,
+  CompanyPaginatedListSchema,
+  CompanySchema,
   IdentitySchema,
   OrderSchema,
   OrderSearchResultSchema,
+  PersonalizationProfileSchema,
+  ProductAssociationSchema,
+  ProductListItemPaginatedResultsSchema,
+  ProductListItemSchema,
+  ProductListPaginatedResultsSchema,
+  ProductListSchema,
+  ProductRecommendationSchema,
   ProductSchema,
-  ProfileSchema
+  ProfileSchema,
+  StoreSchema
 } from "@reactionary/core";
 import { HclCategorySchema } from "../schema/category.schema.js";
 import {
@@ -21,14 +31,20 @@ import {
   HclCartFactory,
   HclCategoryFactory,
   HclCheckoutFactory,
+  HclCompanyFactory,
   HclIdentityFactory,
   HclInventoryFactory,
   HclOrderFactory,
   HclOrderSearchFactory,
+  HclPersonalizationProfileFactory,
   HclPriceFactory,
+  HclProductAssociationsFactory,
   HclProductFactory,
+  HclProductListFactory,
+  HclProductRecommendationsFactory,
   HclProductSearchFactory,
-  HclProfileFactory
+  HclProfileFactory,
+  HclStoreFactory
 } from "../factories/index.js";
 import { HclCartCapability } from "../capabilities/cart.capability.js";
 import { HclCheckoutCapability } from "../capabilities/checkout.capability.js";
@@ -41,6 +57,13 @@ 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 { HclCompanyCapability } from "../capabilities/company.capability.js";
+import { HclStoreCapability } from "../capabilities/store.capability.js";
+import { HclProductListCapability } from "../capabilities/product-list.capability.js";
 import {
   CartIdentifierSchema,
   CartPaginatedSearchResultSchema,
@@ -252,6 +275,129 @@ function withHclCapabilities(configuration, capabilities) {
         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
+      );
+    }
+    if (caps.company?.enabled) {
+      client.company = resolveCapabilityWithFactory(
+        capabilities.company,
+        {
+          factory: new HclCompanyFactory(
+            CompanySchema,
+            CompanyPaginatedListSchema
+          ),
+          capability: (args) => new HclCompanyCapability(
+            args.cache,
+            args.context,
+            args.config,
+            args.hclClient,
+            args.factory
+          )
+        },
+        buildCapabilityArgs
+      );
+    }
+    if (caps.store?.enabled) {
+      client.store = resolveCapabilityWithFactory(
+        capabilities.store,
+        {
+          factory: new HclStoreFactory(StoreSchema),
+          capability: (args) => new HclStoreCapability(
+            args.cache,
+            args.context,
+            args.config,
+            args.hclClient,
+            args.factory
+          )
+        },
+        buildCapabilityArgs
+      );
+    }
+    if (caps.productList?.enabled) {
+      client.productList = resolveCapabilityWithFactory(
+        capabilities.productList,
+        {
+          factory: new HclProductListFactory(
+            ProductListSchema,
+            ProductListItemSchema,
+            ProductListPaginatedResultsSchema,
+            ProductListItemPaginatedResultsSchema
+          ),
+          capability: (args) => new HclProductListCapability(
+            args.cache,
+            args.context,
+            args.config,
+            args.hclClient,
+            args.factory
+          )
+        },
+        buildCapabilityArgs
+      );
+    }
     return client;
   };
 }

package/factories/company/company.factory.js

@@ -0,0 +1,77 @@
+class HclCompanyFactory {
+  companySchema;
+  companyPaginatedListSchema;
+  constructor(companySchema, companyPaginatedListSchema) {
+    this.companySchema = companySchema;
+    this.companyPaginatedListSchema = companyPaginatedListSchema;
+  }
+  parseCompany(_context, data) {
+    const result = {
+      identifier: {
+        taxIdentifier: data.taxPayerId ?? data.organizationId ?? data.orgEntityId ?? ""
+      },
+      name: data.organizationName ?? data.displayName ?? "",
+      dunsIdentifier: void 0,
+      tinIdentifier: data.legalId,
+      logo: void 0,
+      // state '0' = locked/blocked; any other value (or absent) = active
+      status: data.state === "0" ? "blocked" : "active",
+      pointOfContact: {
+        email: data.contactInfo?.email1 ?? "",
+        phone: data.contactInfo?.phone1
+      },
+      billingAddress: data.contactInfo ? this.parseOrgContact(data.contactInfo, "default") : this.parseOrgContact(
+        {
+          nickName: "default",
+          firstName: "",
+          lastName: "",
+          addressLine: [],
+          city: "",
+          stateOrProvinceName: "",
+          zipCode: "",
+          country: ""
+        },
+        "default"
+      ),
+      alternateShippingAddresses: (data.addressBook ?? []).map(
+        (c, i) => this.parseOrgContact(c, c.nickName ?? `address-${i}`)
+      ),
+      isCustomAddressesAllowed: false,
+      isSelfManagementOfShippingAddressesAllowed: false
+    };
+    return this.companySchema.parse(result);
+  }
+  parseCompanyPaginatedList(context, data, _query) {
+    const items = (data.organizationDataBeans ?? []).map(
+      (org) => this.parseCompany(context, org)
+    );
+    const pageSize = Math.max(1, items.length);
+    const result = {
+      identifier: {
+        paginationOptions: { pageNumber: 1, pageSize }
+      },
+      items,
+      totalCount: Number(data.recordSetTotal ?? items.length),
+      pageSize,
+      pageNumber: 1,
+      totalPages: 1
+    };
+    return this.companyPaginatedListSchema.parse(result);
+  }
+  parseOrgContact(contact, defaultNickName) {
+    return {
+      identifier: { nickName: contact.nickName ?? defaultNickName },
+      firstName: contact.firstName ?? "",
+      lastName: contact.lastName ?? "",
+      streetAddress: contact.addressLine?.[0] ?? "",
+      streetNumber: contact.addressLine?.[1] ?? "",
+      city: contact.city ?? "",
+      region: contact.stateOrProvinceName ?? "",
+      postalCode: contact.zipCode ?? "",
+      countryCode: contact.country ?? ""
+    };
+  }
+}
+export {
+  HclCompanyFactory
+};

package/factories/index.js

@@ -1,5 +1,6 @@
 export * from "./cart/cart.factory.js";
 export * from "./checkout/checkout.factory.js";
+export * from "./company/company.factory.js";
 export * from "./product/product.factory.js";
 export * from "./category/category.factory.js";
 export * from "./product-search/product-search.factory.js";
@@ -9,3 +10,8 @@ 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-list/product-list.factory.js";
+export * from "./product-recommendations/product-recommendations.factory.js";
+export * from "./personalization-profile/personalization-profile.factory.js";
+export * from "./store/store.factory.js";

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-list/product-list.factory.js

@@ -0,0 +1,158 @@
+const WISHLIST_TYPES = /* @__PURE__ */ new Set(["favorite", "wish", "shopping"]);
+function encodeWishlistType(type, description) {
+  return `${type}:${description ?? ""}`;
+}
+function decodeWishlistType(raw) {
+  if (raw) {
+    const colonIdx = raw.indexOf(":");
+    if (colonIdx > 0) {
+      const prefix = raw.slice(0, colonIdx);
+      if (WISHLIST_TYPES.has(prefix)) {
+        const desc = raw.slice(colonIdx + 1);
+        return {
+          type: prefix,
+          description: desc || void 0
+        };
+      }
+    }
+  }
+  return { type: "wish", description: raw || void 0 };
+}
+class HclProductListFactory {
+  productListSchema;
+  productListItemSchema;
+  productListPaginatedSchema;
+  productListItemPaginatedSchema;
+  constructor(productListSchema, productListItemSchema, productListPaginatedSchema, productListItemPaginatedSchema) {
+    this.productListSchema = productListSchema;
+    this.productListItemSchema = productListItemSchema;
+    this.productListPaginatedSchema = productListPaginatedSchema;
+    this.productListItemPaginatedSchema = productListItemPaginatedSchema;
+  }
+  parseProductList(_context, data) {
+    const key = data.uniqueID ?? data.externalIdentifier ?? "";
+    const { type, description } = decodeWishlistType(data.description);
+    const result = {
+      identifier: { key, listType: type },
+      type,
+      name: data.descriptionName ?? "",
+      description,
+      published: true
+    };
+    return this.productListSchema.parse(result);
+  }
+  parseProductListItem(_context, data) {
+    const result = {
+      identifier: { key: data.item.giftListItemID ?? "", list: data.list },
+      variant: { sku: data.item.productId ?? data.item.partNumber ?? "" },
+      quantity: Math.max(1, Number(data.item.quantityRequested ?? 1)),
+      order: 1
+    };
+    return this.productListItemSchema.parse(result);
+  }
+  parseProductListPaginatedResult(context, data, query) {
+    const items = (data.GiftList ?? []).map((w) => this.parseProductList(context, w)).filter(
+      (item) => item.identifier.listType === query.search.listType
+    );
+    const result = {
+      identifier: {
+        listType: query.search.listType,
+        paginationOptions: query.search.paginationOptions
+      },
+      items,
+      totalCount: items.length,
+      pageSize: Math.max(1, items.length),
+      pageNumber: 1,
+      totalPages: 1
+    };
+    return this.productListPaginatedSchema.parse(result);
+  }
+  parseProductListItemPaginatedResult(context, data, query) {
+    const rawItems = data.GiftList?.[0]?.item ?? [];
+    const items = rawItems.map(
+      (i) => this.parseProductListItem(context, { item: i, list: query.search.list })
+    );
+    const result = {
+      identifier: {
+        list: query.search.list,
+        paginationOptions: query.search.paginationOptions
+      },
+      items,
+      totalCount: Number(data.recordSetTotal ?? items.length),
+      pageSize: items.length,
+      pageNumber: 1,
+      totalPages: 1
+    };
+    return this.productListItemPaginatedSchema.parse(result);
+  }
+  // ---------------------------------------------------------------------------
+  // Requisition list parsers
+  // ---------------------------------------------------------------------------
+  parseRequisitionList(_context, data) {
+    const result = {
+      identifier: {
+        key: data.requisitionListId ?? "",
+        listType: "requisition"
+      },
+      type: "requisition",
+      name: data.name ?? "",
+      description: data.description,
+      published: true
+    };
+    return this.productListSchema.parse(result);
+  }
+  parseRequisitionListItem(_context, data) {
+    const result = {
+      identifier: {
+        key: data.item.requisitionListItemId ?? "",
+        list: data.list
+      },
+      variant: { sku: data.item.productId ?? data.item.partNumber ?? "" },
+      quantity: Math.max(1, Number(data.item.quantity ?? 1)),
+      order: 1
+    };
+    return this.productListItemSchema.parse(result);
+  }
+  parseRequisitionListPaginatedResult(context, data, query) {
+    const items = (data.resultList ?? []).map(
+      (r) => this.parseRequisitionList(context, r)
+    );
+    const result = {
+      identifier: {
+        listType: query.search.listType,
+        paginationOptions: query.search.paginationOptions
+      },
+      items,
+      totalCount: Number(data.recordSetTotal ?? items.length),
+      pageSize: Math.max(1, items.length),
+      pageNumber: 1,
+      totalPages: 1
+    };
+    return this.productListPaginatedSchema.parse(result);
+  }
+  parseRequisitionListItemPaginatedResult(context, data, query) {
+    const rawItems = data.resultList?.[0]?.item ?? [];
+    const items = rawItems.map(
+      (i) => this.parseRequisitionListItem(context, {
+        item: i,
+        list: query.search.list
+      })
+    );
+    const result = {
+      identifier: {
+        list: query.search.list,
+        paginationOptions: query.search.paginationOptions
+      },
+      items,
+      totalCount: Number(data.recordSetTotal ?? items.length),
+      pageSize: Math.max(1, items.length),
+      pageNumber: 1,
+      totalPages: 1
+    };
+    return this.productListItemPaginatedSchema.parse(result);
+  }
+}
+export {
+  HclProductListFactory,
+  encodeWishlistType
+};