react-native-nitro-amplitude 0.1.0 → 0.5.0

package/src/native/storage.ts

@@ -26,26 +26,26 @@ export class NitroAnalyticsStorage<T> implements AnalyticsStorage<T> {
   }
 
   async getRaw(key: string): Promise<string | undefined> {
-    return getAmplitudeStorage().get(namespaceKey(this.namespace, key), true);
+    const storage = getAmplitudeStorage();
+    return storage.get(namespaceKey(this.namespace, key), true);
   }
 
   async set(key: string, value: T): Promise<void> {
-    getAmplitudeStorage().set(
-      namespaceKey(this.namespace, key),
-      JSON.stringify(value),
-      true,
-    );
+    const storage = getAmplitudeStorage();
+    storage.set(namespaceKey(this.namespace, key), JSON.stringify(value), true);
   }
 
   async remove(key: string): Promise<void> {
-    getAmplitudeStorage().remove(namespaceKey(this.namespace, key), true);
+    const storage = getAmplitudeStorage();
+    storage.remove(namespaceKey(this.namespace, key), true);
   }
 
   async reset(): Promise<void> {
+    const storage = getAmplitudeStorage();
     const prefix = `${this.namespace}::`;
-    const keys = getAmplitudeStorage().getKeysByPrefix(prefix, true);
+    const keys = storage.getKeysByPrefix(prefix, true);
     if (keys.length > 0) {
-      getAmplitudeStorage().removeBatch(keys, true);
+      storage.removeBatch(keys, true);
     }
   }
 }
@@ -54,26 +54,27 @@ 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,
-    );
+    const storage = getAmplitudeStorage();
+    const value = storage.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);
+    const storage = getAmplitudeStorage();
+    storage.set(namespaceKey(this.namespace, key), value, true);
   }
 
   async delete(key: string): Promise<void> {
-    getAmplitudeStorage().remove(namespaceKey(this.namespace, key), true);
+    const storage = getAmplitudeStorage();
+    storage.remove(namespaceKey(this.namespace, key), true);
   }
 
   async reset(): Promise<void> {
+    const storage = getAmplitudeStorage();
     const prefix = `${this.namespace}::`;
-    const keys = getAmplitudeStorage().getKeysByPrefix(prefix, true);
+    const keys = storage.getKeysByPrefix(prefix, true);
     if (keys.length > 0) {
-      getAmplitudeStorage().removeBatch(keys, true);
+      storage.removeBatch(keys, true);
     }
   }
 }
@@ -82,26 +83,27 @@ 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,
-    );
+    const storage = getAmplitudeStorage();
+    const value = storage.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);
+    const storage = getAmplitudeStorage();
+    storage.set(namespaceKey(this.namespace, key), value, false);
   }
 
   async delete(key: string): Promise<void> {
-    getAmplitudeStorage().remove(namespaceKey(this.namespace, key), false);
+    const storage = getAmplitudeStorage();
+    storage.remove(namespaceKey(this.namespace, key), false);
   }
 
   async reset(): Promise<void> {
+    const storage = getAmplitudeStorage();
     const prefix = `${this.namespace}::`;
-    const keys = getAmplitudeStorage().getKeysByPrefix(prefix, false);
+    const keys = storage.getKeysByPrefix(prefix, false);
     if (keys.length > 0) {
-      getAmplitudeStorage().removeBatch(keys, false);
+      storage.removeBatch(keys, false);
     }
   }
 }

package/src/native/storage.web.ts

