insert-affiliate-react-native-sdk 1.8.0 → 1.9.0

package/dist/DeepLinkIapProvider.d.ts

@@ -3,6 +3,11 @@ type T_DEEPLINK_IAP_PROVIDER = {
     children: React.ReactNode;
 };
 export type InsertAffiliateIdentifierChangeCallback = (identifier: string | null) => void;
+export type AffiliateDetails = {
+    affiliateName: string;
+    affiliateShortCode: string;
+    deeplinkurl: string;
+} | null;
 type CustomPurchase = {
     [key: string]: any;
 };
@@ -17,7 +22,8 @@ type T_DEEPLINK_IAP_CONTEXT = {
     returnUserAccountTokenAndStoreExpectedTransaction: () => Promise<string | null>;
     storeExpectedStoreTransaction: (purchaseToken: string) => Promise<void>;
     trackEvent: (eventName: string) => Promise<void>;
-    setShortCode: (shortCode: string) => Promise<void>;
+    setShortCode: (shortCode: string) => Promise<boolean>;
+    getAffiliateDetails: (affiliateCode: string) => Promise<AffiliateDetails>;
     setInsertAffiliateIdentifier: (referringLink: string) => Promise<void | string>;
     setInsertAffiliateIdentifierChangeCallback: (callback: InsertAffiliateIdentifierChangeCallback | null) => void;
     handleInsertLinks: (url: string) => Promise<boolean>;

package/dist/DeepLinkIapProvider.js

@@ -67,7 +67,8 @@ exports.DeepLinkIapContext = (0, react_1.createContext)({
     returnUserAccountTokenAndStoreExpectedTransaction: () => __awaiter(void 0, void 0, void 0, function* () { return ''; }),
     storeExpectedStoreTransaction: (purchaseToken) => __awaiter(void 0, void 0, void 0, function* () { }),
     trackEvent: (eventName) => __awaiter(void 0, void 0, void 0, function* () { }),
-    setShortCode: (shortCode) => __awaiter(void 0, void 0, void 0, function* () { }),
+    setShortCode: (shortCode) => __awaiter(void 0, void 0, void 0, function* () { return false; }),
+    getAffiliateDetails: (affiliateCode) => __awaiter(void 0, void 0, void 0, function* () { return null; }),
     setInsertAffiliateIdentifier: (referringLink) => __awaiter(void 0, void 0, void 0, function* () { }),
     setInsertAffiliateIdentifierChangeCallback: (callback) => { },
     handleInsertLinks: (url) => __awaiter(void 0, void 0, void 0, function* () { return false; }),
@@ -1019,6 +1020,84 @@ const DeepLinkIapProvider = ({ children, }) => {
         const isValidCharacters = /^[a-zA-Z0-9_]+$/.test(referringLink);
         return isValidCharacters && referringLink.length >= 3 && referringLink.length <= 25;
     };
+    const checkAffiliateExists = (affiliateCode) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            const activeCompanyCode = yield getActiveCompanyCode();
+            if (!activeCompanyCode) {
+                verboseLog('Cannot check affiliate: no company code available');
+                return false;
+            }
+            const url = 'https://api.insertaffiliate.com/V1/checkAffiliateExists';
+            const payload = {
+                companyId: activeCompanyCode,
+                affiliateCode: affiliateCode
+            };
+            verboseLog(`Checking if affiliate exists: ${affiliateCode}`);
+            const response = yield axios_1.default.post(url, payload, {
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+            verboseLog(`Affiliate check response: ${JSON.stringify(response.data)}`);
+            if (response.status === 200 && response.data) {
+                const exists = response.data.exists === true;
+                if (exists) {
+                    verboseLog(`Affiliate ${affiliateCode} exists and is valid`);
+                }
+                else {
+                    verboseLog(`Affiliate ${affiliateCode} does not exist`);
+                }
+                return exists;
+            }
+            else {
+                verboseLog(`Unexpected response checking affiliate: status ${response.status}`);
+                return false;
+            }
+        }
+        catch (error) {
+            verboseLog(`Error checking affiliate exists: ${error}`);
+            return false;
+        }
+    });
+    const getAffiliateDetails = (affiliateCode) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            const activeCompanyCode = yield getActiveCompanyCode();
+            if (!activeCompanyCode) {
+                verboseLog('Cannot get affiliate details: no company code available');
+                return null;
+            }
+            const url = 'https://api.insertaffiliate.com/V1/checkAffiliateExists';
+            const payload = {
+                companyId: activeCompanyCode,
+                affiliateCode: affiliateCode
+            };
+            verboseLog(`Getting affiliate details for: ${affiliateCode}`);
+            const response = yield axios_1.default.post(url, payload, {
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+            verboseLog(`Affiliate details response: ${JSON.stringify(response.data)}`);
+            if (response.status === 200 && response.data && response.data.exists === true) {
+                const affiliate = response.data.affiliate;
+                if (affiliate) {
+                    verboseLog(`Retrieved affiliate details: ${JSON.stringify(affiliate)}`);
+                    return {
+                        affiliateName: affiliate.affiliateName || '',
+                        affiliateShortCode: affiliate.affiliateShortCode || '',
+                        deeplinkurl: affiliate.deeplinkurl || ''
+                    };
+                }
+            }
+            verboseLog(`Affiliate ${affiliateCode} not found or invalid response`);
+            return null;
+        }
+        catch (error) {
+            verboseLog(`Error getting affiliate details: ${error}`);
+            console.error('[Insert Affiliate] Error getting affiliate details:', error);
+            return null;
+        }
+    });
     function setShortCode(shortCode) {
         return __awaiter(this, void 0, void 0, function* () {
             console.log('[Insert Affiliate] Setting short code.');
@@ -1026,8 +1105,18 @@ const DeepLinkIapProvider = ({ children, }) => {
             // Validate it is a short code
             const capitalisedShortCode = shortCode.toUpperCase();
             isShortCode(capitalisedShortCode);
-            // If all checks pass, set the Insert Affiliate Identifier
-            yield storeInsertAffiliateIdentifier({ link: capitalisedShortCode });
+            // Check if the affiliate exists before storing
+            const exists = yield checkAffiliateExists(capitalisedShortCode);
+            if (exists) {
+                // If affiliate exists, set the Insert Affiliate Identifier
+                yield storeInsertAffiliateIdentifier({ link: capitalisedShortCode });
+                console.log(`[Insert Affiliate] Short code ${capitalisedShortCode} validated and stored successfully.`);
+                return true;
+            }
+            else {
+                console.warn(`[Insert Affiliate] Short code ${capitalisedShortCode} does not exist. Not storing.`);
+                return false;
+            }
         });
     }
     function getOrCreateUserAccountToken() {
@@ -1529,6 +1618,7 @@ const DeepLinkIapProvider = ({ children, }) => {
             userId,
             OfferCode,
             setShortCode,
+            getAffiliateDetails,
             returnInsertAffiliateIdentifier,
             isAffiliateAttributionValid,
             getAffiliateStoredDate,

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 import DeepLinkIapProvider from "./DeepLinkIapProvider";
 import useDeepLinkIapProvider from "./useDeepLinkIapProvider";
 export { DeepLinkIapProvider, useDeepLinkIapProvider };
-export type { InsertAffiliateIdentifierChangeCallback } from "./DeepLinkIapProvider";
+export type { InsertAffiliateIdentifierChangeCallback, AffiliateDetails } from "./DeepLinkIapProvider";

package/dist/useDeepLinkIapProvider.d.ts

@@ -10,7 +10,8 @@ declare const useDeepLinkIapProvider: () => {
     isAffiliateAttributionValid: () => Promise<boolean>;
     getAffiliateStoredDate: () => Promise<Date | null>;
     trackEvent: (eventName: string) => Promise<void>;
-    setShortCode: (shortCode: string) => Promise<void>;
+    setShortCode: (shortCode: string) => Promise<boolean>;
+    getAffiliateDetails: (affiliateCode: string) => Promise<import("./DeepLinkIapProvider").AffiliateDetails>;
     setInsertAffiliateIdentifier: (referringLink: string) => Promise<void | string>;
     setInsertAffiliateIdentifierChangeCallback: (callback: import("./DeepLinkIapProvider").InsertAffiliateIdentifierChangeCallback | null) => void;
     handleInsertLinks: (url: string) => Promise<boolean>;

package/dist/useDeepLinkIapProvider.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const react_1 = require("react");
 const DeepLinkIapProvider_1 = require("./DeepLinkIapProvider");
 const useDeepLinkIapProvider = () => {
-    const { referrerLink, userId, validatePurchaseWithIapticAPI, storeExpectedStoreTransaction, returnUserAccountTokenAndStoreExpectedTransaction, returnInsertAffiliateIdentifier, isAffiliateAttributionValid, getAffiliateStoredDate, trackEvent, setShortCode, setInsertAffiliateIdentifier, setInsertAffiliateIdentifierChangeCallback, handleInsertLinks, initialize, isInitialized, OfferCode, } = (0, react_1.useContext)(DeepLinkIapProvider_1.DeepLinkIapContext);
+    const { referrerLink, userId, validatePurchaseWithIapticAPI, storeExpectedStoreTransaction, returnUserAccountTokenAndStoreExpectedTransaction, returnInsertAffiliateIdentifier, isAffiliateAttributionValid, getAffiliateStoredDate, trackEvent, setShortCode, getAffiliateDetails, setInsertAffiliateIdentifier, setInsertAffiliateIdentifierChangeCallback, handleInsertLinks, initialize, isInitialized, OfferCode, } = (0, react_1.useContext)(DeepLinkIapProvider_1.DeepLinkIapContext);
     return {
         referrerLink,
         userId,
@@ -15,6 +15,7 @@ const useDeepLinkIapProvider = () => {
         getAffiliateStoredDate,
         trackEvent,
         setShortCode,
+        getAffiliateDetails,
         setInsertAffiliateIdentifier,
         setInsertAffiliateIdentifierChangeCallback,
         handleInsertLinks,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "insert-affiliate-react-native-sdk",
-  "version": "1.8.0",
+  "version": "1.9.0",
   "description": "A package for connecting with the Insert Affiliate Platform to add app based affiliate marketing.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/readme.md

@@ -763,6 +763,7 @@ const DeepLinkHandler = () => {
     // Listen for both deep link types
     appsFlyer.onDeepLink(handleDeepLink);
     appsFlyer.onAppOpenAttribution(handleDeepLink);
+    appsFlyer.onInstallConversionData(handleDeepLink);
 
     initAppsFlyer();
   }, [setInsertAffiliateIdentifier, isInitialized]);
@@ -828,6 +829,7 @@ const DeepLinkHandler = () => {
     // Listen for both deep link types
     appsFlyer.onDeepLink(handleDeepLink);
     appsFlyer.onAppOpenAttribution(handleDeepLink);
+    appsFlyer.onInstallConversionData(handleDeepLink);
 
     initAppsFlyer();
   }, [setInsertAffiliateIdentifier, isInitialized]);
@@ -1214,6 +1216,12 @@ Short codes must meet the following criteria:
 - Contain only **letters, numbers, and underscores** (alphanumeric characters and underscores).
 - Replace {{ user_entered_short_code }} with the short code the user enters through your chosen input method, i.e. an input field / pop up element
 
+**Return Value**: `setShortCode` returns a `Promise<boolean>`:
+- Returns `true` if the short code exists and was successfully validated and stored
+- Returns `false` if the short code does not exist or validation failed
+
+This allows you to provide immediate feedback to users about whether their entered code is valid.
+
 ```javascript
   import {
     DeepLinkIapProvider,
@@ -1223,12 +1231,30 @@ Short codes must meet the following criteria:
     setShortCode,
   } = useDeepLinkIapProvider();
 
+  // Basic usage (without validation feedback)
   <Button
     title={'Set Short Code'}
     onPress={() => setShortCode('JOIN_123')}
   />
+
+  // Recommended usage with validation feedback
+  <Button
+    title={'Set Short Code'}
+    onPress={async () => {
+      const isValid = await setShortCode('JOIN_123');
+      if (isValid) {
+        // Show success message to user
+        Alert.alert('Success', 'Affiliate code applied successfully!');
+      } else {
+        // Show error message to user
+        Alert.alert('Error', 'Invalid affiliate code. Please check and try again.');
+      }
+    }}
+  />
 ```
 
+**Important**: The SDK will automatically validate the short code with the Insert Affiliate backend before storing it. Only valid short codes that exist in your company's affiliate list will be stored. Invalid codes will be rejected and not associated with the user.
+
 ### Attribution Timeout
 
 You can configure how long an affiliate link attribution remains active after being clicked. This allows you to control the attribution window for commissions.
@@ -1308,4 +1334,77 @@ const storedDate = await getAffiliateStoredDate();
 3. **Expired Attribution**: If the attribution has expired, the method returns `null` instead of the affiliate identifier
 4. **Bypass Option**: You can bypass the timeout check by passing `true` to `returnInsertAffiliateIdentifier(true)`
 
-This ensures that affiliates are only credited for purchases made within the specified attribution window, providing fair and accurate commission tracking.
+This ensures that affiliates are only credited for purchases made within the specified attribution window, providing fair and accurate commission tracking.
+
+### Getting Affiliate Details
+
+You can retrieve detailed information about an affiliate by their short code or deep link using the `getAffiliateDetails` method. This is useful for displaying affiliate information to users or showing personalized content based on the referrer.
+
+#### Method Signature
+
+```typescript
+getAffiliateDetails(affiliateCode: string): Promise<AffiliateDetails>
+
+type AffiliateDetails = {
+  affiliateName: string;
+  affiliateShortCode: string;
+  deeplinkurl: string;
+} | null;
+```
+
+#### Usage Example
+
+```javascript
+import { useDeepLinkIapProvider } from 'insert-affiliate-react-native-sdk';
+import type { AffiliateDetails } from 'insert-affiliate-react-native-sdk';
+
+const MyComponent = () => {
+  const { getAffiliateDetails } = useDeepLinkIapProvider();
+
+  const handleGetAffiliateInfo = async (code: string) => {
+    const details = await getAffiliateDetails(code);
+
+    if (details) {
+      console.log('Affiliate Name:', details.affiliateName);
+      console.log('Short Code:', details.affiliateShortCode);
+      console.log('Deep Link:', details.deeplinkurl);
+
+      // Example: Show affiliate name in UI
+      Alert.alert(
+        'Affiliate Found',
+        `This code belongs to ${details.affiliateName}`
+      );
+    } else {
+      console.log('Affiliate not found');
+      Alert.alert('Error', 'Invalid affiliate code');
+    }
+  };
+
+  return (
+    <View>
+      <Button
+        title="Get Affiliate Info"
+        onPress={() => handleGetAffiliateInfo('JOIN_123')}
+      />
+    </View>
+  );
+};
+```
+
+#### Return Value
+
+- Returns an object with affiliate details if the code exists:
+  - `affiliateName`: The name of the affiliate
+  - `affiliateShortCode`: The affiliate's short code
+  - `deeplinkurl`: The affiliate's deep link URL
+- Returns `null` if:
+  - The affiliate code doesn't exist
+  - The company code is not initialized
+  - There's a network error or API issue
+
+#### Important Notes
+
+- This method does **not** store or set the affiliate identifier - it only retrieves information
+- Use `setShortCode()` to actually associate an affiliate with a user
+- The method automatically strips UUIDs from codes (e.g., "ABC123-uuid" becomes "ABC123")
+- Works with both short codes and deep link URLs

package/src/DeepLinkIapProvider.tsx

@@ -17,6 +17,12 @@ type T_DEEPLINK_IAP_PROVIDER = {
 
 export type InsertAffiliateIdentifierChangeCallback = (identifier: string | null) => void;
 
+export type AffiliateDetails = {
+  affiliateName: string;
+  affiliateShortCode: string;
+  deeplinkurl: string;
+} | null;
+
 type CustomPurchase = {
   [key: string]: any; // Accept any fields to allow it to work wtih multiple IAP libraries
 };
@@ -39,7 +45,8 @@ type T_DEEPLINK_IAP_CONTEXT = {
     purchaseToken: string
   ) => Promise<void>;
   trackEvent: (eventName: string) => Promise<void>;
-  setShortCode: (shortCode: string) => Promise<void>;
+  setShortCode: (shortCode: string) => Promise<boolean>;
+  getAffiliateDetails: (affiliateCode: string) => Promise<AffiliateDetails>;
   setInsertAffiliateIdentifier: (
     referringLink: string
   ) => Promise<void | string>;
@@ -92,7 +99,8 @@ export const DeepLinkIapContext = createContext<T_DEEPLINK_IAP_CONTEXT>({
   returnUserAccountTokenAndStoreExpectedTransaction: async () => '',
   storeExpectedStoreTransaction: async (purchaseToken: string) => {},
   trackEvent: async (eventName: string) => {},
-  setShortCode: async (shortCode: string) => {},
+  setShortCode: async (shortCode: string) => false,
+  getAffiliateDetails: async (affiliateCode: string) => null,
   setInsertAffiliateIdentifier: async (referringLink: string) => {},
   setInsertAffiliateIdentifierChangeCallback: (callback: InsertAffiliateIdentifierChangeCallback | null) => {},
   handleInsertLinks: async (url: string) => false,
@@ -1174,7 +1182,94 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
     return isValidCharacters && referringLink.length >= 3 && referringLink.length <= 25;
   };
 
-  async function setShortCode(shortCode: string): Promise<void> {
+  const checkAffiliateExists = async (affiliateCode: string): Promise<boolean> => {
+    try {
+      const activeCompanyCode = await getActiveCompanyCode();
+      if (!activeCompanyCode) {
+        verboseLog('Cannot check affiliate: no company code available');
+        return false;
+      }
+
+      const url = 'https://api.insertaffiliate.com/V1/checkAffiliateExists';
+      const payload = {
+        companyId: activeCompanyCode,
+        affiliateCode: affiliateCode
+      };
+
+      verboseLog(`Checking if affiliate exists: ${affiliateCode}`);
+
+      const response = await axios.post(url, payload, {
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      });
+
+      verboseLog(`Affiliate check response: ${JSON.stringify(response.data)}`);
+
+      if (response.status === 200 && response.data) {
+        const exists = response.data.exists === true;
+        if (exists) {
+          verboseLog(`Affiliate ${affiliateCode} exists and is valid`);
+        } else {
+          verboseLog(`Affiliate ${affiliateCode} does not exist`);
+        }
+        return exists;
+      } else {
+        verboseLog(`Unexpected response checking affiliate: status ${response.status}`);
+        return false;
+      }
+    } catch (error) {
+      verboseLog(`Error checking affiliate exists: ${error}`);
+      return false;
+    }
+  };
+
+  const getAffiliateDetails = async (affiliateCode: string): Promise<AffiliateDetails> => {
+    try {
+      const activeCompanyCode = await getActiveCompanyCode();
+      if (!activeCompanyCode) {
+        verboseLog('Cannot get affiliate details: no company code available');
+        return null;
+      }
+
+      const url = 'https://api.insertaffiliate.com/V1/checkAffiliateExists';
+      const payload = {
+        companyId: activeCompanyCode,
+        affiliateCode: affiliateCode
+      };
+
+      verboseLog(`Getting affiliate details for: ${affiliateCode}`);
+
+      const response = await axios.post(url, payload, {
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      });
+
+      verboseLog(`Affiliate details response: ${JSON.stringify(response.data)}`);
+
+      if (response.status === 200 && response.data && response.data.exists === true) {
+        const affiliate = response.data.affiliate;
+        if (affiliate) {
+          verboseLog(`Retrieved affiliate details: ${JSON.stringify(affiliate)}`);
+          return {
+            affiliateName: affiliate.affiliateName || '',
+            affiliateShortCode: affiliate.affiliateShortCode || '',
+            deeplinkurl: affiliate.deeplinkurl || ''
+          };
+        }
+      }
+
+      verboseLog(`Affiliate ${affiliateCode} not found or invalid response`);
+      return null;
+    } catch (error) {
+      verboseLog(`Error getting affiliate details: ${error}`);
+      console.error('[Insert Affiliate] Error getting affiliate details:', error);
+      return null;
+    }
+  };
+
+  async function setShortCode(shortCode: string): Promise<boolean> {
     console.log('[Insert Affiliate] Setting short code.');
     await generateThenSetUserID();
 
@@ -1182,8 +1277,18 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
     const capitalisedShortCode = shortCode.toUpperCase();
     isShortCode(capitalisedShortCode);
 
-    // If all checks pass, set the Insert Affiliate Identifier
-    await storeInsertAffiliateIdentifier({ link: capitalisedShortCode });
+    // Check if the affiliate exists before storing
+    const exists = await checkAffiliateExists(capitalisedShortCode);
+
+    if (exists) {
+      // If affiliate exists, set the Insert Affiliate Identifier
+      await storeInsertAffiliateIdentifier({ link: capitalisedShortCode });
+      console.log(`[Insert Affiliate] Short code ${capitalisedShortCode} validated and stored successfully.`);
+      return true;
+    } else {
+      console.warn(`[Insert Affiliate] Short code ${capitalisedShortCode} does not exist. Not storing.`);
+      return false;
+    }
   }
 
   async function getOrCreateUserAccountToken(): Promise<string> {
@@ -1779,6 +1884,7 @@ const DeepLinkIapProvider: React.FC<T_DEEPLINK_IAP_PROVIDER> = ({
         userId,
         OfferCode,
         setShortCode,
+        getAffiliateDetails,
         returnInsertAffiliateIdentifier,
         isAffiliateAttributionValid,
         getAffiliateStoredDate,

package/src/index.ts

@@ -4,4 +4,4 @@ import useDeepLinkIapProvider from "./useDeepLinkIapProvider";
 export { DeepLinkIapProvider, useDeepLinkIapProvider };
 
 // Export types
-export type { InsertAffiliateIdentifierChangeCallback } from "./DeepLinkIapProvider";
+export type { InsertAffiliateIdentifierChangeCallback, AffiliateDetails } from "./DeepLinkIapProvider";

package/src/useDeepLinkIapProvider.tsx

@@ -13,6 +13,7 @@ const useDeepLinkIapProvider = () => {
     getAffiliateStoredDate,
     trackEvent,
     setShortCode,
+    getAffiliateDetails,
     setInsertAffiliateIdentifier,
     setInsertAffiliateIdentifierChangeCallback,
     handleInsertLinks,
@@ -32,6 +33,7 @@ const useDeepLinkIapProvider = () => {
     getAffiliateStoredDate,
     trackEvent,
     setShortCode,
+    getAffiliateDetails,
     setInsertAffiliateIdentifier,
     setInsertAffiliateIdentifierChangeCallback,
     handleInsertLinks,