@jmartins-tillster/analytics-react-native 2.21.3

package/packages/core/src/api.ts

@@ -0,0 +1,23 @@
+import type { SegmentEvent } from './types';
+
+export const uploadEvents = async ({
+  writeKey,
+  url,
+  events,
+}: {
+  writeKey: string;
+  url: string;
+  events: SegmentEvent[];
+}) => {
+  return await fetch(url, {
+    method: 'POST',
+    body: JSON.stringify({
+      batch: events,
+      sentAt: new Date().toISOString(),
+      writeKey: writeKey,
+    }),
+    headers: {
+      'Content-Type': 'application/json; charset=utf-8',
+    },
+  });
+};

package/packages/core/src/client.tsx

@@ -0,0 +1,76 @@
+import React, { createContext, useContext } from 'react';
+
+import { defaultConfig } from './constants';
+import type { Config, ClientMethods } from './types';
+import { createLogger } from './logger';
+import { SegmentClient } from './analytics';
+import { SovranStorage } from './storage';
+
+export const createClient = (config: Config) => {
+  const logger = config?.logger || createLogger();
+  if (typeof config?.debug === 'boolean') {
+    if (config.debug) {
+      logger.enable();
+    } else {
+      logger.disable();
+    }
+  }
+  const clientConfig = { ...defaultConfig, ...config };
+
+  const segmentStore = new SovranStorage({
+    storeId: config.writeKey,
+    storePersistor: config.storePersistor,
+    storePersistorSaveDelay: config.storePersistorSaveDelay,
+  });
+
+  const client = new SegmentClient({
+    config: clientConfig,
+    logger,
+    store: segmentStore,
+  });
+
+  // We don't await the client to be initialized to let the user start attaching plugins and queueing events
+  // The client will handle initialization in the background and send events when it is ready
+  // To subscribe to the client being fully initialized use client.isReady.onChange()
+  void client.init();
+
+  return client;
+};
+
+const Context = createContext<SegmentClient | null>(null);
+
+export const AnalyticsProvider = ({
+  client,
+  children,
+}: {
+  client?: SegmentClient;
+  children?: React.ReactNode;
+}) => {
+  if (!client) {
+    return null;
+  }
+
+  return <Context.Provider value={client}>{children}</Context.Provider>;
+};
+
+export const useAnalytics = (): ClientMethods => {
+  const client = useContext(Context);
+  return React.useMemo(() => {
+    if (!client) {
+      console.error(
+        'Segment client not configured!',
+        'To use the useAnalytics() hook, pass an initialized Segment client into the AnalyticsProvider'
+      );
+    }
+
+    return {
+      screen: async (...args) => client?.screen(...args),
+      track: async (...args) => client?.track(...args),
+      identify: async (...args) => client?.identify(...args),
+      flush: async () => client?.flush(),
+      group: async (...args) => client?.group(...args),
+      alias: async (...args) => client?.alias(...args),
+      reset: async (...args) => client?.reset(...args),
+    };
+  }, [client]);
+};

package/packages/core/src/constants.ts

@@ -0,0 +1,18 @@
+import type { Config } from './types';
+
+export const defaultApiHost = 'https://api.segment.io/v1/b';
+export const settingsCDN = 'https://cdn-settings.segment.com/v1/projects';
+
+export const defaultConfig: Config = {
+  writeKey: '',
+  maxBatchSize: 1000,
+  trackDeepLinks: false,
+  trackAppLifecycleEvents: false,
+  autoAddSegmentDestination: true,
+  useSegmentEndpoints: false,
+};
+
+export const workspaceDestinationFilterKey = '';
+
+export const defaultFlushAt = 20;
+export const defaultFlushInterval = 30;

package/packages/core/src/context.ts

