@reactionary/unomi 0.11.1 → 0.12.0

package/capabilities/analytics.capability.js

@@ -1,154 +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 {
-  AnalyticsCapability,
-  AnalyticsMutationSchema,
-  AnalyticsResultSchema
+  AnalyticsProvider,
+  productKey,
+  searchOriginOf
 } from "@reactionary/core";
-import { Reactionary } from "@reactionary/core";
+import { hash } from "node:crypto";
 import { UnomiAPI } from "../core/client.js";
-class UnomiAnalyticsCapability extends AnalyticsCapability {
+class UnomiAnalyticsCapability extends AnalyticsProvider {
   constructor(cache, context, config) {
     super(cache, context);
     this.config = config;
     this.api = new UnomiAPI(config, context);
   }
   config;
+  types = [
+    "search-results-viewed",
+    "product-carousel-viewed",
+    "product-viewed",
+    "product-clicked",
+    "cart-item-added",
+    "order-placed",
+    "user-logged-in"
+  ];
+  /** A CDP builds visitor profiles for personalization. */
+  purpose = "marketing";
   api;
-  async track(event) {
-    return super.track(event);
+  getResourceName() {
+    return "unomi-analytics";
   }
-  async processProductSummaryView(event) {
-    const events = event.products.map((product) => ({
-      eventType: "product_view",
-      scope: this.config.scope,
-      target: {
-        itemId: product.key,
-        itemType: "product"
-      }
-    }));
-    try {
-      await this.postEvents(events);
-      return this.accepted();
-    } catch {
-      return this.rejected();
+  async handle(event, ctx) {
+    const events = await this.toUnomiEvents(event, ctx);
+    if (events.length === 0) {
+      return "ignored";
     }
-  }
-  async processProductSummaryClick(event) {
-    const events = [
-      {
-        eventType: "selectItem",
-        scope: this.config.scope,
-        targetProperties: {
-          productId: event.product.key,
-          sku: event.product.key,
-          index: event.position
-        }
-      }
-    ];
-    try {
-      await this.postEvents(events);
-      return this.accepted();
-    } catch {
-      return this.rejected();
+    const profileId = event.type === "user-logged-in" ? event.payload.previousMarketingId?.key || event.context.marketingIdentifier.key : event.context.marketingIdentifier.key;
+    if (!profileId) {
+      return "ignored";
     }
+    await this.postEvents(profileId, events);
+    return "accepted";
   }
-  async processProductDetailsView(event) {
-    const events = [
-      {
-        eventType: "product_view",
-        scope: this.config.scope,
-        target: {
-          itemId: event.product.key,
-          itemType: "product"
+  async toUnomiEvents(event, ctx) {
+    const scope = this.config.scope;
+    switch (event.type) {
+      case "search-results-viewed":
+      case "product-carousel-viewed":
+        return event.payload.products.map((product) => ({
+          eventType: "product_view",
+          scope,
+          target: { itemId: productKey(product), itemType: "product" }
+        }));
+      case "product-viewed":
+        return [{ eventType: "product_view", scope, target: { itemId: productKey(event.payload.product), itemType: "product" } }];
+      case "product-clicked": {
+        const search = searchOriginOf(event.origin);
+        return [
+          {
+            eventType: "selectItem",
+            scope,
+            target: { itemId: productKey(event.payload.product), itemType: "product" },
+            properties: search ? { index: search.position, searchTerm: search.identifier.term } : void 0
+          }
+        ];
+      }
+      case "cart-item-added": {
+        const line = event.payload.cart.items.find((item) => item.variant.sku === event.payload.variant.sku);
+        if (!line) {
+          return [];
         }
+        const product = await ctx.products.byId(line.product);
+        return [
+          {
+            eventType: "addToCart",
+            scope,
+            target: {
+              itemId: line.product.key,
+              itemType: "product",
+              customItemType: "product",
+              properties: {
+                sku: line.variant.sku,
+                price: line.price.unitPrice.value,
+                currency: line.price.unitPrice.currency,
+                quantity: event.payload.quantity,
+                ...product.success ? { productName: product.value.name } : {}
+              }
+            }
+          }
+        ];
       }
-    ];
-    try {
-      await this.postEvents(events);
-      return this.accepted();
-    } catch {
-      return this.rejected();
-    }
-  }
-  async processProductAddToCart(event) {
-    const events = [
-      {
-        eventType: "addToCart",
-        scope: this.config.scope,
-        target: {
-          itemId: event.product.key,
-          itemType: "product",
-          customItemType: "product",
-          properties: {
-            price: 1,
-            currency: this.context.languageContext.currencyCode ?? "USD",
-            productName: "-"
+      case "order-placed": {
+        const order = event.payload.order;
+        return [
+          {
+            eventType: "purchaseComplete",
+            scope,
+            target: { itemId: order.identifier.key, itemType: "order" },
+            properties: {
+              orderId: order.identifier.key,
+              totalAmount: order.price.grandTotal.value,
+              currency: order.price.grandTotal.currency,
+              itemCount: order.items.length,
+              items: order.items.map((item) => ({
+                sku: item.variant.sku,
+                quantity: item.quantity,
+                price: item.price.unitPrice.value
+              }))
+            }
           }
-        }
+        ];
       }
-    ];
-    try {
-      await this.postEvents(events);
-      return this.accepted();
-    } catch (e) {
-      console.error("Error posting addToCart event to Unomi:", e);
-      return this.rejected();
-    }
-  }
-  async processPurchase(event) {
-    const events = [
-      {
-        eventType: "purchaseComplete",
-        scope: this.config.scope,
-        targetProperties: {
-          totalAmount: event.order.price.grandTotal.value,
-          currency: event.order.price.grandTotal.currency,
-          itemCount: event.order.items.length
-        }
+      case "user-logged-in": {
+        const identity = event.payload.identity;
+        return [
+          {
+            eventType: "login",
+            scope,
+            // An opaque hash: the CDP should not receive the backend user id itself.
+            properties: identity.type === "Anonymous" ? void 0 : { userId: hash("sha256", identity.id.userId) }
+          }
+        ];
       }
-    ];
-    try {
-      await this.postEvents(events);
-      return this.accepted();
-    } catch {
-      return this.rejected();
+      default:
+        return [];
     }
   }
-  async postEvents(events) {
-    const profileId = this.context.session.marketingContext.identifier.key;
-    const source = {
-      itemType: "page",
-      scope: this.config.scope,
-      itemId: "backend"
-    };
-    const payload = {
-      source,
+  async postEvents(profileId, events) {
+    const response = await this.api.postEvent({
+      source: {
+        itemType: "page",
+        scope: this.config.scope,
+        itemId: "backend"
+      },
       profileId,
       events
-    };
-    const s = JSON.stringify(payload, null, 2);
-    console.dir(payload, { depth: null });
-    const response = await this.api.postEvent(payload);
+    });
     if (!response.ok) {
       throw new Error(`Unomi event request failed with status ${response.status}`);
     }
   }
 }
-__decorateClass([
-  Reactionary({
-    inputSchema: AnalyticsMutationSchema,
-    outputSchema: AnalyticsResultSchema
-  })
-], UnomiAnalyticsCapability.prototype, "track", 1);
 export {
   UnomiAnalyticsCapability
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reactionary/unomi",
-  "version": "0.11.1",
+  "version": "0.12.0",
   "type": "module",
   "main": "./index.js",
   "types": "./src/index.d.ts",
@@ -9,7 +9,7 @@
     "url": "git+https://github.com/Solteq/reactionary.git"
   },
   "dependencies": {
-    "@reactionary/core": "0.11.1",
+    "@reactionary/core": "0.12.0",
     "zod": "4.1.9"
   },
   "devDependencies": {

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

@@ -1,15 +1,28 @@
-import { AnalyticsCapability, type AnalyticsMutation, type AnalyticsMutationProductAddToCartEvent, type AnalyticsMutationProductDetailsViewEvent, type AnalyticsMutationProductSummaryClickEvent, type AnalyticsMutationProductSummaryViewEvent, type AnalyticsMutationPurchaseEvent, type AnalyticsResult, type Cache, type RequestContext } from '@reactionary/core';
+import { AnalyticsProvider, type AnalyticsContext, type AnalyticsEvent, type AnalyticsEventType, type AnalyticsOutcome, type AnalyticsPurpose, type Cache, type RequestContext } from '@reactionary/core';
 import { UnomiAPI } from '../core/client.js';
 import type { UnomiConfiguration } from '../schema/configuration.schema.js';
-export declare class UnomiAnalyticsCapability extends AnalyticsCapability {
+interface UnomiEvent {
+    eventType: string;
+    scope: string;
+    target?: Record<string, unknown>;
+    properties?: Record<string, unknown>;
+}
+/**
+ * Sends behavioural events to Apache Unomi's context endpoint, attributed to the visitor's marketing profile.
+ *
+ * Events are attributed to the marketing identifier captured when the event was emitted. Without one there is no profile to
+ * attribute to (Unomi would create a throwaway profile per request), so the event is ignored.
+ */
+export declare class UnomiAnalyticsCapability extends AnalyticsProvider {
     protected readonly config: UnomiConfiguration;
+    readonly types: ReadonlyArray<AnalyticsEventType | `${string}*`>;
+    /** A CDP builds visitor profiles for personalization. */
+    readonly purpose: AnalyticsPurpose;
     protected readonly api: UnomiAPI;
     constructor(cache: Cache, context: RequestContext, config: UnomiConfiguration);
-    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 postEvents(events: Array<unknown>): Promise<void>;
+    protected getResourceName(): string;
+    handle(event: AnalyticsEvent, ctx: AnalyticsContext): Promise<AnalyticsOutcome | void>;
+    protected toUnomiEvents(event: AnalyticsEvent, ctx: AnalyticsContext): Promise<UnomiEvent[]>;
+    protected postEvents(profileId: string, events: UnomiEvent[]): Promise<void>;
 }
+export {};

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

@@ -1,4 +1,4 @@
-import type { AnalyticsCapability, ClientFromCapabilities, PersonalizationProfileFactory } from '@reactionary/core';
+import type { AnalyticsProvider, ClientFromCapabilities, PersonalizationProfileFactory } from '@reactionary/core';
 import type { UnomiPersonalizationProfileCapability } from '../capabilities/personalization-profile.capability.js';
 import type { UnomiPersonalizationProfileFactory } from '../factories/personalization-profile/personalization-profile.factory.js';
 import type { UnomiCapabilities } from '../schema/capabilities.schema.js';
@@ -21,7 +21,7 @@ type ResolvedFactoryMap<T extends UnomiCapabilities> = {
     personalizationProfile: ExtractCapabilityFactory<T['personalizationProfile']>;
 };
 type DefaultCapabilityMap<T extends UnomiCapabilities> = {
-    analytics: AnalyticsCapability;
+    analytics: AnalyticsProvider;
     personalizationProfile: UnomiPersonalizationProfileCapability<ResolvedFactoryMap<T>['personalizationProfile']>;
 };
 type CapabilityImplementationMap<T extends UnomiCapabilities> = {

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

@@ -1,4 +1,4 @@
-import type { AnalyticsCapability, PersonalizationProfileCapability } from '@reactionary/core';
+import type { AnalyticsProvider, PersonalizationProfileCapability } from '@reactionary/core';
 import * as z from 'zod';
 import type { UnomiConfiguration } from './configuration.schema.js';
 import type { UnomiPersonalizationProfileFactory } from '../factories/personalization-profile/personalization-profile.factory.js';
@@ -27,5 +27,5 @@ export interface UnomiPersonalizationProfileCapabilityConfig {
 }
 export interface UnomiAnalyticsCapabilityConfig {
     enabled: boolean;
-    capability?: (args: UnomiCapabilityFactoryArgs) => AnalyticsCapability;
+    capability?: (args: UnomiCapabilityFactoryArgs) => AnalyticsProvider;
 }