@amplitude/analytics-react-native 0.0.1-dev.8 → 0.1.1

package/src/config.ts

@@ -0,0 +1,236 @@
+import {
+  Event,
+  ReactNativeOptions,
+  ReactNativeConfig as IReactNativeConfig,
+  Storage,
+  TrackingOptions,
+  UserSession,
+  SessionManager as ISessionManager,
+} from '@amplitude/analytics-types';
+import { Config, MemoryStorage, UUID } from '@amplitude/analytics-core';
+
+import { CookieStorage } from './storage/cookie';
+import { FetchTransport } from './transports/fetch';
+import { LocalStorage } from './storage/local-storage';
+import { getCookieName } from './utils/cookie-name';
+import { getQueryParams } from './utils/query-params';
+import { SessionManager } from './session-manager';
+
+export const getDefaultConfig = () => {
+  const cookieStorage = new MemoryStorage<UserSession>();
+  return {
+    cookieExpiration: 365,
+    cookieSameSite: 'Lax',
+    cookieSecure: false,
+    cookieStorage,
+    disableCookies: false,
+    domain: '',
+    sessionManager: new SessionManager(cookieStorage, ''),
+    sessionTimeout: 30 * 60 * 1000,
+    storageProvider: new MemoryStorage<Event[]>(),
+    trackingOptions: {
+      city: true,
+      country: true,
+      carrier: true,
+      deviceManufacturer: true,
+      deviceModel: true,
+      dma: true,
+      ipAddress: true,
+      language: true,
+      osName: true,
+      osVersion: true,
+      platform: true,
+      region: true,
+      versionName: true,
+    },
+    transportProvider: new FetchTransport(),
+  };
+};
+
+export class ReactNativeConfig extends Config implements IReactNativeConfig {
+  appVersion?: string;
+  cookieExpiration: number;
+  cookieSameSite: string;
+  cookieSecure: boolean;
+  cookieStorage: Storage<UserSession>;
+  disableCookies: boolean;
+  domain: string;
+  partnerId?: string;
+  sessionTimeout: number;
+  trackingOptions: TrackingOptions;
+  sessionManager: ISessionManager;
+
+  constructor(apiKey: string, userId?: string, options?: ReactNativeOptions) {
+    const defaultConfig = getDefaultConfig();
+    super({
+      flushIntervalMillis: 1000,
+      flushMaxRetries: 5,
+      flushQueueSize: 30,
+      ...options,
+      apiKey,
+      storageProvider: options?.storageProvider ?? defaultConfig.storageProvider,
+      transportProvider: options?.transportProvider ?? defaultConfig.transportProvider,
+    });
+    this.cookieStorage = options?.cookieStorage ?? defaultConfig.cookieStorage;
+    this.sessionManager = options?.sessionManager ?? defaultConfig.sessionManager;
+    this.sessionTimeout = options?.sessionTimeout ?? defaultConfig.sessionTimeout;
+
+    this.appVersion = options?.appVersion;
+    this.cookieExpiration = options?.cookieExpiration ?? defaultConfig.cookieExpiration;
+    this.cookieSameSite = options?.cookieSameSite ?? defaultConfig.cookieSameSite;
+    this.cookieSecure = options?.cookieSecure ?? defaultConfig.cookieSecure;
+    this.deviceId = options?.deviceId;
+    this.disableCookies = options?.disableCookies ?? defaultConfig.disableCookies;
+    this.domain = options?.domain ?? defaultConfig.domain;
+    this.lastEventTime = this.lastEventTime ?? options?.lastEventTime;
+    this.optOut = Boolean(options?.optOut);
+    this.partnerId = options?.partnerId;
+    this.sessionId = options?.sessionId;
+    this.trackingOptions = options?.trackingOptions ?? defaultConfig.trackingOptions;
+    this.userId = userId;
+  }
+
+  get deviceId() {
+    return this.sessionManager.getDeviceId();
+  }
+
+  set deviceId(deviceId: string | undefined) {
+    this.sessionManager.setDeviceId(deviceId);
+  }
+
+  get userId() {
+    return this.sessionManager.getUserId();
+  }
+
+  set userId(userId: string | undefined) {
+    this.sessionManager.setUserId(userId);
+  }
+
+  get sessionId() {
+    return this.sessionManager.getSessionId();
+  }
+
+  set sessionId(sessionId: number | undefined) {
+    this.sessionManager.setSessionId(sessionId);
+  }
+
+  get optOut() {
+    return this.sessionManager.getOptOut();
+  }
+
+  set optOut(optOut: boolean) {
+    this.sessionManager?.setOptOut(Boolean(optOut));
+  }
+
+  get lastEventTime() {
+    return this.sessionManager.getLastEventTime();
+  }
+
+  set lastEventTime(lastEventTime: number | undefined) {
+    this.sessionManager.setLastEventTime(lastEventTime);
+  }
+}
+
+export const useReactNativeConfig = async (
+  apiKey: string,
+  userId?: string,
+  options?: ReactNativeOptions,
+): Promise<IReactNativeConfig> => {
+  const defaultConfig = getDefaultConfig();
+  const domain = options?.domain ?? (await getTopLevelDomain());
+  const cookieStorage = await createCookieStorage({ ...options, domain });
+  const cookieName = getCookieName(apiKey);
+  const cookies = await cookieStorage.get(cookieName);
+  const queryParams = getQueryParams();
+  const sessionManager = await new SessionManager(cookieStorage, apiKey).load();
+
+  return new ReactNativeConfig(apiKey, userId ?? cookies?.userId, {
+    ...options,
+    cookieStorage,
+    sessionManager,
+    deviceId: createDeviceId(cookies?.deviceId, options?.deviceId, queryParams.deviceId),
+    domain,
+    optOut: options?.optOut ?? Boolean(cookies?.optOut),
+    sessionId: (await cookieStorage.get(cookieName))?.sessionId ?? options?.sessionId,
+    storageProvider: await createEventsStorage(options),
+    trackingOptions: { ...defaultConfig.trackingOptions, ...options?.trackingOptions },
+    transportProvider: options?.transportProvider ?? new FetchTransport(),
+  });
+};
+
+export const createCookieStorage = async (
+  overrides?: ReactNativeOptions,
+  baseConfig = getDefaultConfig(),
+): Promise<Storage<UserSession>> => {
+  const options = { ...baseConfig, ...overrides };
+  const cookieStorage = overrides?.cookieStorage;
+  if (!cookieStorage || !(await cookieStorage.isEnabled())) {
+    return createFlexibleStorage<UserSession>(options);
+  }
+  return cookieStorage;
+};
+
+export const createFlexibleStorage = async <T>(options: ReactNativeOptions): Promise<Storage<T>> => {
+  let storage: Storage<T> = new CookieStorage({
+    domain: options.domain,
+    expirationDays: options.cookieExpiration,
+    sameSite: options.cookieSameSite,
+    secure: options.cookieSecure,
+  });
+  if (options.disableCookies || !(await storage.isEnabled())) {
+    storage = new LocalStorage();
+    if (!(await storage.isEnabled())) {
+      storage = new MemoryStorage();
+    }
+  }
+  return storage;
+};
+
+export const createEventsStorage = async (overrides?: ReactNativeOptions): Promise<Storage<Event[]> | undefined> => {
+  const hasStorageProviderProperty = overrides && Object.prototype.hasOwnProperty.call(overrides, 'storageProvider');
+  // If storageProperty is explicitly undefined like `{ storageProperty: undefined }`
+  // then storageProvider is undefined
+  // If storageProvider is implicitly undefined like `{ }`
+  // then storageProvider is LocalStorage
+  // Otherwise storageProvider is overriden
+  if (!hasStorageProviderProperty || overrides.storageProvider) {
+    for (const storage of [overrides?.storageProvider, new LocalStorage<Event[]>()]) {
+      if (storage && (await storage.isEnabled())) {
+        return storage;
+      }
+    }
+  }
+  return undefined;
+};
+
+export const createDeviceId = (idFromCookies?: string, idFromOptions?: string, idFromQueryParams?: string) => {
+  return idFromOptions || idFromQueryParams || idFromCookies || UUID();
+};
+
+export const getTopLevelDomain = async (url?: string) => {
+  if (!(await new CookieStorage<string>().isEnabled()) || (!url && typeof location === 'undefined')) {
+    return '';
+  }
+
+  const host = url ?? location.hostname;
+  const parts = host.split('.');
+  const levels = [];
+  const storageKey = 'AMP_TLDTEST';
+
+  for (let i = parts.length - 2; i >= 0; --i) {
+    levels.push(parts.slice(i).join('.'));
+  }
+  for (let i = 0; i < levels.length; i++) {
+    const domain = levels[i];
+    const options = { domain: '.' + domain };
+    const storage = new CookieStorage<number>(options);
+    await storage.set(storageKey, 1);
+    const value = await storage.get(storageKey);
+    if (value) {
+      await storage.remove(storageKey);
+      return '.' + domain;
+    }
+  }
+
+  return '';
+};

