@drip-apex/sdk 0.1.0

package/src/bucketing-cleanup.ts

@@ -0,0 +1,72 @@
+import type { Experiment } from "./types";
+
+const GOALS_KEY = "drip_goals";
+const CONFIG_CACHE_PREFIX = "drip_cfg:";
+
+function readJsonRecord(key: string): Record<string, unknown> | null {
+  try {
+    const storage = globalThis.localStorage;
+    if (!storage) return null;
+    const raw = storage.getItem(key);
+    return raw ? JSON.parse(raw) as Record<string, unknown> : null;
+  } catch {
+    return null;
+  }
+}
+
+function cleanupGoalStorage(experiments: Experiment[]): void {
+  const stored = readJsonRecord(GOALS_KEY);
+  if (!stored) return;
+
+  const activeGoalIds = new Set<string>();
+  const activeVariationIds = new Set<string>();
+  for (const experiment of experiments) {
+    for (const goal of experiment.goals ?? []) activeGoalIds.add(goal.id);
+    for (const variation of experiment.variations ?? []) activeVariationIds.add(variation.id);
+  }
+
+  const next: Record<string, string[]> = {};
+  for (const [goalId, variationIds] of Object.entries(stored)) {
+    if (!activeGoalIds.has(goalId) || !Array.isArray(variationIds)) continue;
+    const kept = variationIds.filter((variationId) => (
+      typeof variationId === "string" && activeVariationIds.has(variationId)
+    ));
+    if (kept.length) next[goalId] = kept;
+  }
+
+  try {
+    const storage = globalThis.localStorage;
+    if (!storage) return;
+    if (Object.keys(next).length) storage.setItem(GOALS_KEY, JSON.stringify(next));
+    else storage.removeItem(GOALS_KEY);
+  } catch {
+    // ignore storage failures
+  }
+}
+
+function cleanupConfigCache(currentShopId?: string, retentionDays = 180): void {
+  if (!currentShopId) return;
+  const cutoffMs = Date.now() - Math.max(1, retentionDays) * 864e5;
+  try {
+    const storage = globalThis.localStorage;
+    if (!storage) return;
+    for (let i = storage.length - 1; i >= 0; i--) {
+      const key = storage.key(i);
+      if (!key?.startsWith(CONFIG_CACHE_PREFIX)) continue;
+      if (key.startsWith(CONFIG_CACHE_PREFIX + currentShopId + ":")) continue;
+      const parsed = readJsonRecord(key);
+      const fetchedAt = typeof parsed?.fetchedAt === "number" ? parsed.fetchedAt : 0;
+      if (!fetchedAt || fetchedAt < cutoffMs) storage.removeItem(key);
+    }
+  } catch {
+    // ignore storage failures
+  }
+}
+
+export function cleanupBucketingStorage(
+  experiments: Experiment[],
+  options?: { shopId?: string; retentionDays?: number },
+): void {
+  cleanupGoalStorage(experiments);
+  cleanupConfigCache(options?.shopId, options?.retentionDays ?? 180);
+}

package/src/bucketing-parity.test.ts

@@ -0,0 +1,41 @@
+import { readFileSync } from "node:fs";
+import { describe, expect, it } from "vitest";
+
+import { chooseVariation, inTrafficAllocation } from "./bucket";
+import { hashToFloat, murmurhash3_32_gc, variationHashToFloat } from "./hash";
+
+const vectors = JSON.parse(
+  readFileSync(new URL("../../../ops/bucketing-golden-vectors.json", import.meta.url), "utf8"),
+);
+
+describe("bucketing golden parity", () => {
+  it("asserts every canonical murmurhash3_32 vector", () => {
+    for (const vector of vectors.murmurhash3_32) {
+      expect(murmurhash3_32_gc(vector.key, vector.seed)).toBe(vector.expected);
+    }
+  });
+
+  it("asserts every canonical hashToFloat vector", () => {
+    for (const vector of vectors.hashToFloat) {
+      expect(hashToFloat(vector.experimentId, vector.visitorId)).toBe(vector.expected);
+    }
+  });
+
+  it("asserts every canonical variationHashToFloat vector", () => {
+    for (const vector of vectors.variationHashToFloat) {
+      expect(variationHashToFloat(vector.experimentId, vector.visitorId)).toBe(vector.expected);
+    }
+  });
+
+  it("asserts every canonical chooseVariation vector", () => {
+    for (const vector of vectors.chooseVariation) {
+      expect(chooseVariation(vector.hashValue, vector.weights)).toBe(vector.expected);
+    }
+  });
+
+  it("asserts every canonical inTrafficAllocation vector", () => {
+    for (const vector of vectors.inTrafficAllocation) {
+      expect(inTrafficAllocation(vector.hashValue, vector.allocation)).toBe(vector.expected);
+    }
+  });
+});