@datalyr/react-native 1.1.1 → 1.2.0

package/src/native/DatalyrNativeBridge.ts

@@ -0,0 +1,271 @@
+/**
+ * Native Bridge for Meta and TikTok SDKs
+ * Uses bundled native modules instead of separate npm packages
+ */
+
+import { NativeModules, Platform } from 'react-native';
+
+interface DatalyrNativeModule {
+  // Meta SDK Methods
+  initializeMetaSDK(
+    appId: string,
+    clientToken: string | null,
+    advertiserTrackingEnabled: boolean
+  ): Promise<boolean>;
+  fetchDeferredAppLink(): Promise<string | null>;
+  logMetaEvent(
+    eventName: string,
+    valueToSum: number | null,
+    parameters: Record<string, any> | null
+  ): Promise<boolean>;
+  logMetaPurchase(
+    amount: number,
+    currency: string,
+    parameters: Record<string, any> | null
+  ): Promise<boolean>;
+  setMetaUserData(userData: Record<string, string | undefined>): Promise<boolean>;
+  clearMetaUserData(): Promise<boolean>;
+  updateMetaTrackingAuthorization(enabled: boolean): Promise<boolean>;
+
+  // TikTok SDK Methods
+  initializeTikTokSDK(
+    appId: string,
+    tiktokAppId: string,
+    accessToken: string | null,
+    debug: boolean
+  ): Promise<boolean>;
+  trackTikTokEvent(
+    eventName: string,
+    eventId: string | null,
+    properties: Record<string, any> | null
+  ): Promise<boolean>;
+  identifyTikTokUser(
+    externalId: string,
+    externalUserName: string,
+    phoneNumber: string,
+    email: string
+  ): Promise<boolean>;
+  logoutTikTok(): Promise<boolean>;
+  updateTikTokTrackingAuthorization(enabled: boolean): Promise<boolean>;
+
+  // SDK Availability
+  getSDKAvailability(): Promise<{ meta: boolean; tiktok: boolean }>;
+}
+
+// Native module is only available on iOS
+const DatalyrNative: DatalyrNativeModule | null =
+  Platform.OS === 'ios' ? NativeModules.DatalyrNative : null;
+
+/**
+ * Check if native module is available
+ */
+export const isNativeModuleAvailable = (): boolean => {
+  return DatalyrNative !== null;
+};
+
+/**
+ * Get SDK availability status
+ */
+export const getSDKAvailability = async (): Promise<{
+  meta: boolean;
+  tiktok: boolean;
+}> => {
+  if (!DatalyrNative) {
+    return { meta: false, tiktok: false };
+  }
+
+  try {
+    return await DatalyrNative.getSDKAvailability();
+  } catch {
+    return { meta: false, tiktok: false };
+  }
+};
+
+// MARK: - Meta SDK Bridge
+
+export const MetaNativeBridge = {
+  async initialize(
+    appId: string,
+    clientToken?: string,
+    advertiserTrackingEnabled: boolean = false
+  ): Promise<boolean> {
+    if (!DatalyrNative) return false;
+
+    try {
+      return await DatalyrNative.initializeMetaSDK(
+        appId,
+        clientToken || null,
+        advertiserTrackingEnabled
+      );
+    } catch (error) {
+      console.error('[Datalyr/MetaNative] Initialize failed:', error);
+      return false;
+    }
+  },
+
+  async fetchDeferredAppLink(): Promise<string | null> {
+    if (!DatalyrNative) return null;
+
+    try {
+      return await DatalyrNative.fetchDeferredAppLink();
+    } catch {
+      return null;
+    }
+  },
+
+  async logEvent(
+    eventName: string,
+    valueToSum?: number,
+    parameters?: Record<string, any>
+  ): Promise<boolean> {
+    if (!DatalyrNative) return false;
+
+    try {
+      return await DatalyrNative.logMetaEvent(
+        eventName,
+        valueToSum ?? null,
+        parameters || null
+      );
+    } catch (error) {
+      console.error('[Datalyr/MetaNative] Log event failed:', error);
+      return false;
+    }
+  },
+
+  async logPurchase(
+    amount: number,
+    currency: string,
+    parameters?: Record<string, any>
+  ): Promise<boolean> {
+    if (!DatalyrNative) return false;
+
+    try {
+      return await DatalyrNative.logMetaPurchase(amount, currency, parameters || null);
+    } catch (error) {
+      console.error('[Datalyr/MetaNative] Log purchase failed:', error);
+      return false;
+    }
+  },
+
+  async setUserData(userData: Record<string, string | undefined>): Promise<boolean> {
+    if (!DatalyrNative) return false;
+
+    try {
+      return await DatalyrNative.setMetaUserData(userData);
+    } catch (error) {
+      console.error('[Datalyr/MetaNative] Set user data failed:', error);
+      return false;
+    }
+  },
+
+  async clearUserData(): Promise<boolean> {
+    if (!DatalyrNative) return false;
+
+    try {
+      return await DatalyrNative.clearMetaUserData();
+    } catch (error) {
+      console.error('[Datalyr/MetaNative] Clear user data failed:', error);
+      return false;
+    }
+  },
+
+  async updateTrackingAuthorization(enabled: boolean): Promise<boolean> {
+    if (!DatalyrNative) return false;
+
+    try {
+      return await DatalyrNative.updateMetaTrackingAuthorization(enabled);
+    } catch (error) {
+      console.error('[Datalyr/MetaNative] Update tracking failed:', error);
+      return false;
+    }
+  },
+};
+
+// MARK: - TikTok SDK Bridge
+
+export const TikTokNativeBridge = {
+  async initialize(
+    appId: string,
+    tiktokAppId: string,
+    accessToken?: string,
+    debug: boolean = false
+  ): Promise<boolean> {
+    if (!DatalyrNative) return false;
+
+    try {
+      return await DatalyrNative.initializeTikTokSDK(
+        appId,
+        tiktokAppId,
+        accessToken || null,
+        debug
+      );
+    } catch (error) {
+      console.error('[Datalyr/TikTokNative] Initialize failed:', error);
+      return false;
+    }
+  },
+
+  async trackEvent(
+    eventName: string,
+    eventId?: string,
+    properties?: Record<string, any>
+  ): Promise<boolean> {
+    if (!DatalyrNative) return false;
+
+    try {
+      return await DatalyrNative.trackTikTokEvent(
+        eventName,
+        eventId || null,
+        properties || null
+      );
+    } catch (error) {
+      console.error('[Datalyr/TikTokNative] Track event failed:', error);
+      return false;
+    }
+  },
+
+  async identify(
+    externalId?: string,
+    email?: string,
+    phone?: string
+  ): Promise<boolean> {
+    if (!DatalyrNative) return false;
+
+    // Only call if we have at least one value
+    if (!externalId && !email && !phone) return false;
+
+    try {
+      return await DatalyrNative.identifyTikTokUser(
+        externalId || '',
+        '', // externalUserName - not typically available
+        phone || '',
+        email || ''
+      );
+    } catch (error) {
+      console.error('[Datalyr/TikTokNative] Identify failed:', error);
+      return false;
+    }
+  },
+
+  async logout(): Promise<boolean> {
+    if (!DatalyrNative) return false;
+
+    try {
+      return await DatalyrNative.logoutTikTok();
+    } catch (error) {
+      console.error('[Datalyr/TikTokNative] Logout failed:', error);
+      return false;
+    }
+  },
+
+  async updateTrackingAuthorization(enabled: boolean): Promise<boolean> {
+    if (!DatalyrNative) return false;
+
+    try {
+      return await DatalyrNative.updateTikTokTrackingAuthorization(enabled);
+    } catch (error) {
+      console.error('[Datalyr/TikTokNative] Update tracking failed:', error);
+      return false;
+    }
+  },
+};

