react-native-nitro-amplitude 0.1.0

package/src/index.ts

@@ -0,0 +1,66 @@
+import analyticsClient, {
+  createInstance,
+} from "./analytics/react-native-client";
+import { prefetchNativeContext } from "./native/context";
+
+import * as AnalyticsTypes from "./analytics/types";
+
+export { createInstance };
+export const {
+  add,
+  flush,
+  getDeviceId,
+  getSessionId,
+  getUserId,
+  groupIdentify,
+  identify,
+  init,
+  logEvent,
+  remove,
+  reset,
+  revenue,
+  setDeviceId,
+  setGroup,
+  setOptOut,
+  setSessionId,
+  setUserId,
+  shutdown,
+  track,
+  extendSession,
+} = analyticsClient;
+
+export { Revenue, Identify } from "@amplitude/analytics-core";
+export {
+  InMemoryStorage,
+  LocalStorage,
+  MemoryStorage,
+} from "./analytics/storage/local-storage";
+export { NitroAnalyticsStorage, NitroMemoryStorage } from "./native/storage";
+export { nitroHttpClient } from "./native/http";
+export { nitroTransport } from "./analytics/nitro-transport";
+export { prefetchNativeContext };
+export { AnalyticsTypes as Types };
+
+export * from "./experiment/types/config";
+export { Experiment } from "./experiment/factory";
+export { StubExperimentClient } from "./experiment/stubClient";
+export { ExperimentClient } from "./experiment/experimentClient";
+export * from "./experiment/types/client";
+export { Source } from "./experiment/types/source";
+export * from "./experiment/types/user";
+export * from "./experiment/types/variant";
+export * from "./experiment/types/exposure";
+export * from "./experiment/types/storage";
+export { LogLevel } from "./experiment/types/logger";
+export type { Logger } from "./experiment/types/logger";
+export { ConsoleLogger } from "./experiment/logger/consoleLogger";
+export {
+  LocalStorage as ExperimentLocalStorage,
+  MemoryStorage as ExperimentMemoryStorage,
+} from "./experiment/storage/local-storage";
+
+export type { AmplitudeContext } from "./AmplitudeContext.nitro";
+export type { AmplitudeStorage } from "./AmplitudeStorage.nitro";
+export type { AmplitudeWorker } from "./AmplitudeWorker.nitro";
+
+export const VERSION = "0.1.0";

package/src/index.web.ts

@@ -0,0 +1,19 @@
+const unsupported = (name: string): never => {
+  throw new Error(
+    `react-native-nitro-amplitude: ${name} is not supported on web. Use native iOS/Android builds.`,
+  );
+};
+
+export const init = () => unsupported("init");
+export const track = () => unsupported("track");
+export const identify = () => unsupported("identify");
+export const createInstance = () => unsupported("createInstance");
+export const Experiment = {
+  initialize: () => unsupported("Experiment.initialize"),
+  initializeWithAmplitudeAnalytics: () =>
+    unsupported("Experiment.initializeWithAmplitudeAnalytics"),
+};
+
+export type { AmplitudeContext } from "./AmplitudeContext.nitro";
+export type { AmplitudeStorage } from "./AmplitudeStorage.nitro";
+export type { AmplitudeWorker } from "./AmplitudeWorker.nitro";

package/src/native/context.ts