@@ -0,0 +1,107 @@
+import { libraryInfo } from './info';
+
+import type {
+  Config,
+  Context,
+  ContextDevice,
+  GetContextConfig,
+  NativeContextInfo,
+  UserTraits,
+} from './types';
+import { getNativeModule } from './util';
+import { getUUID } from './uuid';
+import type { AnalyticsReactNativeModule } from './types';
+
+const defaultContext = {
+  appName: '',
+  appVersion: '',
+  buildNumber: '',
+  bundleId: '',
+  locale: '',
+  networkType: '',
+  osName: '',
+  osVersion: '',
+  screenHeight: 0,
+  screenWidth: 0,
+  timezone: '',
+  manufacturer: '',
+  model: '',
+  deviceName: '',
+  deviceId: '',
+  deviceType: '',
+  screenDensity: 0,
+};
+
+export const getContext = async (
+  userTraits: UserTraits = {},
+  config?: Config
+): Promise<Context> => {
+  // We need to remove all stuff from the config that is not actually required by the native module
+  const nativeConfig: GetContextConfig = {
+    collectDeviceId: config?.collectDeviceId ?? false,
+  };
+
+  const nativeModule = getNativeModule(
+    'AnalyticsReactNative'
+  ) as AnalyticsReactNativeModule;
+
+  const {
+    appName,
+    appVersion,
+    buildNumber,
+    bundleId,
+    locale,
+    networkType,
+    osName,
+    osVersion,
+    screenHeight,
+    screenWidth,
+    timezone,
+    manufacturer,
+    model,
+    deviceName,
+    deviceId,
+    deviceType,
+    screenDensity,
+  }: NativeContextInfo =
+    (await nativeModule.getContextInfo(nativeConfig)) ?? defaultContext;
+
+  const device: ContextDevice = {
+    id: deviceId,
+    manufacturer: manufacturer,
+    model: model,
+    name: deviceName,
+    type: deviceType,
+  };
+
+  return {
+    app: {
+      build: buildNumber,
+      name: appName,
+      namespace: bundleId,
+      version: appVersion,
+    },
+    device,
+    library: {
+      name: 'analytics-react-native',
+      version: libraryInfo.version,
+    },
+    locale,
+    network: {
+      cellular: networkType === 'cellular',
+      wifi: networkType === 'wifi',
+    },
+    os: {
+      name: osName,
+      version: osVersion,
+    },
+    screen: {
+      width: screenWidth,
+      height: screenHeight,
+      density: screenDensity,
+    },
+    timezone,
+    traits: userTraits,
+    instanceId: getUUID(),
+  };
+};

package/packages/core/src/errors.ts

