insert-affiliate-js-sdk 1.3.0 → 1.4.0

package/CHANGELOG.md

@@ -5,6 +5,13 @@ All notable changes to the Insert Affiliate JavaScript SDK will be documented in
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.3.1] - 2026-03-29
+
+### Fixed
+- **Offer code sanitization** - Fixed offer codes with dashes/underscores being stripped (e.g. `pro-v3-ext` was incorrectly becoming `prov3ext`)
+  - Now checks for API error responses before cleaning the offer code
+  - Sanitization regex updated to preserve dashes and underscores
+
 ## [1.1.0] - 2025-11-23
 
 ### Added

package/dist/index.d.ts

@@ -6,6 +6,11 @@ interface AffiliateDetails {
     affiliateShortCode: string;
     deeplinkUrl: string;
 }
+type AffiliateLookupStatus = 'found' | 'not_found' | 'lookup_failed' | 'not_configured';
+interface AffiliateLookupResult {
+    status: AffiliateLookupStatus;
+    details: AffiliateDetails | null;
+}
 type InsertAffiliateIdentifierChangeCallback = (identifier: string | null, offerCode: string | null) => void;
 declare class InsertAffiliate {
     private static isInitialized;
@@ -24,9 +29,13 @@ declare class InsertAffiliate {
      * Validates and sets a short code for affiliate tracking
      * Validates the short code against the API before storing
      * @param shortCode The short code to validate and set
+     * @param options.onLookupFailed called when the lookup itself couldn't be completed
+     *   (not just an invalid code) — use it to offer a retry instead of proceeding unattributed.
      * @returns true if the code exists and was successfully validated and stored, false otherwise
      */
-    static setShortCode(shortCode: string): Promise<boolean>;
+    static setShortCode(shortCode: string, options?: {
+        onLookupFailed?: () => void;
+    }): Promise<boolean>;
     static setInsertAffiliateIdentifierChangeCallback(callback: InsertAffiliateIdentifierChangeCallback | null): void;
     static isAffiliateAttributionValid(): Promise<boolean>;
     static getAffiliateStoredDate(): Promise<string | null>;
@@ -36,8 +45,21 @@ declare class InsertAffiliate {
      */
     static getAffiliateExpiryTimestamp(): Promise<number | null>;
     /**
-     * Retrieve detailed information about an affiliate by their short code or deep link
-     * This method queries the API and does not store or set the affiliate identifier
+     * Retrieve detailed information about an affiliate by their short code or deep link,
+     * distinguishing "no affiliate matches this code" from "couldn't check" (backend
+     * outage, timeout, rate limit). This method queries the API and does not store or set
+     * the affiliate identifier.
+     * @param affiliateCode The short code or deep link to look up
+     * @returns an AffiliateLookupResult with a status of 'found', 'not_found', 'lookup_failed', or 'not_configured'
+     */
+    static getAffiliateLookupResult(affiliateCode: string, options?: {
+        trackUsage?: boolean;
+    }): Promise<AffiliateLookupResult>;
+    /**
+     * Retrieve detailed information about an affiliate by their short code or deep link.
+     * Kept for backward compatibility: collapses 'not_found' and 'lookup_failed' into the
+     * same null result, exactly as before. Use getAffiliateLookupResult if you need to tell
+     * an invalid code apart from a backend outage.
      * @param affiliateCode The short code or deep link to look up
      * @returns AffiliateDetails if found, null otherwise
      */
@@ -76,4 +98,4 @@ declare class InsertAffiliate {
     private static fetchShortLink;
 }
 
-export { type AffiliateDetails, InsertAffiliate, type InsertAffiliateIdentifierChangeCallback };
+export { type AffiliateDetails, type AffiliateLookupResult, type AffiliateLookupStatus, InsertAffiliate, type InsertAffiliateIdentifierChangeCallback };

package/dist/index.js

@@ -190,9 +190,12 @@ var InsertAffiliate = class {
    * Validates and sets a short code for affiliate tracking
    * Validates the short code against the API before storing
    * @param shortCode The short code to validate and set
+   * @param options.onLookupFailed called when the lookup itself couldn't be completed
+   *   (not just an invalid code) — use it to offer a retry instead of proceeding unattributed.
    * @returns true if the code exists and was successfully validated and stored, false otherwise
    */
-  static async setShortCode(shortCode) {
+  static async setShortCode(shortCode, options) {
+    var _a;
     this.verboseLog(`Setting short code. Input: ${shortCode}`);
     const valid = /^[a-zA-Z0-9]{3,25}$/.test(shortCode);
     this.verboseLog(`Short code validation: ${valid ? "Valid" : "Invalid"}`);
@@ -200,12 +203,16 @@ var InsertAffiliate = class {
       this.verboseLog("Invalid short code format, aborting");
       return false;
     }
-    const affiliateDetails = await this.getAffiliateDetails(shortCode, { trackUsage: true });
-    if (!affiliateDetails) {
-      this.verboseLog(`Short code '${shortCode}' does not exist or validation failed`);
+    const lookup = await this.getAffiliateLookupResult(shortCode, { trackUsage: true });
+    if (lookup.status !== "found" || !lookup.details) {
+      this.verboseLog(`Short code '${shortCode}' does not exist or validation failed (status: ${lookup.status})`);
       console.error(`[Insert Affiliate] Error: Short code '${shortCode}' does not exist or validation failed.`);
+      if (lookup.status === "lookup_failed") {
+        (_a = options == null ? void 0 : options.onLookupFailed) == null ? void 0 : _a.call(options);
+      }
       return false;
     }
+    const affiliateDetails = lookup.details;
     this.verboseLog(`Short code validated successfully for affiliate: ${affiliateDetails.affiliateName}`);
     console.log(`[Insert Affiliate] Short code validated successfully for affiliate: ${affiliateDetails.affiliateName}`);
     this.verboseLog("Calling setInsertAffiliateIdentifier with short code");
@@ -271,17 +278,19 @@ var InsertAffiliate = class {
     return expiryTimestamp;
   }
   /**
-   * Retrieve detailed information about an affiliate by their short code or deep link
-   * This method queries the API and does not store or set the affiliate identifier
+   * Retrieve detailed information about an affiliate by their short code or deep link,
+   * distinguishing "no affiliate matches this code" from "couldn't check" (backend
+   * outage, timeout, rate limit). This method queries the API and does not store or set
+   * the affiliate identifier.
    * @param affiliateCode The short code or deep link to look up
-   * @returns AffiliateDetails if found, null otherwise
+   * @returns an AffiliateLookupResult with a status of 'found', 'not_found', 'lookup_failed', or 'not_configured'
    */
-  static async getAffiliateDetails(affiliateCode, options) {
+  static async getAffiliateLookupResult(affiliateCode, options) {
     this.verboseLog(`Getting affiliate details for: ${affiliateCode}`);
     const companyCode = this.companyCode || await getValue("companyCode");
     if (!companyCode) {
       this.verboseLog("Cannot get affiliate details: no company code available");
-      return null;
+      return { status: "not_configured", details: null };
     }
     const cleanCode = affiliateCode.includes("-") ? affiliateCode.split("-")[0] : affiliateCode;
     this.verboseLog(`Clean code: ${cleanCode}`);
@@ -304,26 +313,42 @@ var InsertAffiliate = class {
       this.verboseLog(`API response status: ${response.status}`);
       if (!response.ok) {
         this.verboseLog(`Failed to get affiliate details, status: ${response.status}`);
-        return null;
+        return { status: "lookup_failed", details: null };
       }
       const data = await response.json();
       this.verboseLog(`API response data: ${JSON.stringify(data)}`);
-      if (data.exists && data.affiliate) {
+      if (data.exists) {
+        if (!data.affiliate) {
+          this.verboseLog("Affiliate exists but response is missing affiliate details");
+          return { status: "lookup_failed", details: null };
+        }
         const details = {
           affiliateName: data.affiliate.affiliateName,
           affiliateShortCode: data.affiliate.affiliateShortCode,
           deeplinkUrl: data.affiliate.deeplinkurl
         };
         this.verboseLog(`Successfully retrieved affiliate details for: ${details.affiliateName}`);
-        return details;
+        return { status: "found", details };
       }
       this.verboseLog("Affiliate does not exist");
-      return null;
+      return { status: "not_found", details: null };
     } catch (error) {
       this.verboseLog(`Error fetching affiliate details: ${error}`);
-      return null;
+      return { status: "lookup_failed", details: null };
     }
   }
+  /**
+   * Retrieve detailed information about an affiliate by their short code or deep link.
+   * Kept for backward compatibility: collapses 'not_found' and 'lookup_failed' into the
+   * same null result, exactly as before. Use getAffiliateLookupResult if you need to tell
+   * an invalid code apart from a backend outage.
+   * @param affiliateCode The short code or deep link to look up
+   * @returns AffiliateDetails if found, null otherwise
+   */
+  static async getAffiliateDetails(affiliateCode, options) {
+    const result = await this.getAffiliateLookupResult(affiliateCode, options);
+    return result.details;
+  }
   static async returnCompanyId() {
     this.verboseLog("Getting company ID...");
     const companyCode = this.companyCode || await getValue("companyCode");
@@ -390,18 +415,13 @@ var InsertAffiliate = class {
         this.verboseLog(`Failed to fetch offer code, status: ${response.status}`);
         return null;
       }
-      const offerCode = (await response.text()).replace(/[^a-zA-Z0-9]/g, "");
-      this.verboseLog(`Received offer code: ${offerCode}`);
-      const errorCodes = [
-        "errorofferCodeNotFound",
-        "errorAffiliateoffercodenotfoundinanycompany",
-        "errorAffiliateoffercodenotfoundinanycompanyAffiliatelinkwas",
-        "Routenotfound"
-      ];
-      if (errorCodes.includes(offerCode)) {
+      const rawOfferCode = await response.text();
+      if (rawOfferCode.includes("errorofferCodeNotFound") || rawOfferCode.includes("errorAffiliateoffercodenotfoundinanycompany") || rawOfferCode.includes("errorAffiliateoffercodenotfoundinanycompanyAffiliatelinkwas") || rawOfferCode.includes("Routenotfound")) {
         this.verboseLog("Offer code not found or invalid");
         return null;
       }
+      const offerCode = rawOfferCode.replace(/[^a-zA-Z0-9_-]/g, "");
+      this.verboseLog(`Received offer code: ${offerCode}`);
       const storageKey = platformType === "stripe" ? "offerCode" : `offerCode_${platformType}`;
       await saveValue(storageKey, offerCode);
       if (platformType === "stripe") {
@@ -431,18 +451,13 @@ var InsertAffiliate = class {
         this.verboseLog(`Failed to fetch offer code, status: ${response.status}`);
         return null;
       }
-      const offerCode = (await response.text()).replace(/[^a-zA-Z0-9]/g, "");
-      this.verboseLog(`Received offer code: ${offerCode}`);
-      const errorCodes = [
-        "errorofferCodeNotFound",
-        "errorAffiliateoffercodenotfoundinanycompany",
-        "errorAffiliateoffercodenotfoundinanycompanyAffiliatelinkwas",
-        "Routenotfound"
-      ];
-      if (errorCodes.includes(offerCode)) {
+      const rawOfferCode = await response.text();
+      if (rawOfferCode.includes("errorofferCodeNotFound") || rawOfferCode.includes("errorAffiliateoffercodenotfoundinanycompany") || rawOfferCode.includes("errorAffiliateoffercodenotfoundinanycompanyAffiliatelinkwas") || rawOfferCode.includes("Routenotfound")) {
         this.verboseLog("Offer code not found or invalid");
         return null;
       }
+      const offerCode = rawOfferCode.replace(/[^a-zA-Z0-9_-]/g, "");
+      this.verboseLog(`Received offer code: ${offerCode}`);
       this.offerCode = offerCode;
       await saveValue("offerCode", offerCode);
       this.verboseLog(`Offer code stored successfully: ${offerCode}`);
@@ -611,18 +626,13 @@ var InsertAffiliate = class {
       this.verboseLog(`API URL: ${url}`);
       const res = await fetch(url);
       this.verboseLog(`API response status: ${res.status}`);
-      const offerCode = (await res.text()).replace(/[^a-zA-Z0-9]/g, "");
-      this.verboseLog(`Received offer code: ${offerCode}`);
-      const errorCodes = [
-        "errorofferCodeNotFound",
-        "errorAffiliateoffercodenotfoundinanycompany",
-        "errorAffiliateoffercodenotfoundinanycompanyAffiliatelinkwas",
-        "Routenotfound"
-      ];
-      if (errorCodes.includes(offerCode)) {
+      const rawOfferCode = await res.text();
+      if (rawOfferCode.includes("errorofferCodeNotFound") || rawOfferCode.includes("errorAffiliateoffercodenotfoundinanycompany") || rawOfferCode.includes("errorAffiliateoffercodenotfoundinanycompanyAffiliatelinkwas") || rawOfferCode.includes("Routenotfound")) {
         this.verboseLog("Offer code not found or invalid");
         return;
       }
+      const offerCode = rawOfferCode.replace(/[^a-zA-Z0-9_-]/g, "");
+      this.verboseLog(`Received offer code: ${offerCode}`);
       const redeemUrl = `https://apps.apple.com/redeem?ctx=offercodes&id=${offerCodeUrlId}&code=${offerCode}`;
       this.verboseLog(`Opening redeem URL: ${redeemUrl}`);
       window.open(redeemUrl, "_blank");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "insert-affiliate-js-sdk",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/sdk/InsertAffiliate.ts

@@ -1,6 +1,6 @@
 // src/sdk/InsertAffiliate.ts
 import { getValue, saveValue } from '../utils/asyncStorage';
-import { generateUUID, generateShortDeviceID } from '../utils/helpers';
+import { generateShortDeviceID, generateUUID } from '../utils/helpers';
 
 interface IapticAndroidReceipt {
   orderId: string;
@@ -25,6 +25,15 @@ export interface AffiliateDetails {
   deeplinkUrl: string;
 }
 
+// 'lookup_failed' (outage, timeout) may be worth retrying. 'not_configured' (no company
+// code set) never will be — it's always a bug in the calling app, not the code or backend.
+export type AffiliateLookupStatus = 'found' | 'not_found' | 'lookup_failed' | 'not_configured';
+
+export interface AffiliateLookupResult {
+  status: AffiliateLookupStatus;
+  details: AffiliateDetails | null;
+}
+
 export type InsertAffiliateIdentifierChangeCallback = (identifier: string | null, offerCode: string | null) => void;
 
 export class InsertAffiliate {
@@ -196,9 +205,11 @@ export class InsertAffiliate {
    * Validates and sets a short code for affiliate tracking
    * Validates the short code against the API before storing
    * @param shortCode The short code to validate and set
+   * @param options.onLookupFailed called when the lookup itself couldn't be completed
+   *   (not just an invalid code) — use it to offer a retry instead of proceeding unattributed.
    * @returns true if the code exists and was successfully validated and stored, false otherwise
    */
-  static async setShortCode(shortCode: string): Promise<boolean> {
+  static async setShortCode(shortCode: string, options?: { onLookupFailed?: () => void }): Promise<boolean> {
     this.verboseLog(`Setting short code. Input: ${shortCode}`);
 
     const valid = /^[a-zA-Z0-9]{3,25}$/.test(shortCode);
@@ -210,12 +221,16 @@ export class InsertAffiliate {
     }
 
     // Validate that the short code exists in the system
-    const affiliateDetails = await this.getAffiliateDetails(shortCode, { trackUsage: true });
-    if (!affiliateDetails) {
-      this.verboseLog(`Short code '${shortCode}' does not exist or validation failed`);
+    const lookup = await this.getAffiliateLookupResult(shortCode, { trackUsage: true });
+    if (lookup.status !== 'found' || !lookup.details) {
+      this.verboseLog(`Short code '${shortCode}' does not exist or validation failed (status: ${lookup.status})`);
       console.error(`[Insert Affiliate] Error: Short code '${shortCode}' does not exist or validation failed.`);
+      if (lookup.status === 'lookup_failed') {
+        options?.onLookupFailed?.();
+      }
       return false;
     }
+    const affiliateDetails = lookup.details;
 
     this.verboseLog(`Short code validated successfully for affiliate: ${affiliateDetails.affiliateName}`);
     console.log(`[Insert Affiliate] Short code validated successfully for affiliate: ${affiliateDetails.affiliateName}`);
@@ -304,18 +319,20 @@ export class InsertAffiliate {
   }
 
   /**
-   * Retrieve detailed information about an affiliate by their short code or deep link
-   * This method queries the API and does not store or set the affiliate identifier
+   * Retrieve detailed information about an affiliate by their short code or deep link,
+   * distinguishing "no affiliate matches this code" from "couldn't check" (backend
+   * outage, timeout, rate limit). This method queries the API and does not store or set
+   * the affiliate identifier.
    * @param affiliateCode The short code or deep link to look up
-   * @returns AffiliateDetails if found, null otherwise
+   * @returns an AffiliateLookupResult with a status of 'found', 'not_found', 'lookup_failed', or 'not_configured'
    */
-  static async getAffiliateDetails(affiliateCode: string, options?: { trackUsage?: boolean }): Promise<AffiliateDetails | null> {
+  static async getAffiliateLookupResult(affiliateCode: string, options?: { trackUsage?: boolean }): Promise<AffiliateLookupResult> {
     this.verboseLog(`Getting affiliate details for: ${affiliateCode}`);
 
     const companyCode = this.companyCode || await getValue('companyCode');
     if (!companyCode) {
       this.verboseLog('Cannot get affiliate details: no company code available');
-      return null;
+      return { status: 'not_configured', details: null };
     }
 
     // Strip UUID from code if present (e.g., "ABC123-uuid" becomes "ABC123")
@@ -346,13 +363,19 @@ export class InsertAffiliate {
 
       if (!response.ok) {
         this.verboseLog(`Failed to get affiliate details, status: ${response.status}`);
-        return null;
+        return { status: 'lookup_failed', details: null };
       }
 
       const data = await response.json();
       this.verboseLog(`API response data: ${JSON.stringify(data)}`);
 
-      if (data.exists && data.affiliate) {
+      if (data.exists) {
+        if (!data.affiliate) {
+          // Malformed response, not a real not-found.
+          this.verboseLog('Affiliate exists but response is missing affiliate details');
+          return { status: 'lookup_failed', details: null };
+        }
+
         const details: AffiliateDetails = {
           affiliateName: data.affiliate.affiliateName,
           affiliateShortCode: data.affiliate.affiliateShortCode,
@@ -360,17 +383,30 @@ export class InsertAffiliate {
         };
 
         this.verboseLog(`Successfully retrieved affiliate details for: ${details.affiliateName}`);
-        return details;
+        return { status: 'found', details };
       }
 
       this.verboseLog('Affiliate does not exist');
-      return null;
+      return { status: 'not_found', details: null };
     } catch (error) {
       this.verboseLog(`Error fetching affiliate details: ${error}`);
-      return null;
+      return { status: 'lookup_failed', details: null };
     }
   }
 
+  /**
+   * Retrieve detailed information about an affiliate by their short code or deep link.
+   * Kept for backward compatibility: collapses 'not_found' and 'lookup_failed' into the
+   * same null result, exactly as before. Use getAffiliateLookupResult if you need to tell
+   * an invalid code apart from a backend outage.
+   * @param affiliateCode The short code or deep link to look up
+   * @returns AffiliateDetails if found, null otherwise
+   */
+  static async getAffiliateDetails(affiliateCode: string, options?: { trackUsage?: boolean }): Promise<AffiliateDetails | null> {
+    const result = await this.getAffiliateLookupResult(affiliateCode, options);
+    return result.details;
+  }
+
   static async returnCompanyId(): Promise<string | null> {
     this.verboseLog('Getting company ID...');
     const companyCode = this.companyCode || await getValue('companyCode');
@@ -453,21 +489,23 @@ export class InsertAffiliate {
         return null;
       }
 
-      const offerCode = (await response.text()).replace(/[^a-zA-Z0-9]/g, '');
-      this.verboseLog(`Received offer code: ${offerCode}`);
-
-      const errorCodes = [
-        'errorofferCodeNotFound',
-        'errorAffiliateoffercodenotfoundinanycompany',
-        'errorAffiliateoffercodenotfoundinanycompanyAffiliatelinkwas',
-        'Routenotfound'
-      ];
+      const rawOfferCode = await response.text();
 
-      if (errorCodes.includes(offerCode)) {
+      // Check for specific error strings from API before cleaning
+      if (
+        rawOfferCode.includes('errorofferCodeNotFound') ||
+        rawOfferCode.includes('errorAffiliateoffercodenotfoundinanycompany') ||
+        rawOfferCode.includes('errorAffiliateoffercodenotfoundinanycompanyAffiliatelinkwas') ||
+        rawOfferCode.includes('Routenotfound')
+      ) {
         this.verboseLog('Offer code not found or invalid');
         return null;
       }
 
+      // Remove special characters, keep only alphanumeric, underscores, and dashes
+      const offerCode = rawOfferCode.replace(/[^a-zA-Z0-9_-]/g, '');
+      this.verboseLog(`Received offer code: ${offerCode}`);
+
       // Store offer code with platform-specific key
       const storageKey = platformType === 'stripe' ? 'offerCode' : `offerCode_${platformType}`;
       await saveValue(storageKey, offerCode);
@@ -507,22 +545,23 @@ export class InsertAffiliate {
         return null;
       }
 
-      const offerCode = (await response.text()).replace(/[^a-zA-Z0-9]/g, '');
-      this.verboseLog(`Received offer code: ${offerCode}`);
+      const rawOfferCode = await response.text();
 
-      // Check for error codes
-      const errorCodes = [
-        'errorofferCodeNotFound',
-        'errorAffiliateoffercodenotfoundinanycompany',
-        'errorAffiliateoffercodenotfoundinanycompanyAffiliatelinkwas',
-        'Routenotfound'
-      ];
-
-      if (errorCodes.includes(offerCode)) {
+      // Check for specific error strings from API before cleaning
+      if (
+        rawOfferCode.includes('errorofferCodeNotFound') ||
+        rawOfferCode.includes('errorAffiliateoffercodenotfoundinanycompany') ||
+        rawOfferCode.includes('errorAffiliateoffercodenotfoundinanycompanyAffiliatelinkwas') ||
+        rawOfferCode.includes('Routenotfound')
+      ) {
         this.verboseLog('Offer code not found or invalid');
         return null;
       }
 
+      // Remove special characters, keep only alphanumeric, underscores, and dashes
+      const offerCode = rawOfferCode.replace(/[^a-zA-Z0-9_-]/g, '');
+      this.verboseLog(`Received offer code: ${offerCode}`);
+
       // Store offer code
       this.offerCode = offerCode;
       await saveValue('offerCode', offerCode);
@@ -739,21 +778,23 @@ export class InsertAffiliate {
       const res = await fetch(url);
       this.verboseLog(`API response status: ${res.status}`);
 
-      const offerCode = (await res.text()).replace(/[^a-zA-Z0-9]/g, '');
-      this.verboseLog(`Received offer code: ${offerCode}`);
+      const rawOfferCode = await res.text();
 
-      const errorCodes = [
-        'errorofferCodeNotFound',
-        'errorAffiliateoffercodenotfoundinanycompany',
-        'errorAffiliateoffercodenotfoundinanycompanyAffiliatelinkwas',
-        'Routenotfound'
-      ];
-
-      if (errorCodes.includes(offerCode)) {
+      // Check for specific error strings from API before cleaning
+      if (
+        rawOfferCode.includes('errorofferCodeNotFound') ||
+        rawOfferCode.includes('errorAffiliateoffercodenotfoundinanycompany') ||
+        rawOfferCode.includes('errorAffiliateoffercodenotfoundinanycompanyAffiliatelinkwas') ||
+        rawOfferCode.includes('Routenotfound')
+      ) {
         this.verboseLog('Offer code not found or invalid');
         return;
       }
 
+      // Remove special characters, keep only alphanumeric, underscores, and dashes
+      const offerCode = rawOfferCode.replace(/[^a-zA-Z0-9_-]/g, '');
+      this.verboseLog(`Received offer code: ${offerCode}`);
+
       const redeemUrl = `https://apps.apple.com/redeem?ctx=offercodes&id=${offerCodeUrlId}&code=${offerCode}`;
       this.verboseLog(`Opening redeem URL: ${redeemUrl}`);
       window.open(redeemUrl, '_blank');

package/.claude/settings.local.json

@@ -1,10 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "WebFetch(domain:github.com)",
-      "WebFetch(domain:www.revenuecat.com)"
-    ],
-    "deny": [],
-    "ask": []
-  }
-}