@reactionary/hcl 0.9.11 → 0.9.13

package/capabilities/analytics.capability.js

@@ -0,0 +1,98 @@
+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 {
+  AnalyticsCapability,
+  AnalyticsMutationSchema,
+  AnalyticsResultSchema,
+  Reactionary
+} from "@reactionary/core";
+import { SESSION_KEY_PERSONALIZATION_ID } from "../core/session-keys.js";
+class HclAnalyticsCapability extends AnalyticsCapability {
+  constructor(cache, context, config, client) {
+    super(cache, context);
+    this.config = config;
+    this.client = client;
+  }
+  async track(event) {
+    return super.track(event);
+  }
+  async processProductSummaryView(event) {
+    try {
+      for (const product of event.products) {
+        await this.fireEvent({ productId: product.key });
+      }
+      return this.accepted();
+    } catch {
+      return this.rejected();
+    }
+  }
+  async processProductSummaryClick(event) {
+    try {
+      await this.fireEvent({ productId: event.product.key });
+      return this.accepted();
+    } catch {
+      return this.rejected();
+    }
+  }
+  async processProductDetailsView(event) {
+    try {
+      await this.fireEvent({ productId: event.product.key });
+      return this.accepted();
+    } catch {
+      return this.rejected();
+    }
+  }
+  async processProductAddToCart(event) {
+    try {
+      await this.fireEvent({ productId: event.product.key });
+      return this.accepted();
+    } catch {
+      return this.rejected();
+    }
+  }
+  async processPurchase(event) {
+    try {
+      for (const item of event.order.items) {
+        await this.fireEvent({ productId: item.variant.sku });
+      }
+      return this.accepted();
+    } catch {
+      return this.rejected();
+    }
+  }
+  async fireEvent(extra) {
+    await this.client.callPost(
+      this.getEventUrl(),
+      this.getEventBody(extra)
+    );
+  }
+  getEventUrl() {
+    return `${this.client.transactionBaseUrl}/event`;
+  }
+  getEventBody(extra) {
+    const personalizationID = this.context.session[SESSION_KEY_PERSONALIZATION_ID];
+    const body = { ...extra };
+    if (personalizationID) {
+      body["personalizationID"] = personalizationID;
+    }
+    return body;
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: AnalyticsMutationSchema,
+    outputSchema: AnalyticsResultSchema
+  })
+], HclAnalyticsCapability.prototype, "track", 1);
+export {
+  HclAnalyticsCapability
+};

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/personalization-profile.capability.js

@@ -0,0 +1,85 @@
+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 {
+  PersonalizationProfileCapability,
+  PersonalizationProfileQueryGetProfileSchema,
+  PersonalizationProfileSchema,
+  Reactionary,
+  success
+} from "@reactionary/core";
+import { SESSION_KEY_PERSONALIZATION_ID } from "../core/session-keys.js";
+class HclPersonalizationProfileCapability extends PersonalizationProfileCapability {
+  constructor(cache, context, config, client, factory) {
+    super(cache, context);
+    this.config = config;
+    this.client = client;
+    this.factory = factory;
+  }
+  async getPersonalizationProfile(_payload) {
+    const personalizationId = this.context.session[SESSION_KEY_PERSONALIZATION_ID];
+    if (!personalizationId) {
+      return success(
+        this.factory.parsePersonalizationProfile(this.context, {
+          personalizationId: "anonymous",
+          segments: []
+        })
+      );
+    }
+    const segments = await this.fetchSegments(personalizationId);
+    return success(
+      this.factory.parsePersonalizationProfile(this.context, {
+        personalizationId,
+        segments
+      })
+    );
+  }
+  /**
+   * Calls the WCS segment API to retrieve the customer segments for the given
+   * personalization ID. Returns an empty array when the API call fails or
+   * returns no segment data.
+   */
+  async fetchSegments(personalizationId) {
+    try {
+      const response = await this.client.callGet(
+        this.getSegmentsUrl(),
+        this.getSegmentsParams(personalizationId),
+        { allowUndefined: true }
+      );
+      if (!response?.MemberGroup) {
+        return [];
+      }
+      return response.MemberGroup.map((g) => g.displayName?.value).filter(
+        (name) => name !== void 0 && name.length > 0
+      );
+    } catch {
+      return [];
+    }
+  }
+  getSegmentsUrl() {
+    return `${this.client.transactionBaseUrl}/segment`;
+  }
+  getSegmentsParams(personalizationId) {
+    const params = new URLSearchParams();
+    params.set("q", "byPersonalizationId");
+    params.set("qPersonalizationId", personalizationId);
+    return params;
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: PersonalizationProfileQueryGetProfileSchema,
+    outputSchema: PersonalizationProfileSchema
+  })
+], HclPersonalizationProfileCapability.prototype, "getPersonalizationProfile", 1);
+export {
+  HclPersonalizationProfileCapability
+};