package/src/native/index.ts

@@ -0,0 +1,11 @@
+/**
+ * Native Module Exports
+ */
+
+export { SKAdNetworkBridge } from './SKAdNetworkBridge';
+export {
+  isNativeModuleAvailable,
+  getSDKAvailability,
+  MetaNativeBridge,
+  TikTokNativeBridge,
+} from './DatalyrNativeBridge';

package/src/types.ts

@@ -7,6 +7,39 @@ export interface AutoEventConfig {
   sessionTimeoutMs?: number;
 }
 
+// Meta (Facebook) SDK Configuration
+export interface MetaConfig {
+  appId: string;                     // Facebook App ID
+  clientToken?: string;              // Client Token for advanced features
+  enableDeferredDeepLink?: boolean;  // Default: true
+  enableAppEvents?: boolean;         // Default: true
+  advertiserTrackingEnabled?: boolean; // iOS ATT status (auto-detected if not set)
+}
+
+// TikTok SDK Configuration
+export interface TikTokConfig {
+  appId: string;                     // Your App ID (for Datalyr)
+  tiktokAppId: string;               // TikTok App ID
+  accessToken?: string;              // Access Token for Events API
+  enableAppEvents?: boolean;         // Default: true
+}
+
+// Deferred Deep Link Result (from platform SDKs)
+export interface DeferredDeepLinkResult {
+  url?: string;
+  source?: string;
+  fbclid?: string;
+  ttclid?: string;
+  utmSource?: string;
+  utmMedium?: string;
+  utmCampaign?: string;
+  utmContent?: string;
+  utmTerm?: string;
+  campaignId?: string;
+  adsetId?: string;
+  adId?: string;
+}
+
 // Core SDK Configuration
 export interface DatalyrConfig {
   apiKey: string; // Required for server-side tracking
@@ -33,6 +66,12 @@ export interface DatalyrConfig {
     retryDelay: number;
   };
   skadTemplate?: 'ecommerce' | 'gaming' | 'subscription';
+
+  // Meta (Facebook) SDK Configuration
+  meta?: MetaConfig;
+
+  // TikTok SDK Configuration
+  tiktok?: TikTokConfig;
 }
 // Event Types
 export interface EventData {

package/src/utils-expo.ts

@@ -9,13 +9,16 @@ import { v4 as uuidv4 } from 'uuid';
 // Storage keys
 export const STORAGE_KEYS = {
   VISITOR_ID: '@datalyr/visitor_id',
+  ANONYMOUS_ID: '@datalyr/anonymous_id',  // Persistent anonymous identifier
   SESSION_ID: '@datalyr/session_id',
   SESSION_START: '@datalyr/session_start',
   USER_ID: '@datalyr/user_id',
   USER_PROPERTIES: '@datalyr/user_properties',
+  EVENT_QUEUE: '@datalyr/event_queue',
   ATTRIBUTION_DATA: '@datalyr/attribution_data',
   INSTALL_TIME: '@datalyr/install_time',
   LAST_APP_VERSION: '@datalyr/last_app_version',
+  LAST_SESSION_TIME: '@datalyr/last_session_time',
   DEVICE_ID: '@datalyr/device_id',
 } as const;
 
@@ -136,17 +139,17 @@ const getOrCreateDeviceId = async (): Promise<string> => {
   }
 };
 
