@jmartins-tillster/analytics-react-native 2.21.3

package/packages/core/src/flushPolicies/flush-policy-executer.ts

@@ -0,0 +1,100 @@
+import type { Unsubscribe } from '@segment/sovran-react-native';
+import type { SegmentEvent } from '../types';
+import type { FlushPolicy } from './types';
+
+export class FlushPolicyExecuter {
+  readonly policies: FlushPolicy[];
+  private observers: Unsubscribe[] = [];
+  private onFlush: () => void;
+
+  constructor(policies: FlushPolicy[], onFlush: () => void) {
+    this.policies = [...policies];
+    this.onFlush = onFlush;
+
+    // Now listen to changes on the flush policies shouldFlush
+    for (const policy of this.policies) {
+      this.startPolicy(policy);
+    }
+  }
+
+  add(policy: FlushPolicy) {
+    this.startPolicy(policy);
+    this.policies.push(policy);
+  }
+
+  remove(policy: FlushPolicy) {
+    policy.end();
+    const i = this.policies.findIndex((p) => p === policy);
+    return this.removeIndex(i);
+  }
+
+  removeIndex(index: number): boolean {
+    if (index < 0) {
+      return false;
+    }
+
+    const policy = this.policies[index];
+
+    if (policy !== undefined) {
+      policy.reset();
+      this.policies.splice(index, 1);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Checks if any flush policy is requesting a flush
+   * This is only intended for startup/initialization, all policy shouldFlush
+   * changes are already observed and reacted to.
+   *
+   * This is for policies that might startup with a shouldFlush = true value
+   */
+  manualFlush() {
+    for (const policy of this.policies) {
+      if (policy.shouldFlush.value) {
+        this.onFlush();
+        break;
+      }
+    }
+  }
+
+  /**
+   * Notifies each flush policy that an event is being processed
+   */
+  notify(event: SegmentEvent) {
+    for (const policy of this.policies) {
+      policy.onEvent(event);
+    }
+  }
+
+  /**
+   * Resets all flush policies
+   */
+  reset() {
+    for (const policy of this.policies) {
+      policy.reset();
+    }
+  }
+
+  cleanup() {
+    if (this.observers.length > 0) {
+      for (const unsubscribe of this.observers) {
+        unsubscribe();
+      }
+    }
+    for (const policy of this.policies) {
+      policy.end();
+    }
+  }
+
+  private startPolicy(policy: FlushPolicy) {
+    const unsubscribe = policy.shouldFlush.onChange((shouldFlush) => {
+      if (shouldFlush) {
+        this.onFlush();
+      }
+    });
+    this.observers.push(unsubscribe);
+    policy.start();
+  }
+}

package/packages/core/src/flushPolicies/index.ts

@@ -0,0 +1,5 @@
+export * from './types';
+export * from './count-flush-policy';
+export * from './timer-flush-policy';
+export * from './startup-flush-policy';
+export * from './background-flush-policy';

package/packages/core/src/flushPolicies/startup-flush-policy.ts

@@ -0,0 +1,20 @@
+import type { SegmentEvent } from '../types';
+import { FlushPolicyBase } from './types';
+
+/**
+ * StatupFlushPolicy triggers a flush right away on client startup
+ */
+export class StartupFlushPolicy extends FlushPolicyBase {
+  constructor() {
+    super();
+    this.shouldFlush.value = true;
+  }
+
+  start(): void {
+    // Nothing to do
+  }
+
+  onEvent(_event: SegmentEvent): void {
+    // Nothing to do
+  }
+}

package/packages/core/src/flushPolicies/timer-flush-policy.ts

@@ -0,0 +1,45 @@
+import type { SegmentEvent } from '../types';
+import { FlushPolicyBase } from './types';
+
+/**
+ * A Timer based flush policy.
+ *
+ * Flushes events on an interval.
+ */
+export class TimerFlushPolicy extends FlushPolicyBase {
+  private flushTimeout!: ReturnType<typeof setTimeout>;
+  private interval: number;
+
+  private startTimer() {
+    clearTimeout(this.flushTimeout);
+    this.flushTimeout = setTimeout(() => {
+      this.shouldFlush.value = true;
+    }, this.interval);
+  }
+
+  /**
+   * @param interval interval to flush in milliseconds
+   */
+  constructor(interval: number) {
+    super();
+    this.interval = interval;
+  }
+
+  start(): void {
+    this.startTimer();
+  }
+
+  end(): void {
+    clearTimeout(this.flushTimeout);
+  }
+
+  onEvent(_event: SegmentEvent): void {
+    // Reset interval
+    this.startTimer();
+  }
+
+  reset(): void {
+    super.reset();
+    this.startTimer();
+  }
+}

package/packages/core/src/flushPolicies/types.ts

@@ -0,0 +1,93 @@
+import type { SegmentEvent } from '../types';
+
+type Observer<T> = (value: T) => void;
+
+/**
+ * A simple observable value or object
+ */
+export class Observable<T> {
+  private internalValue: T;
+  private observers: Observer<T>[];
+
+  constructor(value: T) {
+    this.internalValue = value;
+    this.observers = [];
+  }
+
+  public get value(): T {
+    return this.internalValue;
+  }
+
+  public set value(v: T) {
+    this.internalValue = v;
+    for (const observer of this.observers) {
+      observer(this.internalValue);
+    }
+  }
+
+  public onChange(observer: Observer<T>): () => void {
+    const n = this.observers.push(observer);
+    return () => {
+      this.observers.splice(n - 1, 1);
+    };
+  }
+}
+
+/**
+ * FlushPolicy defines the strategy for executing flushes
+ * (uploading events to destinations)
+ */
+export interface FlushPolicy {
+  /**
+   * Marks when the client should atempt to upload events
+   */
+  shouldFlush: Observable<boolean>;
+
+  /**
+   * Start gets executed when the FlushPolicy is added to the client.
+   *
+   * This is a good place to initialize configuration or timers as it will only
+   * execute when this policy is enabled
+   */
+  start(): void;
+
+  /**
+   * Executed every time an event is tracked by the client
+   * @param event triggered event
+   */
+  onEvent(event: SegmentEvent): void;
+
+  /**
+   * Resets the values of this policy.
+   *
+   * Called when the flush has been completed.
+   */
+  reset(): void;
+
+  /**
+   * Ends the execution of the flush policy.
+   * All cleanup methods should be contained here
+   */
+  end(): void;
+}
+
+/**
+ * A Base Class for implementing a FlushPolicy.
+ *
+ * Initializes the shouldFlush value to false and sets it to false on reset
+ */
+export abstract class FlushPolicyBase implements FlushPolicy {
+  shouldFlush = new Observable<boolean>(false);
+
+  reset(): void {
+    this.shouldFlush.value = false;
+  }
+
+  end(): void {
+    // Nothing to cleanup
+  }
+
+  abstract start(): void;
+
+  abstract onEvent(event: SegmentEvent): void;
+}

package/packages/core/src/index.ts

@@ -0,0 +1,28 @@
+export { defaultConfig } from './constants';
+export * from './client';
+export * from './plugin';
+export * from './types';
+export * from './mapTransform';
+export {
+  getNativeModule,
+  isNumber,
+  isString,
+  isObject,
+  isBoolean,
+  isDate,
+  objectToString,
+  unknownToString,
+  deepCompare,
+  chunk,
+} from './util';
+export { SegmentClient } from './analytics';
+export { QueueFlushingPlugin } from './plugins/QueueFlushingPlugin';
+export { createTrackEvent } from './events';
+export { uploadEvents } from './api';
+export { SegmentDestination } from './plugins/SegmentDestination';
+export {
+  type CategoryConsentStatusProvider,
+  ConsentPlugin,
+} from './plugins/ConsentPlugin';
+export * from './flushPolicies';
+export * from './errors';

package/packages/core/src/logger.ts

@@ -0,0 +1,37 @@
+import type { DeactivableLoggerType } from './types';
+
+export class Logger implements DeactivableLoggerType {
+  isDisabled: boolean;
+
+  constructor(isDisabled: boolean = process.env.NODE_ENV === 'production') {
+    this.isDisabled = isDisabled;
+  }
+
+  enable() {
+    this.isDisabled = false;
+  }
+
+  disable() {
+    this.isDisabled = true;
+  }
+
+  info(message?: unknown, ...optionalParams: unknown[]): void {
+    if (!this.isDisabled) {
+      console.info(message, ...optionalParams);
+    }
+  }
+
+  warn(message?: unknown, ...optionalParams: unknown[]): void {
+    if (!this.isDisabled) {
+      console.warn(message, ...optionalParams);
+    }
+  }
+
+  error(message?: unknown, ...optionalParams: unknown[]): void {
+    if (!this.isDisabled) {
+      console.error(message, ...optionalParams);
+    }
+  }
+}
+
+export const createLogger = (isDisabled?: boolean) => new Logger(isDisabled);

package/packages/core/src/mapTransform.ts

@@ -0,0 +1,48 @@
+import { isObject } from './util';
+
+/**
+ * Generates a mapTransform function from a keymap and a transform map.
+ * The resulting function can be called with any object/dictionary and return
+ * a new object with key replacements and value transformations applied
+ *
+ * @param keyMap A dictionary of key mappings in format: ['OLD':'NEW']
+ * @param transformMap A map of transformations by key (new key if the key was replaced)
+ * @returns A function that maps keys from an object and transforms its values
+ */
+export const generateMapTransform = (
+  keyMap: { [key: string]: string },
+  transformMap: { [key: string]: (oldValue: unknown) => unknown }
+) => {
+  const mapTransform = (
+    json: Record<string, unknown>
+  ): Record<string, unknown> => {
+    // Clone at top level
+    const result: Record<string, unknown> = {};
+
+    for (const key in json) {
+      const newKey = keyMap[key] ?? key;
+
+      let value = json[key];
+
+      if (Array.isArray(value)) {
+        value = value.map((nestedValue) => {
+          if (isObject(nestedValue)) {
+            return mapTransform(nestedValue);
+          }
+          return nestedValue as unknown;
+        });
+      } else if (isObject(value)) {
+        value = mapTransform(value);
+      }
+
+      if (newKey in transformMap) {
+        value = transformMap[newKey](value);
+      }
+
+      result[newKey] = value;
+    }
+
+    return result;
+  };
+  return mapTransform;
+};

package/packages/core/src/plugin.ts

@@ -0,0 +1,212 @@
+import type { SegmentClient } from './analytics';
+import { Timeline } from './timeline';
+import {
+  AliasEventType,
+  EventType,
+  GroupEventType,
+  IdentifyEventType,
+  PluginType,
+  ScreenEventType,
+  SegmentAPISettings,
+  SegmentEvent,
+  TrackEventType,
+  UpdateType,
+} from './types';
+
+export class Plugin {
+  // default to utility to avoid automatic processing
+  type: PluginType = PluginType.utility;
+  analytics?: SegmentClient = undefined;
+
+  configure(analytics: SegmentClient) {
+    this.analytics = analytics;
+  }
+
+  update(_settings: SegmentAPISettings, _type: UpdateType) {
+    // do nothing by default, user can override.
+  }
+
+  execute(
+    event: SegmentEvent
+  ): Promise<SegmentEvent | undefined> | SegmentEvent | undefined {
+    // do nothing.
+    return event;
+  }
+
+  shutdown() {
+    // do nothing by default, user can override.
+  }
+}
+
+export class EventPlugin extends Plugin {
+  execute(
+    event: SegmentEvent
+  ): Promise<SegmentEvent | undefined> | SegmentEvent | undefined {
+    if (event === undefined) {
+      return event;
+    }
+    let result: Promise<SegmentEvent | undefined> | SegmentEvent | undefined =
+      event;
+    switch (result.type) {
+      case EventType.IdentifyEvent:
+        result = this.identify(result);
+        break;
+      case EventType.TrackEvent:
+        result = this.track(result);
+        break;
+      case EventType.ScreenEvent:
+        result = this.screen(result);
+        break;
+      case EventType.AliasEvent:
+        result = this.alias(result);
+        break;
+      case EventType.GroupEvent:
+        result = this.group(result);
+        break;
+    }
+    return result;
+  }
+
+  // Default implementations that forward the event. This gives plugin
+  // implementors the chance to interject on an event.
+  identify(
+    event: IdentifyEventType
+  ): Promise<IdentifyEventType | undefined> | IdentifyEventType | undefined {
+    return event;
+  }
+
+  track(
+    event: TrackEventType
+  ): Promise<TrackEventType | undefined> | TrackEventType | undefined {
+    return event;
+  }
+
+  screen(
+    event: ScreenEventType
+  ): Promise<ScreenEventType | undefined> | ScreenEventType | undefined {
+    return event;
+  }
+
+  alias(
+    event: AliasEventType
+  ): Promise<AliasEventType | undefined> | AliasEventType | undefined {
+    return event;
+  }
+
+  group(
+    event: GroupEventType
+  ): Promise<GroupEventType | undefined> | GroupEventType | undefined {
+    return event;
+  }
+
+  flush(): void | Promise<void> {
+    return;
+  }
+
+  reset(): void | Promise<void> {
+    return;
+  }
+}
+
+export class DestinationPlugin extends EventPlugin {
+  // default to destination
+  type = PluginType.destination;
+
+  key = '';
+
+  timeline = new Timeline();
+
+  private hasSettings() {
+    return this.analytics?.settings.get()?.[this.key] !== undefined;
+  }
+
+  private isEnabled(event: SegmentEvent): boolean {
+    let customerDisabled = false;
+    if (event.integrations?.[this.key] === false) {
+      customerDisabled = true;
+    }
+
+    return this.hasSettings() && !customerDisabled;
+  }
+
+  /**
+     Adds a new plugin to the currently loaded set.
+
+     - Parameter plugin: The plugin to be added.
+     - Returns: Returns the name of the supplied plugin.
+  */
+  add(plugin: Plugin) {
+    const analytics = this.analytics;
+    if (analytics) {
+      plugin.configure(analytics);
+    }
+    this.timeline.add(plugin);
+    return plugin;
+  }
+
+  /**
+     Applies the supplied closure to the currently loaded set of plugins.
+
+     - Parameter closure: A closure that takes an plugin to be operated on as a parameter.
+  */
+  apply(closure: (plugin: Plugin) => void) {
+    this.timeline.apply(closure);
+  }
+
+  configure(analytics: SegmentClient) {
+    this.analytics = analytics;
+    this.apply((plugin) => {
+      plugin.configure(analytics);
+    });
+  }
+
+  /**
+     Removes and unloads plugins with a matching name from the system.
+
+     - Parameter pluginName: An plugin name.
+  */
+  remove(plugin: Plugin) {
+    this.timeline.remove(plugin);
+  }
+
+  async execute(event: SegmentEvent): Promise<SegmentEvent | undefined> {
+    if (!this.isEnabled(event)) {
+      return;
+    }
+
+    // Apply before and enrichment plugins
+    const beforeResult = await this.timeline.applyPlugins({
+      type: PluginType.before,
+      event,
+    });
+
+    if (beforeResult === undefined) {
+      return;
+    }
+
+    const enrichmentResult = await this.timeline.applyPlugins({
+      type: PluginType.enrichment,
+      event: beforeResult,
+    });
+
+    if (enrichmentResult === undefined) {
+      return;
+    }
+
+    // Now send the event to the destination by executing the normal flow of an EventPlugin
+    await super.execute(enrichmentResult);
+
+    // apply .after plugins
+    const afterResult = await this.timeline.applyPlugins({
+      type: PluginType.after,
+      event: enrichmentResult,
+    });
+
+    return afterResult;
+  }
+}
+
+export class UtilityPlugin extends EventPlugin {}
+
+// For internal platform-specific bits
+export class PlatformPlugin extends Plugin {}