moveo-one-segment-destination-web 1.0.0

package/dist/index.cjs

@@ -0,0 +1,591 @@
+'use strict';
+
+// src/types.ts
+var DEFAULTS = {
+  endpoint: "https://api.moveo.one/api/analytic/external/segment-destination",
+  debug: false,
+  gzip: true,
+  batchSize: 20,
+  flushIntervalMs: 3e4,
+  maxQueueBytes: 5e6,
+  maxQueueAgeMs: 7 * 24 * 60 * 60 * 1e3,
+  maxRetries: 10
+};
+
+// src/store.ts
+var encoder = new TextEncoder();
+function byteLength(s) {
+  return encoder.encode(s).length;
+}
+var LocalStorageEventStore = class {
+  constructor(apiKey) {
+    this.current = [];
+    this.currentByteCount = 0;
+    this.prefix = `moveo-one-segment/${hash(apiKey)}`;
+    this.seqKey = `${this.prefix}:seq`;
+    this.currentKey = `${this.prefix}:current`;
+    this.batchPrefix = `${this.prefix}:b:`;
+    const raw = localStorage.getItem(this.currentKey);
+    if (raw) {
+      try {
+        const parsed = JSON.parse(raw);
+        this.current = Array.isArray(parsed) ? parsed : [];
+      } catch {
+        this.current = [];
+      }
+      this.currentByteCount = this.current.reduce((n, e) => n + byteLength(e), 0);
+    }
+  }
+  append(eventJson) {
+    this.current.push(eventJson);
+    this.currentByteCount += byteLength(eventJson);
+    localStorage.setItem(this.currentKey, JSON.stringify(this.current));
+  }
+  currentCount() {
+    return this.current.length;
+  }
+  currentBytes() {
+    return this.currentByteCount;
+  }
+  sealCurrent() {
+    if (this.current.length === 0) return;
+    const seq = this.nextSeq();
+    const key = `${this.batchPrefix}${pad(seq)}`;
+    const batch = {
+      seq,
+      attempts: 0,
+      createdAtMs: Date.now(),
+      events: this.current
+    };
+    localStorage.setItem(key, JSON.stringify(batch));
+    localStorage.removeItem(this.currentKey);
+    this.current = [];
+    this.currentByteCount = 0;
+  }
+  batches() {
+    return this.sealedKeys().map((key) => this.readBatch(key)).filter((b) => b !== null).sort((a, b) => a.seq - b.seq);
+  }
+  delete(batch) {
+    localStorage.removeItem(batch.id);
+  }
+  bumpAttempt(batch) {
+    const stored = this.readStored(batch.id);
+    if (!stored) return;
+    stored.attempts += 1;
+    localStorage.setItem(batch.id, JSON.stringify(stored));
+  }
+  enforceLimits(maxBytes, maxAgeMs, debug) {
+    const now = Date.now();
+    for (const key of this.sealedKeys()) {
+      const stored = this.readStored(key);
+      if (stored && now - stored.createdAtMs > maxAgeMs) {
+        if (debug) console.warn(`[MoveoOne] Evicting aged batch ${key}`);
+        localStorage.removeItem(key);
+      }
+    }
+    const remaining = this.sealedKeys().map((key) => ({ key, stored: this.readStored(key) })).filter((x) => x.stored !== null).sort((a, b) => a.stored.seq - b.stored.seq);
+    let total = remaining.reduce(
+      (n, x) => n + x.stored.events.reduce((m, e) => m + byteLength(e), 0),
+      0
+    );
+    let i = 0;
+    while (total > maxBytes && i < remaining.length) {
+      const x = remaining[i];
+      total -= x.stored.events.reduce((m, e) => m + byteLength(e), 0);
+      if (debug) console.warn(`[MoveoOne] Evicting over-budget batch ${x.key}`);
+      localStorage.removeItem(x.key);
+      i++;
+    }
+  }
+  nextSeq() {
+    const seq = Number(localStorage.getItem(this.seqKey) ?? "0") || 0;
+    localStorage.setItem(this.seqKey, String(seq + 1));
+    return seq;
+  }
+  sealedKeys() {
+    const keys = [];
+    for (let i = 0; i < localStorage.length; i++) {
+      const key = localStorage.key(i);
+      if (key && key.startsWith(this.batchPrefix)) keys.push(key);
+    }
+    return keys;
+  }
+  readStored(key) {
+    const raw = localStorage.getItem(key);
+    if (!raw) return null;
+    try {
+      const parsed = JSON.parse(raw);
+      if (!Array.isArray(parsed.events)) return null;
+      return parsed;
+    } catch {
+      return null;
+    }
+  }
+  readBatch(key) {
+    const stored = this.readStored(key);
+    if (!stored) return null;
+    return {
+      id: key,
+      seq: stored.seq,
+      attempts: stored.attempts,
+      createdAtMs: stored.createdAtMs,
+      events: stored.events.filter((e) => e.trim().length > 0)
+    };
+  }
+};
+var InMemoryEventStore = class {
+  constructor() {
+    this.current = [];
+    this.sealed = [];
+    this.seq = 0;
+    this.currentByteCount = 0;
+  }
+  append(eventJson) {
+    this.current.push(eventJson);
+    this.currentByteCount += byteLength(eventJson);
+  }
+  currentCount() {
+    return this.current.length;
+  }
+  currentBytes() {
+    return this.currentByteCount;
+  }
+  sealCurrent() {
+    if (this.current.length === 0) return;
+    const s = this.seq++;
+    this.sealed.push({
+      id: `mem-${s}`,
+      seq: s,
+      attempts: 0,
+      createdAtMs: Date.now(),
+      events: [...this.current]
+    });
+    this.current = [];
+    this.currentByteCount = 0;
+  }
+  batches() {
+    return [...this.sealed].sort((a, b) => a.seq - b.seq);
+  }
+  delete(batch) {
+    this.sealed = this.sealed.filter((b) => b.id !== batch.id);
+  }
+  bumpAttempt(batch) {
+    const idx = this.sealed.findIndex((b) => b.id === batch.id);
+    if (idx >= 0) this.sealed[idx].attempts += 1;
+  }
+  enforceLimits(maxBytes, maxAgeMs, _debug) {
+    const now = Date.now();
+    this.sealed = this.sealed.filter((b) => now - b.createdAtMs <= maxAgeMs);
+    let total = this.sealed.reduce(
+      (n, b) => n + b.events.reduce((m, e) => m + byteLength(e), 0),
+      0
+    );
+    while (total > maxBytes && this.sealed.length > 0) {
+      const removed = this.sealed.shift();
+      total -= removed.events.reduce((m, e) => m + byteLength(e), 0);
+    }
+  }
+};
+function buildStore(apiKey, debug) {
+  try {
+    if (typeof localStorage === "undefined") throw new Error("no localStorage");
+    const probe = "moveo-one-segment:probe";
+    localStorage.setItem(probe, "1");
+    localStorage.removeItem(probe);
+    return new LocalStorageEventStore(apiKey);
+  } catch (e) {
+    if (debug)
+      console.warn(
+        "[MoveoOne] localStorage unavailable \u2014 using in-memory store (events are NOT durable)",
+        e
+      );
+    return new InMemoryEventStore();
+  }
+}
+function pad(seq) {
+  return String(seq).padStart(12, "0");
+}
+function hash(s) {
+  let h = 0;
+  for (let i = 0; i < s.length; i++) {
+    h = Math.imul(31, h) + s.charCodeAt(i) | 0;
+  }
+  return (h >>> 0).toString(16);
+}
+
+// src/MoveoOneDestination.ts
+var encoder2 = new TextEncoder();
+var MAX_EVENT_BYTES = 32e3;
+var MAX_REQUEST_BYTES = 475e3;
+var BACKOFF_BASE_SEC = 1;
+var BACKOFF_MAX_SEC = 300;
+var BACKOFF_JITTER = 0.2;
+var MoveoOneDestination = class {
+  constructor(options) {
+    this.name = "Moveo One";
+    this.type = "enrichment";
+    this.version = "1.0.0";
+    this.loaded = false;
+    // Retry/backoff state.
+    this.consecutiveFailures = 0;
+    this.nextAllowedSendAtMs = 0;
+    // Guard so overlapping flushes never run concurrently (the browser is
+    // single-threaded, but flush I/O is async), serializing all store + network
+    // access.
+    this.flushing = false;
+    this.flushTimer = null;
+    if (!options || !options.apiKey) {
+      throw new Error("[MoveoOne] `apiKey` is required");
+    }
+    this.options = {
+      apiKey: options.apiKey,
+      endpoint: options.endpoint ?? DEFAULTS.endpoint,
+      debug: options.debug ?? DEFAULTS.debug,
+      gzip: options.gzip ?? DEFAULTS.gzip,
+      batchSize: options.batchSize ?? DEFAULTS.batchSize,
+      flushIntervalMs: options.flushIntervalMs ?? DEFAULTS.flushIntervalMs,
+      maxQueueBytes: options.maxQueueBytes ?? DEFAULTS.maxQueueBytes,
+      maxQueueAgeMs: options.maxQueueAgeMs ?? DEFAULTS.maxQueueAgeMs,
+      maxRetries: options.maxRetries ?? DEFAULTS.maxRetries,
+      filter: options.filter
+    };
+  }
+  isLoaded() {
+    return this.loaded;
+  }
+  // ──────────────────────────────────────────────────────────────────────────
+  // Lifecycle — runs when the plugin is registered with analytics-next.
+  // ──────────────────────────────────────────────────────────────────────────
+  async load(_ctx, _instance) {
+    this.store = buildStore(this.options.apiKey, this.options.debug);
+    this.registerLifecycle();
+    void this.flush();
+    this.flushTimer = setInterval(() => void this.flush(), this.options.flushIntervalMs);
+    this.loaded = true;
+  }
+  async unload() {
+    if (this.flushTimer !== null) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    if (typeof document !== "undefined" && this.onVisibilityChange) {
+      document.removeEventListener("visibilitychange", this.onVisibilityChange);
+    }
+    if (typeof window !== "undefined" && this.onPageHide) {
+      window.removeEventListener("pagehide", this.onPageHide);
+    }
+    await this.flush();
+    this.loaded = false;
+  }
+  // ──────────────────────────────────────────────────────────────────────────
+  // Segment plugin overrides — intercept every event and forward a copy. The
+  // context is returned unchanged so the rest of the Segment pipeline is intact.
+  // ──────────────────────────────────────────────────────────────────────────
+  track(ctx) {
+    this.ship(ctx.event);
+    return ctx;
+  }
+  page(ctx) {
+    this.ship(ctx.event);
+    return ctx;
+  }
+  screen(ctx) {
+    this.ship(ctx.event);
+    return ctx;
+  }
+  identify(ctx) {
+    this.ship(ctx.event);
+    return ctx;
+  }
+  group(ctx) {
+    this.ship(ctx.event);
+    return ctx;
+  }
+  alias(ctx) {
+    this.ship(ctx.event);
+    return ctx;
+  }
+  // ──────────────────────────────────────────────────────────────────────────
+  // Public API
+  // ──────────────────────────────────────────────────────────────────────────
+  /**
+   * Immediately flushes the pending batch and any queued events.
+   * Called automatically on the interval timer and when the page is hidden.
+   */
+  async flush() {
+    await this.doFlush();
+  }
+  // ──────────────────────────────────────────────────────────────────────────
+  // Private helpers
+  // ──────────────────────────────────────────────────────────────────────────
+  ship(event) {
+    if (!this.passesFilter(event)) return;
+    const body = JSON.stringify(this.buildPayload(event));
+    if (byteLength2(body) > MAX_EVENT_BYTES) {
+      if (this.options.debug)
+        console.warn(
+          `[MoveoOne] Event ${event.messageId} is too large (${body.length} chars) \u2014 skipped`
+        );
+      return;
+    }
+    try {
+      this.store.append(body);
+      if (this.store.currentCount() >= this.options.batchSize || this.store.currentBytes() >= MAX_REQUEST_BYTES) {
+        void this.flush();
+      }
+    } catch (e) {
+      if (this.options.debug) console.warn("[MoveoOne] Failed to enqueue event", e);
+    }
+  }
+  /**
+   * Seals the pending events into a batch and uploads everything that is due.
+   * Guarded so only one flush runs at a time.
+   */
+  async doFlush() {
+    if (this.flushing) return;
+    this.flushing = true;
+    try {
+      try {
+        this.store.sealCurrent();
+      } catch (e) {
+        if (this.options.debug) console.warn("[MoveoOne] Seal failed", e);
+      }
+      const now = Date.now();
+      if (now < this.nextAllowedSendAtMs) {
+        if (this.options.debug)
+          console.debug(
+            `[MoveoOne] Backing off \u2014 skipping uploads for ${this.nextAllowedSendAtMs - now}ms`
+          );
+        return;
+      }
+      this.store.enforceLimits(
+        this.options.maxQueueBytes,
+        this.options.maxQueueAgeMs,
+        this.options.debug
+      );
+      for (const batch of this.store.batches()) {
+        if (batch.events.length === 0) {
+          this.store.delete(batch);
+          continue;
+        }
+        const result = await this.postBatch(batch.events);
+        if (result.kind === "success") {
+          this.store.delete(batch);
+          this.onSendSuccess();
+          if (this.options.debug)
+            console.debug(`[MoveoOne] Sent batch ${batch.id} (${batch.events.length} events)`);
+        } else if (result.kind === "permanent") {
+          this.store.delete(batch);
+          if (this.options.debug)
+            console.warn(
+              `[MoveoOne] Dropped batch ${batch.id} \u2014 HTTP ${result.code} (non-retryable)`
+            );
+        } else {
+          const nextAttempt = batch.attempts + 1;
+          if (nextAttempt > this.options.maxRetries) {
+            this.store.delete(batch);
+            if (this.options.debug)
+              console.warn(
+                `[MoveoOne] Dropped batch ${batch.id} after ${this.options.maxRetries} failed attempts`
+              );
+            continue;
+          }
+          this.store.bumpAttempt(batch);
+          this.onSendFailure(result.retryAfterSec);
+          if (this.options.debug)
+            console.warn(
+              `[MoveoOne] Batch ${batch.id} failed (attempt ${nextAttempt}) \u2014 backing off`
+            );
+          return;
+        }
+      }
+    } finally {
+      this.flushing = false;
+    }
+  }
+  onSendSuccess() {
+    this.consecutiveFailures = 0;
+    this.nextAllowedSendAtMs = 0;
+  }
+  onSendFailure(retryAfterSec) {
+    this.consecutiveFailures++;
+    let delaySec;
+    if (retryAfterSec !== null && retryAfterSec > 0) {
+      delaySec = retryAfterSec;
+    } else {
+      const expo = BACKOFF_BASE_SEC * Math.pow(2, this.consecutiveFailures - 1);
+      const capped = Math.min(expo, BACKOFF_MAX_SEC);
+      delaySec = capped + capped * BACKOFF_JITTER * Math.random();
+    }
+    this.nextAllowedSendAtMs = Date.now() + Math.floor(delaySec * 1e3);
+  }
+  /**
+   * Returns true if the event should be forwarded to Moveo One.
+   * When no filter is set all events pass. When a filter is set, all specified
+   * key/value conditions must match against the event's properties or traits.
+   */
+  passesFilter(event) {
+    const filter = this.options.filter;
+    if (!filter || Object.keys(filter).length === 0) return true;
+    let bag;
+    switch (event.type) {
+      case "track":
+      case "page":
+      case "screen":
+        bag = event.properties;
+        break;
+      case "identify":
+      case "group":
+        bag = event.traits;
+        break;
+      default:
+        return true;
+    }
+    const properties = bag ?? {};
+    return Object.entries(filter).every(([key, allowedValues]) => {
+      const value = properties[key];
+      if (value === null || value === void 0) return false;
+      if (typeof value === "object") return false;
+      return allowedValues.includes(String(value));
+    });
+  }
+  /**
+   * Builds the JSON body sent to the Moveo One API.
+   * Follows the Segment event spec so the same fields are available on both sides.
+   */
+  buildPayload(event) {
+    const out = {
+      type: String(event.type).toLowerCase(),
+      messageId: event.messageId,
+      anonymousId: event.anonymousId,
+      timestamp: normalizeTimestamp(event.timestamp),
+      originalTimestamp: normalizeTimestamp(event.timestamp)
+    };
+    if (typeof event.userId === "string" && event.userId.trim().length > 0) {
+      out["userId"] = event.userId;
+    }
+    out["context"] = event.context;
+    out["integrations"] = event.integrations;
+    switch (event.type) {
+      case "track":
+        out["event"] = event.event;
+        out["properties"] = event.properties;
+        break;
+      case "page":
+      case "screen":
+        out["name"] = event.name;
+        out["properties"] = event.properties;
+        break;
+      case "identify":
+        out["traits"] = event.traits;
+        break;
+      case "group":
+        out["groupId"] = event.groupId;
+        out["traits"] = event.traits;
+        break;
+    }
+    return out;
+  }
+  async postBatch(events) {
+    const sentAt = (/* @__PURE__ */ new Date()).toISOString();
+    const wrapped = events.map((raw) => {
+      const obj = JSON.parse(raw);
+      if (Object.prototype.hasOwnProperty.call(obj, "sentAt")) return obj;
+      return { ...obj, sentAt };
+    });
+    const body = JSON.stringify({ events: wrapped });
+    return this.sendRequest(body);
+  }
+  async sendRequest(body) {
+    const headers = {
+      "Content-Type": "application/json; charset=utf-8",
+      Authorization: this.options.apiKey
+    };
+    let payload = body;
+    if (this.options.gzip) {
+      const gzipped = await gzip(body);
+      if (gzipped) {
+        payload = gzipped;
+        headers["Content-Encoding"] = "gzip";
+      }
+    }
+    if (this.options.debug) {
+      console.debug("[MoveoOne] \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+      console.debug(
+        `[MoveoOne] \u2192 POST ${this.options.endpoint}${headers["Content-Encoding"] ? " (gzip)" : ""}`
+      );
+      console.debug(`[MoveoOne] \u2192 Authorization: ${this.options.apiKey.slice(0, 8)}\u2026`);
+      console.debug(`[MoveoOne] \u2192 Body: ${body}`);
+    }
+    let res;
+    try {
+      res = await fetch(this.options.endpoint, {
+        method: "POST",
+        headers,
+        body: payload,
+        // keepalive lets in-flight requests complete during page unload.
+        keepalive: true
+      });
+    } catch (e) {
+      if (this.options.debug) console.warn("[MoveoOne] Network error while uploading", e);
+      return { kind: "retryable", retryAfterSec: null };
+    }
+    const code = res.status;
+    const retryAfter = parseRetryAfter(res.headers.get("Retry-After"));
+    if (this.options.debug) {
+      const responseBody = await res.text().catch(() => "(empty)");
+      console.debug(`[MoveoOne] \u2190 HTTP ${code}`);
+      console.debug(`[MoveoOne] \u2190 Response: ${responseBody || "(empty)"}`);
+      console.debug("[MoveoOne] \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    }
+    if (code >= 200 && code <= 299) return { kind: "success" };
+    if (code === 429) return { kind: "retryable", retryAfterSec: retryAfter };
+    if (code >= 500 && code <= 599) return { kind: "retryable", retryAfterSec: retryAfter };
+    if (code >= 400 && code <= 499) return { kind: "permanent", code };
+    return { kind: "retryable", retryAfterSec: retryAfter };
+  }
+  registerLifecycle() {
+    if (typeof document !== "undefined") {
+      this.onVisibilityChange = () => {
+        if (document.visibilityState === "hidden") void this.flush();
+      };
+      document.addEventListener("visibilitychange", this.onVisibilityChange);
+    }
+    if (typeof window !== "undefined") {
+      this.onPageHide = () => void this.flush();
+      window.addEventListener("pagehide", this.onPageHide);
+    }
+  }
+};
+function byteLength2(s) {
+  return encoder2.encode(s).length;
+}
+function normalizeTimestamp(ts) {
+  if (ts === void 0 || ts === null) return void 0;
+  if (ts instanceof Date) return ts.toISOString();
+  return String(ts);
+}
+function parseRetryAfter(value) {
+  if (!value) return null;
+  const n = parseInt(value.trim(), 10);
+  return Number.isNaN(n) ? null : n;
+}
+async function gzip(s) {
+  if (typeof CompressionStream === "undefined") return null;
+  try {
+    const stream = new Blob([s]).stream().pipeThrough(new CompressionStream("gzip"));
+    return await new Response(stream).blob();
+  } catch {
+    return null;
+  }
+}
+
+// src/index.ts
+function moveoOneDestination(options) {
+  return new MoveoOneDestination(options);
+}
+
+exports.MoveoOneDestination = MoveoOneDestination;
+exports.moveoOneDestination = moveoOneDestination;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map