-// Visitor ID management  
+// Visitor ID management
 export const getOrCreateVisitorId = async (): Promise<string> => {
   try {
     let visitorId = await Storage.getItem<string>(STORAGE_KEYS.VISITOR_ID);
-    
+
     if (!visitorId) {
       visitorId = generateUUID();
       await Storage.setItem(STORAGE_KEYS.VISITOR_ID, visitorId);
       debugLog('Created new visitor ID:', visitorId);
     }
-    
+
     return visitorId;
   } catch (error) {
     errorLog('Error managing visitor ID:', error as Error);
@@ -154,6 +157,25 @@ export const getOrCreateVisitorId = async (): Promise<string> => {
   }
 };
 
+// Anonymous ID management - persistent across app reinstalls
+export const getOrCreateAnonymousId = async (): Promise<string> => {
+  try {
+    let anonymousId = await Storage.getItem<string>(STORAGE_KEYS.ANONYMOUS_ID);
+
+    if (!anonymousId) {
+      // Generate anonymous_id with anon_ prefix to match web SDK
+      anonymousId = `anon_${generateUUID()}`;
+      await Storage.setItem(STORAGE_KEYS.ANONYMOUS_ID, anonymousId);
+      debugLog('Created new anonymous ID:', anonymousId);
+    }
+
+    return anonymousId;
+  } catch (error) {
+    errorLog('Error managing anonymous ID:', error as Error);
+    return `anon_${generateUUID()}`;
+  }
+};
+
 // Session management
 export const getOrCreateSessionId = async (): Promise<string> => {
   try {

package/src/utils-interface.ts

@@ -0,0 +1,38 @@
+/**
+ * Interface for SDK utilities
+ * Both utils.ts and utils-expo.ts implement this interface
+ */
+
+import { DeviceInfo, FingerprintData } from './types';
+
+export interface SDKUtils {
+  STORAGE_KEYS: {
+    VISITOR_ID: string;
+    ANONYMOUS_ID: string;
+    SESSION_ID: string;
+    USER_ID: string;
+    USER_PROPERTIES: string;
+    EVENT_QUEUE: string;
+    ATTRIBUTION_DATA: string;
+    LAST_SESSION_TIME: string;
+  };
+
+  generateUUID: () => string;
+  getOrCreateVisitorId: () => Promise<string>;
+  getOrCreateAnonymousId: () => Promise<string>;
+  getOrCreateSessionId: () => Promise<string>;
+  getDeviceInfo: () => Promise<DeviceInfo>;
+  createFingerprintData: () => Promise<FingerprintData>;
+  getNetworkType: () => string | Promise<string>;
+  validateEventName: (eventName: string) => boolean;
+  validateEventData: (eventData: any) => boolean;
+  debugLog: (message: string, ...args: any[]) => void;
+  errorLog: (message: string, error?: Error) => void;
+
+  Storage: {
+    setItem: (key: string, value: any) => Promise<void>;
+    getItem: <T>(key: string) => Promise<T | null>;
+    removeItem: (key: string) => Promise<void>;
+    clear?: () => Promise<void>;
+  };
+}