gomarketme-react-native 1.1.1 → 4.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gomarketme-react-native",
-  "version": "1.1.1",
+  "version": "4.0.0",
   "description": "Affiliate Marketing for React Native-Based iOS and Android Apps.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -18,16 +18,17 @@
   "author": "GoMarketMe",
   "license": "MIT",
   "dependencies": {
-    "@react-native-async-storage/async-storage": "^1.15.6",
-    "axios": "^0.21.1",
-    "get-user-locale": "^2.3.2",
-    "react-native-device-info": "^14.0.0",
-    "react-native-iap": "^7.0.0"
+    "@react-native-async-storage/async-storage": "^2.2.0",
+    "axios": "^1.13.2",
+    "get-user-locale": "^3.0.0",
+    "react-native-device-info": "^14.1.1",
+    "react-native-iap": "^14.4.38",
+    "react-native-nitro-modules": "^0.31.4"
   },
   "devDependencies": {
-    "@types/node": "^15.12.5",
-    "@types/react-native": "^0.64.12",
-    "typescript": "^4.3.5"
+    "@types/node": "^24.10.0",
+    "@types/react-native": "^0.73.0",
+    "typescript": "^5.9.3"
   },
   "peerDependencies": {
     "react": "*",

package/src/index.tsx

@@ -1,285 +1,390 @@
 import { Platform, Dimensions, PixelRatio } from 'react-native';
 import DeviceInfo from 'react-native-device-info';
-import getUserLocale from 'get-user-locale'
+import getUserLocale from 'get-user-locale';
 import AsyncStorage from '@react-native-async-storage/async-storage';
-import InAppPurchase, { Purchase, Product, Subscription } from 'react-native-iap';
 import axios from 'axios';
 
+import {
+  type Purchase,
+  type PurchaseError,
+  purchaseUpdatedListener,
+  purchaseErrorListener,
+  fetchProducts,
+  ProductCommon,
+  PurchaseCommon,
+  getAvailablePurchases,
+} from 'react-native-iap';
+
+export class GoMarketMeAffiliateMarketingData {
+  campaign: Campaign;
+  affiliate: Affiliate;
+  saleDistribution: SaleDistribution;
+  affiliateCampaignCode: string;
+  deviceId: string;
+  offerCode?: string;
+
+  constructor(
+    campaign: Campaign,
+    affiliate: Affiliate,
+    saleDistribution: SaleDistribution,
+    affiliateCampaignCode: string,
+    deviceId: string,
+    offerCode?: string
+  ) {
+    this.campaign = campaign;
+    this.affiliate = affiliate;
+    this.saleDistribution = saleDistribution;
+    this.affiliateCampaignCode = affiliateCampaignCode;
+    this.deviceId = deviceId;
+    this.offerCode = offerCode;
+  }
+
+  static fromJson(json: Record<string, any>): GoMarketMeAffiliateMarketingData | null {
+    if (!json || Object.keys(json).length === 0) return null;
+    return new GoMarketMeAffiliateMarketingData(
+      Campaign.fromJson(json.campaign),
+      Affiliate.fromJson(json.affiliate),
+      SaleDistribution.fromJson(json.sale_distribution),
+      json.affiliate_campaign_code || '',
+      json.device_id || '',
+      json.offer_code
+    );
+  }
+}
+
+export class Campaign {
+  id: string;
+  name: string;
+  status: string;
+  type: string;
+  publicLinkUrl?: string;
+
+  constructor(id: string, name: string, status: string, type: string, publicLinkUrl?: string) {
+    this.id = id;
+    this.name = name;
+    this.status = status;
+    this.type = type;
+    this.publicLinkUrl = publicLinkUrl;
+  }
+
+  static fromJson(json: Record<string, any>): Campaign {
+    return new Campaign(
+      json?.id || '',
+      json?.name || '',
+      json?.status || '',
+      json?.type || '',
+      json?.public_link_url
+    );
+  }
+}
+
+export class Affiliate {
+  id: string;
+  firstName: string;
+  lastName: string;
+  countryCode: string;
+  instagramAccount: string;
+  tiktokAccount: string;
+  xAccount: string;
+
+  constructor(
+    id: string,
+    firstName: string,
+    lastName: string,
+    countryCode: string,
+    instagramAccount: string,
+    tiktokAccount: string,
+    xAccount: string
+  ) {
+    this.id = id;
+    this.firstName = firstName;
+    this.lastName = lastName;
+    this.countryCode = countryCode;
+    this.instagramAccount = instagramAccount;
+    this.tiktokAccount = tiktokAccount;
+    this.xAccount = xAccount;
+  }
+
+  static fromJson(json: Record<string, any>): Affiliate {
+    return new Affiliate(
+      json?.id || '',
+      json?.first_name || '',
+      json?.last_name || '',
+      json?.country_code || '',
+      json?.instagram_account || '',
+      json?.tiktok_account || '',
+      json?.x_account || ''
+    );
+  }
+}
+
+export class SaleDistribution {
+  platformPercentage: string;
+  affiliatePercentage: string;
+
+  constructor(platformPercentage: string, affiliatePercentage: string) {
+    this.platformPercentage = platformPercentage;
+    this.affiliatePercentage = affiliatePercentage;
+  }
+
+  static fromJson(json: Record<string, any>): SaleDistribution {
+    return new SaleDistribution(json?.platform_percentage || '', json?.affiliate_percentage || '');
+  }
+}
+
 class GoMarketMe {
   private static instance: GoMarketMe;
+  private sdkType = 'ReactNative';
+  private sdkVersion = '4.0.0';
   private sdkInitializedKey = 'GOMARKETME_SDK_INITIALIZED';
-  private affiliateCampaignCode = '';
-  private deviceId = '';
-  private sdkInitializationUrl = 'https://api.gomarketme.net/v1/sdk-initialization';
-  private systemInfoUrl = 'https://api.gomarketme.net/v1/mobile/system-info';
-  private eventUrl = 'https://api.gomarketme.net/v1/event';
+  private sdkInitializationUrl =
+    'https://4v9008q1a5.execute-api.us-west-2.amazonaws.com/prod/v1/sdk-initialization';
+  private systemInfoUrl =
+    'https://4v9008q1a5.execute-api.us-west-2.amazonaws.com/prod/v1/mobile/system-info';
+  private eventUrl = 'https://4v9008q1a5.execute-api.us-west-2.amazonaws.com/prod/v1/event';
+  private _affiliateCampaignCode = '';
+  private _deviceId = '';
+  private _packageName = '';
+  private _purchaseUpdateUnsub?: ReturnType<typeof purchaseUpdatedListener>;
+  private _purchaseErrorUnsub?: ReturnType<typeof purchaseErrorListener>;
+  public affiliateMarketingData?: GoMarketMeAffiliateMarketingData | null;
 
-  private constructor() {}
+  private constructor() { }
 
   public static getInstance(): GoMarketMe {
-    if (!GoMarketMe.instance) {
-      GoMarketMe.instance = new GoMarketMe();
-    }
+    if (!GoMarketMe.instance) GoMarketMe.instance = new GoMarketMe();
     return GoMarketMe.instance;
   }
 
   public async initialize(apiKey: string): Promise<void> {
     try {
-      const isSDKInitialized = await this.isSDKInitialized();
-      if (!isSDKInitialized) {
-        await this.postSDKInitialization(apiKey);
-      }
-      const systemInfo = await this.getSystemInfo();
-      await this.postSystemInfo(systemInfo, apiKey);
-      await this.addListener(apiKey);
+      const isSDKInitialized = await this._isSDKInitialized();
+      if (!isSDKInitialized) await this._postSDKInitialization(apiKey);
+      this._packageName = DeviceInfo.getBundleId();
+      const systemInfo = await this._getSystemInfo();
+      this.affiliateMarketingData = await this._postSystemInfo(systemInfo, apiKey);
+      await this._addListeners(apiKey);
+      this._fetchExistingPurchases(apiKey).catch(e => {
+        console.log('Error in background purchase fetch:', e);
+      });
     } catch (e) {
-      console.error('Error initializing GoMarketMe:', e);
+      console.log('Error initializing GoMarketMe:', e);
     }
   }
 
-  private async addListener(apiKey: string): Promise<void> {
-    InAppPurchase.purchaseUpdatedListener(async (purchase: Purchase) => {
-      if (this.affiliateCampaignCode != '') {
-        const productIds = await this.fetchPurchases([purchase], apiKey);
-        await this.fetchPurchaseProducts(productIds, apiKey);
-      }
-    });
+  public removeListeners(): void {
+    try {
+      this._purchaseUpdateUnsub?.remove?.();
+      this._purchaseErrorUnsub?.remove?.();
+    } catch (e) {
+      console.log('Error removing listeners:', e);
+    }
   }
 
-  private async getSystemInfo(): Promise<any> {
-    const deviceData = Platform.select({
-      ios: await this.readIosDeviceInfo(),
-      android: await this.readAndroidDeviceInfo(),
-    });
-  
+  private async _addListeners(apiKey: string): Promise<void> {
+    if (!this._purchaseUpdateUnsub) {
+      this._purchaseUpdateUnsub = purchaseUpdatedListener(async (purchase: Purchase) => {
+        try {
+          await this._fetchConsolidatedPurchases([purchase], apiKey);
+        } catch (e) {
+          console.log('purchaseUpdated error:', e);
+        }
+      });
+    }
+
+    if (!this._purchaseErrorUnsub) {
+      this._purchaseErrorUnsub = purchaseErrorListener((error: PurchaseError) => {
+        console.log('purchaseErrorListener:', error);
+      });
+    }
+  }
+
+  private async _getSystemInfo(): Promise<any> {
+    const deviceData =
+      Platform.OS === 'ios'
+        ? await this._readIosDeviceInfo()
+        : await this._readAndroidDeviceInfo();
+
+    this._deviceId = deviceData['deviceId'] || '';
+
     const devicePixelRatio = PixelRatio.get();
     const dimension = Dimensions.get('window');
-  
-    const windowData = {
-      devicePixelRatio: devicePixelRatio,
-      width: dimension.width * devicePixelRatio,
-      height: dimension.height * devicePixelRatio,
-    };
-  
+
     return {
       device_info: deviceData,
-      window_info: windowData,
-      time_zone: this.getTimeZone(),
-      language_code: this.getLanguageCode(),
+      window_info: {
+        devicePixelRatio,
+        width: dimension.width * devicePixelRatio,
+        height: dimension.height * devicePixelRatio,
+      },
+      time_zone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+      language_code: getUserLocale(),
+      sdk_type: this.sdkType,
+      sdk_version: this.sdkVersion,
+      package_name: this._packageName,
+      is_production: await this._isProduction()
     };
   }
 
-  private async postSDKInitialization(apiKey: string): Promise<void> {
+  private async _postSDKInitialization(apiKey: string): Promise<void> {
     try {
-      const response = await axios.post(this.sdkInitializationUrl, {}, {
-        headers: {
-          'Content-Type': 'application/json',
-          'x-api-key': apiKey,
-        },
+      const res = await axios.post(this.sdkInitializationUrl, {}, {
+        headers: { 'x-api-key': apiKey },
       });
-      if (response.status === 200) {
-        await this.markSDKAsInitialized();
-      } else {
-        console.error('Failed to mark SDK as Initialized. Status code:', response.status);
-      }
+      if (res.status === 200) await this._markSDKAsInitialized();
     } catch (e) {
-      console.error('Error sending SDK information to server:', e);
+      console.log('Error posting SDK initialization:', e);
     }
   }
 
-  private async postSystemInfo(systemInfo: any, apiKey: string): Promise<void> {
+  private async _postSystemInfo(data: any, apiKey: string) {
     try {
-      const response = await axios.post(this.systemInfoUrl, systemInfo, {
-        headers: {
-          'Content-Type': 'application/json',
-          'x-api-key': apiKey,
-        },
+      const res = await axios.post(this.systemInfoUrl, data, {
+        headers: { 'x-api-key': apiKey },
       });
-      if (response.status === 200) {
-        const responseData = response.data;
-        if (responseData.affiliate_campaign_code) {
-          this.affiliateCampaignCode = responseData.affiliate_campaign_code;
-        }
-        if (responseData.device_id) {
-          this.deviceId = responseData.device_id;
-        }
-
-      } else {
-        console.error('Failed to send system info. Status code:', response.status);
+      if (res.status === 200) {
+        const obj = GoMarketMeAffiliateMarketingData.fromJson(res.data);
+        if (obj) this._affiliateCampaignCode = obj.affiliateCampaignCode;
+        return obj;
       }
     } catch (e) {
-      console.error('Error sending system info to server:', e);
+      console.log('Error posting system info:', e);
     }
+    return null;
   }
 
-  private async readAndroidDeviceInfo(): Promise<any> {
-
-    let androidId = await DeviceInfo.getAndroidId();
-    let uniqueId = await DeviceInfo.getUniqueId();
-    let deviceId = await DeviceInfo.getDeviceId(); // model
-    let systemName = await DeviceInfo.getSystemName();
-    let systemVersion = await DeviceInfo.getSystemVersion()
-    let brand = await DeviceInfo.getBrand();
-    let model = await DeviceInfo.getModel();
-    let manufacturer = await DeviceInfo.getManufacturer();
-    let isEmulator = await DeviceInfo.isEmulator();
-
+  private async _readAndroidDeviceInfo() {
     return {
-      deviceId: androidId,
-      _deviceId: deviceId,
-      _uniqueId: uniqueId,
-      systemName: systemName,
-      systemVersion: systemVersion,
-      brand: brand,
-      model: model,
-      manufacturer: manufacturer,
-      isEmulator: isEmulator
+      deviceId: await DeviceInfo.getAndroidId(),
+      brand: await DeviceInfo.getBrand(),
+      model: await DeviceInfo.getModel(),
+      manufacturer: await DeviceInfo.getManufacturer(),
+      systemName: await DeviceInfo.getSystemName(),
+      systemVersion: await DeviceInfo.getSystemVersion(),
     };
   }
 
-  private async readIosDeviceInfo(): Promise<any> {
-
-    let uniqueId = await DeviceInfo.getUniqueId();
-    let deviceId = await DeviceInfo.getDeviceId(); // model
-    let systemName = await DeviceInfo.getSystemName();
-    let systemVersion = await DeviceInfo.getSystemVersion()
-    let brand = await DeviceInfo.getBrand();
-    let model = await DeviceInfo.getModel();
-    let manufacturer = await DeviceInfo.getManufacturer();
-    let isEmulator = await DeviceInfo.isEmulator();
-
+  private async _readIosDeviceInfo() {
     return {
-      deviceId: uniqueId,
-      _deviceId: deviceId,
-      systemName: systemName,
-      systemVersion: systemVersion,
-      brand: brand,
-      model: model,
-      manufacturer: manufacturer,
-      isEmulator: isEmulator
+      deviceId: await DeviceInfo.getUniqueId(),
+      brand: await DeviceInfo.getBrand(),
+      model: await DeviceInfo.getModel(),
+      manufacturer: await DeviceInfo.getManufacturer(),
+      systemName: await DeviceInfo.getSystemName(),
+      systemVersion: await DeviceInfo.getSystemVersion(),
     };
   }
 
-  private getTimeZone = (): string => {
-    return Intl.DateTimeFormat().resolvedOptions().timeZone;
-};
-
-  private getLanguageCode(): string {
-    return getUserLocale();
-  }
+  private async _fetchConsolidatedPurchases(purchases: Purchase[], apiKey: string) {
+    for (const purchase of purchases) {
+      const receipt = purchase.purchaseToken;
+      if (!receipt) continue;
 
-  private async fetchPurchases(purchaseDetailsList: Purchase[], apiKey: string): Promise<string[]> {
-    const productIds: string[] = [];
-    for (const purchase of purchaseDetailsList) {
-      if (purchase.transactionReceipt) {
-        await this.sendEventToServer(JSON.stringify(this.serializePurchaseDetails(purchase)), 'purchase', apiKey);
-        if (purchase.productId && !productIds.includes(purchase.productId)) {
-          productIds.push(purchase.productId);
-        }
-      }
-    }
-    return productIds;
-  }
+      const data: any = this._serializePurchaseDetails(purchase);
+      data.products = [];
 
-  private async fetchPurchaseProducts(productIds: string[], apiKey: string): Promise<void> {
-    try {
-      const products = await InAppPurchase.getProducts(productIds);
-      if (products.length > 0) {
-        for (const product of products) {
-          await this.sendEventToServer(JSON.stringify(this.serializeProductDetails(product)), 'product', apiKey);
-        }
-      } else {
-        const products = await InAppPurchase.getSubscriptions(productIds);
-        if (products.length > 0) {
-          for (const product of products) {
-            await this.sendEventToServer(JSON.stringify(this.serializeSubscriptionDetails(product)), 'product', apiKey);
+      const pid = data.productID || '';
+      if (pid) {
+        try {
+          const products = await fetchProducts({ skus: [pid] });
+          if (products && products.length) {
+            for (const p of products) {
+              data.products.push(this._serializeProductDetails(p));
+            }
           }
-        } else {
-          await this.sendEventToServer(JSON.stringify({ notFoundIDs: productIds.join(',') }), 'product', apiKey);
+        } catch (e) {
+          console.warn('Error fetching products:', e);
         }
       }
-    } catch (e) {
-      console.error('Error fetching products:', e);
+
+      await this._sendEventToServer(JSON.stringify(data), 'purchase_product', apiKey);
     }
   }
 
-  private async sendEventToServer(body: string, eventType: string, apiKey: string): Promise<void> {
+  private async _sendEventToServer(body: string, eventType: string, apiKey: string) {
     try {
-      const response = await axios.post(this.eventUrl, body, {
+      await axios.post(this.eventUrl, body, {
         headers: {
-          'Content-Type': 'application/json',
-          'x-affiliate-campaign-code': this.affiliateCampaignCode,
-          'x-device-id': this.deviceId,
+          'x-affiliate-campaign-code': this._affiliateCampaignCode,
+          'x-device-id': this._deviceId,
           'x-event-type': eventType,
           'x-product-type': Platform.OS,
           'x-source-name': Platform.OS === 'android' ? 'google_play' : 'app_store',
           'x-api-key': apiKey,
         },
       });
-      if (response.status === 200) {
-        console.log(`${eventType} sent successfully`);
-      } else {
-        console.error(`Failed to send ${eventType}. Status code:`, response.status);
-      }
+      console.log(`${eventType} sent successfully`);
     } catch (e) {
-      console.error(`Error sending ${eventType} to server:`, e);
+      console.log(`Error sending ${eventType}:`, e);
     }
   }
 
-  private serializePurchaseDetails(purchase: Purchase): any {
+  private _serializePurchaseDetails(purchase: PurchaseCommon) {
     return {
+      packageName: this._packageName,
       productID: purchase.productId,
-      purchaseID: purchase.transactionId || '',
-      transactionDate: purchase.transactionDate || '',
-      status: Platform.select({
-        ios: (purchase as any).transactionStateIOS, // Removed non-existent properties
-        android: (purchase as any).purchaseStateAndroid,
-      }),
+      purchaseID: purchase.id,
+      transactionDate: purchase.transactionDate,
       verificationData: {
-        localVerificationData: purchase.transactionReceipt,
+        localVerificationData: purchase.purchaseToken,
+        source: Platform.OS === 'android' ? 'google_play' : 'app_store',
       },
     };
   }
 
-  private serializeProductDetails(product: Product): any {
+  private _serializeProductDetails(product: ProductCommon) {
     return {
-      productID: product.productId,
+      packageName: this._packageName,
+      productID: product.id,
       productTitle: product.title,
       productDescription: product.description,
-      productPrice: product.price,
-      productRawPrice: product.price,
+      productPrice: product.displayPrice,
+      productRawPrice: product.price || '',
       productCurrencyCode: product.currency,
     };
   }
 
-  private serializeSubscriptionDetails(subscription: Subscription): any {
-    return {
-      productID: subscription.productId,
-      productTitle: subscription.title,
-      productDescription: subscription.description,
-      productPrice: subscription.price,
-      productRawPrice: subscription.price,
-      productCurrencyCode: subscription.currency,
-    };
+  private async _markSDKAsInitialized() {
+    await AsyncStorage.setItem(this.sdkInitializedKey, 'true');
+  }
+
+  private async _isSDKInitialized() {
+    const val = await AsyncStorage.getItem(this.sdkInitializedKey);
+    return val === 'true';
   }
 
-  private async markSDKAsInitialized(): Promise<boolean> {
+  private async _isProduction(): Promise<boolean> {
+    if (__DEV__) return false;
+
     try {
-      await AsyncStorage.setItem(this.sdkInitializedKey, 'true');
-      return true;
-    } catch (e) {
-      console.error('Failed to save SDK initialization:', e);
+      const installer = await DeviceInfo.getInstallerPackageName();
+
+      if (
+        installer === 'com.android.vending' ||
+        installer === 'com.amazon.venezia'
+      ) {
+        return true;
+      }
+
+      if (installer == null && !__DEV__) {
+        return true;
+      }
+
+      return false;
+    } catch (error) {
+      console.warn('Error determining production status:', error);
       return false;
     }
   }
 
-  private async isSDKInitialized(): Promise<boolean> {
+  private async _fetchExistingPurchases(apiKey: string): Promise<void> {
     try {
-      const value = await AsyncStorage.getItem(this.sdkInitializedKey);
-      return value === 'true';
+      const purchases = await getAvailablePurchases();
+      if (purchases && purchases.length > 0) {
+        await this._fetchConsolidatedPurchases(purchases, apiKey);
+      }
     } catch (e) {
-      console.error('Failed to load SDK initialization:', e);
-      return false;
+      console.log('Error fetching existing purchases on app open:', e);
     }
   }
 }