@@ -0,0 +1,152 @@
+import type { Storage as AnalyticsStorage } from "@amplitude/analytics-core";
+import type { Storage as ExperimentStorage } from "../experiment/types/storage";
+
+function namespaceKey(namespace: string, key: string): string {
+  return `${namespace}::${key}`;
+}
+
+class WebStringStorage {
+  private static readonly memory = new Map<string, string>();
+
+  constructor(private readonly namespace: string) {}
+
+  get(key: string): string | undefined {
+    const storageKey = namespaceKey(this.namespace, key);
+    try {
+      if (typeof localStorage !== "undefined") {
+        return localStorage.getItem(storageKey) ?? undefined;
+      }
+    } catch {}
+    return WebStringStorage.memory.get(storageKey);
+  }
+
+  set(key: string, value: string): void {
+    const storageKey = namespaceKey(this.namespace, key);
+    WebStringStorage.memory.set(storageKey, value);
+    try {
+      if (typeof localStorage !== "undefined") {
+        localStorage.setItem(storageKey, value);
+      }
+    } catch {}
+  }
+
+  remove(key: string): void {
+    const storageKey = namespaceKey(this.namespace, key);
+    WebStringStorage.memory.delete(storageKey);
+    try {
+      if (typeof localStorage !== "undefined") {
+        localStorage.removeItem(storageKey);
+      }
+    } catch {}
+  }
+
+  reset(): void {
+    const prefix = `${this.namespace}::`;
+    for (const key of WebStringStorage.memory.keys()) {
+      if (key.startsWith(prefix)) {
+        WebStringStorage.memory.delete(key);
+      }
+    }
+    try {
+      if (typeof localStorage !== "undefined") {
+        for (let index = localStorage.length - 1; index >= 0; index--) {
+          const key = localStorage.key(index);
+          if (key?.startsWith(prefix)) {
+            localStorage.removeItem(key);
+          }
+        }
+      }
+    } catch {}
+  }
+}
+
+export class NitroAnalyticsStorage<T> implements AnalyticsStorage<T> {
+  private readonly storage: WebStringStorage;
+
+  constructor(namespace: string) {
+    this.storage = new WebStringStorage(namespace);
+  }
+
+  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 this.storage.get(key);
+  }
+
+  async set(key: string, value: T): Promise<void> {
+    this.storage.set(key, JSON.stringify(value));
+  }
+
+  async remove(key: string): Promise<void> {
+    this.storage.remove(key);
+  }
+
+  async reset(): Promise<void> {
+    this.storage.reset();
+  }
+}
+
+export class NitroExperimentStorage implements ExperimentStorage {
+  private readonly storage: WebStringStorage;
+
+  constructor(namespace: string) {
+    this.storage = new WebStringStorage(namespace);
+  }
+
+  async get(key: string): Promise<string | null> {
+    return this.storage.get(key) ?? null;
+  }
+
+  async put(key: string, value: string): Promise<void> {
+    this.storage.set(key, value);
+  }
+
+  async delete(key: string): Promise<void> {
+    this.storage.remove(key);
+  }
+
+  async reset(): Promise<void> {
+    this.storage.reset();
+  }
+}
+
+export class NitroMemoryStorage implements ExperimentStorage {
+  private readonly values = new Map<string, string>();
+
+  constructor(private readonly namespace: string) {}
+
+  async get(key: string): Promise<string | null> {
+    return this.values.get(namespaceKey(this.namespace, key)) ?? null;
+  }
+
+  async put(key: string, value: string): Promise<void> {
+    this.values.set(namespaceKey(this.namespace, key), value);
+  }
+
+  async delete(key: string): Promise<void> {
+    this.values.delete(namespaceKey(this.namespace, key));
+  }
+
+  async reset(): Promise<void> {
+    const prefix = `${this.namespace}::`;
+    for (const key of this.values.keys()) {
+      if (key.startsWith(prefix)) {
+        this.values.delete(key);
+      }
+    }
+  }
+}

package/src/network.ts

