@walkeros/server-destination-amplitude 3.3.0-next-1776098542393

package/dist/examples/index.mjs

@@ -0,0 +1,418 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/examples/env.ts
+var env_exports = {};
+__export(env_exports, {
+  init: () => init,
+  push: () => push,
+  simulation: () => simulation
+});
+var noop = () => {
+};
+var noopPromise = () => ({ promise: Promise.resolve() });
+var MockIdentify = class {
+  set() {
+    return this;
+  }
+  setOnce() {
+    return this;
+  }
+  add() {
+    return this;
+  }
+  append() {
+    return this;
+  }
+  prepend() {
+    return this;
+  }
+  preInsert() {
+    return this;
+  }
+  postInsert() {
+    return this;
+  }
+  remove() {
+    return this;
+  }
+  unset() {
+    return this;
+  }
+  clearAll() {
+    return this;
+  }
+};
+var MockRevenue = class {
+  setProductId() {
+    return this;
+  }
+  setPrice() {
+    return this;
+  }
+  setQuantity() {
+    return this;
+  }
+  setRevenueType() {
+    return this;
+  }
+  setCurrency() {
+    return this;
+  }
+  setRevenue() {
+    return this;
+  }
+  setReceipt() {
+    return this;
+  }
+  setReceiptSig() {
+    return this;
+  }
+  setEventProperties() {
+    return this;
+  }
+};
+var init = {
+  amplitude: {
+    init: noopPromise,
+    track: noop,
+    identify: noop,
+    revenue: noop,
+    setOptOut: noop,
+    setGroup: noop,
+    groupIdentify: noop,
+    flush: noopPromise,
+    Identify: MockIdentify,
+    Revenue: MockRevenue
+  }
+};
+var push = {
+  amplitude: {
+    init: noopPromise,
+    track: noop,
+    identify: noop,
+    revenue: noop,
+    setOptOut: noop,
+    setGroup: noop,
+    groupIdentify: noop,
+    flush: noopPromise,
+    Identify: MockIdentify,
+    Revenue: MockRevenue
+  }
+};
+var simulation = [
+  "call:amplitude.init",
+  "call:amplitude.track",
+  "call:amplitude.identify",
+  "call:amplitude.revenue",
+  "call:amplitude.setOptOut",
+  "call:amplitude.setGroup",
+  "call:amplitude.groupIdentify"
+];
+
+// src/examples/step.ts
+var step_exports = {};
+__export(step_exports, {
+  consentGrantOptIn: () => consentGrantOptIn,
+  consentRevokeOptOut: () => consentRevokeOptOut,
+  defaultEventForwarding: () => defaultEventForwarding,
+  destinationLevelIdentify: () => destinationLevelIdentify,
+  destinationLevelInclude: () => destinationLevelInclude,
+  eventOptionsTimeInsertId: () => eventOptionsTimeInsertId,
+  groupAssignmentWithProperties: () => groupAssignmentWithProperties,
+  orderCompleteMultiProduct: () => orderCompleteMultiProduct,
+  subscriptionRenewRevenue: () => subscriptionRenewRevenue,
+  userLoginIdentify: () => userLoginIdentify,
+  wildcardIgnored: () => wildcardIgnored
+});
+import { getEvent } from "@walkeros/core";
+var defaultEventForwarding = {
+  in: getEvent("product view", { timestamp: 1700000100 }),
+  out: ["amplitude.track", "product view", {}]
+};
+var wildcardIgnored = {
+  in: getEvent("debug noise", { timestamp: 1700000101 }),
+  mapping: { ignore: true },
+  out: []
+};
+var destinationLevelInclude = {
+  in: getEvent("product view", { timestamp: 1700000102 }),
+  configInclude: ["data"],
+  out: [
+    "amplitude.track",
+    "product view",
+    {
+      data_id: "ers",
+      data_name: "Everyday Ruck Snack",
+      data_color: "black",
+      data_size: "l",
+      data_price: 420
+    }
+  ]
+};
+var destinationLevelIdentify = {
+  in: getEvent("page view", { timestamp: 1700000104 }),
+  settings: {
+    identify: {
+      map: {
+        user_id: "user.id",
+        device_id: "user.device",
+        session_id: "user.session"
+      }
+    }
+  },
+  out: [
+    "amplitude.track",
+    "page view",
+    {},
+    {
+      user_id: "us3r",
+      device_id: "c00k13",
+      session_id: 394324160
+    }
+  ]
+};
+var userLoginIdentify = {
+  in: getEvent("user login", {
+    timestamp: 1700000105,
+    data: {
+      user_id: "new-user-123",
+      plan: "premium",
+      company: "Acme",
+      email: "user@acme.com"
+    }
+  }),
+  mapping: {
+    skip: true,
+    settings: {
+      identify: {
+        map: {
+          user_id: "data.user_id",
+          set: {
+            map: {
+              plan: "data.plan",
+              company: "data.company",
+              email: "data.email"
+            }
+          },
+          setOnce: {
+            map: {
+              first_login: "timestamp"
+            }
+          },
+          add: {
+            map: {
+              login_count: { value: 1 }
+            }
+          }
+        }
+      }
+    }
+  },
+  out: [
+    "amplitude.identify",
+    {
+      set: {
+        plan: "premium",
+        company: "Acme",
+        email: "user@acme.com"
+      },
+      setOnce: {
+        first_login: 1700000105
+      },
+      add: {
+        login_count: 1
+      }
+    },
+    {
+      user_id: "new-user-123"
+    }
+  ]
+};
+var subscriptionRenewRevenue = {
+  in: getEvent("subscription renew", {
+    timestamp: 1700000107,
+    data: {
+      plan_id: "plan-pro",
+      amount: 9.99
+    }
+  }),
+  mapping: {
+    skip: true,
+    settings: {
+      revenue: {
+        map: {
+          productId: "data.plan_id",
+          price: "data.amount",
+          revenueType: { value: "renewal" },
+          currency: { key: "data.currency", value: "EUR" }
+        }
+      }
+    }
+  },
+  out: [
+    "amplitude.revenue",
+    {
+      productId: "plan-pro",
+      price: 9.99,
+      revenueType: "renewal",
+      currency: "EUR"
+    }
+  ]
+};
+var orderCompleteMultiProduct = {
+  in: getEvent("order complete", { timestamp: 1700000108 }),
+  mapping: {
+    include: ["data", "globals"],
+    settings: {
+      revenue: {
+        loop: [
+          "nested",
+          {
+            condition: (value) => {
+              var _a;
+              const v = value;
+              return typeof ((_a = v == null ? void 0 : v.data) == null ? void 0 : _a.price) === "number";
+            },
+            map: {
+              productId: "data.id",
+              price: "data.price",
+              quantity: { key: "data.quantity", value: 1 },
+              revenueType: { value: "purchase" },
+              currency: { key: "data.currency", value: "EUR" }
+            }
+          }
+        ]
+      }
+    }
+  },
+  out: [
+    [
+      "amplitude.revenue",
+      {
+        productId: "ers",
+        price: 420,
+        quantity: 1,
+        revenueType: "purchase",
+        currency: "EUR"
+      }
+    ],
+    [
+      "amplitude.revenue",
+      {
+        productId: "cc",
+        price: 42,
+        quantity: 1,
+        revenueType: "purchase",
+        currency: "EUR"
+      }
+    ],
+    [
+      "amplitude.track",
+      "order complete",
+      {
+        data_id: "0rd3r1d",
+        data_currency: "EUR",
+        data_shipping: 5.22,
+        data_taxes: 73.76,
+        data_total: 555,
+        globals_pagegroup: "shop"
+      }
+    ]
+  ]
+};
+var groupAssignmentWithProperties = {
+  in: getEvent("company update", {
+    timestamp: 1700000109,
+    data: {
+      company: "Acme",
+      industry: "tech",
+      employee_count: 50,
+      founded_year: 2020
+    }
+  }),
+  mapping: {
+    skip: true,
+    settings: {
+      group: {
+        map: {
+          type: { value: "company" },
+          name: "data.company"
+        }
+      },
+      groupIdentify: {
+        map: {
+          type: { value: "company" },
+          name: "data.company",
+          set: {
+            map: {
+              industry: "data.industry",
+              size: "data.employee_count"
+            }
+          },
+          setOnce: {
+            map: {
+              founded: "data.founded_year"
+            }
+          }
+        }
+      }
+    }
+  },
+  out: [
+    ["amplitude.setGroup", "company", "Acme"],
+    [
+      "amplitude.groupIdentify",
+      "company",
+      "Acme",
+      {
+        set: {
+          industry: "tech",
+          size: 50
+        },
+        setOnce: {
+          founded: 2020
+        }
+      }
+    ]
+  ]
+};
+var eventOptionsTimeInsertId = {
+  in: getEvent("page view", { timestamp: 1700000110 }),
+  settings: {
+    eventOptions: {
+      map: {
+        time: "timestamp",
+        insert_id: "id"
+      }
+    }
+  },
+  out: [
+    "amplitude.track",
+    "page view",
+    {},
+    {
+      time: 1700000110,
+      insert_id: "1700000110-gr0up-1"
+    }
+  ]
+};
+var consentRevokeOptOut = {
+  command: "consent",
+  in: { analytics: false },
+  settings: {},
+  out: ["amplitude.setOptOut", true]
+};
+var consentGrantOptIn = {
+  command: "consent",
+  in: { analytics: true },
+  settings: {},
+  out: ["amplitude.setOptOut", false]
+};
+export {
+  env_exports as env,
+  step_exports as step
+};

