@reactionary/unomi 0.10.11

package/capabilities/analytics.capability.js

@@ -0,0 +1,154 @@
+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
+} from "@reactionary/core";
+import { Reactionary } from "@reactionary/core";
+import { UnomiAPI } from "../core/client.js";
+class UnomiAnalyticsCapability extends AnalyticsCapability {
+  constructor(cache, context, config) {
+    super(cache, context);
+    this.config = config;
+    this.api = new UnomiAPI(config, context);
+  }
+  config;
+  api;
+  async track(event) {
+    return super.track(event);
+  }
+  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 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();
+    }
+  }
+  async processProductDetailsView(event) {
+    const events = [
+      {
+        eventType: "product_view",
+        scope: this.config.scope,
+        target: {
+          itemId: event.product.key,
+          itemType: "product"
+        }
+      }
+    ];
+    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: "-"
+          }
+        }
+      }
+    ];
+    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
+        }
+      }
+    ];
+    try {
+      await this.postEvents(events);
+      return this.accepted();
+    } catch {
+      return this.rejected();
+    }
+  }
+  async postEvents(events) {
+    const profileId = this.context.session.marketingContext.identifier.key;
+    const source = {
+      itemType: "page",
+      scope: this.config.scope,
+      itemId: "backend"
+    };
+    const payload = {
+      source,
+      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/capabilities/personalization-profile.capability.js

@@ -0,0 +1,70 @@
+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,
+  error,
+  success
+} from "@reactionary/core";
+import {
+} from "../factories/personalization-profile/personalization-profile.factory.js";
+import { UnomiAPI } from "../core/client.js";
+import { SESSION_KEY_PERSONALIZATION_ID, SESSION_KEY_UNOMI_SESSION_ID } from "../core/session-keys.js";
+class UnomiPersonalizationProfileCapability extends PersonalizationProfileCapability {
+  constructor(config, cache, context, factory) {
+    super(cache, context);
+    this.config = config;
+    this.factory = factory;
+    this.api = new UnomiAPI(config, context);
+  }
+  config;
+  factory;
+  api;
+  async getPersonalizationProfile(payload) {
+    const newId = globalThis.crypto.randomUUID();
+    const profileId = payload.personalizationProfileIdentifier?.key ?? newId;
+    const response = await this.api.getProfile(profileId);
+    if (response.status === 404) {
+      return error({ type: "NotFound", identifier: { key: profileId } });
+    }
+    if (!response.ok) {
+      throw new Error(`Unomi profile request failed with status ${response.status}`);
+    }
+    if (response.status === 204) {
+      return success(this.factory.parsePersonalizationProfile(this.context, {
+        profileId
+      }));
+    }
+    const profile = await response.json();
+    return success(this.factory.parsePersonalizationProfile(this.context, {
+      ...profile,
+      profileId
+    }));
+  }
+  async hash(value) {
+    const digest = await globalThis.crypto.subtle.digest(
+      "SHA-256",
+      new TextEncoder().encode(value)
+    );
+    return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: PersonalizationProfileQueryGetProfileSchema,
+    outputSchema: PersonalizationProfileSchema
+  })
+], UnomiPersonalizationProfileCapability.prototype, "getPersonalizationProfile", 1);
+export {
+  UnomiPersonalizationProfileCapability
+};

package/core/client.js

@@ -0,0 +1,43 @@
+class UnomiAPI {
+  constructor(config, _context) {
+    this.config = config;
+    this._context = _context;
+  }
+  config;
+  _context;
+  async getProfile(profileId) {
+    return fetch(this.getProfileUrl(profileId), {
+      headers: this.getHeaders()
+    });
+  }
+  async postEvent(body) {
+    return fetch(this.getEventsUrl(), {
+      method: "POST",
+      headers: {
+        ...this.getHeaders(),
+        "content-type": "application/json"
+      },
+      body: JSON.stringify(body)
+    });
+  }
+  getProfileUrl(profileId) {
+    const baseUrl = this.config.apiUrl.replace(/\/$/, "");
+    const profilePath = this.config.profilePath.replace(/^\/|\/$/g, "");
+    return `${baseUrl}/${profilePath}/${encodeURIComponent(profileId)}`;
+  }
+  getEventsUrl() {
+    return `${this.config.apiUrl.replace(/\/$/, "")}/cxs/context.json`;
+  }
+  getHeaders() {
+    const headers = { accept: "application/json" };
+    if (this.config.apiKey) {
+      headers["authorization"] = `Bearer ${this.config.apiKey}`;
+    } else if (this.config.username && this.config.password) {
+      headers["authorization"] = `Basic ${btoa(`${this.config.username}:${this.config.password}`)}`;
+    }
+    return headers;
+  }
+}
+export {
+  UnomiAPI
+};

package/core/initialize.js