@@ -0,0 +1,73 @@
+import type { ReactNativeTrackingOptions } from "@amplitude/analytics-core";
+import { getAmplitudeContext } from "./hybrid";
+
+export type NativeApplicationContext = {
+  version?: string;
+  platform?: string;
+  language?: string;
+  country?: string;
+  osName?: string;
+  osVersion?: string;
+  deviceBrand?: string;
+  deviceManufacturer?: string;
+  deviceModel?: string;
+  carrier?: string;
+  adid?: string;
+  appSetId?: string;
+  idfv?: string;
+};
+
+export type LegacySessionData = {
+  deviceId?: string;
+  userId?: string;
+  sessionId?: number;
+  lastEventTime?: number;
+  lastEventId?: number;
+};
+
+export function prefetchNativeContext(): void {
+  getAmplitudeContext().prefetch();
+}
+
+export function getNativeApplicationContext(
+  options: ReactNativeTrackingOptions,
+): NativeApplicationContext {
+  const json = getAmplitudeContext().getApplicationContextJson(
+    JSON.stringify(options),
+  );
+  if (!json) {
+    return {};
+  }
+  try {
+    return JSON.parse(json) as NativeApplicationContext;
+  } catch {
+    return {};
+  }
+}
+
+export function getLegacySessionData(instanceName: string): LegacySessionData {
+  const json = getAmplitudeContext().getLegacySessionDataJson(instanceName);
+  if (!json) {
+    return {};
+  }
+  try {
+    return JSON.parse(json) as LegacySessionData;
+  } catch {
+    return {};
+  }
+}
+
+export function getLegacyEvents(
+  instanceName: string,
+  eventKind: string,
+): string[] {
+  return getAmplitudeContext().getLegacyEventsJson(instanceName, eventKind);
+}
+
+export function removeLegacyEvent(
+  instanceName: string,
+  eventKind: string,
+  eventId: number,
+): void {
+  getAmplitudeContext().removeLegacyEvent(instanceName, eventKind, eventId);
+}

package/src/native/http.ts