@@ -0,0 +1,123 @@
+/**
+ * Error types reported through the errorHandler in the client
+ */
+export enum ErrorType {
+  NetworkUnexpectedHTTPCode,
+  NetworkServerLimited,
+  NetworkServerRejected,
+  NetworkUnknown,
+
+  JsonUnableToSerialize,
+  JsonUnableToDeserialize,
+  JsonUnknown,
+
+  PluginError,
+
+  InitializationError,
+  ResetError,
+  FlushError,
+}
+
+/**
+ * Segment Error object for ErrorHandler option
+ */
+export class SegmentError extends Error {
+  type: ErrorType;
+  message: string;
+  innerError?: unknown;
+
+  constructor(type: ErrorType, message: string, innerError?: unknown) {
+    super(message);
+    Object.setPrototypeOf(this, SegmentError.prototype);
+    this.type = type;
+    this.message = message;
+    this.innerError = innerError;
+  }
+}
+
+/**
+ * Custom Error type for Segment HTTP Error responses
+ */
+export class NetworkError extends SegmentError {
+  statusCode: number;
+  type:
+    | ErrorType.NetworkServerLimited
+    | ErrorType.NetworkServerRejected
+    | ErrorType.NetworkUnexpectedHTTPCode
+    | ErrorType.NetworkUnknown;
+
+  constructor(statusCode: number, message: string, innerError?: unknown) {
+    let type: ErrorType;
+    if (statusCode === 429) {
+      type = ErrorType.NetworkServerLimited;
+    } else if (statusCode > 300 && statusCode < 400) {
+      type = ErrorType.NetworkUnexpectedHTTPCode;
+    } else if (statusCode >= 400) {
+      type = ErrorType.NetworkServerRejected;
+    } else {
+      type = ErrorType.NetworkUnknown;
+    }
+
+    super(type, message, innerError);
+    Object.setPrototypeOf(this, NetworkError.prototype);
+
+    this.statusCode = statusCode;
+    this.type = type;
+  }
+}
+
+/**
+ * Error type for JSON Serialization errors
+ */
+export class JSONError extends SegmentError {
+  constructor(
+    type: ErrorType.JsonUnableToDeserialize | ErrorType.JsonUnableToSerialize,
+    message: string,
+    innerError?: unknown
+  ) {
+    super(type, message, innerError);
+    Object.setPrototypeOf(this, JSONError.prototype);
+  }
+}
+
+/**
+ * Utility method for handling HTTP fetch errors
+ * @param response Fetch Response
+ * @returns response if status OK, throws NetworkError for everything else
+ */
+export const checkResponseForErrors = (response: Response) => {
+  if (!response.ok) {
+    throw new NetworkError(response.status, response.statusText);
+  }
+
+  return response;
+};
+
+/**
+ * Converts a .fetch() error to a SegmentError object for reporting to the error handler
+ * @param error any JS error instance
+ * @returns a SegmentError object
+ */
+export const translateHTTPError = (error: unknown): SegmentError => {
+  // SegmentError already
+  if (error instanceof SegmentError) {
+    return error;
+    // JSON Deserialization Errors
+  } else if (error instanceof SyntaxError) {
+    return new JSONError(
+      ErrorType.JsonUnableToDeserialize,
+      error.message,
+      error
+    );
+
+    // HTTP Errors
+  } else {
+    const message =
+      error instanceof Error
+        ? error.message
+        : typeof error === 'string'
+        ? error
+        : 'Unknown error';
+    return new NetworkError(-1, message, error);
+  }
+};

package/packages/core/src/events.ts

@@ -0,0 +1,75 @@
+import {
+  GroupEventType,
+  GroupTraits,
+  IdentifyEventType,
+  JsonMap,
+  ScreenEventType,
+  TrackEventType,
+  UserTraits,
+  AliasEventType,
+  EventType,
+} from './types';
+
+export const createTrackEvent = ({
+  event,
+  properties = {},
+}: {
+  event: string;
+  properties?: JsonMap;
+}): TrackEventType => ({
+  type: EventType.TrackEvent,
+  event,
+  properties,
+});
+
+export const createScreenEvent = ({
+  name,
+  properties = {},
+}: {
+  name: string;
+  properties?: JsonMap;
+}): ScreenEventType => ({
+  type: EventType.ScreenEvent,
+  name,
+  properties,
+});
+
+export const createIdentifyEvent = ({
+  userId,
+  userTraits = {},
+}: {
+  userId?: string;
+  userTraits?: UserTraits;
+}): IdentifyEventType => {
+  return {
+    type: EventType.IdentifyEvent,
+    userId: userId,
+    traits: userTraits,
+  };
+};
+
+export const createGroupEvent = ({
+  groupId,
+  groupTraits = {},
+}: {
+  groupId: string;
+  groupTraits?: GroupTraits;
+}): GroupEventType => ({
+  type: EventType.GroupEvent,
+  groupId,
+  traits: groupTraits,
+});
+
+export const createAliasEvent = ({
+  anonymousId,
+  userId,
+  newUserId,
+}: {
+  anonymousId: string;
+  userId?: string;
+  newUserId: string;
+}): AliasEventType => ({
+  type: EventType.AliasEvent,
+  userId: newUserId,
+  previousId: userId ?? anonymousId,
+});

package/packages/core/src/flushPolicies/__tests__/background-flush-policy.test.ts

