@jitsu/js 0.0.0

package/.pnpm-debug.log

@@ -0,0 +1,23 @@
+{
+  "0 debug pnpm:scope": {
+    "selected": 1,
+    "workspacePrefix": "/Users/ildarnurislamov/Projects/onetag"
+  },
+  "1 error pnpm": {
+    "code": "ELIFECYCLE",
+    "errno": "ENOENT",
+    "syscall": "spawn",
+    "file": "sh",
+    "pkgid": "@jitsu/js@0.0.0",
+    "stage": "build",
+    "script": "tsc -p . && rollup -c && cp src/jitsu.d.ts dist",
+    "pkgname": "@jitsu/js",
+    "err": {
+      "name": "pnpm",
+      "message": "@jitsu/js@0.0.0 build: `tsc -p . && rollup -c && cp src/jitsu.d.ts dist`\nspawn ENOENT",
+      "code": "ELIFECYCLE",
+      "stack": "pnpm: @jitsu/js@0.0.0 build: `tsc -p . && rollup -c && cp src/jitsu.d.ts dist`\nspawn ENOENT\n    at ChildProcess.<anonymous> (/opt/homebrew/lib/node_modules/pnpm/dist/pnpm.cjs:93535:22)\n    at ChildProcess.emit (node:events:527:28)\n    at maybeClose (node:internal/child_process:1092:16)\n    at Process.ChildProcess._handle.onexit (node:internal/child_process:302:5)"
+    }
+  },
+  "2 warn pnpm:global": " Local package.json exists, but node_modules missing, did you mean to install?"
+}

package/.turbo/turbo-build.log

@@ -0,0 +1,15 @@
+@jitsu/js:build: cache hit, replaying output fd9a15b75ea61c02
+@jitsu/js:build: 
+@jitsu/js:build: > @jitsu/js@0.0.1 build /Users/ildarnurislamov/Projects/onetag/libs/jitsu-js
+@jitsu/js:build: > tsc -p . && rollup -c && cp src/jitsu.d.ts dist
+@jitsu/js:build: 
+@jitsu/js:build: 
+@jitsu/js:build: ./compiled/src/browser.js → dist/web/p.js.txt...
+@jitsu/js:build: (!) Circular dependency
+@jitsu/js:build: compiled/src/index.js -> compiled/src/analytics-plugin.js -> compiled/src/index.js
+@jitsu/js:build: created dist/web/p.js.txt in 552ms
+@jitsu/js:build: 
+@jitsu/js:build: ./compiled/src/index.js → dist/jitsu.es.js, dist/jitsu.cjs.js...
+@jitsu/js:build: (!) Circular dependency
+@jitsu/js:build: compiled/src/index.js -> compiled/src/analytics-plugin.js -> compiled/src/index.js
+@jitsu/js:build: created dist/jitsu.es.js, dist/jitsu.cjs.js in 308ms

package/.turbo/turbo-clean.log

@@ -0,0 +1,5 @@
+@jitsu/js:clean: cache hit, replaying output 6cc5edb43189bde9
+@jitsu/js:clean: 
+@jitsu/js:clean: > @jitsu/js@0.0.1 clean /Users/ildarnurislamov/Projects/onetag/libs/jitsu-js
+@jitsu/js:clean: > rm -rf ./dist
+@jitsu/js:clean: 

package/__tests__/node/nodejs.test.ts