@@ -0,0 +1,77 @@
+import type { HttpClient, SimpleResponse } from "../experiment/types/transport";
+import { getAmplitudeWorker } from "./hybrid";
+
+type PendingRequest = {
+  resolve: (response: SimpleResponse) => void;
+  reject: (error: Error) => void;
+  timeoutId: ReturnType<typeof setTimeout>;
+};
+
+const pendingRequests = new Map<string, PendingRequest>();
+let listenerInstalled = false;
+
+function ensureListener(): void {
+  if (listenerInstalled) {
+    return;
+  }
+  listenerInstalled = true;
+  getAmplitudeWorker().addOnComplete((requestId, statusCode, body, error) => {
+    const pending = pendingRequests.get(requestId);
+    if (!pending) {
+      return;
+    }
+    pendingRequests.delete(requestId);
+    clearTimeout(pending.timeoutId);
+    if (error) {
+      pending.reject(new Error(error));
+      return;
+    }
+    pending.resolve({
+      status: statusCode,
+      body,
+    });
+  });
+}
+
+function createRequestId(): string {
+  return `req_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+}
+
+export class NitroHttpClient implements HttpClient {
+  async request(
+    requestUrl: string,
+    method: string,
+    headers: Record<string, string>,
+    data: string | null,
+    timeoutMillis = 10000,
+  ): Promise<SimpleResponse> {
+    ensureListener();
+    const requestId = createRequestId();
+    return new Promise<SimpleResponse>((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        pendingRequests.delete(requestId);
+        getAmplitudeWorker().cancel(requestId);
+        reject(new Error(`Request timed out after ${timeoutMillis}ms`));
+      }, timeoutMillis + 250);
+
+      pendingRequests.set(requestId, { resolve, reject, timeoutId });
+
+      try {
+        getAmplitudeWorker().enqueue(
+          requestId,
+          requestUrl,
+          method,
+          JSON.stringify(headers),
+          data ?? "",
+          timeoutMillis,
+        );
+      } catch (error) {
+        pendingRequests.delete(requestId);
+        clearTimeout(timeoutId);
+        reject(error instanceof Error ? error : new Error(String(error)));
+      }
+    });
+  }
+}
+
+export const nitroHttpClient = new NitroHttpClient();

package/src/native/hybrid.ts

@@ -0,0 +1,32 @@
+import { NitroModules } from "react-native-nitro-modules";
+import type { AmplitudeContext } from "../AmplitudeContext.nitro";
+import type { AmplitudeStorage } from "../AmplitudeStorage.nitro";
+import type { AmplitudeWorker } from "../AmplitudeWorker.nitro";
+
+let contextInstance: AmplitudeContext | undefined;
+let storageInstance: AmplitudeStorage | undefined;
+let workerInstance: AmplitudeWorker | undefined;
+
+export function getAmplitudeContext(): AmplitudeContext {
+  contextInstance ??=
+    NitroModules.createHybridObject<AmplitudeContext>("AmplitudeContext");
+  return contextInstance;
+}
+
+export function getAmplitudeStorage(): AmplitudeStorage {
+  storageInstance ??=
+    NitroModules.createHybridObject<AmplitudeStorage>("AmplitudeStorage");
+  return storageInstance;
+}
+
+export function getAmplitudeWorker(): AmplitudeWorker {
+  workerInstance ??=
+    NitroModules.createHybridObject<AmplitudeWorker>("AmplitudeWorker");
+  return workerInstance;
+}
+
+export function resetHybridInstancesForTests(): void {
+  contextInstance = undefined;
+  storageInstance = undefined;
+  workerInstance = undefined;
+}

package/src/native/storage.ts

@@ -0,0 +1,107 @@
+import type { Storage as AnalyticsStorage } from "@amplitude/analytics-core";
+import type { Storage as ExperimentStorage } from "../experiment/types/storage";
+import { getAmplitudeStorage } from "./hybrid";
+
+function namespaceKey(namespace: string, key: string): string {
+  return `${namespace}::${key}`;
+}
+
+export class NitroAnalyticsStorage<T> implements AnalyticsStorage<T> {
+  constructor(private readonly namespace: string) {}
+
+  async isEnabled(): Promise<boolean> {
+    return true;
+  }
+
+  async get(key: string): Promise<T | undefined> {
+    const raw = await this.getRaw(key);
+    if (!raw) {
+      return undefined;
+    }
+    try {
+      return JSON.parse(raw) as T;
+    } catch {
+      return undefined;
+    }
+  }
+
+  async getRaw(key: string): Promise<string | undefined> {
+    return getAmplitudeStorage().get(namespaceKey(this.namespace, key), true);
+  }
+
+  async set(key: string, value: T): Promise<void> {
+    getAmplitudeStorage().set(
+      namespaceKey(this.namespace, key),
+      JSON.stringify(value),
+      true,
+    );
+  }
+
+  async remove(key: string): Promise<void> {
+    getAmplitudeStorage().remove(namespaceKey(this.namespace, key), true);
+  }
+
+  async reset(): Promise<void> {
+    const prefix = `${this.namespace}::`;
+    const keys = getAmplitudeStorage().getKeysByPrefix(prefix, true);
+    if (keys.length > 0) {
+      getAmplitudeStorage().removeBatch(keys, true);
+    }
+  }
+}
+
+export class NitroExperimentStorage implements ExperimentStorage {
+  constructor(private readonly namespace: string) {}
+
+  async get(key: string): Promise<string | null> {
+    const value = getAmplitudeStorage().get(
+      namespaceKey(this.namespace, key),
+      true,
+    );
+    return value ?? null;
+  }
+
+  async put(key: string, value: string): Promise<void> {
+    getAmplitudeStorage().set(namespaceKey(this.namespace, key), value, true);
+  }
+
+  async delete(key: string): Promise<void> {
+    getAmplitudeStorage().remove(namespaceKey(this.namespace, key), true);
+  }
+
+  async reset(): Promise<void> {
+    const prefix = `${this.namespace}::`;
+    const keys = getAmplitudeStorage().getKeysByPrefix(prefix, true);
+    if (keys.length > 0) {
+      getAmplitudeStorage().removeBatch(keys, true);
+    }
+  }
+}
+
+export class NitroMemoryStorage implements ExperimentStorage {
+  constructor(private readonly namespace: string) {}
+
+  async get(key: string): Promise<string | null> {
+    const value = getAmplitudeStorage().get(
+      namespaceKey(this.namespace, key),
+      false,
+    );
+    return value ?? null;
+  }
+
+  async put(key: string, value: string): Promise<void> {
+    getAmplitudeStorage().set(namespaceKey(this.namespace, key), value, false);
+  }
+
+  async delete(key: string): Promise<void> {
+    getAmplitudeStorage().remove(namespaceKey(this.namespace, key), false);
+  }
+
+  async reset(): Promise<void> {
+    const prefix = `${this.namespace}::`;
+    const keys = getAmplitudeStorage().getKeysByPrefix(prefix, false);
+    if (keys.length > 0) {
+      getAmplitudeStorage().removeBatch(keys, false);
+    }
+  }
+}