@@ -0,0 +1,39 @@
+import { BackgroundFlushPolicy } from '../background-flush-policy';
+import { FlushPolicyBase } from '../types';
+import { createTrackEvent } from '../../events';
+
+describe('BackgroundFlushPolicy', () => {
+  let policy: BackgroundFlushPolicy;
+
+  beforeEach(() => {
+    policy = new BackgroundFlushPolicy();
+  });
+
+  test('should be an instance of FlushPolicyBase', () => {
+    expect(policy).toBeInstanceOf(FlushPolicyBase);
+  });
+
+  test('start() should do nothing', () => {
+    expect(policy.start()).toBeUndefined();
+  });
+
+  test('end() should do nothing', () => {
+    expect(policy.end()).toBeUndefined();
+  });
+
+  test('onEvent() should set shouldFlush to true for "Application Backgrounded" event', () => {
+    const event = createTrackEvent({
+      event: 'Application Backgrounded',
+    });
+    policy.onEvent(event);
+    expect(policy.shouldFlush.value).toBe(true);
+  });
+
+  test('onEvent() should not set shouldFlush for other events', () => {
+    const event = createTrackEvent({
+      event: 'Application Opened',
+    });
+    policy.onEvent(event);
+    expect(policy.shouldFlush.value).toBeFalsy();
+  });
+});

package/packages/core/src/flushPolicies/__tests__/count-flush-policy.test.ts

@@ -0,0 +1,28 @@
+import type { SegmentEvent } from '../../types';
+import { CountFlushPolicy } from '../count-flush-policy';
+
+describe('CountFlushPolicy', () => {
+  it('triggers a flush when reaching limit', () => {
+    const policy = new CountFlushPolicy(3);
+
+    const observer = jest.fn();
+
+    policy.shouldFlush.onChange(observer);
+
+    policy.onEvent({} as SegmentEvent);
+    policy.onEvent({} as SegmentEvent);
+    policy.onEvent({} as SegmentEvent);
+
+    expect(observer).toHaveBeenCalledWith(true);
+
+    // Keeps triggering until handled / reset
+    policy.onEvent({} as SegmentEvent);
+    expect(observer).toHaveBeenCalledTimes(2);
+
+    policy.reset();
+    policy.onEvent({} as SegmentEvent);
+    policy.onEvent({} as SegmentEvent);
+    policy.onEvent({} as SegmentEvent);
+    expect(observer).toHaveBeenCalledTimes(4);
+  });
+});

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

