@jitsu/js 1.7.2 → 1.8.1

package/src/analytics-plugin.ts

@@ -20,6 +20,7 @@ const defaultConfig: Required<JitsuOptions> = {
   echoEvents: false,
   cookieDomain: undefined,
   runtime: undefined,
+  s2s: undefined,
 };
 
 export const parseQuery = (qs?: string): Record<string, string> => {
@@ -62,11 +63,24 @@ function safeCall<T>(f: () => T, defaultVal?: T): T | undefined {
 }
 
 function restoreTraits(storage: PersistentStorage) {
-  const val = storage.getItem("__user_traits");
+  let val = storage.getItem("__user_traits");
   if (typeof val === "string") {
-    return safeCall(() => JSON.parse(val), {});
+    val = safeCall(() => JSON.parse(val), {});
   }
-  return val;
+  if (typeof val !== "object" || val === null) {
+    val = {};
+  }
+  let groupVal = storage.getItem("__group_traits");
+  if (typeof groupVal === "string") {
+    groupVal = safeCall(() => JSON.parse(groupVal), {});
+  }
+  if (typeof groupVal !== "object" || groupVal === null) {
+    groupVal = {};
+  }
+  return {
+    ...(groupVal || {}),
+    ...(val || {}), //user traits override group traits
+  };
 }
 
 export type StorageFactory = (cookieDomain: string, cookie2key: Record<string, string>) => PersistentStorage;
@@ -284,12 +298,33 @@ export function isInBrowser() {
   return typeof document !== "undefined" && typeof window !== "undefined";
 }
 
-function adjustPayload(payload: any, config: JitsuOptions, storage: PersistentStorage): AnalyticsClientEvent {
+/**
+ * Fixes a weird bug in analytics URL where path
+ * of https://test.com becomes //test.com
+ */
+function fixPath(path: string): string {
+  if (path.indexOf("//") === 0 && path.lastIndexOf("/") === 1) {
+    return "/";
+  }
+  return path;
+}
+
+function adjustPayload(
+  payload: any,
+  config: JitsuOptions,
+  storage: PersistentStorage,
+  s2s: boolean
+): AnalyticsClientEvent {
   const runtime: RuntimeFacade = config.runtime || (isInBrowser() ? windowRuntime(config) : emptyRuntime(config));
   const url = runtime.pageUrl();
   const parsedUrl = safeCall(() => new URL(url), undefined);
   const query = parsedUrl ? parseQuery(parsedUrl.search) : {};
   const properties = payload.properties || {};
+
+  if (properties.path) {
+    properties.path = fixPath(properties.path);
+  }
+
   const customContext = payload.properties?.context || {};
   delete payload.properties?.context;
   const referrer = runtime.referrer();
@@ -297,6 +332,7 @@ function adjustPayload(payload: any, config: JitsuOptions, storage: PersistentSt
     library: {
       name: jitsuLibraryName,
       version: jitsuVersion,
+      env: s2s ? "node" : "browser",
     },
     userAgent: runtime.userAgent(),
     locale: runtime.language(),
@@ -325,6 +361,7 @@ function adjustPayload(payload: any, config: JitsuOptions, storage: PersistentSt
     sentAt: new Date().toISOString(),
     messageId: randomId(properties.path || (parsedUrl && parsedUrl.pathname)),
     writeKey: maskWriteKey(config.writeKey),
+    groupId: storage.getItem("__group_id"),
     context: deepMerge(context, customContext),
   };
   delete withContext.meta;
@@ -471,19 +508,19 @@ function maskWriteKey(writeKey?: string): string | undefined {
   return writeKey;
 }
 
-function send(
+async function send(
   method,
   payload,
   jitsuConfig: Required<JitsuOptions>,
   instance: AnalyticsInstance,
   store: PersistentStorage
-): Promise<void> {
+): Promise<any> {
   if (jitsuConfig.echoEvents) {
     console.log(`[JITSU DEBUG] sending '${method}' event:`, payload);
     return;
   }
-
-  const url = `${jitsuConfig.host}/api/s/${method}`;
+  const s2s = jitsuConfig.s2s === undefined ? !isInBrowser() : jitsuConfig.s2s;
+  const url = s2s ? `${jitsuConfig.host}/api/s/s2s/${method}` : `${jitsuConfig.host}/api/s/${method}`;
   const fetch = jitsuConfig.fetch || globalThis.fetch;
   if (!fetch) {
     throw new Error(
@@ -495,85 +532,72 @@ function send(
   // if (jitsuConfig.debug) {
   //   console.log(`[JITSU] Sending event to ${url}: `, JSON.stringify(payload, null, 2));
   // }
-  const adjustedPayload = adjustPayload(payload, jitsuConfig, store);
+  const adjustedPayload = adjustPayload(payload, jitsuConfig, store, s2s);
 
   const authHeader = jitsuConfig.writeKey ? { "X-Write-Key": jitsuConfig.writeKey } : {};
+  let fetchResult;
+  try {
+    fetchResult = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
 
-  return fetch(url, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
+        ...authHeader,
+        ...debugHeader,
+      },
+      body: JSON.stringify(adjustedPayload),
+    });
+  } catch (e: any) {
+    throw new Error(`Calling ${url} failed: ${e.message}`);
+  }
+  let responseText;
+  try {
+    responseText = await fetchResult.text();
+  } catch (e) {
+    console.warn(
+      `Can't read response text from ${url} (status - ${fetchResult.status}  ${fetchResult.statusText}): ${e?.message}`
+    );
+  }
+  if (jitsuConfig.debug) {
+    console.log(
+      `[JITSU DEBUG] ${url} replied ${fetchResult.status}: ${responseText}. Original payload:\n${JSON.stringify(
+        adjustedPayload,
+        null,
+        2
+      )}`
+    );
+  }
+  if (!fetchResult.ok) {
+    throw new Error(`Jitsu ${url} replied ${fetchResult.status} - ${fetchResult.statusText}: ${responseText}`);
+  }
 
-      ...authHeader,
-      ...debugHeader,
-    },
-    body: JSON.stringify(adjustedPayload),
-  })
-    .then(res => {
-      if (jitsuConfig.debug) {
-        console.log(
-          `[JITSU] ${url} replied ${res.status}. Original payload: `,
-          JSON.stringify(adjustedPayload, null, 2)
-        );
-      }
-      if (res.ok) {
-        return res.text();
-      } else {
-        return Promise.reject(res.text());
-      }
-    })
-    .then(responseText => {
-      let response: any;
-      try {
-        response = JSON.parse(responseText);
-      } catch (e) {
-        return Promise.reject(`Can't parse JSON: ${responseText}: ${e?.message}`);
-      }
-      if (response.destinations) {
-        if (jitsuConfig.debug) {
-          console.log(`[JITSU] Processing device destinations: `, JSON.stringify(response.destinations, null, 2));
-        }
-        return processDestinations(response.destinations, method, adjustedPayload, !!jitsuConfig.debug, instance);
-      }
-    })
-    .catch(err => {
+  let responseJson: any;
+  try {
+    responseJson = JSON.parse(responseText);
+  } catch (e) {
+    return Promise.reject(`Can't parse JSON: ${responseText}: ${e?.message}`);
+  }
+
+  if (responseJson.destinations && responseJson.destinations.length > 0) {
+    if (jitsuConfig.s2s) {
+      console.warn(
+        `[JITSU] ${payload.type} responded with list of ${responseJson.destinations.length} destinations. However, this code is running in server-to-server mode, so destinations will be ignored`,
+        jitsuConfig.debug ? JSON.stringify(responseJson.destinations, null, 2) : undefined
+      );
+    } else {
       if (jitsuConfig.debug) {
-        console.error(`Jitsu ${url} failed: `, err);
+        console.log(`[JITSU] Processing device destinations: `, JSON.stringify(responseJson.destinations, null, 2));
       }
-    });
+      return processDestinations(responseJson.destinations, method, adjustedPayload, !!jitsuConfig.debug, instance);
+    }
+  }
+  return adjustedPayload;
 }
 
-const jitsuAnalyticsPlugin = (pluginConfig: JitsuOptions = {}): AnalyticsPlugin => {
-  const storageCache: any = {};
-
-  // AnalyticsInstance's storage is async somewhere inside. So if we make 'page' call right after 'identify' call
-  // 'page' call will load traits from storage before 'identify' call had a change to save them.
-  // to avoid that we use in-memory cache for storage
-  const cachingStorageWrapper = (persistentStorage: PersistentStorage): PersistentStorage => ({
-    setItem(key: string, val: any) {
-      if (pluginConfig.debug) {
-        console.log(`[JITSU DEBUG] Caching storage setItem: ${key}=${val}`);
-      }
-      storageCache[key] = val;
-      persistentStorage.setItem(key, val);
-    },
-    getItem(key: string) {
-      const value = storageCache[key] || persistentStorage.getItem(key);
-      if (pluginConfig.debug) {
-        console.log(
-          `[JITSU DEBUG] Caching storage getItem: ${key}=${value}. Evicted from cache: ${!storageCache[key]}`
-        );
-      }
-      return value;
-    },
-    removeItem(key: string) {
-      if (pluginConfig.debug) {
-        console.log(`[JITSU DEBUG] Caching storage removeItem: ${key}`);
-      }
-      delete storageCache[key];
-      persistentStorage.removeItem(key);
-    },
-  });
+export type JitsuPluginConfig = JitsuOptions & {
+  storageWrapper?: (persistentStorage: PersistentStorage) => PersistentStorage & { reset: () => void };
+};
+const jitsuAnalyticsPlugin = (pluginConfig: JitsuPluginConfig = {}): AnalyticsPlugin => {
   const instanceConfig = {
     ...defaultConfig,
     ...pluginConfig,
@@ -594,30 +618,59 @@ const jitsuAnalyticsPlugin = (pluginConfig: JitsuOptions = {}): AnalyticsPlugin
     },
     page: args => {
       const { payload, config, instance } = args;
-      return send("page", payload, config, instance, cachingStorageWrapper(instance.storage));
+      return send(
+        "page",
+        payload,
+        config,
+        instance,
+        pluginConfig.storageWrapper ? pluginConfig.storageWrapper(instance.storage) : instance.storage
+      );
     },
     track: args => {
       const { payload, config, instance } = args;
-      return send("track", payload, config, instance, cachingStorageWrapper(instance.storage));
+      return send(
+        "track",
+        payload,
+        config,
+        instance,
+        pluginConfig.storageWrapper ? pluginConfig.storageWrapper(instance.storage) : instance.storage
+      );
     },
     identify: args => {
       const { payload, config, instance } = args;
       // Store traits in cache to be able to use them in page and track events that run asynchronously with current identify.
-      storageCache["__user_traits"] = payload.traits;
-      return send("identify", payload, config, instance, cachingStorageWrapper(instance.storage));
+      const storage = pluginConfig.storageWrapper ? pluginConfig.storageWrapper(instance.storage) : instance.storage;
+      storage.setItem("__user_id", payload.userId);
+      if (payload.traits && typeof payload.traits === "object") {
+        storage.setItem("__user_traits", payload.traits);
+      }
+      return send("identify", payload, config, instance, storage);
     },
     reset: args => {
       //clear storage cache
-      Object.keys(storageCache).forEach(key => delete storageCache[key]);
+      if (pluginConfig.storageWrapper) {
+        pluginConfig.storageWrapper(args.instance.storage).reset();
+      }
     },
     methods: {
       //analytics doesn't support group as a base method, so we need to add it manually
       group(groupId?: ID, traits?: JSONObject | null, options?: Options, callback?: Callback) {
+        if (typeof groupId === "number") {
+          //fix potential issues with group id being used incorrectly
+          groupId = groupId + "";
+        }
+
         const analyticsInstance = this.instance;
-        const cacheWrap = cachingStorageWrapper(analyticsInstance.storage);
+        const cacheWrap = pluginConfig.storageWrapper
+          ? pluginConfig.storageWrapper(analyticsInstance.storage)
+          : analyticsInstance.storage;
         const user = analyticsInstance.user();
         const userId = options?.userId || user?.userId;
         const anonymousId = options?.anonymousId || user?.anonymousId || cacheWrap.getItem("__anon_id");
+        cacheWrap.setItem("__group_id", groupId);
+        if (traits && typeof traits === "object") {
+          cacheWrap.setItem("__group_traits", traits);
+        }
         return send(
           "group",
           { type: "group", groupId, traits, ...(anonymousId ? { anonymousId } : {}), ...(userId ? { userId } : {}) },

package/src/browser.ts

@@ -75,7 +75,8 @@ function getScriptAttributes(scriptElement: HTMLScriptElement) {
    * New callback based queue, see below
    */
   //make a copy of the queue
-  const callbackQueue = [...(window[JITSU_V2_ID + "Q"] || [])];
+  const callbackQueue =
+    window[JITSU_V2_ID + "Q"] && window[JITSU_V2_ID + "Q"].length ? [...window[JITSU_V2_ID + "Q"]] : [];
   //replace push with a function that calls callback immediately
   window[JITSU_V2_ID + "Q"] = {
     push: (callback: any) => {
@@ -88,7 +89,7 @@ function getScriptAttributes(scriptElement: HTMLScriptElement) {
   };
 
   if (options.debug) {
-    console.log(`Jitsu callback queue size: ${callbackQueue.length}`, callbackQueue);
+    console.log(`[JITSU DEBUG] Jitsu callback queue size: ${callbackQueue.length}`, callbackQueue);
   }
   callbackQueue.forEach((callback: any) => {
     try {

package/src/index.ts

@@ -1,5 +1,5 @@
 import Analytics from "analytics";
-import { AnalyticsInterface, JitsuOptions, RuntimeFacade } from "./jitsu";
+import { AnalyticsInterface, JitsuOptions, PersistentStorage, RuntimeFacade } from "./jitsu";
 import jitsuAnalyticsPlugin, { emptyRuntime, isInBrowser, windowRuntime } from "./analytics-plugin";
 import { Callback, DispatchedEvent, ID, JSONObject, Options } from "@jitsu/protocols/analytics";
 
@@ -39,25 +39,87 @@ function createUnderlyingAnalyticsInstance(
   plugins: any[] = []
 ): AnalyticsInterface {
   const storage = rt.store();
+
+  const storageCache: any = {};
+
+  // AnalyticsInstance's storage is async somewhere inside. So if we make 'page' call right after 'identify' call
+  // 'page' call will load traits from storage before 'identify' call had a change to save them.
+  // to avoid that we use in-memory cache for storage
+  const cachingStorageWrapper = (persistentStorage: PersistentStorage) => ({
+    setItem(key: string, val: any) {
+      if (opts.debug) {
+        console.log(`[JITSU DEBUG] Caching storage setItem: ${key}=${val}`);
+      }
+      storageCache[key] = val;
+      persistentStorage.setItem(key, val);
+    },
+    getItem(key: string) {
+      const value = storageCache[key] || persistentStorage.getItem(key);
+      if (opts.debug) {
+        console.log(
+          `[JITSU DEBUG] Caching storage getItem: ${key}=${value}. Evicted from cache: ${!storageCache[key]}`
+        );
+      }
+      return value;
+    },
+    reset() {
+      for (const key of [...Object.keys(storageCache)]) {
+        storage.removeItem(key);
+        delete storageCache[key];
+      }
+    },
+    removeItem(key: string) {
+      if (opts.debug) {
+        console.log(`[JITSU DEBUG] Caching storage removeItem: ${key}`);
+      }
+      delete storageCache[key];
+      persistentStorage.removeItem(key);
+    },
+  });
+
   const analytics = Analytics({
-    app: "test",
     debug: !!opts.debug,
     storage,
-    plugins: [jitsuAnalyticsPlugin(opts), ...plugins],
+    plugins: [jitsuAnalyticsPlugin({ ...opts, storageWrapper: cachingStorageWrapper }), ...plugins],
   } as any);
-  const originalPage = analytics.page;
-  analytics.page = (...args) => {
-    if (args.length === 2 && typeof args[0] === "string" && typeof args[1] === "object") {
-      return originalPage({
-        name: args[0],
-        ...args[1],
-      });
-    } else {
-      return originalPage(...args);
-    }
-  };
+
   return {
     ...analytics,
+    page: (...args) => {
+      if (args.length === 2 && typeof args[0] === "string" && typeof args[1] === "object") {
+        return analytics.page({
+          name: args[0],
+          ...args[1],
+        });
+      } else {
+        return (analytics.page as any)(...args);
+      }
+    },
+    identify: (...args) => {
+      if (args[0] && typeof args[0] !== "object" && typeof args[0] !== "string") {
+        //fix the quirk of analytics.js: if you pass number as first argument, it will be converted to string
+        args[0] = args[0] + "";
+      }
+
+      //analytics.js sets userId and traits asynchronously, so if
+      //we want them to be available immediately after identify call in subsequent page() calls,
+      //we need to put them into storage manually
+      const storage = (analytics as any).storage;
+      const storageWrapper = cachingStorageWrapper(storage);
+      if (typeof args[0] === "string") {
+        //first argument is user id
+        storageWrapper.setItem("__user_id", args[0]);
+      } else if (typeof args[0] === "object") {
+        //first argument is traits
+        storageWrapper.setItem("__user_traits", args[0]);
+      }
+
+      if (args.length === 2 && typeof args[1] === "object") {
+        //first argument is user id, second is traits
+        storageWrapper.setItem("__user_traits", args[1]);
+      }
+      return (analytics.identify as any)(...args);
+    },
     setAnonymousId: (id: string) => {
       if (opts.debug) {
         console.log("[JITSU DEBUG] Setting anonymous id to " + id);
@@ -71,13 +133,21 @@ function createUnderlyingAnalyticsInstance(
         (analytics as any).setAnonymousId(id);
       }
     },
-    group(groupId?: ID, traits?: JSONObject | null, options?: Options, callback?: Callback): Promise<DispatchedEvent> {
+    async group(
+      groupId?: ID,
+      traits?: JSONObject | null,
+      options?: Options,
+      callback?: Callback
+    ): Promise<DispatchedEvent> {
+      const results: any[] = [];
       for (const plugin of Object.values(analytics.plugins)) {
         if (plugin["group"]) {
-          plugin["group"](groupId, traits, options, callback);
+          results.push(await plugin["group"](groupId, traits, options, callback));
         }
       }
-      return Promise.resolve({});
+      //It's incorrect at many levels. First, it's not a dispatched event. Second, we take a first result
+      //However, since returned values are used for debugging purposes only, it's ok
+      return results[0];
     },
   } as AnalyticsInterface;
 }

package/src/jitsu.ts

@@ -38,6 +38,13 @@ type JitsuOptions = {
    * writeKey / host. It's useful for debugging development environment
    */
   echoEvents?: boolean;
+
+  /**
+   * If true, events will go to s2s endpoints like ${host}/api/s/s2s/{type}. Otherwise they'll go to ${host}/api/s/{type}.
+   *
+   * If not set at all, it will be detected automatically by presence of `window` object
+   */
+  s2s?: boolean;
 };
 
 type PersistentStorage = {

package/src/version.ts

@@ -1,3 +1,6 @@
-import { name as jitsuLibraryName, version as jitsuVersion } from "../package.json";
+//import pkg from "../package.json";
+
+const jitsuVersion = "0.0.0";
+const jitsuLibraryName = "@jitsu/js";
 
 export { jitsuVersion, jitsuLibraryName };