package/src/cookie-migration/index.ts

@@ -0,0 +1,54 @@
+import { BrowserOptions, Storage, UserSession } from '@amplitude/analytics-types';
+import { getOldCookieName } from '../utils/cookie-name';
+import { LocalStorage } from '../storage/local-storage';
+import { CookieStorage } from '../storage/cookie';
+
+export const parseOldCookies = async (apiKey: string, options?: BrowserOptions): Promise<UserSession> => {
+  let storage: Storage<string> = new CookieStorage<string>();
+  if (!(await storage.isEnabled()) || options?.disableCookies) {
+    storage = new LocalStorage<string>();
+  }
+  if (!(await storage.isEnabled())) {
+    return {
+      optOut: false,
+    };
+  }
+
+  const oldCookieName = getOldCookieName(apiKey);
+  const cookies = await storage.getRaw(oldCookieName);
+
+  if (!cookies) {
+    return {
+      optOut: false,
+    };
+  }
+
+  await storage.remove(oldCookieName);
+  const [deviceId, userId, optOut, sessionId, lastEventTime] = cookies.split('.');
+  return {
+    deviceId,
+    userId: decode(userId),
+    sessionId: parseTime(sessionId),
+    lastEventTime: parseTime(lastEventTime),
+    optOut: Boolean(optOut),
+  };
+};
+
+export const parseTime = (num: string) => {
+  const integer = parseInt(num, 32);
+  if (isNaN(integer)) {
+    return undefined;
+  }
+  return integer;
+};
+
+export const decode = (value?: string): string | undefined => {
+  if (!atob || !escape || !value) {
+    return undefined;
+  }
+  try {
+    return decodeURIComponent(escape(atob(value)));
+  } catch {
+    return undefined;
+  }
+};