package/capabilities/product-associations.capability.js

@@ -0,0 +1,117 @@
+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 {
+  ProductAssociationsCapability,
+  ProductAssociationSchema,
+  ProductAssociationsGetAccessoriesQuerySchema,
+  ProductAssociationsGetSparepartsQuerySchema,
+  ProductAssociationsGetReplacementsQuerySchema,
+  Reactionary,
+  success
+} from "@reactionary/core";
+import * as z from "zod";
+class HclProductAssociationsCapability extends ProductAssociationsCapability {
+  constructor(cache, context, config, client, factory) {
+    super(cache, context);
+    this.config = config;
+    this.client = client;
+    this.factory = factory;
+  }
+  async getAccessories(query) {
+    const associations = await this.fetchAssociations(
+      query.forProduct.key,
+      this.config.associationTypes.accessories,
+      query.numberOfAccessories
+    );
+    return success(
+      associations.map((a) => this.factory.parseAssociation(this.context, a))
+    );
+  }
+  async getSpareparts(query) {
+    const associations = await this.fetchAssociations(
+      query.forProduct.key,
+      this.config.associationTypes.spareparts,
+      query.numberOfSpareparts
+    );
+    return success(
+      associations.map((a) => this.factory.parseAssociation(this.context, a))
+    );
+  }
+  async getReplacements(query) {
+    const associations = await this.fetchAssociations(
+      query.forProduct.key,
+      this.config.associationTypes.replacements,
+      query.numberOfReplacements
+    );
+    return success(
+      associations.map((a) => this.factory.parseAssociation(this.context, a))
+    );
+  }
+  /**
+   * Fetches the product detail for the given part number and returns the
+   * `merchandisingAssociations` filtered to the requested association types,
+   * capped at `maxCount`.
+   */
+  async fetchAssociations(partNumber, types, maxCount) {
+    const response = await this.client.callGet(
+      this.getProductsUrl(),
+      this.getProductsParams(partNumber)
+    );
+    const product = (response.contents ?? response.catalogEntryView ?? [])[0];
+    if (!product?.merchandisingAssociations) {
+      return [];
+    }
+    return product.merchandisingAssociations.filter(
+      (a) => a.associationCodeType && types.includes(a.associationCodeType)
+    ).slice(0, maxCount);
+  }
+  getProductsUrl() {
+    return `${this.client.catalogBaseUrl}/api/v2/products`;
+  }
+  getProductsParams(partNumber) {
+    const params = new URLSearchParams();
+    params.set("storeId", this.config.storeId);
+    params.append("partNumber", partNumber);
+    params.set("profileName", this.config.profiles.product);
+    return params;
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: ProductAssociationsGetAccessoriesQuerySchema,
+    outputSchema: z.array(ProductAssociationSchema),
+    cache: true,
+    cacheTimeToLiveInSeconds: 300,
+    currencyDependentCaching: false
+  })
+], HclProductAssociationsCapability.prototype, "getAccessories", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: ProductAssociationsGetSparepartsQuerySchema,
+    outputSchema: z.array(ProductAssociationSchema),
+    cache: true,
+    cacheTimeToLiveInSeconds: 300,
+    currencyDependentCaching: false
+  })
+], HclProductAssociationsCapability.prototype, "getSpareparts", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: ProductAssociationsGetReplacementsQuerySchema,
+    outputSchema: z.array(ProductAssociationSchema),
+    cache: true,
+    cacheTimeToLiveInSeconds: 300,
+    currencyDependentCaching: false
+  })
+], HclProductAssociationsCapability.prototype, "getReplacements", 1);
+export {
+  HclProductAssociationsCapability
+};

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
+};