package/dist/index.d.mts

@@ -0,0 +1,167 @@
+import { Mapping as Mapping$1, Destination as Destination$1 } from '@walkeros/core';
+import { DestinationServer } from '@walkeros/server-core';
+
+/**
+ * Amplitude SDK surface -- the subset of @amplitude/analytics-node the
+ * destination actually uses. Tests provide a mock via env.amplitude;
+ * production uses the real SDK import.
+ *
+ * Key difference from web: no setUserId/setDeviceId/setSessionId.
+ * Identity is per-event via EventOptions on every SDK call.
+ */
+interface AmplitudeSDK {
+    init: (apiKey: string, options?: Record<string, unknown>) => {
+        promise: Promise<void>;
+    };
+    track: (eventType: string, eventProperties?: Record<string, unknown>, eventOptions?: EventOptions) => void;
+    identify: (identify: IdentifyInstance, eventOptions?: EventOptions) => void;
+    revenue: (revenue: RevenueInstance, eventOptions?: EventOptions) => void;
+    setGroup: (groupType: string, groupName: string | string[], eventOptions?: EventOptions) => void;
+    groupIdentify: (groupType: string, groupName: string, identify: IdentifyInstance, eventOptions?: EventOptions) => void;
+    setOptOut: (optOut: boolean) => void;
+    flush: () => {
+        promise: Promise<void>;
+    };
+    Identify: new () => IdentifyInstance;
+    Revenue: new () => RevenueInstance;
+}
+/**
+ * Per-event identity and metadata fields. Passed to every SDK call.
+ * Maps directly to Amplitude's EventOptions type from the Node SDK.
+ */
+interface EventOptions {
+    user_id?: string;
+    device_id?: string;
+    session_id?: number;
+    time?: number;
+    insert_id?: string;
+    ip?: string;
+    city?: string;
+    country?: string;
+    region?: string;
+    language?: string;
+    platform?: string;
+    os_name?: string;
+    os_version?: string;
+    device_brand?: string;
+    device_manufacturer?: string;
+    device_model?: string;
+    app_version?: string;
+    carrier?: string;
+    user_agent?: string;
+    groups?: Record<string, unknown>;
+    plan?: Record<string, unknown>;
+    ingestion_metadata?: Record<string, unknown>;
+    partner_id?: string;
+    extra?: Record<string, unknown>;
+}
+/** Chainable Identify -- mirrors @amplitude/analytics-node Identify class. */
+interface IdentifyInstance {
+    set: (property: string, value: unknown) => IdentifyInstance;
+    setOnce: (property: string, value: unknown) => IdentifyInstance;
+    add: (property: string, value: number) => IdentifyInstance;
+    append: (property: string, value: unknown) => IdentifyInstance;
+    prepend: (property: string, value: unknown) => IdentifyInstance;
+    preInsert: (property: string, value: unknown) => IdentifyInstance;
+    postInsert: (property: string, value: unknown) => IdentifyInstance;
+    remove: (property: string, value: unknown) => IdentifyInstance;
+    unset: (property: string) => IdentifyInstance;
+    clearAll: () => IdentifyInstance;
+}
+/** Chainable Revenue -- mirrors @amplitude/analytics-node Revenue class. */
+interface RevenueInstance {
+    setProductId: (id: string) => RevenueInstance;
+    setPrice: (price: number) => RevenueInstance;
+    setQuantity: (quantity: number) => RevenueInstance;
+    setRevenueType: (type: string) => RevenueInstance;
+    setCurrency: (currency: string) => RevenueInstance;
+    setRevenue: (revenue: number) => RevenueInstance;
+    setReceipt: (receipt: string) => RevenueInstance;
+    setReceiptSig: (signature: string) => RevenueInstance;
+    setEventProperties: (properties: Record<string, unknown>) => RevenueInstance;
+}
+/**
+ * Destination-level settings. apiKey is required; all other fields
+ * are optional and passed through to the Amplitude Node SDK init().
+ */
+interface Settings {
+    apiKey: string;
+    serverZone?: 'US' | 'EU';
+    flushIntervalMillis?: number;
+    flushQueueSize?: number;
+    flushMaxRetries?: number;
+    useBatch?: boolean;
+    minIdLength?: number;
+    serverUrl?: string;
+    logLevel?: number;
+    optOut?: boolean;
+    offline?: boolean;
+    enableRequestBodyCompression?: boolean;
+    plan?: Record<string, unknown>;
+    ingestionMetadata?: Record<string, unknown>;
+    /** walkerOS mapping value for per-event identity resolution. */
+    identify?: Mapping$1.Value;
+    /** walkerOS mapping value for per-event EventOptions (time, insert_id, ip, etc). */
+    eventOptions?: Mapping$1.Value;
+    /** Sections to include as event_properties (e.g., ['data', 'globals']). */
+    include?: string[];
+}
+type InitSettings = Partial<Settings>;
+/**
+ * Per-rule mapping settings. Each is a walkerOS mapping value resolved
+ * via getMappingValue(). Revenue supports loop for multi-item orders.
+ */
+interface Mapping {
+    identify?: Mapping$1.Value;
+    revenue?: Mapping$1.Value;
+    group?: Mapping$1.Value;
+    groupIdentify?: Mapping$1.Value;
+    eventOptions?: Mapping$1.Value;
+    include?: string[];
+}
+/**
+ * Env -- optional SDK override. Production leaves this undefined and the
+ * destination falls back to the real @amplitude/analytics-node import.
+ * Tests provide a mock via env.amplitude.
+ */
+interface Env extends DestinationServer.Env {
+    amplitude?: AmplitudeSDK;
+}
+type Types = Destination$1.Types<Settings, Mapping, Env, InitSettings>;
+interface Destination extends DestinationServer.Destination<Types> {
+    init: DestinationServer.InitFn<Types>;
+}
+type Config = {
+    settings: Settings;
+} & DestinationServer.Config<Types>;
+type InitFn = DestinationServer.InitFn<Types>;
+type PushFn = DestinationServer.PushFn<Types>;
+type PartialConfig = DestinationServer.PartialConfig<Types>;
+type PushEvents = DestinationServer.PushEvents<Mapping>;
+type Rule = Mapping$1.Rule<Mapping>;
+type Rules = Mapping$1.Rules<Rule>;
+
+type index_AmplitudeSDK = AmplitudeSDK;
+type index_Config = Config;
+type index_Destination = Destination;
+type index_Env = Env;
+type index_EventOptions = EventOptions;
+type index_IdentifyInstance = IdentifyInstance;
+type index_InitFn = InitFn;
+type index_InitSettings = InitSettings;
+type index_Mapping = Mapping;
+type index_PartialConfig = PartialConfig;
+type index_PushEvents = PushEvents;
+type index_PushFn = PushFn;
+type index_RevenueInstance = RevenueInstance;
+type index_Rule = Rule;
+type index_Rules = Rules;
+type index_Settings = Settings;
+type index_Types = Types;
+declare namespace index {
+  export type { index_AmplitudeSDK as AmplitudeSDK, index_Config as Config, index_Destination as Destination, index_Env as Env, index_EventOptions as EventOptions, index_IdentifyInstance as IdentifyInstance, index_InitFn as InitFn, index_InitSettings as InitSettings, index_Mapping as Mapping, index_PartialConfig as PartialConfig, index_PushEvents as PushEvents, index_PushFn as PushFn, index_RevenueInstance as RevenueInstance, index_Rule as Rule, index_Rules as Rules, index_Settings as Settings, index_Types as Types };
+}
+
+declare const destinationAmplitude: Destination;
+
+export { index as DestinationAmplitude, destinationAmplitude as default, destinationAmplitude };