@jitsu/js 1.9.9 → 1.9.11

package/src/analytics-plugin.ts

@@ -1,15 +1,17 @@
 /* global analytics */
 
 import {
-  DynamicJitsuOptions,
-  JitsuOptions,
-  PersistentStorage,
-  RuntimeFacade,
   AnalyticsClientEvent,
   Callback,
+  DynamicJitsuOptions,
+  ErrorHandler,
   ID,
+  JitsuOptions,
   JSONObject,
   Options,
+  PersistentStorage,
+  RuntimeFacade,
+  Traits,
 } from "@jitsu/protocols/analytics";
 import parse from "./index";
 
@@ -35,6 +37,7 @@ const defaultConfig: Required<JitsuOptions> = {
   fetchTimeoutMs: undefined,
   s2s: undefined,
   idEndpoint: undefined,
+  errorPolicy: "log",
   privacy: {
     dontSend: false,
     disableUserIds: false,
@@ -415,12 +418,13 @@ function adjustPayload(
   const query = parsedUrl ? parseQuery(parsedUrl.search) : {};
   const properties = payload.properties || {};
 
-  if (payload.type === "page" && url) {
-    properties.url = url.replace(hashRegex, "");
-    properties.path = fixPath(urlPath(url));
+  if (payload.type === "page" && (properties.url || url)) {
+    const targetUrl = properties.url || url;
+    properties.url = targetUrl.replace(hashRegex, "");
+    properties.path = fixPath(urlPath(targetUrl));
   }
 
-  const customContext = payload.properties?.context || {};
+  const customContext = payload.properties?.context || payload.options?.context || {};
   delete payload.properties?.context;
   const referrer = runtime.referrer();
   const context: AnalyticsClientEvent["context"] = {
@@ -627,6 +631,22 @@ function maskWriteKey(writeKey?: string): string | undefined {
   return writeKey;
 }
 
+function getErrorHandler(opts: JitsuOptions): ErrorHandler {
+  const configuredHandler = opts.errorPolicy || "log";
+  if (typeof configuredHandler === "function") {
+    return configuredHandler;
+  } else if (configuredHandler === "rethrow") {
+    return (msg, ...args) => {
+      //ignore args, not clear what to do with them
+      throw new Error(msg);
+    };
+  } else {
+    return (msg, ...args) => {
+      console.error(msg, ...args);
+    };
+  }
+}
+
 async function send(
   method,
   payload,
@@ -642,6 +662,7 @@ async function send(
   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"
     );
@@ -681,7 +702,8 @@ async function send(
       clearTimeout(abortTimeout);
     }
   } catch (e: any) {
-    throw new Error(`Calling ${url} failed: ${e.message}`);
+    getErrorHandler(jitsuConfig)(`Call to ${url} failed with error ${e.message}`);
+    return Promise.resolve();
   }
   let responseText;
   try {
@@ -708,7 +730,8 @@ async function send(
   try {
     responseJson = JSON.parse(responseText);
   } catch (e) {
-    return Promise.reject(`Can't parse JSON: ${responseText}: ${e?.message}`);
+    getErrorHandler(jitsuConfig)(`Can't parse JSON: ${responseText}: ${e?.message}`);
+    return Promise.resolve();
   }
 
   if (responseJson.destinations && responseJson.destinations.length > 0) {
@@ -730,6 +753,23 @@ async function send(
   return adjustedPayload;
 }
 
+const controllingTraits = ["$doNotSend"] as const;
+/**
+ * Remove all members of traits that controls identify/group behavior (see analytics.d.ts), and should not be recorded. Returns
+ * copy of the object with these members removed.
+ *
+ * Do not modify traits object, but creates one
+ * @param traits
+ */
+function stripControllingTraits(traits: Traits): Exclude<Traits, (typeof controllingTraits)[number]> {
+  const res = { ...traits };
+  // see Traits definition in analytics.d.ts. We cannot define const here, so here's a little code duplication
+  for (const key of controllingTraits) {
+    delete res[key];
+  }
+  return res;
+}
+
 export const jitsuAnalyticsPlugin = (jitsuOptions: JitsuOptions = {}, storage: PersistentStorage): AnalyticsPlugin => {
   // just to make sure that all undefined values are replaced with defaultConfig values
   mergeConfig(jitsuOptions, jitsuOptions);
@@ -792,9 +832,14 @@ export const jitsuAnalyticsPlugin = (jitsuOptions: JitsuOptions = {}, storage: P
       }
       // Store traits in cache to be able to use them in page and track events that run asynchronously with current identify.
       storage.setItem("__user_id", payload.userId);
+      const doNotSend = payload.traits?.$doNotSend;
       if (payload.traits && typeof payload.traits === "object") {
+        payload.traits = stripControllingTraits(payload.traits);
         storage.setItem("__user_traits", payload.traits);
       }
+      if (doNotSend) {
+        return Promise.resolve();
+      }
       return send("identify", payload, config, instance, storage);
     },
     reset: args => {
@@ -838,9 +883,14 @@ export const jitsuAnalyticsPlugin = (jitsuOptions: JitsuOptions = {}, storage: P
         const userId = options?.userId || user?.userId;
         const anonymousId = options?.anonymousId || user?.anonymousId || storage.getItem("__anon_id");
         storage.setItem("__group_id", groupId);
+        const doNotSend = traits?.$doNotSend;
         if (traits && typeof traits === "object") {
+          traits = stripControllingTraits(traits);
           storage.setItem("__group_traits", traits);
         }
+        if (doNotSend) {
+          return Promise.resolve();
+        }
         return send(
           "group",
           { type: "group", groupId, traits, ...(anonymousId ? { anonymousId } : {}), ...(userId ? { userId } : {}) },