@jitsu/js 1.9.7-canary.903.20240731114701 → 1.9.8

package/__tests__/node/nodejs.test.ts

@@ -38,99 +38,234 @@ describe("Test Jitsu NodeJS client", () => {
     console.log("Server is down " + server.baseUrl);
   };
 
-  test("setAnonymousId test2", async () => {
+  beforeAll(async () => {
     await startServer();
+  });
+
+  beforeEach(() => {
+    requestLog = [];
+  });
+
+  afterAll(async () => {
+    await shutdownServer();
+  });
+
+  test("setAnonymousId test2", async () => {
+    const config = {
+      host: server.baseUrl,
+      writeKey: "key:secret",
+      debug: true,
+    };
+
+    console.log("[JITSU TEST] Initializing Jitsu");
+    const client = jitsuAnalytics(config);
+    console.log("[JITSU TEST] Jitsu instance", client);
+
+    const anonymousId = "anonymous_id_test";
+    console.log("[JITSU TEST] Setting anonymous id to " + anonymousId);
+    await client.setAnonymousId(anonymousId);
+    console.log("user state", client.getState("user"));
+
+    expect(requestLog.length).toBe(0);
+    console.log("[JITSU TEST] Sending event EVENT_1");
+    await client.track("EVENT_1");
+    await client.track("EVENT_2");
+    await client.track("groupId");
+
+    await new Promise(resolve => setTimeout(resolve, 1000));
+
+    expect(requestLog.length).toBe(3);
+    expect(requestLog[1].body.anonymousId).toBe("anonymous_id_test");
+    expect(requestLog[0].body.anonymousId).toBe("anonymous_id_test");
+    expect(requestLog[2].body.anonymousId).toBe("anonymous_id_test");
+  });
+
+  test("test privacy dontSend", async () => {
+    const config = {
+      host: server.baseUrl,
+      writeKey: "key:secret",
+      debug: true,
+      privacy: {
+        dontSend: true,
+      },
+    };
+    const client = jitsuAnalytics(config);
+    expect(requestLog.length).toBe(0);
+    await client.identify("myUserId", { email: "myUserId@example.com" });
+    await client.group("myGroupId", { name: "myGroupId" });
+    await client.track("myEvent", { prop1: "value1" });
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    expect(requestLog.length).toBe(0);
+  });
+
+  test("test privacy dontSend then consent", async () => {
+    const config = {
+      host: server.baseUrl,
+      writeKey: "key:secret",
+      debug: true,
+      privacy: {
+        dontSend: true,
+      },
+    };
+    const client = jitsuAnalytics(config);
+    expect(requestLog.length).toBe(0);
+    await client.identify("myUserId", { email: "myUserId@example.com" });
+    await client.group("myGroupId", { name: "myGroupId" });
+    await client.track("myEvent", { prop1: "value1" });
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    expect(requestLog.length).toBe(0);
 
+    client.configure({
+      privacy: {
+        dontSend: false,
+        consentCategories: {
+          analytics: true,
+        },
+      },
+    });
+    await client.identify("myUserId", { email: "myUserId@example.com" });
+    await client.group("myGroupId", { name: "myGroupId" });
+    await client.track("myEvent", { prop1: "value1" });
+    await new Promise(resolve => setTimeout(resolve, 1000));
+
+    expect(requestLog.length).toBe(3);
+    const p = requestLog[2];
+    expect(p.type).toEqual("track");
+    expect(p.body.event).toBe("myEvent");
+    expect(p.body.userId).toEqual("myUserId");
+    expect(p.body.groupId).toEqual("myGroupId");
+    expect(p.body.context?.traits?.email).toEqual("myUserId@example.com");
+    expect(p.body.context?.consent?.categoryPreferences).toEqual({ analytics: true });
+    expect((p.body.anonymousId ?? "").length).toBeGreaterThan(0);
+  });
+
+  test("test privacy disableUserIds", async () => {
+    const config = {
+      host: server.baseUrl,
+      writeKey: "key:secret",
+      debug: true,
+      privacy: {
+        disableUserIds: true,
+      },
+    };
+    const client = jitsuAnalytics(config);
+    expect(requestLog.length).toBe(0);
+    await client.identify("myUserId", { email: "myUserId@example.com" });
+    await client.group("myGroupId", { name: "myGroupId" });
+    await client.track("myEvent", { prop1: "value1" });
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    expect(requestLog.length).toBe(1);
+    const p = requestLog[0];
+    expect(p.type).toEqual("track");
+    expect(p.body.event).toBe("myEvent");
+    expect(p.body.userId).toBeUndefined();
+    expect(p.body.groupId).toBeUndefined();
+    expect(p.body.context?.traits?.email).toBeUndefined();
+    expect(p.body.anonymousId).toBeUndefined();
+    expect(p.body.properties?.prop1).toBe("value1");
+  });
+
+  test("test privacy disableUserIds then consent", async () => {
     const config = {
       host: server.baseUrl,
       writeKey: "key:secret",
       debug: true,
+      privacy: {
+        disableUserIds: true,
+      },
     };
+    const client = jitsuAnalytics(config);
+    expect(requestLog.length).toBe(0);
+    await client.identify("myUserId", { email: "myUserId@example.com" });
+    await client.group("myGroupId", { name: "myGroupId" });
+    await client.track("myEvent", { prop1: "value1" });
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    expect(requestLog.length).toBe(1);
+    let p = requestLog[0];
+    expect(p.type).toEqual("track");
+    expect(p.body.event).toBe("myEvent");
+    expect(p.body.userId).toBeUndefined();
+    expect(p.body.groupId).toBeUndefined();
+    expect(p.body.context?.traits?.email).toBeUndefined();
+    expect(p.body.anonymousId).toBeUndefined();
+    expect(p.body.properties?.prop1).toBe("value1");
 
-    try {
-      console.log("[JITSU TEST] Initializing Jitsu");
-      const client = jitsuAnalytics(config);
-      console.log("[JITSU TEST] Jitsu instance", client);
-
-      const anonymousId = "anonymous_id_test";
-      console.log("[JITSU TEST] Setting anonymous id to " + anonymousId);
-      await client.setAnonymousId(anonymousId);
-      console.log("user state", client.getState("user"));
-
-      expect(requestLog.length).toBe(0);
-      console.log("[JITSU TEST] Sending event EVENT_1");
-      await client.track("EVENT_1");
-      await client.track("EVENT_2");
-      await client.track("groupId");
-
-      await new Promise(resolve => setTimeout(resolve, 1000));
-
-      expect(requestLog.length).toBe(3);
-      expect(requestLog[1].body.anonymousId).toBe("anonymous_id_test");
-      expect(requestLog[0].body.anonymousId).toBe("anonymous_id_test");
-      expect(requestLog[2].body.anonymousId).toBe("anonymous_id_test");
-    } finally {
-      shutdownServer();
-    }
+    client.configure({
+      privacy: {
+        disableUserIds: false,
+        consentCategories: {
+          analytics: true,
+        },
+      },
+    });
+    await client.identify("myUserId", { email: "myUserId@example.com" });
+    await client.group("myGroupId", { name: "myGroupId" });
+    await client.track("myEvent", { prop1: "value1" });
+    await new Promise(resolve => setTimeout(resolve, 1000));
+
+    expect(requestLog.length).toBe(4);
+    p = requestLog[3];
+    expect(p.type).toEqual("track");
+    expect(p.body.event).toBe("myEvent");
+    expect(p.body.userId).toEqual("myUserId");
+    expect(p.body.groupId).toEqual("myGroupId");
+    expect(p.body.context?.traits?.email).toEqual("myUserId@example.com");
+    expect(p.body.context?.consent?.categoryPreferences).toEqual({ analytics: true });
+    expect((p.body.anonymousId ?? "").length).toBeGreaterThan(0);
   });
 
   test("node js", async () => {
-    await startServer();
-    try {
-      const jitsu: AnalyticsInterface = jitsuAnalytics({
-        writeKey: "key:secret",
-        host: server.baseUrl,
-        debug: true,
-        fetch: fetchImpl,
-      });
-      await jitsu.track("testTrack");
+    const jitsu: AnalyticsInterface = jitsuAnalytics({
+      writeKey: "key:secret",
+      host: server.baseUrl,
+      debug: true,
+      fetch: fetchImpl,
+    });
+    await jitsu.track("testTrack");
 
-      await jitsu.identify("testUser", {
-        email: "test@test.com",
-      });
+    await jitsu.identify("testUser", {
+      email: "test@test.com",
+    });
 
-      await jitsu.group("testGroup", {
-        name: "Test Group",
-      });
+    await jitsu.group("testGroup", {
+      name: "Test Group",
+    });
 
-      await jitsu.page({
-        name: "test",
-        environment: "nodejs",
-        context: {
-          page: {
-            url: "http://server.com",
-          },
+    await jitsu.page({
+      name: "test",
+      environment: "nodejs",
+      context: {
+        page: {
+          url: "http://server.com",
         },
-      });
-      await new Promise(resolve => setTimeout(resolve, 1000));
-      expect(requestLog.length).toBe(4);
-      expect(requestLog[0].type).toBe("track");
-      expect(requestLog[1].type).toBe("identify");
-      expect(requestLog[2].type).toBe("group");
-      expect(requestLog[3].type).toBe("page");
-
-      const track = requestLog[0].body as AnalyticsClientEvent;
-      const identify = requestLog[1].body as AnalyticsClientEvent;
-      const group = requestLog[2].body as AnalyticsClientEvent;
-      const page = requestLog[3].body as AnalyticsClientEvent;
-
-      //expect(track.userId).toBe(undefined);
-      expect(page.properties.name).toBe("test");
-      expect(page.properties?.environment).toBe("nodejs");
-      expect(page.context.page.url).toBe("http://server.com");
-      expect(page.userId).toBe("testUser");
-      expect(identify.traits.email).toBe("test@test.com");
-      expect(identify.anonymousId).toBe(page.anonymousId);
-      expect(group.traits.name).toBe("Test Group");
-      expect(group.anonymousId).toBe(page.anonymousId);
-      expect(group.userId).toBe("testUser");
-      expect(group.groupId).toBe("testGroup");
-
-      const pagePayload = requestLog[0].body;
-      console.log("pagePayload", pagePayload);
-    } finally {
-      await shutdownServer();
-    }
+      },
+    });
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    expect(requestLog.length).toBe(4);
+    expect(requestLog[0].type).toBe("track");
+    expect(requestLog[1].type).toBe("identify");
+    expect(requestLog[2].type).toBe("group");
+    expect(requestLog[3].type).toBe("page");
+
+    const track = requestLog[0].body as AnalyticsClientEvent;
+    const identify = requestLog[1].body as AnalyticsClientEvent;
+    const group = requestLog[2].body as AnalyticsClientEvent;
+    const page = requestLog[3].body as AnalyticsClientEvent;
+
+    //expect(track.userId).toBe(undefined);
+    expect(page.properties.name).toBe("test");
+    expect(page.properties?.environment).toBe("nodejs");
+    expect(page.context.page.url).toBe("http://server.com");
+    expect(page.userId).toBe("testUser");
+    expect(identify.traits.email).toBe("test@test.com");
+    expect(identify.anonymousId).toBe(page.anonymousId);
+    expect(group.traits.name).toBe("Test Group");
+    expect(group.anonymousId).toBe(page.anonymousId);
+    expect(group.userId).toBe("testUser");
+    expect(group.groupId).toBe("testGroup");
+
+    const pagePayload = requestLog[0].body;
+    console.log("pagePayload", pagePayload);
   });
 
   test("tld", async () => {

package/__tests__/playwright/cases/disable-user-ids.html

@@ -0,0 +1,23 @@
+<!DOCTYPE html>
+
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+
+    <title>Tracking page</title>
+
+    <script
+      type="text/javascript"
+      src="<%=trackingBase%>/p.js"
+      data-privacy-disable-user-ids="true"
+      data-init-only="true"
+      data-debug="true"
+      defer
+    ></script>
+  </head>
+
+  <body>
+    <h1>Test</h1>
+  </body>
+</html>

package/__tests__/playwright/cases/dont-send.html

@@ -0,0 +1,22 @@
+<!DOCTYPE html>
+
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+
+    <title>Tracking page</title>
+
+    <script
+      type="text/javascript"
+      src="<%=trackingBase%>/p.js"
+      data-privacy-dont-send="true"
+      data-debug="true"
+      defer
+    ></script>
+  </head>
+
+  <body>
+    <h1>Test</h1>
+  </body>
+</html>

package/__tests__/playwright/cases/ip-policy.html

@@ -0,0 +1,22 @@
+<!DOCTYPE html>
+
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+
+    <title>Tracking page</title>
+
+    <script
+      type="text/javascript"
+      src="<%=trackingBase%>/p.js"
+      data-privacy-ip-policy="stripLastOctet"
+      data-debug="true"
+      defer
+    ></script>
+  </head>
+
+  <body>
+    <h1>Test</h1>
+  </body>
+</html>

package/__tests__/playwright/integration.test.ts

@@ -5,7 +5,6 @@ import * as path from "path";
 import ejs from "ejs";
 // import chalk from "chalk";
 import * as process from "process";
-import * as console from "console";
 import { AnalyticsClientEvent, AnalyticsInterface } from "@jitsu/protocols/analytics.d";
 
 test.use({
@@ -24,7 +23,7 @@ const app = express();
 
 let server: SimpleSyrup;
 
-let requestLog: { type: string; body: AnalyticsClientEvent }[] = [];
+let requestLog: { type: string; body: AnalyticsClientEvent; headers: any }[] = [];
 
 test.beforeAll(async () => {
   const testCasesHandlers = fs.readdirSync(path.join(__dirname, "cases")).reduce((res, file) => {
@@ -60,6 +59,7 @@ test.beforeAll(async () => {
         res.send({ ok: true });
         requestLog.push({
           type: req.params.type,
+          headers: req.headers,
           body: req.body,
         });
       },
@@ -279,6 +279,174 @@ test("reset", async ({ browser }) => {
   expect(secondTrack.body.anonymousId).not.toEqual("john-doe-id-1");
 });
 
+const generateEventsForConsentTests = async () => {
+  const analytics = window["jitsu"] as AnalyticsInterface;
+  await analytics.identify("myUserId", { email: "myUserId@example.com" });
+  await analytics.group("myGroupId", { name: "myGroupId" });
+  await analytics.page("myPage");
+};
+
+test("ip-policy", async ({ browser }) => {
+  clearRequestLog();
+  const browserContext = await browser.newContext();
+  const { page, uncaughtErrors } = await createLoggingPage(browserContext);
+  const [pageResult] = await Promise.all([page.goto(`${server.baseUrl}/ip-policy.html`)]);
+  await page.waitForFunction(() => window["jitsu"] !== undefined, undefined, {
+    timeout: 1000,
+    polling: 100,
+  });
+  expect(pageResult?.status()).toBe(200);
+  //wait for some time since the server has an artificial latency of 30ms
+  await new Promise(resolve => setTimeout(resolve, 1000));
+  expect(uncaughtErrors.length).toEqual(0);
+  expect(requestLog.length).toBe(1);
+  const p = requestLog[0];
+  expect(p.headers?.["x-ip-policy"]).toEqual("stripLastOctet");
+});
+
+test("dont-send", async ({ browser }) => {
+  clearRequestLog();
+  const browserContext = await browser.newContext();
+  const { page, uncaughtErrors } = await createLoggingPage(browserContext);
+  const [pageResult] = await Promise.all([page.goto(`${server.baseUrl}/dont-send.html`)]);
+  await page.waitForFunction(() => window["jitsu"] !== undefined, undefined, {
+    timeout: 1000,
+    polling: 100,
+  });
+  expect(pageResult?.status()).toBe(200);
+  //wait for some time since the server has an artificial latency of 30ms
+  await new Promise(resolve => setTimeout(resolve, 1000));
+  expect(uncaughtErrors.length).toEqual(0);
+  expect(requestLog.length).toBe(0);
+  await page.evaluate(generateEventsForConsentTests);
+
+  const cookies = await browserContext.cookies();
+
+  expect(uncaughtErrors.length).toEqual(0);
+  expect(requestLog.length).toBe(0);
+  expect(cookies.length).toBe(0);
+});
+
+test("dont-send-then-consent", async ({ browser }) => {
+  clearRequestLog();
+  const browserContext = await browser.newContext();
+  const { page, uncaughtErrors } = await createLoggingPage(browserContext);
+  const [pageResult] = await Promise.all([page.goto(`${server.baseUrl}/dont-send.html`)]);
+  await page.waitForFunction(() => window["jitsu"] !== undefined, undefined, {
+    timeout: 1000,
+    polling: 100,
+  });
+  expect(pageResult?.status()).toBe(200);
+  //wait for some time since the server has an artificial latency of 30ms
+  await new Promise(resolve => setTimeout(resolve, 1000));
+  expect(uncaughtErrors.length).toEqual(0);
+  expect(requestLog.length).toBe(0);
+
+  await page.evaluate(async () => {
+    const analytics = window["jitsu"] as AnalyticsInterface;
+    analytics.configure({
+      privacy: {
+        dontSend: false,
+        consentCategories: {
+          analytics: true,
+        },
+      },
+    });
+  });
+  await page.evaluate(generateEventsForConsentTests);
+  await new Promise(resolve => setTimeout(resolve, 1000));
+
+  const cookies = await browserContext.cookies();
+  expect(uncaughtErrors.length).toEqual(0);
+  expect(requestLog.length).toBe(3);
+  expect(cookies.length).toBe(5);
+  const p = requestLog[2];
+  expect(p.type).toEqual("page");
+  expect(p.body.userId).toEqual("myUserId");
+  expect(p.body.groupId).toEqual("myGroupId");
+  expect(p.body.context?.traits?.email).toEqual("myUserId@example.com");
+  expect(p.body.context?.consent?.categoryPreferences).toEqual({ analytics: true });
+  expect((p.body.anonymousId ?? "").length).toBeGreaterThan(0);
+});
+
+test("disable-user-ids", async ({ browser }) => {
+  clearRequestLog();
+  const browserContext = await browser.newContext();
+  const { page, uncaughtErrors } = await createLoggingPage(browserContext);
+  const [pageResult] = await Promise.all([page.goto(`${server.baseUrl}/disable-user-ids.html`)]);
+  await page.waitForFunction(() => window["jitsu"] !== undefined, undefined, {
+    timeout: 1000,
+    polling: 100,
+  });
+  expect(pageResult?.status()).toBe(200);
+  //wait for some time since the server has an artificial latency of 30ms
+  await new Promise(resolve => setTimeout(resolve, 1000));
+  expect(uncaughtErrors.length).toEqual(0);
+
+  expect(requestLog.length).toBe(0);
+  await page.evaluate(generateEventsForConsentTests);
+
+  const cookies = await browserContext.cookies();
+
+  expect(uncaughtErrors.length).toEqual(0);
+  expect(cookies.length).toBe(0);
+  expect(requestLog.length).toBe(1);
+  const p = requestLog[0];
+  expect(p.type).toEqual("page");
+  expect(p.body.userId).toBeUndefined();
+  expect(p.body.groupId).toBeUndefined();
+  expect(p.body.context?.traits?.email).toBeUndefined();
+  expect(p.body.anonymousId).toBeUndefined();
+  expect(p.body.properties?.path).toBe("/disable-user-ids.html");
+});
+
+test("disable-user-ids-then-consent", async ({ browser }) => {
+  clearRequestLog();
+  const browserContext = await browser.newContext();
+  const { page, uncaughtErrors } = await createLoggingPage(browserContext);
+  const [pageResult] = await Promise.all([page.goto(`${server.baseUrl}/disable-user-ids.html`)]);
+  await page.waitForFunction(() => window["jitsu"] !== undefined, undefined, {
+    timeout: 1000,
+    polling: 100,
+  });
+  expect(pageResult?.status()).toBe(200);
+  //wait for some time since the server has an artificial latency of 30ms
+  await new Promise(resolve => setTimeout(resolve, 1000));
+  expect(uncaughtErrors.length).toEqual(0);
+  expect(requestLog.length).toBe(0);
+  await page.evaluate(generateEventsForConsentTests);
+  let cookies = await browserContext.cookies();
+  expect(uncaughtErrors.length).toEqual(0);
+  expect(cookies.length).toBe(0);
+  expect(requestLog.length).toBe(1);
+
+  await page.evaluate(async () => {
+    const analytics = window["jitsu"] as AnalyticsInterface;
+    analytics.configure({
+      privacy: {
+        disableUserIds: false,
+        consentCategories: {
+          analytics: true,
+        },
+      },
+    });
+  });
+  await page.evaluate(generateEventsForConsentTests);
+  await new Promise(resolve => setTimeout(resolve, 1000));
+
+  cookies = await browserContext.cookies();
+  expect(uncaughtErrors.length).toEqual(0);
+  expect(requestLog.length).toBe(4);
+  expect(cookies.length).toBe(5);
+  const p = requestLog[3];
+  expect(p.type).toEqual("page");
+  expect(p.body.userId).toEqual("myUserId");
+  expect(p.body.groupId).toEqual("myGroupId");
+  expect(p.body.context?.traits?.email).toEqual("myUserId@example.com");
+  expect(p.body.context?.consent?.categoryPreferences).toEqual({ analytics: true });
+  expect((p.body.anonymousId ?? "").length).toBeGreaterThan(0);
+});
+
 test("basic", async ({ browser }) => {
   clearRequestLog();
   const browserContext = await browser.newContext();

package/dist/analytics-plugin.d.ts

@@ -1,4 +1,4 @@
-import { JitsuOptions, PersistentStorage, RuntimeFacade } from "./jitsu";
+import { JitsuOptions, PersistentStorage, RuntimeFacade } from "@jitsu/protocols/analytics";
 import { AnalyticsPlugin } from "analytics";
 export declare const parseQuery: (qs?: string) => Record<string, string>;
 export type StorageFactory = (cookieDomain: string, cookie2key: Record<string, string>) => PersistentStorage;
@@ -23,8 +23,6 @@ export type InternalPluginDescriptor = {
     name: string;
 };
 export type DeviceOptions = AnalyticsPluginDescriptor | InternalPluginDescriptor;
-export type JitsuPluginConfig = JitsuOptions & {
-    storageWrapper?: (persistentStorage: PersistentStorage) => PersistentStorage;
-};
-export declare const jitsuAnalyticsPlugin: (pluginConfig?: JitsuPluginConfig) => AnalyticsPlugin;
+export declare const jitsuAnalyticsPlugin: (jitsuOptions: JitsuOptions, storage: PersistentStorage) => AnalyticsPlugin;
 export declare function randomId(hashString?: string | undefined): string;
+export declare function uuid(): string;

package/dist/browser.d.ts

@@ -1,8 +1,10 @@
-import type { JitsuOptions } from "./jitsu";
+import type { JitsuOptions } from "@jitsu/protocols/analytics";
 export type JitsuBrowserOptions = {
     namespace?: string;
-    userId?: string;
     onload?: string;
     initOnly?: boolean;
 } & JitsuOptions;
-export type Parser = (arg: string) => any;
+export type Parser = {
+    path?: (name: string) => string[];
+    parse: (arg: string) => any;
+};

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-import { AnalyticsInterface, JitsuOptions } from "./jitsu";
+import { Callback, DispatchedEvent, ID, JSONObject, Options, AnalyticsInterface, JitsuOptions, PersistentStorage, RuntimeFacade, DynamicJitsuOptions } from "@jitsu/protocols/analytics";
 export default function parse(input: any): any;
 export declare const emptyAnalytics: AnalyticsInterface;
 export declare function jitsuAnalytics(_opts: JitsuOptions): AnalyticsInterface;
-export * from "./jitsu";
+export { Callback, DispatchedEvent, ID, JSONObject, Options, AnalyticsInterface, JitsuOptions, PersistentStorage, RuntimeFacade, DynamicJitsuOptions, };
 export * from "./analytics-plugin";