package/src/index.ts

@@ -0,0 +1,24 @@
+export {
+  add,
+  flush,
+  getDeviceId,
+  getSessionId,
+  getUserId,
+  groupIdentify,
+  identify,
+  init,
+  logEvent,
+  remove,
+  revenue,
+  setDeviceId,
+  setGroup,
+  setOptOut,
+  setSessionId,
+  setUserId,
+  track,
+} from './react-native-client';
+export { Revenue, Identify } from '@amplitude/analytics-core';
+// Hack - react-native apps have trouble with:
+// export * as Types from '@amplitude/analytics-types
+import * as Types from '@amplitude/analytics-types';
+export { Types };

package/src/plugins/context.ts

@@ -0,0 +1,106 @@
+import { BeforePlugin, ReactNativeConfig, Event, PluginType } from '@amplitude/analytics-types';
+import UAParser from '@amplitude/ua-parser-js';
+import { UUID } from '@amplitude/analytics-core';
+import { getLanguage } from '../utils/language';
+import { VERSION } from '../version';
+import { NativeModules } from 'react-native';
+
+const BROWSER_PLATFORM = 'Web';
+const IP_ADDRESS = '$remote';
+
+type NativeContext = {
+  version: string;
+  platform: string;
+  language: string;
+  osName: string;
+  osVersion: string;
+  deviceBrand: string;
+  deviceManufacturer: string;
+  deviceModel: string;
+  carrier: string;
+};
+
+export interface AmplitudeReactNative {
+  getApplicationContext(): Promise<NativeContext>;
+}
+
+export class Context implements BeforePlugin {
+  name = 'context';
+  type = PluginType.BEFORE as const;
+
+  // this.config is defined in setup() which will always be called first
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+  config: ReactNativeConfig;
+  eventId = 0;
+  uaResult: UAParser.IResult;
+  nativeModule: AmplitudeReactNative | undefined = NativeModules.AmplitudeReactNative as
+    | AmplitudeReactNative
+    | undefined;
+  library = `amplitude-react-native-ts/${VERSION}`;
+
+  constructor() {
+    let agent: string | undefined;
+    /* istanbul ignore else */
+    if (typeof navigator !== 'undefined') {
+      agent = navigator.userAgent;
+    }
+    this.uaResult = new UAParser(agent).getResult();
+  }
+
+  setup(config: ReactNativeConfig): Promise<undefined> {
+    this.config = config;
+    return Promise.resolve(undefined);
+  }
+
+  async execute(context: Event): Promise<Event> {
+    /**
+     * Manages user session triggered by new events
+     */
+    if (!this.isSessionValid()) {
+      // Creates new session
+      this.config.sessionId = Date.now();
+    } // else use previously creates session
+    // Updates last event time to extend time-based session
+    this.config.lastEventTime = Date.now();
+    const time = new Date().getTime();
+    const nativeContext = await this.nativeModule?.getApplicationContext();
+    const appVersion = nativeContext?.version || this.config.appVersion;
+    const platform = nativeContext?.platform || BROWSER_PLATFORM;
+    const osName = nativeContext?.osName || this.uaResult.browser.name;
+    const osVersion = nativeContext?.osVersion || this.uaResult.browser.version;
+    const deviceVendor = nativeContext?.deviceManufacturer || this.uaResult.device.vendor;
+    const deviceModel = nativeContext?.deviceModel || this.uaResult.device.model || this.uaResult.os.name;
+    const language = nativeContext?.language || getLanguage();
+    const carrier = nativeContext?.carrier;
+
+    const event: Event = {
+      user_id: this.config.userId,
+      device_id: this.config.deviceId,
+      session_id: this.config.sessionId,
+      time,
+      ...(this.config.appVersion && { app_version: appVersion }),
+      ...(this.config.trackingOptions.platform && { platform: platform }),
+      ...(this.config.trackingOptions.osName && { os_name: osName }),
+      ...(this.config.trackingOptions.osVersion && { os_version: osVersion }),
+      ...(this.config.trackingOptions.deviceManufacturer && { device_manufacturer: deviceVendor }),
+      ...(this.config.trackingOptions.deviceModel && { device_model: deviceModel }),
+      ...(this.config.trackingOptions.language && { language: language }),
+      ...(this.config.trackingOptions.carrier && { carrier: carrier }),
+      ...(this.config.trackingOptions.ipAddress && { ip: IP_ADDRESS }),
+      insert_id: UUID(),
+      partner_id: this.config.partnerId,
+      plan: this.config.plan,
+      ...context,
+      event_id: this.eventId++,
+      library: this.library,
+    };
+    return event;
+  }
+
+  isSessionValid() {
+    const lastEventTime = this.config.lastEventTime || Date.now();
+    const timeSinceLastEvent = Date.now() - lastEventTime;
+    return timeSinceLastEvent < this.config.sessionTimeout;
+  }
+}

package/src/plugins/identity.ts

@@ -0,0 +1,21 @@
+import { BeforePlugin, PluginType, Event, Config } from '@amplitude/analytics-types';
+import { getAnalyticsConnector } from '../utils/analytics-connector';
+
+export class IdentityEventSender implements BeforePlugin {
+  name = 'identity';
+  type = PluginType.BEFORE as const;
+
+  identityStore = getAnalyticsConnector().identityStore;
+
+  async execute(context: Event): Promise<Event> {
+    const userProperties = context.user_properties as Record<string, any>;
+    if (userProperties) {
+      this.identityStore.editIdentity().updateUserProperties(userProperties).commit();
+    }
+    return context;
+  }
+
+  setup(_: Config): Promise<undefined> {
+    return Promise.resolve(undefined);
+  }
+}