@jitsu/js 1.9.18-canary.1269.20250403142744 → 1.9.18-canary.1288.20250415191203

package/__tests__/simple-syrup.ts

@@ -0,0 +1,136 @@
+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 => {
+    let resolved = false;
+    const resolveIfNeeded = () => {
+      if (!resolved) {
+        resolved = true;
+        resolve();
+      }
+    };
+    setTimeout(resolveIfNeeded, 5000);
+    server.close(resolveIfNeeded);
+  });
+}
+
+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,
+      });
+    });
+  });
+}

package/dist/jitsu.cjs.js

@@ -1462,7 +1462,6 @@ function adjustPayload(payload, config, storage, s2s) {
         userAgent: runtime.userAgent(),
         locale: runtime.language(),
         screen: runtime.screen(),
-        ip: runtime.ip ? runtime.ip() : undefined,
         traits: payload.type != "identify" && payload.type != "group" ? Object.assign({}, (restoreTraits(storage) || {})) : undefined,
         page: {
             path: properties.path || (parsedUrl && parsedUrl.pathname),
@@ -1609,22 +1608,19 @@ function getErrorHandler(opts) {
 function send(method, payload, jitsuConfig, instance, store) {
     return __awaiter$1(this, void 0, void 0, function* () {
         var _a, _b;
+        const s2s = !!jitsuConfig.s2s;
+        const debugHeader = jitsuConfig.debug ? { "X-Enable-Debug": "true" } : {};
+        const adjustedPayload = adjustPayload(payload, jitsuConfig, store);
         if (jitsuConfig.echoEvents) {
-            console.log(`[JITSU DEBUG] sending '${method}' event:`, payload);
+            console.log(`[JITSU DEBUG] sending '${method}' event:`, adjustedPayload);
             return;
         }
-        const s2s = !!jitsuConfig.s2s;
         const url = s2s ? `${jitsuConfig.host}/api/s/s2s/${method}` : `${jitsuConfig.host}/api/s/${method}`;
         const fetch = jitsuConfig.fetch || globalThis.fetch;
         if (!fetch) {
             //don't run it through error handler since error is critical and should be addressed
             throw new Error("Please specify fetch function in jitsu plugin initialization, fetch isn't available in global scope");
         }
-        const debugHeader = jitsuConfig.debug ? { "X-Enable-Debug": "true" } : {};
-        // if (jitsuConfig.debug) {
-        //   console.log(`[JITSU] Sending event to ${url}: `, JSON.stringify(payload, null, 2));
-        // }
-        const adjustedPayload = adjustPayload(payload, jitsuConfig, store);
         const abortController = jitsuConfig.fetchTimeoutMs ? new AbortController() : undefined;
         const abortTimeout = jitsuConfig.fetchTimeoutMs
             ? setTimeout(() => {

package/dist/jitsu.es.js

@@ -1460,7 +1460,6 @@ function adjustPayload(payload, config, storage, s2s) {
         userAgent: runtime.userAgent(),
         locale: runtime.language(),
         screen: runtime.screen(),
-        ip: runtime.ip ? runtime.ip() : undefined,
         traits: payload.type != "identify" && payload.type != "group" ? Object.assign({}, (restoreTraits(storage) || {})) : undefined,
         page: {
             path: properties.path || (parsedUrl && parsedUrl.pathname),
@@ -1607,22 +1606,19 @@ function getErrorHandler(opts) {
 function send(method, payload, jitsuConfig, instance, store) {
     return __awaiter$1(this, void 0, void 0, function* () {
         var _a, _b;
+        const s2s = !!jitsuConfig.s2s;
+        const debugHeader = jitsuConfig.debug ? { "X-Enable-Debug": "true" } : {};
+        const adjustedPayload = adjustPayload(payload, jitsuConfig, store);
         if (jitsuConfig.echoEvents) {
-            console.log(`[JITSU DEBUG] sending '${method}' event:`, payload);
+            console.log(`[JITSU DEBUG] sending '${method}' event:`, adjustedPayload);
             return;
         }
-        const s2s = !!jitsuConfig.s2s;
         const url = s2s ? `${jitsuConfig.host}/api/s/s2s/${method}` : `${jitsuConfig.host}/api/s/${method}`;
         const fetch = jitsuConfig.fetch || globalThis.fetch;
         if (!fetch) {
             //don't run it through error handler since error is critical and should be addressed
             throw new Error("Please specify fetch function in jitsu plugin initialization, fetch isn't available in global scope");
         }
-        const debugHeader = jitsuConfig.debug ? { "X-Enable-Debug": "true" } : {};
-        // if (jitsuConfig.debug) {
-        //   console.log(`[JITSU] Sending event to ${url}: `, JSON.stringify(payload, null, 2));
-        // }
-        const adjustedPayload = adjustPayload(payload, jitsuConfig, store);
         const abortController = jitsuConfig.fetchTimeoutMs ? new AbortController() : undefined;
         const abortTimeout = jitsuConfig.fetchTimeoutMs
             ? setTimeout(() => {

package/dist/web/p.js.txt

@@ -1463,7 +1463,6 @@
           userAgent: runtime.userAgent(),
           locale: runtime.language(),
           screen: runtime.screen(),
-          ip: runtime.ip ? runtime.ip() : undefined,
           traits: payload.type != "identify" && payload.type != "group" ? Object.assign({}, (restoreTraits(storage) || {})) : undefined,
           page: {
               path: properties.path || (parsedUrl && parsedUrl.pathname),
@@ -1610,22 +1609,19 @@
   function send(method, payload, jitsuConfig, instance, store) {
       return __awaiter$1(this, void 0, void 0, function* () {
           var _a, _b;
+          const s2s = !!jitsuConfig.s2s;
+          const debugHeader = jitsuConfig.debug ? { "X-Enable-Debug": "true" } : {};
+          const adjustedPayload = adjustPayload(payload, jitsuConfig, store);
           if (jitsuConfig.echoEvents) {
-              console.log(`[JITSU DEBUG] sending '${method}' event:`, payload);
+              console.log(`[JITSU DEBUG] sending '${method}' event:`, adjustedPayload);
               return;
           }
-          const s2s = !!jitsuConfig.s2s;
           const url = s2s ? `${jitsuConfig.host}/api/s/s2s/${method}` : `${jitsuConfig.host}/api/s/${method}`;
           const fetch = jitsuConfig.fetch || globalThis.fetch;
           if (!fetch) {
               //don't run it through error handler since error is critical and should be addressed
               throw new Error("Please specify fetch function in jitsu plugin initialization, fetch isn't available in global scope");
           }
-          const debugHeader = jitsuConfig.debug ? { "X-Enable-Debug": "true" } : {};
-          // if (jitsuConfig.debug) {
-          //   console.log(`[JITSU] Sending event to ${url}: `, JSON.stringify(payload, null, 2));
-          // }
-          const adjustedPayload = adjustPayload(payload, jitsuConfig, store);
           const abortController = jitsuConfig.fetchTimeoutMs ? new AbortController() : undefined;
           const abortTimeout = jitsuConfig.fetchTimeoutMs
               ? setTimeout(() => {

package/jest.config.js

@@ -0,0 +1,13 @@
+/** @type {import("ts-jest").JestConfigWithTsJest} */
+module.exports = {
+  //preset: "ts-jest",
+  preset: "ts-jest",
+  testEnvironment: "node",
+  runner: "jest-runner",
+  rootDir: "./__tests__/node/",
+  globals: {
+    'ts-jest': {
+      tsConfig: 'tsconfig.test.json'
+    }
+  }
+};

package/package/README.md

@@ -0,0 +1,9 @@
+## Install
+
+```bash
+npm install --save @jitsu/jitsu-js
+```
+
+## Usage
+
+**Please read a documentation on [Jitsu Docs](https://docs.jitsu.com/sending-data/npm)**

package/package/dist/analytics-plugin.d.ts

@@ -0,0 +1,28 @@
+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, key2Cookie: (key: string) => string) => PersistentStorage;
+export declare function windowRuntime(opts: JitsuOptions): RuntimeFacade;
+export declare const emptyRuntime: (config: JitsuOptions) => RuntimeFacade;
+export declare function isInBrowser(): boolean;
+export type DestinationDescriptor = {
+  id: string;
+  destinationType: string;
+  credentials: any;
+  options: any;
+  newEvents?: any[];
+  deviceOptions: DeviceOptions;
+};
+export type AnalyticsPluginDescriptor = {
+  type: "analytics-plugin";
+  packageCdn: string;
+  moduleVarName: string;
+};
+export type InternalPluginDescriptor = {
+  type: "internal-plugin";
+  name: string;
+};
+export type DeviceOptions = AnalyticsPluginDescriptor | InternalPluginDescriptor;
+export declare const jitsuAnalyticsPlugin: (jitsuOptions: JitsuOptions, storage: PersistentStorage) => AnalyticsPlugin;
+export declare function randomId(hashString?: string | undefined): string;
+export declare function uuid(): string;

package/package/dist/browser.d.ts

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

package/package/dist/index.d.ts

@@ -0,0 +1,28 @@
+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 {
+  Callback,
+  DispatchedEvent,
+  ID,
+  JSONObject,
+  Options,
+  AnalyticsInterface,
+  JitsuOptions,
+  PersistentStorage,
+  RuntimeFacade,
+  DynamicJitsuOptions,
+};
+export * from "./analytics-plugin";