@snowplow/react-native-tracker 1.4.0 → 2.1.0

package/src/subject.ts

@@ -0,0 +1,302 @@
+'use strict';
+
+import { RNSnowplowTracker } from './native';
+import { logMessages } from './constants';
+import { isScreenSize, isValidSubjectConf } from './configurations';
+import type { ScreenSize, SubjectConfiguration } from './types';
+
+/**
+ * Sets the userId of the tracker subject
+ *
+ * @param namespace {string} - the tracker namespace
+ * @param newUid {string | null} - the new userId
+ * @returns - Promise
+ */
+function setUserId(namespace: string, newUid: string | null): Promise<void> {
+  if (!(newUid === null || typeof newUid === 'string')) {
+    return Promise.reject(new Error(logMessages.setUserId));
+  }
+  return <Promise<void>>Promise.resolve(
+    RNSnowplowTracker.setUserId({
+      tracker: namespace,
+      userId: newUid,
+    })
+  );
+}
+
+/**
+ * Sets the networkUserId of the tracker subject
+ *
+ * @param namespace {string} - the tracker namespace
+ * @param newNuid {string | null} - the new networkUserId
+ * @returns - Promise
+ */
+function setNetworkUserId(
+  namespace: string,
+  newNuid: string | null
+): Promise<void> {
+  if (!(newNuid === null || typeof newNuid === 'string')) {
+    return Promise.reject(new Error(logMessages.setNetworkUserId));
+  }
+  return <Promise<void>>Promise.resolve(
+    RNSnowplowTracker.setNetworkUserId({
+      tracker: namespace,
+      networkUserId: newNuid,
+    })
+  );
+}
+
+/**
+ * Sets the domainUserId of the tracker subject
+ *
+ * @param namespace {string} - the tracker namespace
+ * @param newDuid {string | null} - the new domainUserId
+ * @returns - Promise
+ */
+function setDomainUserId(
+  namespace: string,
+  newDuid: string | null
+): Promise<void> {
+  if (!(newDuid === null || typeof newDuid === 'string')) {
+    return Promise.reject(new Error(logMessages.setDomainUserId));
+  }
+  return <Promise<void>>Promise.resolve(
+    RNSnowplowTracker.setDomainUserId({
+      tracker: namespace,
+      domainUserId: newDuid,
+    })
+  );
+}
+
+/**
+ * Sets the ipAddress of the tracker subject
+ *
+ * @param namespace {string} - the tracker namespace
+ * @param newIp {string | null} - the new ipAddress
+ * @returns - Promise
+ */
+function setIpAddress(namespace: string, newIp: string | null): Promise<void> {
+  if (!(newIp === null || typeof newIp === 'string')) {
+    return Promise.reject(new Error(logMessages.setIpAddress));
+  }
+  return <Promise<void>>Promise.resolve(
+    RNSnowplowTracker.setIpAddress({
+      tracker: namespace,
+      ipAddress: newIp,
+    })
+  );
+}
+
+/**
+ * Sets the useragent of the tracker subject
+ *
+ * @param namespace {string} - the tracker namespace
+ * @param newUagent {string | null} - the new useragent
+ * @returns - Promise
+ */
+function setUseragent(
+  namespace: string,
+  newUagent: string | null
+): Promise<void> {
+  if (!(newUagent === null || typeof newUagent === 'string')) {
+    return Promise.reject(new Error(logMessages.setUseragent));
+  }
+  return <Promise<void>>Promise.resolve(
+    RNSnowplowTracker.setUseragent({
+      tracker: namespace,
+      useragent: newUagent,
+    })
+  );
+}
+
+/**
+ * Sets the timezone of the tracker subject
+ *
+ * @param namespace {string} - the tracker namespace
+ * @param newTz {string | null} - the new timezone
+ * @returns - Promise
+ */
+function setTimezone(namespace: string, newTz: string | null): Promise<void> {
+  if (!(newTz === null || typeof newTz === 'string')) {
+    return Promise.reject(new Error(logMessages.setTimezone));
+  }
+  return <Promise<void>>Promise.resolve(
+    RNSnowplowTracker.setTimezone({
+      tracker: namespace,
+      timezone: newTz,
+    })
+  );
+}
+
+/**
+ * Sets the language of the tracker subject
+ *
+ * @param namespace {string} - the tracker namespace
+ * @param newLang {string | null} - the new language
+ * @returns - Promise
+ */
+function setLanguage(namespace: string, newLang: string | null): Promise<void> {
+  if (!(newLang === null || typeof newLang === 'string')) {
+    return Promise.reject(new Error(logMessages.setLanguage));
+  }
+  return <Promise<void>>Promise.resolve(
+    RNSnowplowTracker.setLanguage({
+      tracker: namespace,
+      language: newLang,
+    })
+  );
+}
+
+/**
+ * Sets the screenResolution of the tracker subject
+ *
+ * @param namespace {string} - the tracker namespace
+ * @param newRes {ScreenSize | null} - the new screenResolution
+ * @returns - Promise
+ */
+function setScreenResolution(
+  namespace: string,
+  newRes: ScreenSize | null
+): Promise<void> {
+  if (!(newRes === null || isScreenSize(newRes))) {
+    return Promise.reject(new Error(logMessages.setScreenResolution));
+  }
+  return <Promise<void>>Promise.resolve(
+    RNSnowplowTracker.setScreenResolution({
+      tracker: namespace,
+      screenResolution: newRes,
+    })
+  );
+}
+
+/**
+ * Sets the screenViewport of the tracker subject
+ *
+ * @param namespace {string} - the tracker namespace
+ * @param newView {ScreenSize | null} - the new screenViewport
+ * @returns - Promise
+ */
+function setScreenViewport(
+  namespace: string,
+  newView: ScreenSize | null
+): Promise<void> {
+  if (!(newView === null || isScreenSize(newView))) {
+    return Promise.reject(new Error(logMessages.setScreenViewport));
+  }
+  return <Promise<void>>Promise.resolve(
+    RNSnowplowTracker.setScreenViewport({
+      tracker: namespace,
+      screenViewport: newView,
+    })
+  );
+}
+
+/**
+ * Sets the colorDepth of the tracker subject
+ *
+ * @param namespace {string} - the tracker namespace
+ * @param newColorD {number | null} - the new colorDepth
+ * @returns - Promise
+ */
+function setColorDepth(
+  namespace: string,
+  newColorD: number | null
+): Promise<void> {
+  if (!(newColorD === null || typeof newColorD === 'number')) {
+    return Promise.reject(new Error(logMessages.setColorDepth));
+  }
+  return <Promise<void>>Promise.resolve(
+    RNSnowplowTracker.setColorDepth({
+      tracker: namespace,
+      colorDepth: newColorD,
+    })
+  );
+}
+
+const setterMap = {
+  userId: setUserId,
+  networkUserId: setNetworkUserId,
+  domainUserId: setDomainUserId,
+  ipAddress: setIpAddress,
+  useragent: setUseragent,
+  timezone: setTimezone,
+  language: setLanguage,
+  screenResolution: setScreenResolution,
+  screenViewport: setScreenViewport,
+  colorDepth: setColorDepth,
+} as Record<
+  keyof SubjectConfiguration,
+  <Type>(namespace: string, x: Type | null) => Promise<void>
+>;
+
+/**
+ * Sets the tracker subject
+ *
+ * @param namespace {string} - the tracker namespace
+ * @param config {SubjectConfiguration} - the new subject data
+ * @returns - Promise
+ */
+function setSubjectData(
+  namespace: string,
+  config: SubjectConfiguration
+): Promise<void> {
+  if (!isValidSubjectConf(config)) {
+    return Promise.reject(
+      new Error(`${logMessages.setSubjectData} ${logMessages.subject}`)
+    );
+  }
+
+  const promises = Object.keys(config)
+    .map((k) => {
+      const fun = setterMap[k];
+      return fun ? fun(namespace, config[k]) : undefined;
+    })
+    .filter((f) => f !== undefined);
+
+  // to use Promise.all (Promise.allSettled not supported in all RN versions)
+  const safePromises = promises.map((p) =>
+    (p as Promise<void>)
+      .then(
+        (x) =>
+          Object.assign({
+            status: 'fulfilled',
+            value: x,
+          }) as PromiseFulfilledResult<void>
+      )
+      .catch(
+        (err) =>
+          Object.assign({
+            status: 'rejected',
+            reason: err.message as string,
+          }) as PromiseRejectedResult
+      )
+  );
+
+  return <Promise<void>>Promise.all(safePromises).then((outcomes) => {
+    const anyReasons = outcomes.filter(
+      (res) => res.status === 'rejected'
+    ) as PromiseRejectedResult[];
+    if (anyReasons.length > 0) {
+      const allReasons = anyReasons.reduce(
+        (acc, curr) => acc + ':' + curr.reason,
+        logMessages.setSubjectData
+      );
+      throw new Error(allReasons);
+    }
+    return true;
+  });
+}
+
+export {
+  setUserId,
+  setNetworkUserId,
+  setDomainUserId,
+  setIpAddress,
+  setUseragent,
+  setTimezone,
+  setLanguage,
+  setScreenResolution,
+  setScreenViewport,
+  setColorDepth,
+  setSubjectData,
+};