@@ -0,0 +1,258 @@
+import { BaseTransport } from "@amplitude/analytics-core";
+import type { Payload, Response, Transport } from "@amplitude/analytics-core";
+import type { HttpClient, SimpleResponse } from "./experiment/types/transport";
+import { createAmplitudeError } from "./errors";
+
+let networkEnabled = true;
+
+export type DryRunRequest = {
+  url: string;
+  method: string;
+  headers: Record<string, string>;
+  data: string | null;
+  timeoutMillis: number;
+  createdAt: number;
+};
+
+export type DryRunEvent = {
+  serverUrl: string;
+  payload: Payload;
+  createdAt: number;
+};
+
+export type AmplitudeNetworkTiming = {
+  kind: "analytics" | "experiment";
+  url: string;
+  method: string;
+  startedAt: number;
+  finishedAt: number;
+  durationMillis: number;
+  status?: number | string;
+  error?: string;
+};
+
+export type AmplitudeNetworkTimingRecorder = (
+  timing: AmplitudeNetworkTiming,
+) => void;
+
+export type AmplitudeNetworkTimingBuffer = {
+  record: AmplitudeNetworkTimingRecorder;
+  getTimings: () => AmplitudeNetworkTiming[];
+  clear: () => void;
+};
+
+const dryRunRequests: DryRunRequest[] = [];
+const dryRunEvents: DryRunEvent[] = [];
+
+export function setNetworkEnabled(enabled: boolean): void {
+  networkEnabled = enabled;
+}
+
+export function getNetworkEnabled(): boolean {
+  return networkEnabled;
+}
+
+export function clearDryRunTransportRecords(): void {
+  dryRunRequests.length = 0;
+  dryRunEvents.length = 0;
+}
+
+export function getDryRunTransportRecords(): DryRunRequest[] {
+  return dryRunRequests.map((request) => ({ ...request }));
+}
+
+export function getDryRunAnalyticsEvents(): DryRunEvent[] {
+  return dryRunEvents.map((event) => ({
+    ...event,
+    payload: { ...event.payload },
+  }));
+}
+
+export function assertNetworkEnabled(): void {
+  if (!networkEnabled) {
+    throw createAmplitudeError(
+      "network_error",
+      "Amplitude network traffic is disabled",
+    );
+  }
+}
+
+function nowMillis(): number {
+  return typeof performance !== "undefined" && performance.now
+    ? performance.now()
+    : Date.now();
+}
+
+function createTiming(
+  kind: AmplitudeNetworkTiming["kind"],
+  url: string,
+  method: string,
+  startedAt: number,
+  status?: number | string,
+  error?: unknown,
+): AmplitudeNetworkTiming {
+  const finishedAt = nowMillis();
+  return {
+    kind,
+    url,
+    method,
+    startedAt,
+    finishedAt,
+    durationMillis: Math.round((finishedAt - startedAt) * 10) / 10,
+    status,
+    error:
+      error === undefined
+        ? undefined
+        : error instanceof Error
+          ? error.message
+          : String(error),
+  };
+}
+
+export function createNetworkTimingBuffer(
+  limit = 20,
+): AmplitudeNetworkTimingBuffer {
+  const timings: AmplitudeNetworkTiming[] = [];
+  const normalizedLimit = Number.isFinite(limit) && limit > 0 ? limit : 20;
+  return {
+    record: (timing) => {
+      timings.push(timing);
+      while (timings.length > normalizedLimit) {
+        timings.shift();
+      }
+    },
+    getTimings: () => timings.map((timing) => ({ ...timing })),
+    clear: () => {
+      timings.length = 0;
+    },
+  };
+}
+
+export function createTimedAnalyticsTransport(
+  transport: Transport,
+  record: AmplitudeNetworkTimingRecorder,
+): Transport {
+  return {
+    async send(
+      serverUrl: string,
+      payload: Payload,
+      enableRequestBodyCompression?: boolean,
+    ): Promise<Response | null> {
+      const startedAt = nowMillis();
+      try {
+        const response = await transport.send(
+          serverUrl,
+          payload,
+          enableRequestBodyCompression,
+        );
+        record(
+          createTiming(
+            "analytics",
+            serverUrl,
+            "POST",
+            startedAt,
+            response?.status,
+          ),
+        );
+        return response;
+      } catch (error) {
+        record(
+          createTiming(
+            "analytics",
+            serverUrl,
+            "POST",
+            startedAt,
+            undefined,
+            error,
+          ),
+        );
+        throw error;
+      }
+    },
+  };
+}
+
+export function createTimedHttpClient(
+  httpClient: HttpClient,
+  record: AmplitudeNetworkTimingRecorder,
+): HttpClient {
+  return {
+    async request(
+      requestUrl: string,
+      method: string,
+      headers: Record<string, string>,
+      data: string | null,
+      timeoutMillis?: number,
+    ): Promise<SimpleResponse> {
+      const startedAt = nowMillis();
+      try {
+        const response = await httpClient.request(
+          requestUrl,
+          method,
+          headers,
+          data,
+          timeoutMillis,
+        );
+        record(
+          createTiming(
+            "experiment",
+            requestUrl,
+            method,
+            startedAt,
+            response.status,
+          ),
+        );
+        return response;
+      } catch (error) {
+        record(
+          createTiming(
+            "experiment",
+            requestUrl,
+            method,
+            startedAt,
+            undefined,
+            error,
+          ),
+        );
+        throw error;
+      }
+    },
+  };
+}
+
+export class DryRunHttpClient implements HttpClient {
+  async request(
+    requestUrl: string,
+    method: string,
+    headers: Record<string, string>,
+    data: string | null,
+    timeoutMillis = 10000,
+  ): Promise<SimpleResponse> {
+    dryRunRequests.push({
+      url: requestUrl,
+      method,
+      headers: { ...headers },
+      data,
+      timeoutMillis,
+      createdAt: Date.now(),
+    });
+    return {
+      status: 202,
+      body: JSON.stringify({ code: 202, dryRun: true }),
+    };
+  }
+}
+
+export class DryRunTransport extends BaseTransport implements Transport {
+  async send(serverUrl: string, payload: Payload): Promise<Response | null> {
+    dryRunEvents.push({
+      serverUrl,
+      payload: { ...payload },
+      createdAt: Date.now(),
+    });
+    return this.buildResponse({ code: 202, dryRun: true });
+  }
+}
+
+export const dryRunHttpClient = new DryRunHttpClient();
+export const dryRunTransport = new DryRunTransport();