@@ -0,0 +1,85 @@
+import { CountFlushPolicy } from '../count-flush-policy';
+import { FlushPolicyExecuter } from '../flush-policy-executer';
+import { TimerFlushPolicy } from '../timer-flush-policy';
+import type { SegmentEvent } from '../../types';
+
+describe('FlushPolicyExecuter', () => {
+  beforeEach(() => {
+    jest.useFakeTimers();
+  });
+
+  it('executes flush per policy', () => {
+    const policies = [new CountFlushPolicy(2), new TimerFlushPolicy(100)];
+    const flush = jest.fn();
+
+    const executer = new FlushPolicyExecuter(policies, flush);
+
+    executer.notify({} as SegmentEvent);
+    executer.notify({} as SegmentEvent);
+
+    // CountFlushPolicy should flush as there's 2 events now
+    expect(flush).toHaveBeenCalledTimes(1);
+
+    // When the timer is up the TimerFlushPolicy should also execute
+    jest.advanceTimersByTime(100);
+    expect(flush).toHaveBeenCalledTimes(2);
+  });
+
+  it('resets al policies', () => {
+    const countPolicy = new CountFlushPolicy(2);
+    const timerPolicy = new TimerFlushPolicy(100);
+    const policies = [countPolicy, timerPolicy];
+    const flush = jest.fn();
+
+    const executer = new FlushPolicyExecuter(policies, flush);
+
+    executer.notify({} as SegmentEvent);
+    executer.notify({} as SegmentEvent);
+    expect(countPolicy.shouldFlush.value).toBe(true);
+
+    executer.reset();
+    expect(countPolicy.shouldFlush.value).toBe(false);
+  });
+
+  it('can remove policies', () => {
+    const countPolicy = new CountFlushPolicy(2);
+    const timerPolicy = new TimerFlushPolicy(100);
+    const policies = [countPolicy, timerPolicy];
+    const flush = jest.fn();
+
+    const executer = new FlushPolicyExecuter(policies, flush);
+
+    executer.notify({} as SegmentEvent);
+
+    executer.remove(countPolicy);
+
+    executer.notify({} as SegmentEvent);
+
+    // No CountPolicy so it shouldn't trigger
+    expect(flush).not.toHaveBeenCalled();
+
+    // But timer will still flush
+    jest.advanceTimersByTime(100);
+    expect(flush).toHaveBeenCalledTimes(1);
+  });
+
+  it('can add policies', () => {
+    const countPolicy = new CountFlushPolicy(2);
+    const policies = [countPolicy];
+    const flush = jest.fn();
+
+    const executer = new FlushPolicyExecuter(policies, flush);
+
+    executer.notify({} as SegmentEvent);
+    executer.notify({} as SegmentEvent);
+
+    expect(flush).toHaveBeenCalledTimes(1);
+
+    const timerPolicy = new TimerFlushPolicy(100);
+    executer.add(timerPolicy);
+
+    // But timer will still flush
+    jest.advanceTimersByTime(100);
+    expect(flush).toHaveBeenCalledTimes(2);
+  });
+});

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

@@ -0,0 +1,30 @@
+import { TimerFlushPolicy } from '../timer-flush-policy';
+
+describe('TimerFlushPolicy', () => {
+  beforeEach(() => {
+    jest.useFakeTimers();
+  });
+
+  it('triggers a flush when timer is done', () => {
+    const time = 100;
+    const policy = new TimerFlushPolicy(time);
+    policy.start();
+
+    const observer = jest.fn();
+
+    policy.shouldFlush.onChange(observer);
+
+    jest.advanceTimersByTime(time);
+    expect(observer).toHaveBeenCalledWith(true);
+
+    // Won't trigger again until it is handled and reset
+    jest.advanceTimersByTime(time);
+    expect(observer).toHaveBeenCalledTimes(1);
+
+    policy.reset();
+    expect(observer).toHaveBeenCalledWith(false);
+    jest.advanceTimersByTime(time);
+    // + 1 for reset, + 1 for timer
+    expect(observer).toHaveBeenCalledTimes(3);
+  });
+});

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

@@ -0,0 +1,21 @@
+import type { SegmentEvent } from '../types';
+import { FlushPolicyBase } from './types';
+
+/**
+ * StatupFlushPolicy triggers a flush right away on client startup
+ */
+export class BackgroundFlushPolicy extends FlushPolicyBase {
+  start() {
+    // Nothing to do
+  }
+
+  onEvent(_event: SegmentEvent): void {
+    if ('event' in _event && _event.event === 'Application Backgrounded') {
+      this.shouldFlush.value = true;
+    }
+  }
+
+  end(): void {
+    // Nothing to do
+  }
+}

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

@@ -0,0 +1,31 @@
+import type { SegmentEvent } from '../types';
+import { FlushPolicyBase } from './types';
+
+/**
+ * CountFlushPolicy uploads events when the count of events reaches a set limit
+ */
+export class CountFlushPolicy extends FlushPolicyBase {
+  private count = 0;
+  private flushAt: number;
+
+  constructor(limit: number) {
+    super();
+    this.flushAt = limit;
+  }
+
+  start(): void {
+    this.count = 0;
+  }
+
+  onEvent(_event: SegmentEvent): void {
+    this.count += 1;
+    if (this.count >= this.flushAt) {
+      this.shouldFlush.value = true;
+    }
+  }
+
+  reset(): void {
+    super.reset();
+    this.count = 0;
+  }
+}