package/src/tracker.ts

@@ -0,0 +1,377 @@
+'use strict';
+
+import { RNSnowplowTracker } from './native';
+import { logMessages } from './constants';
+import {
+  validateContexts,
+  validateSelfDesc,
+  validateScreenView,
+  validateScrollChanged,
+  validateListItemView,
+  validateStructured,
+  validatePageView,
+  validateTiming,
+  validateConsentGranted,
+  validateConsentWithdrawn,
+  validateEcommerceTransaction,
+  validateDeepLinkReceived,
+  validateMessageNotification,
+} from './events';
+import type {
+  SelfDescribing,
+  EventContext,
+  ScreenViewProps,
+  StructuredProps,
+  PageViewProps,
+  TimingProps,
+  ConsentGrantedProps,
+  ConsentWithdrawnProps,
+  EcommerceTransactionProps,
+  DeepLinkReceivedProps,
+  MessageNotificationProps,
+  ScrollChangedProps,
+  ListItemViewProps,
+} from './types';
+
+/**
+ * Tracks a self-describing event
+ *
+ * @param namespace {string} - the tracker namespace
+ * @param argmap {Object} - the event data
+ * @param contexts {Array}- the event contexts
+ * @returns {Promise}
+ */
+function trackSelfDescribingEvent(
+  namespace: string | null,
+  argmap: SelfDescribing,
+  contexts: EventContext[] = []
+): Promise<void> {
+  return <Promise<void>>validateSelfDesc(argmap)
+    .then(() => validateContexts(contexts))
+    .then(
+      () => <Promise<void>>RNSnowplowTracker.trackSelfDescribingEvent({
+          tracker: namespace,
+          eventData: argmap,
+          contexts: contexts,
+        })
+    )
+    .catch((error) => {
+      throw new Error(`${logMessages.trackSelfDesc} ${error.message}`);
+    });
+}
+
+/**
+ * Tracks a screen-view event
+ *
+ * @param namespace {string} - the tracker namespace
+ * @param argmap {Object} - the event data
+ * @param contexts {Array}- the event contexts
+ * @returns {Promise}
+ */
+function trackScreenViewEvent(
+  namespace: string | null,
+  argmap: ScreenViewProps,
+  contexts: EventContext[] = []
+): Promise<void> {
+  return <Promise<void>>validateScreenView(argmap)
+    .then(() => validateContexts(contexts))
+    .then(
+      () => <Promise<void>>RNSnowplowTracker.trackScreenViewEvent({
+          tracker: namespace,
+          eventData: argmap,
+          contexts: contexts,
+        })
+    )
+    .catch((error) => {
+      throw new Error(`${logMessages.trackScreenView} ${error.message}`);
+    });
+}
+
+/**
+ * Tracks a scroll-changed event
+ *
+ * @param namespace {string} - the tracker namespace
+ * @param argmap {Object} - the event data
+ * @param contexts {Array}- the event contexts
+ * @returns {Promise}
+ */
+function trackScrollChangedEvent(
+  namespace: string | null,
+  argmap: ScrollChangedProps,
+  contexts: EventContext[] = []
+): Promise<void> {
+  return <Promise<void>>validateScrollChanged(argmap)
+    .then(() => validateContexts(contexts))
+    .then(
+      () => <Promise<void>>RNSnowplowTracker.trackScrollChangedEvent({
+          tracker: namespace,
+          eventData: argmap,
+          contexts: contexts,
+        })
+    )
+    .catch((error) => {
+      throw new Error(`${logMessages.trackScrollChanged} ${error.message}`);
+    });
+}
+
+/**
+ * Tracks a list item view event
+ *
+ * @param namespace {string} - the tracker namespace
+ * @param argmap {Object} - the event data
+ * @param contexts {Array}- the event contexts
+ * @returns {Promise}
+ */
+function trackListItemViewEvent(
+  namespace: string | null,
+  argmap: ListItemViewProps,
+  contexts: EventContext[] = []
+): Promise<void> {
+  return <Promise<void>>validateListItemView(argmap)
+    .then(() => validateContexts(contexts))
+    .then(
+      () => <Promise<void>>RNSnowplowTracker.trackListItemViewEvent({
+          tracker: namespace,
+          eventData: argmap,
+          contexts: contexts,
+        })
+    )
+    .catch((error) => {
+      throw new Error(`${logMessages.trackListItemView} ${error.message}`);
+    });
+}
+
+/**
+ * Tracks a structured event
+ *
+ * @param namespace {string} - the tracker namespace
+ * @param argmap {Object} - the event data
+ * @param contexts {Array}- the event contexts
+ * @returns {Promise}
+ */
+function trackStructuredEvent(
+  namespace: string | null,
+  argmap: StructuredProps,
+  contexts: EventContext[] = []
+): Promise<void> {
+  return <Promise<void>>validateStructured(argmap)
+    .then(() => validateContexts(contexts))
+    .then(
+      () => <Promise<void>>RNSnowplowTracker.trackStructuredEvent({
+          tracker: namespace,
+          eventData: argmap,
+          contexts: contexts,
+        })
+    )
+    .catch((error) => {
+      throw new Error(`${logMessages.trackStructured} ${error.message}`);
+    });
+}
+
+/**
+ * Tracks a page-view event
+ *
+ * @param namespace {string} - the tracker namespace
+ * @param argmap {Object} - the event data
+ * @param contexts {Array}- the event contexts
+ * @returns {Promise}
+ */
+function trackPageViewEvent(
+  namespace: string | null,
+  argmap: PageViewProps,
+  contexts: EventContext[] = []
+): Promise<void> {
+  return <Promise<void>>validatePageView(argmap)
+    .then(() => validateContexts(contexts))
+    .then(
+      () => <Promise<void>>RNSnowplowTracker.trackPageViewEvent({
+          tracker: namespace,
+          eventData: argmap,
+          contexts: contexts,
+        })
+    )
+    .catch((error) => {
+      throw new Error(`${logMessages.trackPageView} ${error.message}`);
+    });
+}
+
+/**
+ * Tracks a timing event
+ *
+ * @param namespace {string} - the tracker namespace
+ * @param argmap {Object} - the event data
+ * @param contexts {Array}- the event contexts
+ * @returns {Promise}
+ */
+function trackTimingEvent(
+  namespace: string | null,
+  argmap: TimingProps,
+  contexts: EventContext[] = []
+): Promise<void> {
+  return <Promise<void>>validateTiming(argmap)
+    .then(() => validateContexts(contexts))
+    .then(
+      () => <Promise<void>>RNSnowplowTracker.trackTimingEvent({
+          tracker: namespace,
+          eventData: argmap,
+          contexts: contexts,
+        })
+    )
+    .catch((error) => {
+      throw new Error(`${logMessages.trackTiming} ${error.message}`);
+    });
+}
+
+/**
+ * Tracks a consent-granted event
+ *
+ * @param namespace {string} - the tracker namespace
+ * @param argmap {Object} - the event data
+ * @param contexts {Array}- the event contexts
+ * @returns {Promise}
+ */
+function trackConsentGrantedEvent(
+  namespace: string | null,
+  argmap: ConsentGrantedProps,
+  contexts: EventContext[] = []
+): Promise<void> {
+  return <Promise<void>>validateConsentGranted(argmap)
+    .then(() => validateContexts(contexts))
+    .then(
+      () => <Promise<void>>RNSnowplowTracker.trackConsentGrantedEvent({
+          tracker: namespace,
+          eventData: argmap,
+          contexts: contexts,
+        })
+    )
+    .catch((error) => {
+      throw new Error(`${logMessages.trackConsentGranted} ${error.message}`);
+    });
+}
+
+/**
+ * Tracks a consent-withdrawn event
+ *
+ * @param namespace {string} - the tracker namespace
+ * @param argmap {Object} - the event data
+ * @param contexts {Array}- the event contexts
+ * @returns {Promise}
+ */
+function trackConsentWithdrawnEvent(
+  namespace: string | null,
+  argmap: ConsentWithdrawnProps,
+  contexts: EventContext[] = []
+): Promise<void> {
+  return <Promise<void>>validateConsentWithdrawn(argmap)
+    .then(() => validateContexts(contexts))
+    .then(
+      () => <Promise<void>>RNSnowplowTracker.trackConsentWithdrawnEvent({
+          tracker: namespace,
+          eventData: argmap,
+          contexts: contexts,
+        })
+    )
+    .catch((error) => {
+      throw new Error(`${logMessages.trackConsentWithdrawn} ${error.message}`);
+    });
+}
+
+/**
+ * Tracks an ecommerce-transaction event
+ *
+ * @param namespace {string} - the tracker namespace
+ * @param argmap {Object} - the event data
+ * @param contexts {Array}- the event contexts
+ * @returns {Promise}
+ */
+function trackEcommerceTransactionEvent(
+  namespace: string | null,
+  argmap: EcommerceTransactionProps,
+  contexts: EventContext[] = []
+): Promise<void> {
+  return <Promise<void>>validateEcommerceTransaction(argmap)
+    .then(() => validateContexts(contexts))
+    .then(
+      () => <Promise<void>>RNSnowplowTracker.trackEcommerceTransactionEvent({
+          tracker: namespace,
+          eventData: argmap,
+          contexts: contexts,
+        })
+    )
+    .catch((error) => {
+      throw new Error(
+        `${logMessages.trackEcommerceTransaction} ${error.message}`
+      );
+    });
+}
+
+/**
+ * Tracks a deep link received event
+ *
+ * @param namespace {string} - the tracker namespace
+ * @param argmap {Object} - the event data
+ * @param contexts {Array}- the event contexts
+ * @returns {Promise}
+ */
+function trackDeepLinkReceivedEvent(
+  namespace: string | null,
+  argmap: DeepLinkReceivedProps,
+  contexts: EventContext[] = []
+): Promise<void> {
+  return <Promise<void>>validateDeepLinkReceived(argmap)
+    .then(() => validateContexts(contexts))
+    .then(
+      () => <Promise<void>>RNSnowplowTracker.trackDeepLinkReceivedEvent({
+          tracker: namespace,
+          eventData: argmap,
+          contexts: contexts,
+        })
+    )
+    .catch((error) => {
+      throw new Error(`${logMessages.trackDeepLinkReceived} ${error.message}`);
+    });
+}
+
+/**
+ * Tracks a message notification event
+ *
+ * @param namespace {string} - the tracker namespace
+ * @param argmap {Object} - the event data
+ * @param contexts {Array}- the event contexts
+ * @returns {Promise}
+ */
+function trackMessageNotificationEvent(
+  namespace: string | null,
+  argmap: MessageNotificationProps,
+  contexts: EventContext[] = []
+): Promise<void> {
+  return <Promise<void>>validateMessageNotification(argmap)
+    .then(() => validateContexts(contexts))
+    .then(
+      () => <Promise<void>>RNSnowplowTracker.trackMessageNotificationEvent({
+          tracker: namespace,
+          eventData: argmap,
+          contexts: contexts,
+        })
+    )
+    .catch((error) => {
+      throw new Error(
+        `${logMessages.trackMessageNotification} ${error.message}`
+      );
+    });
+}
+
+export {
+  trackSelfDescribingEvent,
+  trackScreenViewEvent,
+  trackScrollChangedEvent,
+  trackListItemViewEvent,
+  trackStructuredEvent,
+  trackPageViewEvent,
+  trackTimingEvent,
+  trackConsentGrantedEvent,
+  trackConsentWithdrawnEvent,
+  trackEcommerceTransactionEvent,
+  trackDeepLinkReceivedEvent,
+  trackMessageNotificationEvent,
+};