@@ -0,0 +1,42 @@
+import {
+  PersonalizationProfileSchema
+} from "@reactionary/core";
+import { UnomiPersonalizationProfileCapability } from "../capabilities/personalization-profile.capability.js";
+import { UnomiAnalyticsCapability } from "../capabilities/analytics.capability.js";
+import { UnomiPersonalizationProfileFactory } from "../factories/personalization-profile/personalization-profile.factory.js";
+import {
+  UnomiCapabilitiesSchema
+} from "../schema/capabilities.schema.js";
+import { UnomiConfigurationSchema } from "../schema/configuration.schema.js";
+import { resolveCapabilityWithFactory } from "./initialize.types.js";
+function withUnomiCapabilities(configuration, capabilities) {
+  return (cache, context) => {
+    const config = UnomiConfigurationSchema.parse(configuration);
+    const caps = UnomiCapabilitiesSchema.parse(capabilities);
+    const client = {};
+    const personalizationProfile = capabilities.personalizationProfile;
+    const analytics = capabilities.analytics;
+    if (caps.analytics?.enabled) {
+      client.analytics = analytics?.capability?.({ config }) ?? new UnomiAnalyticsCapability(cache, context, config);
+    }
+    if (caps.personalizationProfile?.enabled) {
+      client.personalizationProfile = resolveCapabilityWithFactory(
+        personalizationProfile,
+        {
+          factory: new UnomiPersonalizationProfileFactory(PersonalizationProfileSchema),
+          capability: (args) => new UnomiPersonalizationProfileCapability(
+            config,
+            cache,
+            context,
+            args.factory
+          )
+        },
+        (factory) => ({ config, factory })
+      );
+    }
+    return client;
+  };
+}
+export {
+  withUnomiCapabilities
+};

package/core/initialize.types.js

@@ -0,0 +1,7 @@
+function resolveCapabilityWithFactory(capability, defaults, buildArgs) {
+  const factory = capability?.factory ?? defaults.factory;
+  return (capability?.capability ?? defaults.capability)(buildArgs(factory));
+}
+export {
+  resolveCapabilityWithFactory
+};

package/core/session-keys.js

@@ -0,0 +1,6 @@
+const SESSION_KEY_PERSONALIZATION_ID = "unomi.personalizationId";
+const SESSION_KEY_UNOMI_SESSION_ID = "unomi.sessionId";
+export {
+  SESSION_KEY_PERSONALIZATION_ID,
+  SESSION_KEY_UNOMI_SESSION_ID
+};

package/factories/index.js

@@ -0,0 +1 @@
+export * from "./personalization-profile/personalization-profile.factory.js";

package/factories/personalization-profile/personalization-profile.factory.js

@@ -0,0 +1,18 @@
+class UnomiPersonalizationProfileFactory {
+  personalizationProfileSchema;
+  constructor(personalizationProfileSchema) {
+    this.personalizationProfileSchema = personalizationProfileSchema;
+  }
+  parsePersonalizationProfile(_context, data) {
+    const segments = (data.segments ?? []).map((segment) => typeof segment === "string" ? segment : segment.name ?? segment.id).filter((segment) => Boolean(segment));
+    const blurb = typeof data.properties?.["description"] === "string" ? data.properties["description"] : "";
+    return this.personalizationProfileSchema.parse({
+      identifier: { key: data.profileId },
+      segments,
+      blurb
+    });
+  }
+}
+export {
+  UnomiPersonalizationProfileFactory
+};

package/index.js

@@ -0,0 +1,8 @@
+export * from "./schema/configuration.schema.js";
+export * from "./schema/capabilities.schema.js";
+export * from "./core/client.js";
+export * from "./core/initialize.js";
+export * from "./core/initialize.types.js";
+export * from "./factories/index.js";
+export * from "./capabilities/personalization-profile.capability.js";
+export * from "./capabilities/analytics.capability.js";

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@reactionary/unomi",
+  "version": "0.10.11",
+  "type": "module",
+  "main": "./index.js",
+  "types": "./src/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Solteq/reactionary.git"
+  },
+  "dependencies": {
+    "@reactionary/core": "0.10.11",
+    "zod": "4.1.9"
+  },
+  "private": false,
+  "license": "MIT",
+  "devDependencies": {
+    "vitest": "^4.0.9"
+  },
+  "sideEffects": false
+}

package/schema/capabilities.schema.js

@@ -0,0 +1,20 @@
+import { CapabilitiesSchema } from "@reactionary/core";
+import * as z from "zod";
+const OverridableCapabilitySchema = z.looseObject({
+  enabled: z.boolean(),
+  factory: z.unknown().optional(),
+  capability: z.unknown().optional()
+});
+const UnomiCapabilitiesSchema = CapabilitiesSchema.pick({
+  analytics: true,
+  personalizationProfile: true
+}).extend({
+  analytics: z.looseObject({
+    enabled: z.boolean(),
+    capability: z.unknown().optional()
+  }).optional(),
+  personalizationProfile: OverridableCapabilitySchema.optional()
+}).partial();
+export {
+  UnomiCapabilitiesSchema
+};

