@reactionary/hcl 0.9.12 → 0.9.14

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

@@ -0,0 +1,18 @@
+class HclStoreFactory {
+  storeSchema;
+  constructor(storeSchema) {
+    this.storeSchema = storeSchema;
+  }
+  parseStore(_context, data) {
+    const name = data.Description?.[0]?.displayStoreName ?? data.storeName ?? data.uniqueID;
+    const result = {
+      identifier: { key: data.uniqueID },
+      name,
+      fulfillmentCenter: { key: data.uniqueID }
+    };
+    return this.storeSchema.parse(result);
+  }
+}
+export {
+  HclStoreFactory
+};

package/index.js

@@ -17,3 +17,10 @@ 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";
+export * from "./capabilities/company.capability.js";
+export * from "./capabilities/store.capability.js";
+export * from "./capabilities/product-list.capability.js";

package/package.json

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

package/schema/capabilities.schema.js

@@ -9,26 +9,40 @@ const HclCapabilitiesSchema = CapabilitiesSchema.pick({
   cart: true,
   checkout: true,
   category: true,
+  company: true,
   product: true,
   price: true,
   inventory: true,
   identity: true,
   productSearch: true,
+  productList: true,
   profile: true,
   order: true,
-  orderSearch: true
+  orderSearch: true,
+  analytics: true,
+  productAssociations: true,
+  productRecommendations: true,
+  personalizationProfile: true,
+  store: true
 }).extend({
   cart: OverridableCapabilitySchema.optional(),
   checkout: OverridableCapabilitySchema.optional(),
   category: OverridableCapabilitySchema.optional(),
+  company: OverridableCapabilitySchema.optional(),
   product: OverridableCapabilitySchema.optional(),
   price: OverridableCapabilitySchema.optional(),
   inventory: OverridableCapabilitySchema.optional(),
   identity: OverridableCapabilitySchema.optional(),
   productSearch: OverridableCapabilitySchema.optional(),
+  productList: OverridableCapabilitySchema.optional(),
   profile: OverridableCapabilitySchema.optional(),
   order: OverridableCapabilitySchema.optional(),
-  orderSearch: OverridableCapabilitySchema.optional()
+  orderSearch: OverridableCapabilitySchema.optional(),
+  analytics: OverridableCapabilitySchema.optional(),
+  productAssociations: OverridableCapabilitySchema.optional(),
+  productRecommendations: OverridableCapabilitySchema.optional(),
+  personalizationProfile: OverridableCapabilitySchema.optional(),
+  store: OverridableCapabilitySchema.optional()
 }).partial();
 export {
   HclCapabilitiesSchema

package/schema/configuration.schema.js

@@ -37,7 +37,43 @@ const HclConfigurationSchema = z.looseObject({
    */
   priceRuleId: z.string().optional().meta({
     description: "Price rule ID for /display_price WCS calls. Optional \u2014 the server uses its default rule when absent."
-  })
+  }),
+  /**
+   * Maps Reactionary association types to the HCL `associationCodeType` values
+   * returned in `merchandisingAssociations` on product detail responses.
+   * Override to match custom HCL store configuration.
+   */
+  associationTypes: z.looseObject({
+    accessories: z.array(z.string()).default(["ACCESSORY"]),
+    spareparts: z.array(z.string()).default(["SPAREPART"]),
+    replacements: z.array(z.string()).default(["REPLACEMENT"])
+  }).default(() => ({
+    accessories: ["ACCESSORY"],
+    spareparts: ["SPAREPART"],
+    replacements: ["REPLACEMENT"]
+  })),
+  /**
+   * Names of HCL marketing spots used for product recommendation algorithms.
+   * Each algorithm calls the corresponding named espot via the WCS Transaction Service.
+   * These espots must be configured in HCL Commerce to return catalog entry data.
+   */
+  espotNames: z.looseObject({
+    frequentlyBoughtTogether: z.string().default("Reactionary_FrequentlyBoughtTogether"),
+    similar: z.string().default("Reactionary_SimilarProducts"),
+    related: z.string().default("Reactionary_RelatedProducts"),
+    trendingInCategory: z.string().default("Reactionary_TrendingInCategory"),
+    popular: z.string().default("Reactionary_Popular"),
+    topPicks: z.string().default("Reactionary_TopPicks"),
+    alsoViewed: z.string().default("Reactionary_AlsoViewed")
+  }).default(() => ({
+    frequentlyBoughtTogether: "Reactionary_FrequentlyBoughtTogether",
+    similar: "Reactionary_SimilarProducts",
+    related: "Reactionary_RelatedProducts",
+    trendingInCategory: "Reactionary_TrendingInCategory",
+    popular: "Reactionary_Popular",
+    topPicks: "Reactionary_TopPicks",
+    alsoViewed: "Reactionary_AlsoViewed"
+  }))
 });
 export {
   HclConfigurationSchema

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

@@ -0,0 +1,17 @@
+import { AnalyticsCapability, type AnalyticsMutation, type AnalyticsMutationProductAddToCartEvent, type AnalyticsMutationProductDetailsViewEvent, type AnalyticsMutationProductSummaryClickEvent, type AnalyticsMutationProductSummaryViewEvent, type AnalyticsMutationPurchaseEvent, type AnalyticsResult, type Cache, type RequestContext } from '@reactionary/core';
+import type { HclConfiguration } from '../schema/configuration.schema.js';
+import type { HclClient } from '../core/client.js';
+export declare class HclAnalyticsCapability extends AnalyticsCapability {
+    protected readonly config: HclConfiguration;
+    protected readonly client: HclClient;
+    constructor(cache: Cache, context: RequestContext, config: HclConfiguration, client: HclClient);
+    track(event: AnalyticsMutation): Promise<AnalyticsResult>;
+    protected processProductSummaryView(event: AnalyticsMutationProductSummaryViewEvent): Promise<AnalyticsResult>;
+    protected processProductSummaryClick(event: AnalyticsMutationProductSummaryClickEvent): Promise<AnalyticsResult>;
+    protected processProductDetailsView(event: AnalyticsMutationProductDetailsViewEvent): Promise<AnalyticsResult>;
+    protected processProductAddToCart(event: AnalyticsMutationProductAddToCartEvent): Promise<AnalyticsResult>;
+    protected processPurchase(event: AnalyticsMutationPurchaseEvent): Promise<AnalyticsResult>;
+    protected fireEvent(extra: Record<string, string>): Promise<void>;
+    protected getEventUrl(): string;
+    protected getEventBody(extra: Record<string, string>): Record<string, string>;
+}

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

@@ -0,0 +1,26 @@
+import { type Address, type Cache, CompanyCapability, type CompanyFactory, type CompanyFactoryOutput, type CompanyFactoryWithOutput, type CompanyMutationAddShippingAddress, type CompanyMutationMakeShippingAddressDefault, type CompanyMutationRemoveShippingAddress, type CompanyMutationUpdateShippingAddress, type CompanyPaginatedList, type CompanyQueryById, type CompanyQueryList, type NotFoundError, type RequestContext, type Result } from '@reactionary/core';
+import type { HclConfiguration } from '../schema/configuration.schema.js';
+import type { HclClient } from '../core/client.js';
+import type { HclCompanyFactory } from '../factories/company/company.factory.js';
+import type { HclOrganizationItem, HclWcsOrgContact } from '../schema/hcl.schema.js';
+export declare class HclCompanyCapability<TFactory extends CompanyFactory = HclCompanyFactory> extends CompanyCapability {
+    protected readonly config: HclConfiguration;
+    protected readonly client: HclClient;
+    protected readonly factory: CompanyFactoryWithOutput<TFactory>;
+    constructor(cache: Cache, context: RequestContext, config: HclConfiguration, client: HclClient, factory: CompanyFactoryWithOutput<TFactory>);
+    getById(payload: CompanyQueryById): Promise<Result<CompanyFactoryOutput<TFactory>>>;
+    listCompanies(payload: CompanyQueryList): Promise<Result<CompanyPaginatedList>>;
+    addShippingAddress(payload: CompanyMutationAddShippingAddress): Promise<Result<CompanyFactoryOutput<TFactory>, NotFoundError>>;
+    updateShippingAddress(payload: CompanyMutationUpdateShippingAddress): Promise<Result<CompanyFactoryOutput<TFactory>, NotFoundError>>;
+    removeShippingAddress(payload: CompanyMutationRemoveShippingAddress): Promise<Result<CompanyFactoryOutput<TFactory>, NotFoundError>>;
+    makeShippingAddressDefault(payload: CompanyMutationMakeShippingAddressDefault): Promise<Result<CompanyFactoryOutput<TFactory>, NotFoundError>>;
+    protected getOrganizationUrl(orgId: string): string;
+    protected getOrganizationDetailsParams(): URLSearchParams;
+    protected getOrganizationListUrl(): string;
+    protected getOrganizationListParams(query: CompanyQueryList): URLSearchParams;
+    protected getUpdateOrganizationUrl(orgId: string): string;
+    protected getUpdateOrganizationBody(org: HclOrganizationItem, addressBook: HclWcsOrgContact[]): Record<string, unknown>;
+    protected fetchOrganization(orgId: string): Promise<HclOrganizationItem | undefined>;
+    protected fetchOrganizationOrThrow(orgId: string): Promise<HclOrganizationItem>;
+    protected toOrgContact(address: Address): HclWcsOrgContact;
+}

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

@@ -0,0 +1,19 @@
+import { PersonalizationProfileCapability, type Cache, type NotFoundError, type PersonalizationProfileFactory, type PersonalizationProfileFactoryOutput, type PersonalizationProfileFactoryWithOutput, type PersonalizationProfileQueryGetProfile, type RequestContext, type Result } from '@reactionary/core';
+import type { HclConfiguration } from '../schema/configuration.schema.js';
+import type { HclClient } from '../core/client.js';
+import type { HclPersonalizationProfileFactory } from '../factories/personalization-profile/personalization-profile.factory.js';
+export declare class HclPersonalizationProfileCapability<TFactory extends PersonalizationProfileFactory = HclPersonalizationProfileFactory> extends PersonalizationProfileCapability<PersonalizationProfileFactoryOutput<TFactory>> {
+    protected readonly config: HclConfiguration;
+    protected readonly client: HclClient;
+    protected readonly factory: PersonalizationProfileFactoryWithOutput<TFactory>;
+    constructor(cache: Cache, context: RequestContext, config: HclConfiguration, client: HclClient, factory: PersonalizationProfileFactoryWithOutput<TFactory>);
+    getPersonalizationProfile(_payload: PersonalizationProfileQueryGetProfile): Promise<Result<PersonalizationProfileFactoryOutput<TFactory>, NotFoundError>>;
+    /**
+     * 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.
+     */
+    protected fetchSegments(personalizationId: string): Promise<string[]>;
+    protected getSegmentsUrl(): string;
+    protected getSegmentsParams(personalizationId: string): URLSearchParams;
+}

package/src/capabilities/product-associations.capability.d.ts

@@ -0,0 +1,22 @@
+import { ProductAssociationsCapability, type Cache, type ProductAssociationsFactory, type ProductAssociationsFactoryOutput, type ProductAssociationsFactoryWithOutput, type ProductAssociationsGetAccessoriesQuery, type ProductAssociationsGetReplacementsQuery, type ProductAssociationsGetSparepartsQuery, type RequestContext, type Result } from '@reactionary/core';
+import type { HclConfiguration } from '../schema/configuration.schema.js';
+import type { HclClient } from '../core/client.js';
+import type { HclAssociation } from '../schema/hcl.schema.js';
+import type { HclProductAssociationsFactory } from '../factories/product-associations/product-associations.factory.js';
+export declare class HclProductAssociationsCapability<TFactory extends ProductAssociationsFactory = HclProductAssociationsFactory> extends ProductAssociationsCapability<ProductAssociationsFactoryOutput<TFactory>> {
+    protected readonly config: HclConfiguration;
+    protected readonly client: HclClient;
+    protected readonly factory: ProductAssociationsFactoryWithOutput<TFactory>;
+    constructor(cache: Cache, context: RequestContext, config: HclConfiguration, client: HclClient, factory: ProductAssociationsFactoryWithOutput<TFactory>);
+    getAccessories(query: ProductAssociationsGetAccessoriesQuery): Promise<Result<ProductAssociationsFactoryOutput<TFactory>[]>>;
+    getSpareparts(query: ProductAssociationsGetSparepartsQuery): Promise<Result<ProductAssociationsFactoryOutput<TFactory>[]>>;
+    getReplacements(query: ProductAssociationsGetReplacementsQuery): Promise<Result<ProductAssociationsFactoryOutput<TFactory>[]>>;
+    /**
+     * Fetches the product detail for the given part number and returns the
+     * `merchandisingAssociations` filtered to the requested association types,
+     * capped at `maxCount`.
+     */
+    protected fetchAssociations(partNumber: string, types: string[], maxCount: number): Promise<HclAssociation[]>;
+    protected getProductsUrl(): string;
+    protected getProductsParams(partNumber: string): URLSearchParams;
+}

package/src/capabilities/product-list.capability.d.ts

@@ -0,0 +1,42 @@
+import { type Cache, ProductListCapability, type ProductListFactory, type ProductListFactoryItemOutput, type ProductListFactoryItemPaginatedOutput, type ProductListFactoryListOutput, type ProductListFactoryListPaginatedOutput, type ProductListFactoryWithOutput, type ProductListItemMutationCreate, type ProductListItemMutationDelete, type ProductListItemMutationUpdate, type ProductListItemsQuery, type ProductListMutationCreate, type ProductListMutationDelete, type ProductListMutationUpdate, type ProductListQuery, type ProductListQueryById, type RequestContext, type Result } from '@reactionary/core';
+import type { HclConfiguration } from '../schema/configuration.schema.js';
+import type { HclClient } from '../core/client.js';
+import type { HclProductListFactory, HclRequisitionListFactoryExtension } from '../factories/product-list/product-list.factory.js';
+export declare class HclProductListCapability<TFactory extends ProductListFactory = HclProductListFactory> extends ProductListCapability<ProductListFactoryListOutput<TFactory>, ProductListFactoryItemOutput<TFactory>, ProductListFactoryListPaginatedOutput<TFactory>, ProductListFactoryItemPaginatedOutput<TFactory>> {
+    protected readonly config: HclConfiguration;
+    protected readonly client: HclClient;
+    protected readonly factory: ProductListFactoryWithOutput<TFactory>;
+    constructor(cache: Cache, context: RequestContext, config: HclConfiguration, client: HclClient, factory: ProductListFactoryWithOutput<TFactory>);
+    /**
+     * Returns the factory cast to include the HCL-specific requisition list parse methods.
+     * Subclasses can override this if they provide a custom factory.
+     */
+    protected get requisitionFactory(): ProductListFactoryWithOutput<TFactory> & HclRequisitionListFactoryExtension;
+    getById(payload: ProductListQueryById): Promise<Result<ProductListFactoryListOutput<TFactory>>>;
+    queryLists(query: ProductListQuery): Promise<Result<ProductListFactoryListPaginatedOutput<TFactory>>>;
+    addList(mutation: ProductListMutationCreate): Promise<Result<ProductListFactoryListOutput<TFactory>>>;
+    updateList(mutation: ProductListMutationUpdate): Promise<Result<ProductListFactoryListOutput<TFactory>>>;
+    deleteList(mutation: ProductListMutationDelete): Promise<Result<void>>;
+    queryListItems(query: ProductListItemsQuery): Promise<Result<ProductListFactoryItemPaginatedOutput<TFactory>>>;
+    addItem(mutation: ProductListItemMutationCreate): Promise<Result<ProductListFactoryItemOutput<TFactory>>>;
+    updateItem(mutation: ProductListItemMutationUpdate): Promise<Result<ProductListFactoryItemOutput<TFactory>>>;
+    deleteItem(mutation: ProductListItemMutationDelete): Promise<Result<void>>;
+    protected getWishlistsUrl(): string;
+    protected getWishlistUrl(listId: string): string;
+    protected getWishlistItemsUrl(listId: string): string;
+    protected getWishlistItemUrl(listId: string, itemId: string): string;
+    protected getWishlistItemsParams(query: ProductListItemsQuery): URLSearchParams;
+    protected getCreateWishlistBody(mutation: ProductListMutationCreate): Record<string, unknown>;
+    protected getUpdateWishlistBody(mutation: ProductListMutationUpdate): Record<string, unknown>;
+    protected getAddItemParams(): URLSearchParams;
+    protected getAddItemBody(mutation: ProductListItemMutationCreate): Record<string, unknown>;
+    protected getRequisitionListsUrl(): string;
+    protected getRequisitionListUrl(listId: string): string;
+    protected getRequisitionListItemsUrl(listId: string): string;
+    protected getRequisitionListItemUrl(listId: string, itemId: string): string;
+    protected getRequisitionListItemsParams(query: ProductListItemsQuery): URLSearchParams;
+    protected getCreateRequisitionListBody(mutation: ProductListMutationCreate): Record<string, unknown>;
+    protected getUpdateRequisitionListBody(mutation: ProductListMutationUpdate): Record<string, unknown>;
+    protected getRequisitionAddItemParams(): URLSearchParams;
+    protected getRequisitionAddItemBody(mutation: ProductListItemMutationCreate): Record<string, unknown>;
+}

package/src/capabilities/product-recommendations.capability.d.ts

@@ -0,0 +1,29 @@
+import { ProductRecommendationsCapability, type Cache, type ProductRecommendation, type ProductRecommendationAlgorithmAlsoViewedProductsQuery, type ProductRecommendationAlgorithmFrequentlyBoughtTogetherQuery, type ProductRecommendationAlgorithmPopuplarProductsQuery, type ProductRecommendationAlgorithmRelatedProductsQuery, type ProductRecommendationAlgorithmSimilarProductsQuery, type ProductRecommendationAlgorithmTopPicksProductsQuery, type ProductRecommendationAlgorithmTrendingInCategoryQuery, type ProductRecommendationsByCollectionQuery, type ProductRecommendationsFactory, type ProductRecommendationsFactoryWithOutput, type RequestContext, type Result } from '@reactionary/core';
+import type { HclConfiguration } from '../schema/configuration.schema.js';
+import type { HclClient } from '../core/client.js';
+import type { HclProductRecommendationsFactory } from '../factories/product-recommendations/product-recommendations.factory.js';
+export declare class HclProductRecommendationsCapability<TFactory extends ProductRecommendationsFactory = HclProductRecommendationsFactory> extends ProductRecommendationsCapability {
+    protected readonly config: HclConfiguration;
+    protected readonly client: HclClient;
+    protected readonly factory: ProductRecommendationsFactoryWithOutput<TFactory>;
+    constructor(cache: Cache, context: RequestContext, config: HclConfiguration, client: HclClient, factory: ProductRecommendationsFactoryWithOutput<TFactory>);
+    getRecommendations(...args: Parameters<ProductRecommendationsCapability['getRecommendations']>): Promise<Result<ProductRecommendation[]>>;
+    getCollection(query: ProductRecommendationsByCollectionQuery): Promise<Result<ProductRecommendation[]>>;
+    protected getFrequentlyBoughtTogetherRecommendations(query: ProductRecommendationAlgorithmFrequentlyBoughtTogetherQuery): Promise<ProductRecommendation[]>;
+    protected getSimilarProductsRecommendations(query: ProductRecommendationAlgorithmSimilarProductsQuery): Promise<ProductRecommendation[]>;
+    protected getRelatedProductsRecommendations(query: ProductRecommendationAlgorithmRelatedProductsQuery): Promise<ProductRecommendation[]>;
+    protected getTrendingInCategoryRecommendations(query: ProductRecommendationAlgorithmTrendingInCategoryQuery): Promise<ProductRecommendation[]>;
+    protected getPopularProductsRecommendations(query: ProductRecommendationAlgorithmPopuplarProductsQuery): Promise<ProductRecommendation[]>;
+    protected getTopPicksProductsRecommendations(query: ProductRecommendationAlgorithmTopPicksProductsQuery): Promise<ProductRecommendation[]>;
+    protected getAlsoViewedProductsRecommendations(query: ProductRecommendationAlgorithmAlsoViewedProductsQuery): Promise<ProductRecommendation[]>;
+    /**
+     * 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.
+     */
+    protected fetchEspot(name: string, algorithm: string, params?: Record<string, string | undefined>): Promise<ProductRecommendation[]>;
+    protected getEspotUrl(name: string): string;
+    protected getEspotParams(params: Record<string, string | undefined>): URLSearchParams;
+}

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

@@ -0,0 +1,13 @@
+import { type Cache, type RequestContext, type Result, StoreCapability, type StoreFactory, type StoreFactoryOutput, type StoreFactoryWithOutput, type StoreQueryByProximity } from '@reactionary/core';
+import type { HclConfiguration } from '../schema/configuration.schema.js';
+import type { HclClient } from '../core/client.js';
+import type { HclStoreFactory } from '../factories/store/store.factory.js';
+export declare class HclStoreCapability<TFactory extends StoreFactory = HclStoreFactory> extends StoreCapability<StoreFactoryOutput<TFactory>> {
+    protected readonly config: HclConfiguration;
+    protected readonly client: HclClient;
+    protected readonly factory: StoreFactoryWithOutput<TFactory>;
+    constructor(cache: Cache, context: RequestContext, config: HclConfiguration, client: HclClient, factory: StoreFactoryWithOutput<TFactory>);
+    queryByProximity(payload: StoreQueryByProximity): Promise<Result<StoreFactoryOutput<TFactory>[]>>;
+    protected getStoreLocatorUrl(payload: StoreQueryByProximity): string;
+    protected getStoreLocatorParams(payload: StoreQueryByProximity): URLSearchParams;
+}

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

@@ -2,16 +2,19 @@ import type { ClientFromCapabilities } from '@reactionary/core';
 import type { HclCapabilities } from '../schema/capabilities.schema.js';
 import type { HclCartCapability } from '../capabilities/cart.capability.js';
 import type { HclCheckoutCapability } from '../capabilities/checkout.capability.js';
+import type { HclCompanyCapability } from '../capabilities/company.capability.js';
 import type { HclProductCapability } from '../capabilities/product.capability.js';
 import type { HclCategoryCapability } from '../capabilities/category.capability.js';
 import type { HclProductSearchCapability } from '../capabilities/product-search.capability.js';
 import type { HclPriceCapability } from '../capabilities/price.capability.js';
 import type { HclInventoryCapability } from '../capabilities/inventory.capability.js';
 import type { HclIdentityCapability } from '../capabilities/identity.capability.js';
+import type { HclProductListCapability } from '../capabilities/product-list.capability.js';
 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';
+import type { HclStoreCapability } from '../capabilities/store.capability.js';
+type OverridableCapabilityKey = 'product' | 'productSearch' | 'cart' | 'checkout' | 'category' | 'company' | 'price' | 'inventory' | 'identity' | 'productList' | 'profile' | 'order' | 'orderSearch' | 'store';
 type EnabledCapability<TCapability> = TCapability extends {
     enabled: true;
 } ? true : false;
@@ -28,12 +31,15 @@ type DefaultCapabilityMap = {
     cart: HclCartCapability;
     checkout: HclCheckoutCapability;
     category: HclCategoryCapability;
+    company: HclCompanyCapability;
     price: HclPriceCapability;
     inventory: HclInventoryCapability;
     identity: HclIdentityCapability;
+    productList: HclProductListCapability;
     profile: HclProfileCapability;
     order: HclOrderCapability;
     orderSearch: HclOrderSearchCapability;
+    store: HclStoreCapability;
 };
 type CapabilityImplementationMap<T extends HclCapabilities> = {
     [K in OverridableCapabilityKey]: ExtractCapabilityImplementation<T[K], DefaultCapabilityMap[K]>;

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

@@ -0,0 +1,11 @@
+import type * as z from 'zod';
+import type { Address, AnyCompanyPaginatedListSchema, AnyCompanySchema, CompanyFactory, CompanyQueryList, CompanySchema, CompanyPaginatedListSchema, RequestContext } from '@reactionary/core';
+import type { HclOrganizationItem, HclOrganizationListResponse, HclWcsOrgContact } from '../../schema/hcl.schema.js';
+export declare class HclCompanyFactory<TCompanySchema extends AnyCompanySchema = typeof CompanySchema, TCompanyPaginatedListSchema extends AnyCompanyPaginatedListSchema = typeof CompanyPaginatedListSchema> implements CompanyFactory<TCompanySchema, TCompanyPaginatedListSchema> {
+    readonly companySchema: TCompanySchema;
+    readonly companyPaginatedListSchema: TCompanyPaginatedListSchema;
+    constructor(companySchema: TCompanySchema, companyPaginatedListSchema: TCompanyPaginatedListSchema);
+    parseCompany(_context: RequestContext, data: HclOrganizationItem): z.output<TCompanySchema>;
+    parseCompanyPaginatedList(context: RequestContext, data: HclOrganizationListResponse, _query: CompanyQueryList): z.output<TCompanyPaginatedListSchema>;
+    protected parseOrgContact(contact: HclWcsOrgContact, defaultNickName: string): Address;
+}

package/src/factories/index.d.ts

@@ -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/src/factories/personalization-profile/personalization-profile.factory.d.ts

@@ -0,0 +1,11 @@
+import type { AnyPersonalizationProfileSchema, PersonalizationProfileFactory, PersonalizationProfileSchema, RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+export interface HclPersonalizationProfileData {
+    personalizationId: string;
+    segments: string[];
+}
+export declare class HclPersonalizationProfileFactory<TPersonalizationProfileSchema extends AnyPersonalizationProfileSchema = typeof PersonalizationProfileSchema> implements PersonalizationProfileFactory<TPersonalizationProfileSchema> {
+    readonly personalizationProfileSchema: TPersonalizationProfileSchema;
+    constructor(personalizationProfileSchema: TPersonalizationProfileSchema);
+    parsePersonalizationProfile(_context: RequestContext, data: HclPersonalizationProfileData): z.output<TPersonalizationProfileSchema>;
+}

package/src/factories/product-associations/product-associations.factory.d.ts

@@ -0,0 +1,8 @@
+import type { AnyProductAssociationSchema, ProductAssociationSchema, ProductAssociationsFactory, RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+import type { HclAssociation } from '../../schema/hcl.schema.js';
+export declare class HclProductAssociationsFactory<TProductAssociationSchema extends AnyProductAssociationSchema = typeof ProductAssociationSchema> implements ProductAssociationsFactory<TProductAssociationSchema> {
+    readonly productAssociationSchema: TProductAssociationSchema;
+    constructor(productAssociationSchema: TProductAssociationSchema);
+    parseAssociation(_context: RequestContext, data: HclAssociation): z.output<TProductAssociationSchema>;
+}

package/src/factories/product-list/product-list.factory.d.ts

@@ -0,0 +1,40 @@
+import type * as z from 'zod';
+import type { AnyProductListItemPaginatedSchema, AnyProductListItemSchema, AnyProductListPaginatedSchema, AnyProductListSchema, ProductListFactory, ProductListIdentifier, ProductListItemPaginatedResultsSchema, ProductListItemSchema, ProductListItemsQuery, ProductListPaginatedResultsSchema, ProductListQuery, ProductListSchema, RequestContext } from '@reactionary/core';
+import type { HclRequisitionList, HclRequisitionListDetailResponse, HclRequisitionListItem, HclRequisitionListResponse, HclWishlist, HclWishlistItem, HclWishlistItemResponse, HclWishlistListResponse } from '../../schema/hcl.schema.js';
+/** Passed to parseProductListItem so it can include the parent list reference. */
+export interface HclProductListItemInput {
+    item: HclWishlistItem;
+    list: ProductListIdentifier;
+}
+/** Passed to parseRequisitionListItem so it can include the parent list reference. */
+export interface HclRequisitionListItemInput {
+    item: HclRequisitionListItem;
+    list: ProductListIdentifier;
+}
+/** Extension interface implemented by HclProductListFactory for requisition list parsing. */
+export interface HclRequisitionListFactoryExtension {
+    parseRequisitionList(context: RequestContext, data: HclRequisitionList): unknown;
+    parseRequisitionListItem(context: RequestContext, data: HclRequisitionListItemInput): unknown;
+    parseRequisitionListPaginatedResult(context: RequestContext, data: HclRequisitionListResponse, query: ProductListQuery): unknown;
+    parseRequisitionListItemPaginatedResult(context: RequestContext, data: HclRequisitionListDetailResponse, query: ProductListItemsQuery): unknown;
+}
+/**
+ * Encode a listType and user description into HCL's description field.
+ * Format: `{type}:{description}` — e.g. `favorite:My list` or `wish:`
+ */
+export declare function encodeWishlistType(type: string, description: string | undefined): string;
+export declare class HclProductListFactory<TProductListSchema extends AnyProductListSchema = typeof ProductListSchema, TProductListItemSchema extends AnyProductListItemSchema = typeof ProductListItemSchema, TProductListPaginatedSchema extends AnyProductListPaginatedSchema = typeof ProductListPaginatedResultsSchema, TProductListItemPaginatedSchema extends AnyProductListItemPaginatedSchema = typeof ProductListItemPaginatedResultsSchema> implements ProductListFactory<TProductListSchema, TProductListItemSchema, TProductListPaginatedSchema, TProductListItemPaginatedSchema> {
+    readonly productListSchema: TProductListSchema;
+    readonly productListItemSchema: TProductListItemSchema;
+    readonly productListPaginatedSchema: TProductListPaginatedSchema;
+    readonly productListItemPaginatedSchema: TProductListItemPaginatedSchema;
+    constructor(productListSchema: TProductListSchema, productListItemSchema: TProductListItemSchema, productListPaginatedSchema: TProductListPaginatedSchema, productListItemPaginatedSchema: TProductListItemPaginatedSchema);
+    parseProductList(_context: RequestContext, data: HclWishlist): z.output<TProductListSchema>;
+    parseProductListItem(_context: RequestContext, data: HclProductListItemInput): z.output<TProductListItemSchema>;
+    parseProductListPaginatedResult(context: RequestContext, data: HclWishlistListResponse, query: ProductListQuery): z.output<TProductListPaginatedSchema>;
+    parseProductListItemPaginatedResult(context: RequestContext, data: HclWishlistItemResponse, query: ProductListItemsQuery): z.output<TProductListItemPaginatedSchema>;
+    parseRequisitionList(_context: RequestContext, data: HclRequisitionList): z.output<TProductListSchema>;
+    parseRequisitionListItem(_context: RequestContext, data: HclRequisitionListItemInput): z.output<TProductListItemSchema>;
+    parseRequisitionListPaginatedResult(context: RequestContext, data: HclRequisitionListResponse, query: ProductListQuery): z.output<TProductListPaginatedSchema>;
+    parseRequisitionListItemPaginatedResult(context: RequestContext, data: HclRequisitionListDetailResponse, query: ProductListItemsQuery): z.output<TProductListItemPaginatedSchema>;
+}

package/src/factories/product-recommendations/product-recommendations.factory.d.ts

@@ -0,0 +1,12 @@
+import type { AnyProductRecommendationSchema, ProductRecommendationSchema, ProductRecommendationsFactory, RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+import type { HclEspotActivityData } from '../../schema/hcl.schema.js';
+export interface HclEspotRecommendationData {
+    activityData: HclEspotActivityData;
+    algorithm: string;
+}
+export declare class HclProductRecommendationsFactory<TProductRecommendationSchema extends AnyProductRecommendationSchema = typeof ProductRecommendationSchema> implements ProductRecommendationsFactory<TProductRecommendationSchema> {
+    readonly productRecommendationSchema: TProductRecommendationSchema;
+    constructor(productRecommendationSchema: TProductRecommendationSchema);
+    parseRecommendation(_context: RequestContext, data: HclEspotRecommendationData): z.output<TProductRecommendationSchema>;
+}

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

@@ -0,0 +1,8 @@
+import type * as z from 'zod';
+import type { AnyStoreSchema, RequestContext, StoreFactory, StoreSchema } from '@reactionary/core';
+import type { HclPhysicalStore } from '../../schema/hcl.schema.js';
+export declare class HclStoreFactory<TStoreSchema extends AnyStoreSchema = typeof StoreSchema> implements StoreFactory<TStoreSchema> {
+    readonly storeSchema: TStoreSchema;
+    constructor(storeSchema: TStoreSchema);
+    parseStore(_context: RequestContext, data: HclPhysicalStore): z.output<TStoreSchema>;
+}

package/src/index.d.ts

@@ -17,3 +17,10 @@ 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';
+export * from './capabilities/company.capability.js';
+export * from './capabilities/store.capability.js';
+export * from './capabilities/product-list.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, OrderFactory, OrderFactoryWithOutput, OrderCapability, OrderSearchFactory, OrderSearchFactoryWithOutput, OrderSearchCapability, PriceFactory, PriceFactoryWithOutput, PriceCapability, ProductFactory, ProductFactoryWithOutput, ProductCapability, ProductSearchFactory, ProductSearchFactoryWithOutput, ProductSearchCapability, ProfileFactory, ProfileFactoryWithOutput, ProfileCapability } from '@reactionary/core';
+import type { Cache, RequestContext, AnalyticsCapability, CartFactory, CartFactoryWithOutput, CartCapability, CategoryFactory, CategoryFactoryWithOutput, CategoryCapability, CheckoutFactory, CheckoutFactoryWithOutput, CheckoutCapability, CompanyCapability, CompanyFactory, CompanyFactoryWithOutput, IdentityFactory, IdentityFactoryWithOutput, IdentityCapability, InventoryFactory, InventoryFactoryWithOutput, InventoryCapability, OrderFactory, OrderFactoryWithOutput, OrderCapability, OrderSearchFactory, OrderSearchFactoryWithOutput, OrderSearchCapability, PersonalizationProfileCapability, PersonalizationProfileFactory, PersonalizationProfileFactoryWithOutput, PriceFactory, PriceFactoryWithOutput, PriceCapability, ProductAssociationsCapability, ProductAssociationsFactory, ProductAssociationsFactoryWithOutput, ProductFactory, ProductFactoryWithOutput, ProductCapability, ProductListCapability, ProductListFactory, ProductListFactoryWithOutput, ProductRecommendationsCapability, ProductRecommendationsFactory, ProductRecommendationsFactoryWithOutput, ProductSearchFactory, ProductSearchFactoryWithOutput, ProductSearchCapability, ProfileFactory, ProfileFactoryWithOutput, ProfileCapability, StoreCapability, StoreFactory, StoreFactoryWithOutput } from '@reactionary/core';
 import type { HclConfiguration } from './configuration.schema.js';
 import type { HclClient } from '../core/client.js';
 import * as z from 'zod';
@@ -18,6 +18,11 @@ export declare const HclCapabilitiesSchema: z.ZodObject<{
         factory: z.ZodOptional<z.ZodUnknown>;
         capability: z.ZodOptional<z.ZodUnknown>;
     }, z.core.$loose>>>;
+    company: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
     product: z.ZodOptional<z.ZodOptional<z.ZodObject<{
         enabled: z.ZodBoolean;
         factory: z.ZodOptional<z.ZodUnknown>;
@@ -43,6 +48,11 @@ export declare const HclCapabilitiesSchema: z.ZodObject<{
         factory: z.ZodOptional<z.ZodUnknown>;
         capability: z.ZodOptional<z.ZodUnknown>;
     }, z.core.$loose>>>;
+    productList: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        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>;
@@ -58,6 +68,31 @@ export declare const HclCapabilitiesSchema: z.ZodObject<{
         factory: z.ZodOptional<z.ZodUnknown>;
         capability: z.ZodOptional<z.ZodUnknown>;
     }, z.core.$loose>>>;
+    analytics: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+    productAssociations: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+    productRecommendations: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+    personalizationProfile: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+    store: 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 {
@@ -85,3 +120,12 @@ export type HclIdentityCapabilityConfig = HclCapabilityConfig<IdentityFactoryWit
 export type HclProfileCapabilityConfig = HclCapabilityConfig<ProfileFactoryWithOutput<ProfileFactory>, ProfileCapability>;
 export type HclOrderCapabilityConfig = HclCapabilityConfig<OrderFactoryWithOutput<OrderFactory>, OrderCapability>;
 export type HclOrderSearchCapabilityConfig = HclCapabilityConfig<OrderSearchFactoryWithOutput<OrderSearchFactory>, OrderSearchCapability>;
+/** Analytics does not use a factory — the capability writes events directly. */
+export type HclAnalyticsCapabilityConfig = HclCapabilityConfig<never, AnalyticsCapability>;
+export type HclProductAssociationsCapabilityConfig = HclCapabilityConfig<ProductAssociationsFactoryWithOutput<ProductAssociationsFactory>, ProductAssociationsCapability>;
+/** Product recommendations uses a factory to parse espot activity data into recommendations. */
+export type HclProductRecommendationsCapabilityConfig = HclCapabilityConfig<ProductRecommendationsFactoryWithOutput<ProductRecommendationsFactory>, ProductRecommendationsCapability>;
+export type HclPersonalizationProfileCapabilityConfig = HclCapabilityConfig<PersonalizationProfileFactoryWithOutput<PersonalizationProfileFactory>, PersonalizationProfileCapability>;
+export type HclCompanyCapabilityConfig = HclCapabilityConfig<CompanyFactoryWithOutput<CompanyFactory>, CompanyCapability>;
+export type HclStoreCapabilityConfig = HclCapabilityConfig<StoreFactoryWithOutput<StoreFactory>, StoreCapability>;
+export type HclProductListCapabilityConfig = HclCapabilityConfig<ProductListFactoryWithOutput<ProductListFactory>, ProductListCapability>;

package/src/schema/configuration.schema.d.ts

@@ -21,5 +21,29 @@ export declare const HclConfigurationSchema: z.ZodObject<{
      * In Karkkainen this is '10003'.
      */
     priceRuleId: z.ZodOptional<z.ZodString>;
+    /**
+     * Maps Reactionary association types to the HCL `associationCodeType` values
+     * returned in `merchandisingAssociations` on product detail responses.
+     * Override to match custom HCL store configuration.
+     */
+    associationTypes: z.ZodDefault<z.ZodObject<{
+        accessories: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        spareparts: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        replacements: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$loose>>;
+    /**
+     * Names of HCL marketing spots used for product recommendation algorithms.
+     * Each algorithm calls the corresponding named espot via the WCS Transaction Service.
+     * These espots must be configured in HCL Commerce to return catalog entry data.
+     */
+    espotNames: z.ZodDefault<z.ZodObject<{
+        frequentlyBoughtTogether: z.ZodDefault<z.ZodString>;
+        similar: z.ZodDefault<z.ZodString>;
+        related: z.ZodDefault<z.ZodString>;
+        trendingInCategory: z.ZodDefault<z.ZodString>;
+        popular: z.ZodDefault<z.ZodString>;
+        topPicks: z.ZodDefault<z.ZodString>;
+        alsoViewed: z.ZodDefault<z.ZodString>;
+    }, z.core.$loose>>;
 }, z.core.$loose>;
 export type HclConfiguration = z.infer<typeof HclConfigurationSchema>;