@advenue/react-native 0.3.1 → 0.4.0

package/src/native-storage.ts

@@ -0,0 +1,63 @@
+// Adapters over the native modules' built-in storage (UserDefaults /
+// SharedPreferences + iOS Keychain), so the app never supplies storage —
+// Adjust/AppsFlyer parity. Pure functions over a passed module (rather than
+// resolving the module themselves) so they stay unit-testable and respect the
+// test mocks of './native'.
+import type { SecureStorageAdapter, StorageAdapter } from '@advenue/sdk-core';
+
+interface NativeStorageFns {
+  storageGetItem?(key: string): string | null;
+  storageSetItem?(key: string, value: string): void;
+  storageRemoveItem?(key: string): void;
+}
+
+interface NativeSecureFns {
+  secureGetItem?(key: string): string | null;
+  secureSetItem?(key: string, value: string): void;
+  secureRemoveItem?(key: string): void;
+}
+
+/**
+ * Wraps a native module's built-in key/value storage as the sync
+ * {@link StorageAdapter}. Returns null when the module is absent or predates
+ * the storage capability (feature-detected), so callers fall back.
+ */
+export function createNativeStorage(mod: unknown): StorageAdapter | null {
+  const m = mod as NativeStorageFns | null;
+  if (
+    !m ||
+    typeof m.storageGetItem !== 'function' ||
+    typeof m.storageSetItem !== 'function' ||
+    typeof m.storageRemoveItem !== 'function'
+  ) {
+    return null;
+  }
+  return {
+    getItem: (key) => m.storageGetItem?.(key) ?? null,
+    setItem: (key, value) => m.storageSetItem?.(key, value),
+    removeItem: (key) => m.storageRemoveItem?.(key),
+  };
+}
+
+/**
+ * Wraps the iOS module's Keychain functions as the async
+ * {@link SecureStorageAdapter} (with erasure support). Returns null when the
+ * module is absent or predates the capability — including all of Android,
+ * which has no reinstall-durable store.
+ */
+export function createNativeSecureStore(mod: unknown): SecureStorageAdapter | null {
+  const m = mod as NativeSecureFns | null;
+  if (
+    !m ||
+    typeof m.secureGetItem !== 'function' ||
+    typeof m.secureSetItem !== 'function' ||
+    typeof m.secureRemoveItem !== 'function'
+  ) {
+    return null;
+  }
+  return {
+    getItemAsync: async (key) => m.secureGetItem?.(key) ?? null,
+    setItemAsync: async (key, value) => m.secureSetItem?.(key, value),
+    deleteItemAsync: async (key) => m.secureRemoveItem?.(key),
+  };
+}

package/src/native.ts

@@ -25,6 +25,19 @@ export function getAndroidNative(): AdvenueAndroidNativeModule | null {
   }
 }
 
+/**
+ * Lazy access to React Native's Platform.OS ('ios' | 'android' | 'web' |
+ * 'windows' | 'macos'). Returns null when react-native isn't resolvable, so
+ * callers can require an explicit platform instead of guessing.
+ */
+export function getPlatformOS(): string | null {
+  try {
+    return (require('react-native') as { Platform: { OS: string } }).Platform.OS ?? null;
+  } catch {
+    return null;
+  }
+}
+
 /** Subscription handle returned by AppState.addEventListener. */
 export interface AppStateSubscription {
   remove(): void;

package/src/secure-store.ts

@@ -8,6 +8,8 @@ import type { SecureStorageAdapter } from '@advenue/sdk-core';
 export interface SecureStoreLike {
   getItemAsync(key: string): Promise<string | null>;
   setItemAsync(key: string, value: string): Promise<void>;
+  /** Optional — forwarded so GDPR erasure can wipe the durable entries. */
+  deleteItemAsync?(key: string): Promise<void>;
 }
 
 /** Wraps expo-secure-store as an Advenue SecureStorageAdapter (async, durable). */
@@ -15,5 +17,10 @@ export function createSecureStore(secureStore: SecureStoreLike): SecureStorageAd
   return {
     getItemAsync: async (key) => (await secureStore.getItemAsync(key)) ?? null,
     setItemAsync: (key, value) => secureStore.setItemAsync(key, value),
+    ...(secureStore.deleteItemAsync
+      ? {
+          deleteItemAsync: (key: string) => secureStore.deleteItemAsync?.(key) ?? Promise.resolve(),
+        }
+      : {}),
   };
 }