@snowplow/react-native-tracker 1.4.0 → 2.1.0

package/src/configurations.ts

@@ -0,0 +1,325 @@
+'use strict';
+
+import { isObject } from './utils';
+import { isValidSD } from './events';
+import { logMessages } from './constants';
+import type {
+  NetworkConfiguration,
+  TrackerConfiguration,
+  SessionConfiguration,
+  EmitterConfiguration,
+  SubjectConfiguration,
+  GdprConfiguration,
+  GCConfiguration,
+  GlobalContext,
+  InitTrackerConfiguration,
+} from './types';
+
+/**
+ * Configuration properties
+ */
+const networkProps = ['endpoint', 'method', 'customPostPath', 'requestHeaders'];
+const trackerProps = [
+  'appId',
+  'devicePlatform',
+  'base64Encoding',
+  'logLevel',
+  'applicationContext',
+  'platformContext',
+  'geoLocationContext',
+  'sessionContext',
+  'deepLinkContext',
+  'screenContext',
+  'screenViewAutotracking',
+  'screenEngagementAutotracking',
+  'lifecycleAutotracking',
+  'installAutotracking',
+  'exceptionAutotracking',
+  'diagnosticAutotracking',
+  'userAnonymisation',
+];
+const sessionProps = ['foregroundTimeout', 'backgroundTimeout'];
+const emitterProps = [
+  'bufferOption',
+  'emitRange',
+  'threadPoolSize',
+  'byteLimitPost',
+  'byteLimitGet',
+  'serverAnonymisation',
+];
+const subjectProps = [
+  'userId',
+  'networkUserId',
+  'domainUserId',
+  'useragent',
+  'ipAddress',
+  'timezone',
+  'language',
+  'screenResolution',
+  'screenViewport',
+  'colorDepth',
+];
+const gdprProps = [
+  'basisForProcessing',
+  'documentId',
+  'documentVersion',
+  'documentDescription',
+];
+const gcProps = ['tag', 'globalContexts'];
+
+/**
+ * Validates whether an object is of valid configuration given its default keys
+ *
+ * @param config {Object} - the object to validate
+ * @param defaultKeys {Array} - the default keys to validate against
+ * @returns - boolean
+ */
+function isValidConfig<Type extends Record<string, any>>(
+  config: Type,
+  defaultKeys: Array<string>
+): config is Type {
+  return Object.keys(config).every((key) => defaultKeys.includes(key));
+}
+
+/**
+ * Validates the networkConfig
+ *
+ * @param config {Object} - the config to validate
+ * @returns - boolean
+ */
+function isValidNetworkConf(config: NetworkConfiguration): boolean {
+  if (
+    !isObject(config) ||
+    !isValidConfig(config, networkProps) ||
+    typeof config.endpoint !== 'string' ||
+    !config.endpoint
+  ) {
+    return false;
+  }
+  return true;
+}
+
+/**
+ * Validates the trackerConfig
+ *
+ * @param config {Object} - the config to validate
+ * @returns - boolean
+ */
+function isValidTrackerConf(config: TrackerConfiguration): boolean {
+  if (!isObject(config) || !isValidConfig(config, trackerProps)) {
+    return false;
+  }
+  return true;
+}
+
+/**
+ * Validates the sessionConfig
+ *
+ * @param config {Object} - the config to validate
+ * @returns - boolean
+ */
+function isValidSessionConf(config: SessionConfiguration): boolean {
+  if (
+    !isObject(config) ||
+    !isValidConfig(config, sessionProps) ||
+    !sessionProps.every((key) =>
+      Object.keys(config as SessionConfiguration).includes(key)
+    )
+  ) {
+    return false;
+  }
+  return true;
+}
+
+/**
+ * Validates the emitterConfig
+ *
+ * @param config {Object} - the config to validate
+ * @returns - boolean
+ */
+function isValidEmitterConf(config: EmitterConfiguration): boolean {
+  if (!isObject(config) || !isValidConfig(config, emitterProps)) {
+    return false;
+  }
+  return true;
+}
+
+/**
+ * Validates whether an object is of ScreenSize type
+ *
+ * @param arr {Object} - the object to validate
+ * @returns - boolean
+ */
+function isScreenSize<Type>(arr: Type): boolean {
+  return (
+    Array.isArray(arr) &&
+    arr.length === 2 &&
+    arr.every(<Type>(n: Type) => typeof n === 'number')
+  );
+}
+
+/**
+ * Validates the subjectConfig
+ *
+ * @param config {Object} - the config to validate
+ * @returns - boolean
+ */
+function isValidSubjectConf(config: SubjectConfiguration): boolean {
+  if (!isObject(config) || !isValidConfig(config, subjectProps)) {
+    return false;
+  }
+
+  // validating ScreenSize here to simplify array handling in bridge
+  if (
+    Object.prototype.hasOwnProperty.call(config, 'screenResolution') &&
+    config.screenResolution !== null &&
+    !isScreenSize(config.screenResolution as unknown)
+  ) {
+    return false;
+  }
+
+  if (
+    Object.prototype.hasOwnProperty.call(config, 'screenViewport') &&
+    config.screenViewport !== null &&
+    !isScreenSize(config.screenViewport as unknown)
+  ) {
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * Validates the gdprConfig
+ *
+ * @param config {Object} - the config to validate
+ * @returns - boolean
+ */
+function isValidGdprConf(config: GdprConfiguration): boolean {
+  if (
+    !isObject(config) ||
+    !isValidConfig(config, gdprProps) ||
+    !gdprProps.every((key) =>
+      Object.keys(config as GdprConfiguration).includes(key)
+    ) ||
+    ![
+      'consent',
+      'contract',
+      'legal_obligation',
+      'legitimate_interests',
+      'public_task',
+      'vital_interests',
+    ].includes(config.basisForProcessing)
+  ) {
+    return false;
+  }
+  return true;
+}
+
+/**
+ * Validates whether an object is of GlobalContext type
+ *
+ * @param gc {Object} - the object to validate
+ * @returns - boolean
+ */
+function isValidGC(gc: GlobalContext): boolean {
+  return (
+    isObject(gc) &&
+    isValidConfig(gc, gcProps) &&
+    typeof gc.tag === 'string' &&
+    Array.isArray(gc.globalContexts) &&
+    gc.globalContexts.every((c) => isValidSD(c))
+  );
+}
+
+/**
+ * Validates the GCConfig (global contexts)
+ *
+ * @param config {Object} - the config to validate
+ * @returns - boolean
+ */
+function isValidGCConf(config: GCConfiguration): boolean {
+  if (!Array.isArray(config)) {
+    return false;
+  }
+  if (!config.every((gc) => isValidGC(gc as GlobalContext))) {
+    return false;
+  }
+  return true;
+}
+
+/**
+ * Validates the initTrackerConfiguration
+ *
+ * @param init {Object} - the config to validate
+ * @returns - boolean promise
+ */
+function initValidate(init: InitTrackerConfiguration): Promise<boolean> {
+  if (typeof init.namespace !== 'string' || !init.namespace) {
+    return Promise.reject(new Error(logMessages.namespace));
+  }
+
+  if (
+    !Object.prototype.hasOwnProperty.call(init, 'networkConfig') ||
+    !isValidNetworkConf(init.networkConfig as NetworkConfiguration)
+  ) {
+    return Promise.reject(new Error(logMessages.network));
+  }
+
+  if (
+    Object.prototype.hasOwnProperty.call(init, 'trackerConfig') &&
+    !isValidTrackerConf(init.trackerConfig as TrackerConfiguration)
+  ) {
+    return Promise.reject(new Error(logMessages.tracker));
+  }
+
+  if (
+    Object.prototype.hasOwnProperty.call(init, 'sessionConfig') &&
+    !isValidSessionConf(init.sessionConfig as SessionConfiguration)
+  ) {
+    return Promise.reject(new Error(logMessages.session));
+  }
+
+  if (
+    Object.prototype.hasOwnProperty.call(init, 'emitterConfig') &&
+    !isValidEmitterConf(init.emitterConfig as EmitterConfiguration)
+  ) {
+    return Promise.reject(new Error(logMessages.emitter));
+  }
+
+  if (
+    Object.prototype.hasOwnProperty.call(init, 'subjectConfig') &&
+    !isValidSubjectConf(init.subjectConfig as SubjectConfiguration)
+  ) {
+    return Promise.reject(new Error(logMessages.subject));
+  }
+
+  if (
+    Object.prototype.hasOwnProperty.call(init, 'gdprConfig') &&
+    !isValidGdprConf(init.gdprConfig as GdprConfiguration)
+  ) {
+    return Promise.reject(new Error(logMessages.gdpr));
+  }
+
+  if (
+    Object.prototype.hasOwnProperty.call(init, 'gcConfig') &&
+    !isValidGCConf(init.gcConfig as GCConfiguration)
+  ) {
+    return Promise.reject(new Error(logMessages.gc));
+  }
+
+  return Promise.resolve(true);
+}
+
+export {
+  isValidNetworkConf,
+  isValidTrackerConf,
+  isValidSessionConf,
+  isValidEmitterConf,
+  isValidSubjectConf,
+  isValidGdprConf,
+  isValidGCConf,
+  isValidGC,
+  isScreenSize,
+  initValidate,
+};

package/src/constants.ts

@@ -0,0 +1,97 @@
+'use strict';
+
+const logMessages = {
+  // configuration errors
+  namespace: 'namespace parameter is required to be set',
+  endpoint: 'endpoint parameter is required to be set',
+  network: 'networkConfig is invalid',
+  tracker: 'trackerConfig is invalid',
+  session: 'sessionConfig is invalid',
+  emitter: 'emitterConfig is invalid',
+  subject: 'subjectConfig is invalid',
+  gdpr: 'gdprConfig is invalid',
+  gc: 'gcConfig is invalid',
+
+  // event errors
+  context: 'invalid contexts parameter',
+  selfDesc:
+    'selfDescribing event requires schema and data parameters to be set',
+  evType: 'event argument can only be an object',
+  screenViewReq: 'screenView event requires name as string parameter to be set',
+  listItemViewReq:
+    'listItemView event requires index asn integer parameter to be set',
+  structuredReq:
+    'structured event requires category and action parameters to be set',
+  pageviewReq: 'pageView event requires pageUrl parameter to be set',
+  timingReq:
+    'timing event requires category, variable and timing parameters to be set',
+  consentGReq:
+    'consentGranted event requires expiry, documentId and version parameters to be set',
+  consentWReq:
+    'consentWithdrawn event requires all, documentId and version parameters to be set',
+  ecomReq:
+    'ecommerceTransaction event requires orderId, totalValue to be set and items to be an array of valid ecommerceItems',
+  deepLinkReq: 'deepLinkReceived event requires the url parameter to be set',
+  messageNotificationReq:
+    'messageNotification event requires title, body, and trigger parameters to be set',
+
+  // global contexts errors
+  gcTagType: 'tag argument is required to be a string',
+  gcType: 'global context argument is invalid',
+
+  // api error prefix
+  createTracker: 'createTracker:',
+  removeTracker: 'removeTracker: trackerNamespace can only be a string',
+
+  // methods
+  trackSelfDesc: 'trackSelfDescribingEvent:',
+  trackScreenView: 'trackScreenViewEvent:',
+  trackScrollChanged: 'trackScrollChangedEvent:',
+  trackListItemView: 'trackListItemViewEvent:',
+  trackStructured: 'trackStructuredEvent:',
+  trackPageView: 'trackPageViewEvent:',
+  trackTiming: 'trackTimingEvent:',
+  trackConsentGranted: 'trackConsentGranted:',
+  trackConsentWithdrawn: 'trackConsentWithdrawn:',
+  trackEcommerceTransaction: 'trackEcommerceTransaction:',
+  trackDeepLinkReceived: 'trackDeepLinkReceivedEvent:',
+  trackMessageNotification: 'trackMessageNotificationEvent:',
+  removeGlobalContexts: 'removeGlobalContexts:',
+  addGlobalContexts: 'addGlobalContexts:',
+
+  // setters
+  setUserId: 'setUserId: userId can only be a string or null',
+  setNetworkUserId:
+    'setNetworkUserId: networkUserId can only be a string(UUID) or null',
+  setDomainUserId:
+    'setDomainUserId: domainUserId can only be a string(UUID) or null',
+  setIpAddress: 'setIpAddress: ipAddress can only be a string or null',
+  setUseragent: 'setUseragent: useragent can only be a string or null',
+  setTimezone: 'setTimezone: timezone can only be a string or null',
+  setLanguage: 'setLanguage: language can only be a string or null',
+  setScreenResolution:
+    'setScreenResolution: screenResolution can only be of ScreenSize type or null',
+  setScreenViewport:
+    'setScreenViewport: screenViewport can only be of ScreenSize type or null',
+  setColorDepth:
+    'setColorDepth: colorDepth can only be a number(integer) or null',
+  setSubjectData: 'setSubjectData:',
+};
+
+const schemas = {
+  payloadData:
+    'iglu:com.snowplowanalytics.snowplow/payload_data/jsonschema/1-0-4',
+  timingSchema: 'iglu:com.snowplowanalytics.snowplow/timing/jsonschema/1-0-0',
+  deepLinkReceivedSchema:
+    'iglu:com.snowplowanalytics.mobile/deep_link_received/jsonschema/1-0-0',
+  messageNotificationSchema:
+    'iglu:com.snowplowanalytics.mobile/message_notification/jsonschema/1-0-0',
+  screenViewSchema:
+    'iglu:com.snowplowanalytics.mobile/screen_view/jsonschema/1-0-0',
+  scrollChangedSchema:
+    'iglu:com.snowplowanalytics.mobile/scroll_changed/jsonschema/1-0-0',
+  listItemViewSchema:
+    'iglu:com.snowplowanalytics.mobile/list_item_view/jsonschema/1-0-0',
+};
+
+export { logMessages, schemas };