@@ -0,0 +1,84 @@
+import fs from "fs";
+import path from "path";
+import { createServer, SimpleSyrup } from "../simple-syrup";
+import process from "process";
+import { AnalyticsClientEvent, AnalyticsInterface } from "@jitsu/types/analytics";
+
+const jitsuAnalytics = require("../../dist/jitsu.cjs.js").jitsuAnalytics;
+const fetchImpl = require("node-fetch-commonjs");
+
+describe("Test Jitsu NodeJS client", () => {
+  let server: SimpleSyrup;
+
+  let requestLog: { type: string; body: AnalyticsClientEvent }[] = [];
+
+  const startServer = async () => {
+    server = await createServer({
+      port: 3088,
+      https: false,
+      handlers: {
+        "/s/:type": (req, res) => {
+          res.setHeader("Content-Type", "text/javascript");
+          res.send({ ok: true });
+          requestLog.push({
+            type: req.params.type,
+            body: req.body,
+          });
+        },
+      },
+    });
+    console.log("Running on " + server.baseUrl);
+  };
+  const shutdownServer = async () => {
+    console.log("Shutting down server " + server.baseUrl);
+    await server.close();
+  };
+
+  test("node js", async () => {
+    await startServer();
+    try {
+      const jitsu: AnalyticsInterface = jitsuAnalytics({
+        writeKey: "test",
+        host: server.baseUrl,
+        debug: true,
+        fetch: fetchImpl,
+      });
+      await jitsu.track("testTrack");
+
+      await jitsu.identify("testUser", {
+        email: "test@test.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(3);
+      expect(requestLog[0].type).toBe("track");
+      expect(requestLog[1].type).toBe("identify");
+      expect(requestLog[2].type).toBe("page");
+
+      const track = requestLog[0].body as AnalyticsClientEvent;
+      const identify = requestLog[1].body as AnalyticsClientEvent;
+      const page = requestLog[2].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);
+      const pagePayload = requestLog[0].body;
+      console.log("pagePayload", pagePayload);
+    } finally {
+      await shutdownServer();
+    }
+  });
+});

package/__tests__/playwright/cases/basic.html

@@ -0,0 +1,27 @@
+<!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>
+      window.testOnload = async j => {
+        j.identify("user1", { email: "john.doe@gmail.com" });
+        j.track("pageLoaded", { trackParam: "trackValue" });
+      };
+    </script>
+    <script
+      type="text/javascript"
+      src="<%=trackingBase%>/p.js"
+      data-onload="testOnload"
+      data-debug="true"
+      defer
+    ></script>
+  </head>
+
+  <body>
+    <h1>Test</h1>
+  </body>
+</html>

package/__tests__/playwright/cases/segment-reference.html

@@ -0,0 +1,64 @@
+<html>
+  <head>
+    <script type="text/javascript">
+      !(function () {
+        var analytics = (window.analytics = window.analytics || []);
+        if (!analytics.initialize)
+          if (analytics.invoked) window.console && console.error && console.error("Segment snippet included twice.");
+          else {
+            analytics.invoked = !0;
+            analytics.methods = [
+              "trackSubmit",
+              "trackClick",
+              "trackLink",
+              "trackForm",
+              "pageview",
+              "identify",
+              "reset",
+              "group",
+              "track",
+              "ready",
+              "alias",
+              "debug",
+              "page",
+              "once",
+              "off",
+              "on",
+              "addSourceMiddleware",
+              "addIntegrationMiddleware",
+              "setAnonymousId",
+              "addDestinationMiddleware",
+            ];
+            analytics.factory = function (e) {
+              return function () {
+                var t = Array.prototype.slice.call(arguments);
+                t.unshift(e);
+                analytics.push(t);
+                return analytics;
+              };
+            };
+            for (var e = 0; e < analytics.methods.length; e++) {
+              var key = analytics.methods[e];
+              analytics[key] = analytics.factory(key);
+            }
+            analytics.load = function (key, e) {
+              var t = document.createElement("script");
+              t.type = "text/javascript";
+              t.async = !0;
+              t.src = "https://cdn.segment.com/analytics.js/v1/" + key + "/analytics.min.js";
+              var n = document.getElementsByTagName("script")[0];
+              n.parentNode.insertBefore(t, n);
+              analytics._loadOptions = e;
+            };
+            analytics._writeKey = "<%= process.env.SEGMENT_WRITE_KEY%>";
+            analytics.SNIPPET_VERSION = "4.15.3";
+            analytics.load("<%= process.env.SEGMENT_WRITE_KEY%>");
+
+            analytics.ready(() => {
+              window.__analyticsReady = true;
+            });
+          }
+      })();
+    </script>
+  </head>
+</html>

package/__tests__/playwright/integration.test.ts

@@ -0,0 +1,262 @@
+import { BrowserContext, expect, Page, test } from "@playwright/test";
+import { createServer, SimpleSyrup } from "../simple-syrup";
+import * as fs from "fs";
+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/types/analytics.d";
+import type { AnalyticsCore } from "@segment/analytics-next/src/core/analytics/interfaces";
+import { response } from "express";
+
+test.use({
+  ignoreHTTPSErrors: true,
+});
+
+const express = require("express");
+const cookieParser = require("cookie-parser");
+const app = express();
+//const forge = require("node-forge");
+
+let server: SimpleSyrup;
+
+let requestLog: { type: string; body: AnalyticsClientEvent }[] = [];
+
+test.beforeAll(async () => {
+  const testCasesHandlers = fs.readdirSync(path.join(__dirname, "cases")).reduce((res, file) => {
+    console.log("Processing file", file);
+    return {
+      ...res,
+      [`/${file}`]: (req, res) => {
+        res.setHeader("Content-Type", "text/html");
+        res.send(
+          ejs.compile(
+            fs.readFileSync(path.join(__dirname, "cases", file)).toString(),
+            {}
+          )({
+            trackingBase: server.baseUrl,
+          })
+        );
+      },
+    };
+  }, {});
+  server = await createServer({
+    port: 3088,
+    https: process.env.DISABLE_HTTPS !== "1" && process.env.DISABLE_HTTPS !== "true",
+    handlers: {
+      "/p.js": (req, res) => {
+        res.setHeader("Content-Type", "text/javascript");
+        res.send(fs.readFileSync(path.join(__dirname, "../../dist/web/p.js.txt")).toString());
+      },
+      "/s/:type": (req, res) => {
+        res.setHeader("Content-Type", "text/javascript");
+        res.send({ ok: true });
+        requestLog.push({
+          type: req.params.type,
+          body: req.body,
+        });
+      },
+      ...testCasesHandlers,
+    },
+  });
+  console.log("Running on " + server.baseUrl);
+});
+
+test.afterAll(async () => {
+  await server?.close();
+});
+
+function sortKeysRecursively(obj: any): any {
+  if (typeof obj === "object" && obj !== null && !Array.isArray(obj)) {
+    return Object.keys(obj)
+      .sort()
+      .reduce((res, key) => {
+        res[key] = sortKeysRecursively(obj[key]);
+        return res;
+      }, {});
+  }
+  return obj;
+}
+
+function logColor(type: string) {
+  return (
+    {
+      error: chalk.bgRed,
+      warn: chalk.bgYellow,
+      info: chalk.bgBlack,
+      log: chalk.bgGray,
+    }[type] || (x => x)
+  );
+}
+
+function shouldKeepBrowserOpen() {
+  return process.env.KEEP_BROWSER_OPEN === "true" || process.env.KEEP_BROWSER_OPEN === "1";
+}
+
+async function createLoggingPage(browserContext: BrowserContext): Promise<{ page: Page; uncaughtErrors: Error[] }> {
+  const page = await browserContext.newPage();
+  const errors: Error[] = [];
+
+  page.on("pageerror", error => {
+    errors.push(error);
+    const border = chalk.cyan("│");
+    console.log();
+    console.log(`${border} ${chalk.cyan(`Browser Console UNCAUGHT ERROR:`)}`);
+    console.log(`${border} ` + error.stack.split("\n").join(`\n${border} `));
+  });
+
+  page.on("console", msg => {
+    const border = chalk.cyan("│");
+    console.log();
+    console.log(`${border} ${chalk.cyan(`Browser Console ${msg.type().toUpperCase()}`)}`);
+    console.log(`${border} ` + msg.text().split("\n").join(`\n${border} `));
+  });
+  return { page, uncaughtErrors: errors };
+}
+
+const generateTestEvents = async () => {
+  const implName = `${window["analytics"] ? "segment" : "jitsu"}`;
+  const analytics = (window["analytics"] || window["jitsu"]) as AnalyticsInterface;
+  console.log(`Generating test events. Implementation ${implName}: ${Object.keys(analytics)}`);
+  await analytics.identify("userId2", { email: "john.doe2@gmail.com", caseName: "basic-identify" });
+  // jitsu must extract traits even from 'id' object
+  await analytics.identify({ email: "john.doe3@gmail.com", caseName: "identify-without-user-id" });
+  await analytics.page({ caseName: "page-without-name", context: { page: { title: "Synthetic Title" } } });
+  await analytics.page("test-page", { caseName: "page-with-name" });
+  await analytics.track("testEvent", { caseName: "track-with-name" });
+  console.log(`Test events for ${implName} has been generated`);
+};
+
+/**
+ * This test isn't really testing anything. It generates reference segment events
+ */
+test("segment-reference", async ({ browser }) => {
+  if (!process.env.SEGMENT_WRITE_KEY) {
+    console.log("Skipping segment reference generation, no SEGMENT_WRITE_KEY provided");
+    return;
+  }
+  // Using the browser fixture, you can get access to the BrowserContext
+  const browserContext = await browser.newContext();
+  const { page } = await createLoggingPage(browserContext);
+  const requests: Record<string, { payload: any }[]> = {};
+  page.on("response", async response => {
+    const request = response.request();
+    const apiPrefix = "https://api.segment.io/v1/";
+    if (request.url().startsWith(apiPrefix) && request.method() === "POST") {
+      const type = request.url().substring(apiPrefix.length);
+      requests[type] = requests[type] || [];
+      requests[type].push({
+        payload: await request.postDataJSON(),
+      });
+    }
+    console.log(`Request ${request.method()} ${request.url()} → ${response.status()}`);
+  });
+
+  await page.goto(`${server.baseUrl}/segment-reference.html?utm_source=source&utm_medium=medium&utm_campaign=campaign`);
+
+  await page.waitForFunction(() => window["__analyticsReady"] === true, undefined, {
+    timeout: 5000,
+    polling: 100,
+  });
+  console.log("Segment has been page loaded. Sending events");
+  await page.evaluate(generateTestEvents);
+  const cookies = (await browserContext.cookies()).reduce(
+    (res, cookie) => ({
+      ...res,
+      [cookie.name]: cookie.value,
+    }),
+    {}
+  );
+  console.log("🍪 Segment Cookies", cookies);
+
+  for (const type of Object.keys(requests)) {
+    for (const { payload } of requests[type]) {
+      const dir = path.join(__dirname, "artifacts", "segment-reference");
+      fs.mkdirSync(dir, { recursive: true });
+      const file = path.join(
+        dir,
+        `${payload.traits?.caseName || payload.properties?.caseName || payload.context?.caseName}.json`
+      );
+      fs.writeFileSync(file, JSON.stringify(sortKeysRecursively(payload), null, 2));
+    }
+  }
+});
+
+test("basic", async ({ browser }) => {
+  const browserContext = await browser.newContext();
+
+  const { page: firstPage, uncaughtErrors: fistPageErrors } = await createLoggingPage(browserContext);
+  const [pageResult] = await Promise.all([
+    firstPage.goto(`${server.baseUrl}/basic.html?utm_source=source&utm_medium=medium&utm_campaign=campaign`),
+  ]);
+
+  await firstPage.waitForFunction(() => window["jitsu"] !== undefined, undefined, {
+    timeout: 1000,
+    polling: 100,
+  });
+  expect(pageResult.status()).toBe(200);
+  const cookies = (await browserContext.cookies()).reduce(
+    (res, cookie) => ({
+      ...res,
+      [cookie.name]: cookie.value,
+    }),
+    {}
+  );
+  console.log("🍪 Jitsu Cookies", cookies);
+  expect(fistPageErrors.length).toEqual(0);
+  const anonymousId = cookies["__eventn_id"];
+  expect(anonymousId).toBeDefined();
+  expect(cookies["__eventn_uid"]).toBe("user1");
+  expect(cookies["__eventn_id_usr"]).toBeDefined();
+  expect(JSON.parse(cookies["__eventn_id_usr"]).email).toEqual("john.doe@gmail.com");
+  let identifies = requestLog.filter(x => x.type === "identify");
+  let pages = requestLog.filter(x => x.type === "page");
+  let tracks = requestLog.filter(x => x.type === "track");
+  expect(identifies.length).toBe(1);
+  expect(pages.length).toBe(1);
+  expect(tracks.length).toBe(1);
+
+  const track = tracks[0].body as AnalyticsClientEvent;
+  const page = pages[0].body as AnalyticsClientEvent;
+  const identify = identifies[0].body as AnalyticsClientEvent;
+
+  console.log(chalk.bold("📝 Checking track event"), JSON.stringify(track, null, 3));
+  expect(track.properties.trackParam).toEqual("trackValue");
+  expect(track.type).toEqual("track");
+  expect(track.context.traits.email).toEqual("john.doe@gmail.com");
+  expect(track.userId).toEqual("user1");
+  expect(track.event).toEqual("pageLoaded");
+
+  console.log(chalk.bold("📝 Checking identify event"), JSON.stringify(identify, null, 3));
+  expect(identify.traits.email).toEqual("john.doe@gmail.com");
+  expect(identify.userId).toEqual("user1");
+  expect(identify.anonymousId).toEqual(anonymousId);
+
+  console.log(chalk.bold("📝 Checking page event"), JSON.stringify(page, null, 3));
+  expect(page.anonymousId).toEqual(anonymousId);
+  expect(page.context.traits.email).toEqual("john.doe@gmail.com");
+  expect(page.userId).toEqual("user1");
+
+  expect(page.context.campaign.source).toEqual("source");
+
+  const { page: secondPage, uncaughtErrors: secondPageErrors } = await createLoggingPage(browserContext);
+  await secondPage.goto(`${server.baseUrl}/basic.html?utm_source=source&utm_medium=medium&utm_campaign=campaign`);
+  await secondPage.waitForFunction(() => window["jitsu"] !== undefined, undefined, {
+    timeout: 1000,
+    polling: 100,
+  });
+  requestLog.length = 0;
+
+  await secondPage.evaluate(generateTestEvents);
+  expect(secondPageErrors.length).toBe(0);
+  requestLog.forEach(({ body: payload }) => {
+    const dir = path.join(__dirname, "artifacts", "requests");
+    fs.mkdirSync(dir, { recursive: true });
+    const file = path.join(
+      dir,
+      `${payload.traits?.caseName || payload.properties?.caseName || payload.context?.caseName}.json`
+    );
+    fs.writeFileSync(file, JSON.stringify(sortKeysRecursively(payload), null, 2));
+  });
+});

package/__tests__/simple-syrup.ts

@@ -0,0 +1,130 @@
+import type { Application, RequestHandler } from "express";
+import http from "http";
+import https from "https";
+
+const express = require("express");
+
+const forge = require("node-forge");
+
+export type SimpleSyrupOpts = {
+  port?: number;
+  https?: boolean;
+  handlers?: Record<string, RequestHandler>;
+};
+
+export type SimpleSyrup = {
+  app: Application;
+  server: http.Server;
+  port: number;
+  baseUrl: string;
+  close: () => Promise<void>;
+};
+
+function getNextAvailablePort(port: number) {
+  return new Promise<number>(resolve => {
+    const server = http.createServer();
+    server.on("error", () => {
+      resolve(getNextAvailablePort(port + 1));
+    });
+    server.on("listening", () => {
+      server.close(() => {
+        resolve(port);
+      });
+    });
+    server.listen(port);
+  });
+}
+
+function generateX509Certificate(altNames: { type: number; value: string }[]) {
+  const issuer = [
+    { name: "commonName", value: "localhost" },
+    { name: "organizationName", value: "ACME Corp" },
+    { name: "organizationalUnitName", value: "XYZ Department" },
+  ];
+  const certificateExtensions = [
+    { name: "basicConstraints", cA: true },
+    {
+      name: "keyUsage",
+      keyCertSign: true,
+      digitalSignature: true,
+      nonRepudiation: true,
+      keyEncipherment: true,
+      dataEncipherment: true,
+    },
+    {
+      name: "extKeyUsage",
+      serverAuth: true,
+      clientAuth: true,
+      codeSigning: true,
+      emailProtection: true,
+      timeStamping: true,
+    },
+    {
+      name: "nsCertType",
+      client: true,
+      server: true,
+      email: true,
+      objsign: true,
+      sslCA: true,
+      emailCA: true,
+      objCA: true,
+    },
+    { name: "subjectAltName", altNames },
+    { name: "subjectKeyIdentifier" },
+  ];
+  const keys = forge.pki.rsa.generateKeyPair(2048);
+  const cert = forge.pki.createCertificate();
+  cert.validity.notBefore = new Date();
+  cert.validity.notAfter = new Date();
+  cert.validity.notAfter.setFullYear(cert.validity.notBefore.getFullYear() + 1);
+  cert.publicKey = keys.publicKey;
+  cert.setSubject(issuer);
+  cert.setIssuer(issuer);
+  cert.setExtensions(certificateExtensions);
+  cert.sign(keys.privateKey);
+  return {
+    key: forge.pki.privateKeyToPem(keys.privateKey),
+    cert: forge.pki.certificateToPem(cert),
+  };
+}
+
+function shutdownFunction(server): Promise<void> {
+  return new Promise<void>(resolve => {
+    server.close(() => {
+      resolve();
+    });
+  });
+}
+
+export function createServer(opts: SimpleSyrupOpts = {}): Promise<SimpleSyrup> {
+  return new Promise<SimpleSyrup>(async (resolve, reject) => {
+    const app: Application = express();
+    app.use(express.json());
+    const server = opts?.https ? https.createServer(generateX509Certificate([]), app) : http.createServer(app);
+    const port = opts?.port ? await getNextAvailablePort(opts.port) : 0;
+    server.listen(port, () => {
+      const address = server.address();
+      if (!address) {
+        reject(new Error(`Unable to get server address`));
+        return;
+      }
+      if (typeof address === "string") {
+        reject(new Error(`Address is not an of network. This is not supported: ${address} `));
+        return;
+      }
+      const port = address.port;
+      if (opts?.handlers) {
+        for (const [path, handler] of Object.entries(opts?.handlers)) {
+          app.all(path, handler);
+        }
+      }
+      resolve({
+        app: app,
+        port,
+        close: () => shutdownFunction(server),
+        baseUrl: `${opts.https ? "https" : "http"}://localhost:${port}`,
+        server: server,
+      });
+    });
+  });
+}