package/schema/configuration.schema.js

@@ -0,0 +1,12 @@
+import * as z from "zod";
+const UnomiConfigurationSchema = z.looseObject({
+  apiUrl: z.string().url(),
+  username: z.string().optional(),
+  password: z.string().optional(),
+  apiKey: z.string().optional(),
+  profilePath: z.string().default("/cxs/profiles"),
+  scope: z.string().default("default")
+});
+export {
+  UnomiConfigurationSchema
+};

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

@@ -0,0 +1,15 @@
+import { AnalyticsCapability, type AnalyticsMutation, type AnalyticsMutationProductAddToCartEvent, type AnalyticsMutationProductDetailsViewEvent, type AnalyticsMutationProductSummaryClickEvent, type AnalyticsMutationProductSummaryViewEvent, type AnalyticsMutationPurchaseEvent, type AnalyticsResult, 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 {
+    protected readonly config: UnomiConfiguration;
+    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>;
+}

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

@@ -0,0 +1,12 @@
+import { PersonalizationProfileCapability, type Cache, type NotFoundError, type PersonalizationProfileFactory, type PersonalizationProfileFactoryOutput, type PersonalizationProfileFactoryWithOutput, type PersonalizationProfileQueryGetProfile, type RequestContext, type Result } from '@reactionary/core';
+import { type UnomiPersonalizationProfileFactory } from '../factories/personalization-profile/personalization-profile.factory.js';
+import type { UnomiConfiguration } from '../schema/configuration.schema.js';
+import { UnomiAPI } from '../core/client.js';
+export declare class UnomiPersonalizationProfileCapability<TFactory extends PersonalizationProfileFactory = UnomiPersonalizationProfileFactory> extends PersonalizationProfileCapability<PersonalizationProfileFactoryOutput<TFactory>> {
+    protected readonly config: UnomiConfiguration;
+    protected readonly factory: PersonalizationProfileFactoryWithOutput<TFactory>;
+    protected readonly api: UnomiAPI;
+    constructor(config: UnomiConfiguration, cache: Cache, context: RequestContext, factory: PersonalizationProfileFactoryWithOutput<TFactory>);
+    getPersonalizationProfile(payload: PersonalizationProfileQueryGetProfile): Promise<Result<PersonalizationProfileFactoryOutput<TFactory>, NotFoundError>>;
+    protected hash(value: string): Promise<string>;
+}

package/src/core/client.d.ts

@@ -0,0 +1,12 @@
+import type { RequestContext } from '@reactionary/core';
+import type { UnomiConfiguration } from '../schema/configuration.schema.js';
+export declare class UnomiAPI {
+    protected readonly config: UnomiConfiguration;
+    protected readonly _context: RequestContext;
+    constructor(config: UnomiConfiguration, _context: RequestContext);
+    getProfile(profileId: string): Promise<Response>;
+    postEvent(body: Record<string, unknown>): Promise<Response>;
+    protected getProfileUrl(profileId: string): string;
+    protected getEventsUrl(): string;
+    protected getHeaders(): Record<string, string>;
+}

package/src/core/initialize.d.ts

@@ -0,0 +1,5 @@
+import { type Cache, type RequestContext } from '@reactionary/core';
+import { type UnomiCapabilities } from '../schema/capabilities.schema.js';
+import { type UnomiConfiguration } from '../schema/configuration.schema.js';
+import { type UnomiClientFromCapabilities } from './initialize.types.js';
+export declare function withUnomiCapabilities<T extends UnomiCapabilities>(configuration: UnomiConfiguration, capabilities: T): (cache: Cache, context: RequestContext) => UnomiClientFromCapabilities<T>;

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

@@ -0,0 +1,31 @@
+import type { PersonalizationProfileFactory } from '@reactionary/core';
+import type { AnalyticsCapability } from '@reactionary/core';
+import type { UnomiCapabilities } from '../schema/capabilities.schema.js';
+import type { UnomiPersonalizationProfileFactory } from '../factories/personalization-profile/personalization-profile.factory.js';
+import type { UnomiPersonalizationProfileCapability } from '../capabilities/personalization-profile.capability.js';
+type ExtractFactory<TCapability> = TCapability extends {
+    enabled: true;
+    factory?: infer TFactory;
+} ? TFactory extends PersonalizationProfileFactory ? TFactory : UnomiPersonalizationProfileFactory : UnomiPersonalizationProfileFactory;
+type ExtractCapability<TCapability> = TCapability extends {
+    enabled: true;
+    capability?: infer TCapabilityFactory;
+} ? TCapabilityFactory extends (...args: never[]) => infer TResolvedCapability ? TResolvedCapability : UnomiPersonalizationProfileCapability : UnomiPersonalizationProfileCapability;
+export type UnomiClientFromCapabilities<T extends UnomiCapabilities> = (T['analytics'] extends {
+    enabled: true;
+} ? {
+    analytics: AnalyticsCapability;
+} : Record<string, never>) & (T['personalizationProfile'] extends {
+    enabled: true;
+} ? {
+    personalizationProfile: ExtractCapability<T['personalizationProfile']>;
+} : Record<string, never>);
+export declare function resolveCapabilityWithFactory<TFactory, TResolvedCapability, TArgs>(capability: {
+    factory?: TFactory;
+    capability?: (args: TArgs) => TResolvedCapability;
+} | undefined, defaults: {
+    factory: TFactory;
+    capability: (args: TArgs) => TResolvedCapability;
+}, buildArgs: (factory: TFactory) => TArgs): TResolvedCapability;
+export type UnomiPersonalizationProfileFactoryFor<T extends UnomiCapabilities> = ExtractFactory<T['personalizationProfile']>;
+export {};

package/src/core/session-keys.d.ts

@@ -0,0 +1,2 @@
+export declare const SESSION_KEY_PERSONALIZATION_ID = "unomi.personalizationId";
+export declare const SESSION_KEY_UNOMI_SESSION_ID = "unomi.sessionId";

package/src/factories/index.d.ts

@@ -0,0 +1 @@
+export * from './personalization-profile/personalization-profile.factory.js';

package/src/factories/personalization-profile/personalization-profile.factory.d.ts

@@ -0,0 +1,18 @@
+import type { AnyPersonalizationProfileSchema, PersonalizationProfileFactory, PersonalizationProfileSchema, RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+export interface UnomiProfileResponse {
+    itemId?: string;
+    profileId?: string;
+    properties?: Record<string, unknown>;
+    segments?: Array<string | {
+        id?: string;
+        name?: string;
+    }>;
+}
+export declare class UnomiPersonalizationProfileFactory<TPersonalizationProfileSchema extends AnyPersonalizationProfileSchema = typeof PersonalizationProfileSchema> implements PersonalizationProfileFactory<TPersonalizationProfileSchema> {
+    readonly personalizationProfileSchema: TPersonalizationProfileSchema;
+    constructor(personalizationProfileSchema: TPersonalizationProfileSchema);
+    parsePersonalizationProfile(_context: RequestContext, data: UnomiProfileResponse & {
+        profileId: string;
+    }): z.output<TPersonalizationProfileSchema>;
+}

package/src/index.d.ts

@@ -0,0 +1,8 @@
+export * from './schema/configuration.schema.js';
+export * from './schema/capabilities.schema.js';
+export * from './core/client.js';
+export * from './core/initialize.js';
+export * from './core/initialize.types.js';
+export * from './factories/index.js';
+export * from './capabilities/personalization-profile.capability.js';
+export * from './capabilities/analytics.capability.js';

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

@@ -0,0 +1,31 @@
+import type { AnalyticsCapability, 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';
+export declare const UnomiCapabilitiesSchema: z.ZodObject<{
+    analytics: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        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>>>;
+}, z.core.$loose>;
+export type UnomiCapabilities = z.infer<typeof UnomiCapabilitiesSchema>;
+export interface UnomiCapabilityFactoryArgs {
+    config: UnomiConfiguration;
+}
+export interface UnomiFactoryCapabilityArgs<TFactory> extends UnomiCapabilityFactoryArgs {
+    factory: TFactory;
+}
+export interface UnomiPersonalizationProfileCapabilityConfig {
+    enabled: boolean;
+    factory?: UnomiPersonalizationProfileFactory;
+    capability?: (args: UnomiFactoryCapabilityArgs<UnomiPersonalizationProfileFactory>) => PersonalizationProfileCapability;
+}
+export interface UnomiAnalyticsCapabilityConfig {
+    enabled: boolean;
+    capability?: (args: UnomiCapabilityFactoryArgs) => AnalyticsCapability;
+}

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

@@ -0,0 +1,10 @@
+import * as z from 'zod';
+export declare const UnomiConfigurationSchema: z.ZodObject<{
+    apiUrl: z.ZodString;
+    username: z.ZodOptional<z.ZodString>;
+    password: z.ZodOptional<z.ZodString>;
+    apiKey: z.ZodOptional<z.ZodString>;
+    profilePath: z.ZodDefault<z.ZodString>;
+    scope: z.ZodDefault<z.ZodString>;
+}, z.core.$loose>;
+export type UnomiConfiguration = z.infer<typeof UnomiConfigurationSchema>;