@glomopay/react-native-sdk 3.0.1 → 4.0.0

package/src/utils/analytics.ts

@@ -16,7 +16,7 @@ import { getSegmentClient, isSegmentAvailable, getAnonymousId, getSegmentWriteKe
 /**
  * Flow type for checkout
  */
-export type FlowType = "lrs" | "standard" | "unified";
+export type FlowType = "lrs" | "standard" | "unified" | "subscriptions";
 
 /**
  * Common properties that should be included with every event
@@ -40,7 +40,7 @@ export interface CommonEventProperties {
 export interface SdkError {
     type: "validation_error" | "device_forbidden";
     message: string;
-    field?: "publicKey" | "orderId" | "baseCheckoutUrl" | "generatedCheckoutUrl";
+    field?: "publicKey" | "orderId" | "subscriptionId" | "baseCheckoutUrl" | "generatedCheckoutUrl";
 }
 
 /**
@@ -52,7 +52,6 @@ export interface SdkError {
 function getSdkVersion(): string {
     try {
         // Using require to dynamically import package.json
-        // eslint-disable-next-line @typescript-eslint/no-require-imports
         const packageJson = require("../../package.json");
         return packageJson.version || "unknown";
     } catch {
@@ -632,7 +631,11 @@ export function trackStandardStartSuccess(
             jailbreakDetected: jailbreakDetectionInfo.jailbreakDetected,
         }),
     };
-    trackEvent("Standard Checkout Started", properties, devMode).catch(() => {});
+    trackEvent("Standard Checkout Started", properties, devMode).catch((error) => {
+        if (devMode) {
+            console.error("[Glomo-RN-SDK] Event tracking error on standard start:", error);
+        }
+    });
 }
 
 /**
@@ -658,7 +661,11 @@ export function trackStandardStartAttempt(
             jailbreakDetected: jailbreakDetectionInfo.jailbreakDetected,
         }),
     };
-    trackEvent("Standard Checkout Start Attempted", properties, devMode).catch(() => {});
+    trackEvent("Standard Checkout Start Attempted", properties, devMode).catch((error) => {
+        if (devMode) {
+            console.error("[Glomo-RN-SDK] Event tracking error on standard start attempt:", error);
+        }
+    });
 }
 
 /**
@@ -684,7 +691,11 @@ export function trackStandardStartFailure(
             jailbreakDetected: jailbreakDetectionInfo.jailbreakDetected,
         }),
     };
-    trackEvent("Standard Checkout Start Failed", properties, devMode).catch(() => {});
+    trackEvent("Standard Checkout Start Failed", properties, devMode).catch((error) => {
+        if (devMode) {
+            console.error("[Glomo-RN-SDK] Event tracking error on standard start failure:", error);
+        }
+    });
 }
 
 /**
@@ -704,7 +715,11 @@ export function trackStandardWindowOpen(
         source,
         url,
     };
-    trackEvent("Standard Checkout Window Open", properties, devMode).catch(() => {});
+    trackEvent("Standard Checkout Window Open", properties, devMode).catch((error) => {
+        if (devMode) {
+            console.error("[Glomo-RN-SDK] Event tracking error on standard window open:", error);
+        }
+    });
 }
 
 /**
@@ -722,7 +737,11 @@ export function trackStandardWindowClose(
         ...buildCommonProperties(orderId, publicKey, devMode, mockMode, standardUrl, "standard"),
         source,
     };
-    trackEvent("Standard Checkout Window Close", properties, devMode).catch(() => {});
+    trackEvent("Standard Checkout Window Close", properties, devMode).catch((error) => {
+        if (devMode) {
+            console.error("[Glomo-RN-SDK] Event tracking error on standard window close:", error);
+        }
+    });
 }
 
 /**
@@ -762,7 +781,11 @@ export function trackStandardInvalidMessageReceived(
         dataType: data === null ? "null" : typeof data,
         ...(url && { url }),
     };
-    trackEvent("Standard Checkout Invalid Message Received", properties, devMode).catch(() => {});
+    trackEvent("Standard Checkout Invalid Message Received", properties, devMode).catch((error) => {
+        if (devMode) {
+            console.error("[Glomo-RN-SDK] Event tracking error on standard invalid message:", error);
+        }
+    });
 }
 
 /**
@@ -780,7 +803,11 @@ export function trackStandardPaymentSuccess(
         ...buildCommonProperties(orderId, publicKey, devMode, mockMode, standardUrl, "standard"),
         paymentId,
     };
-    trackEvent("Standard Payment Success", properties, devMode).catch(() => {});
+    trackEvent("Standard Payment Success", properties, devMode).catch((error) => {
+        if (devMode) {
+            console.error("[Glomo-RN-SDK] Event tracking error on standard payment success:", error);
+        }
+    });
 }
 
 /**
@@ -798,7 +825,11 @@ export function trackStandardPaymentFailure(
         ...buildCommonProperties(orderId, publicKey, devMode, mockMode, standardUrl, "standard"),
         paymentId,
     };
-    trackEvent("Standard Payment Failure", properties, devMode).catch(() => {});
+    trackEvent("Standard Payment Failure", properties, devMode).catch((error) => {
+        if (devMode) {
+            console.error("[Glomo-RN-SDK] Event tracking error on standard payment failure:", error);
+        }
+    });
 }
 
 /**
@@ -816,7 +847,11 @@ export function trackStandardPaymentTerminate(
         ...buildCommonProperties(orderId, publicKey, devMode, mockMode, standardUrl, "standard"),
         terminationSource: source,
     };
-    trackEvent("Standard Payment Terminated", properties, devMode).catch(() => {});
+    trackEvent("Standard Payment Terminated", properties, devMode).catch((error) => {
+        if (devMode) {
+            console.error("[Glomo-RN-SDK] Event tracking error on standard payment terminate:", error);
+        }
+    });
 }
 
 /**
@@ -834,7 +869,11 @@ export function trackStandardConnectionError(
         ...buildCommonProperties(orderId, publicKey, devMode, mockMode, standardUrl, "standard"),
         ...(errorCode !== undefined && { errorCode }),
     };
-    trackEvent("Standard Connection Error", properties, devMode).catch(() => {});
+    trackEvent("Standard Connection Error", properties, devMode).catch((error) => {
+        if (devMode) {
+            console.error("[Glomo-RN-SDK] Event tracking error on standard connection error:", error);
+        }
+    });
 }
 
 /**
@@ -853,7 +892,11 @@ export function trackStandardSdkError(
         errors,
         errorCount: errors.length,
     };
-    trackEvent("Standard SDK Error", properties, devMode).catch(() => {});
+    trackEvent("Standard SDK Error", properties, devMode).catch((error) => {
+        if (devMode) {
+            console.error("[Glomo-RN-SDK] Event tracking error on standard SDK error:", error);
+        }
+    });
 }
 
 export function trackStandardBankTransferSubmitted(
@@ -866,7 +909,11 @@ export function trackStandardBankTransferSubmitted(
     const properties = {
         ...buildCommonProperties(orderId, publicKey, devMode, mockMode, standardUrl, "standard"),
     };
-    trackEvent("Standard Bank Transfer Submitted", properties, devMode).catch(() => {});
+    trackEvent("Standard Bank Transfer Submitted", properties, devMode).catch((error) => {
+        if (devMode) {
+            console.error("[Glomo-RN-SDK] Event tracking error on standard bank transfer submitted:", error);
+        }
+    });
 }
 
 export function trackStandardPayViaBankCompleted(
@@ -881,22 +928,11 @@ export function trackStandardPayViaBankCompleted(
         ...buildCommonProperties(orderId, publicKey, devMode, mockMode, standardUrl, "standard"),
         payViaBankStatus: status,
     };
-    trackEvent("Standard Pay Via Bank Completed", properties, devMode).catch(() => {});
-}
-
-export function trackStandardPayViaBankBankConnectionSuccessful(
-    orderId: string,
-    publicKey: string,
-    bankIdentifier: string,
-    devMode: boolean = false,
-    mockMode: boolean = false,
-    standardUrl?: string
-): void {
-    const properties = {
-        ...buildCommonProperties(orderId, publicKey, devMode, mockMode, standardUrl, "standard"),
-        bankIdentifier,
-    };
-    trackEvent("Standard Pay Via Bank Bank Connection Successful", properties, devMode).catch(() => {});
+    trackEvent("Standard Pay Via Bank Completed", properties, devMode).catch((error) => {
+        if (devMode) {
+            console.error("[Glomo-RN-SDK] Event tracking error on standard pay via bank completed:", error);
+        }
+    });
 }
 
 // ---------------------------------------------------------------------------
@@ -991,3 +1027,405 @@ export function checkAnalyticsStatus(devMode: boolean = false): boolean {
 
     return available;
 }
+
+// ---------------------------------------------------------------------------
+// Subscription Checkout Trackers
+// ---------------------------------------------------------------------------
+
+/**
+ * Tracks when the subscription checkout start() method is called (attempted)
+ */
+export function trackSubscriptionStartAttempt(
+    status: string,
+    orderId: string,
+    publicKey: string,
+    devMode: boolean = false,
+    mockMode: boolean = false,
+    checkoutUrl?: string,
+    jailbreakDetectionInfo?: {
+        jailbreakDetectionLibraryInstalled: boolean;
+        jailbreakDetected: boolean | null;
+    }
+): void {
+    const properties = {
+        ...buildCommonProperties(orderId, publicKey, devMode, mockMode, checkoutUrl, "subscriptions"),
+        subscriptionId: orderId,
+        status,
+        ...(jailbreakDetectionInfo && {
+            jailbreakDetectionLibraryInstalled: jailbreakDetectionInfo.jailbreakDetectionLibraryInstalled,
+            jailbreakDetected: jailbreakDetectionInfo.jailbreakDetected,
+        }),
+    };
+    trackEvent("Subscription Checkout Start Attempted", properties, devMode).catch((error) => {
+        if (devMode) {
+            console.error("[Glomo-RN-SDK] Event tracking error on subscription start attempt:", error);
+        }
+    });
+}
+
+/**
+ * Tracks when the subscription checkout start() method has been called successfully
+ */
+export function trackSubscriptionStartSuccess(
+    orderId: string,
+    publicKey: string,
+    devMode: boolean = false,
+    mockMode: boolean = false,
+    checkoutUrl?: string,
+    jailbreakDetectionInfo?: {
+        jailbreakDetectionLibraryInstalled: boolean;
+        jailbreakDetected: boolean | null;
+    }
+): void {
+    const properties = {
+        ...buildCommonProperties(orderId, publicKey, devMode, mockMode, checkoutUrl, "subscriptions"),
+        subscriptionId: orderId,
+        ...(jailbreakDetectionInfo && {
+            jailbreakDetectionLibraryInstalled: jailbreakDetectionInfo.jailbreakDetectionLibraryInstalled,
+            jailbreakDetected: jailbreakDetectionInfo.jailbreakDetected,
+        }),
+    };
+    trackEvent("Subscription Checkout Started", properties, devMode).catch((error) => {
+        if (devMode) {
+            console.error("[Glomo-RN-SDK] Event tracking error on subscription start:", error);
+        }
+    });
+}
+
+/**
+ * Tracks when the subscription checkout start() method fails
+ */
+export function trackSubscriptionStartFailure(
+    reason: "device_forbidden" | "validation_error" | "payment_successful" | "invalid_status" | "invalid_url",
+    orderId?: string,
+    publicKey?: string,
+    devMode: boolean = false,
+    mockMode: boolean = false,
+    checkoutUrl?: string,
+    jailbreakDetectionInfo?: {
+        jailbreakDetectionLibraryInstalled: boolean;
+        jailbreakDetected: boolean | null;
+    }
+): void {
+    const properties = {
+        ...buildCommonProperties(orderId, publicKey, devMode, mockMode, checkoutUrl, "subscriptions"),
+        subscriptionId: orderId,
+        failureReason: reason,
+        ...(jailbreakDetectionInfo && {
+            jailbreakDetectionLibraryInstalled: jailbreakDetectionInfo.jailbreakDetectionLibraryInstalled,
+            jailbreakDetected: jailbreakDetectionInfo.jailbreakDetected,
+        }),
+    };
+    trackEvent("Subscription Checkout Start Failed", properties, devMode).catch((error) => {
+        if (devMode) {
+            console.error("[Glomo-RN-SDK] Event tracking error on subscription start failure:", error);
+        }
+    });
+}
+
+/**
+ * Tracks when window.open is intercepted from the subscription checkout WebView
+ */
+export function trackSubscriptionWindowOpen(
+    source: "main" | "flow",
+    url: string,
+    orderId: string,
+    publicKey: string,
+    devMode: boolean = false,
+    mockMode: boolean = false,
+    checkoutUrl?: string
+): void {
+    const properties = {
+        ...buildCommonProperties(orderId, publicKey, devMode, mockMode, checkoutUrl, "subscriptions"),
+        subscriptionId: orderId,
+        source,
+        url,
+    };
+    trackEvent("Subscription Checkout Window Open", properties, devMode).catch((error) => {
+        if (devMode) {
+            console.error("[Glomo-RN-SDK] Event tracking error on subscription window open:", error);
+        }
+    });
+}
+
+/**
+ * Tracks when window.close is intercepted from the subscription checkout WebView
+ */
+export function trackSubscriptionWindowClose(
+    source: "main" | "flow",
+    orderId: string,
+    publicKey: string,
+    devMode: boolean = false,
+    mockMode: boolean = false,
+    checkoutUrl?: string
+): void {
+    const properties = {
+        ...buildCommonProperties(orderId, publicKey, devMode, mockMode, checkoutUrl, "subscriptions"),
+        subscriptionId: orderId,
+        source,
+    };
+    trackEvent("Subscription Checkout Window Close", properties, devMode).catch((error) => {
+        if (devMode) {
+            console.error("[Glomo-RN-SDK] Event tracking error on subscription window close:", error);
+        }
+    });
+}
+
+/**
+ * Tracks when invalid message data is received from a subscription checkout WebView
+ */
+export function trackSubscriptionInvalidMessageReceived(
+    webviewType: "main" | "flow",
+    data: unknown,
+    url: string | undefined,
+    orderId: string,
+    publicKey: string,
+    devMode: boolean = false,
+    mockMode: boolean = false,
+    checkoutUrl?: string
+): void {
+    let dataString: string;
+    try {
+        if (data === null) {
+            dataString = "null";
+        } else if (data === undefined) {
+            dataString = "undefined";
+        } else if (typeof data === "string") {
+            dataString = data;
+        } else if (typeof data === "object") {
+            dataString = JSON.stringify(data);
+        } else {
+            dataString = String(data);
+        }
+    } catch {
+        dataString = "[unable to stringify]";
+    }
+
+    const properties = {
+        ...buildCommonProperties(orderId, publicKey, devMode, mockMode, checkoutUrl, "subscriptions"),
+        subscriptionId: orderId,
+        webviewType,
+        data: dataString,
+        dataType: data === null ? "null" : typeof data,
+        ...(url && { url }),
+    };
+    trackEvent("Subscription Checkout Invalid Message Received", properties, devMode).catch((error) => {
+        if (devMode) {
+            console.error("[Glomo-RN-SDK] Event tracking error on subscription invalid message:", error);
+        }
+    });
+}
+
+/**
+ * Tracks when subscription checkout onPaymentSuccess callback is invoked
+ */
+export function trackSubscriptionPaymentSuccess(
+    orderId: string,
+    paymentId: string,
+    publicKey: string,
+    devMode: boolean = false,
+    mockMode: boolean = false,
+    checkoutUrl?: string
+): void {
+    const properties = {
+        ...buildCommonProperties(orderId, publicKey, devMode, mockMode, checkoutUrl, "subscriptions"),
+        subscriptionId: orderId,
+        paymentId,
+    };
+    trackEvent("Subscription Payment Success", properties, devMode).catch((error) => {
+        if (devMode) {
+            console.error("[Glomo-RN-SDK] Event tracking error on subscription payment success:", error);
+        }
+    });
+}
+
+/**
+ * Tracks when subscription checkout onPaymentFailure callback is invoked
+ */
+export function trackSubscriptionPaymentFailure(
+    orderId: string,
+    paymentId: string,
+    publicKey: string,
+    devMode: boolean = false,
+    mockMode: boolean = false,
+    checkoutUrl?: string
+): void {
+    const properties = {
+        ...buildCommonProperties(orderId, publicKey, devMode, mockMode, checkoutUrl, "subscriptions"),
+        subscriptionId: orderId,
+        paymentId,
+    };
+    trackEvent("Subscription Payment Failure", properties, devMode).catch((error) => {
+        if (devMode) {
+            console.error("[Glomo-RN-SDK] Event tracking error on subscription payment failure:", error);
+        }
+    });
+}
+
+/**
+ * Tracks when subscription checkout onPaymentTerminate callback is invoked
+ */
+export function trackSubscriptionPaymentTerminate(
+    orderId: string,
+    source: "user_dismiss" | "back_button" | "checkout_closed",
+    publicKey: string,
+    devMode: boolean = false,
+    mockMode: boolean = false,
+    checkoutUrl?: string
+): void {
+    const properties = {
+        ...buildCommonProperties(orderId, publicKey, devMode, mockMode, checkoutUrl, "subscriptions"),
+        subscriptionId: orderId,
+        terminationSource: source,
+    };
+    trackEvent("Subscription Payment Terminated", properties, devMode).catch((error) => {
+        if (devMode) {
+            console.error("[Glomo-RN-SDK] Event tracking error on subscription payment terminate:", error);
+        }
+    });
+}
+
+/**
+ * Tracks when subscription checkout onConnectionError callback is invoked
+ */
+export function trackSubscriptionConnectionError(
+    orderId: string,
+    errorCode: number | undefined,
+    publicKey: string,
+    devMode: boolean = false,
+    mockMode: boolean = false,
+    checkoutUrl?: string
+): void {
+    const properties = {
+        ...buildCommonProperties(orderId, publicKey, devMode, mockMode, checkoutUrl, "subscriptions"),
+        subscriptionId: orderId,
+        ...(errorCode !== undefined && { errorCode }),
+    };
+    trackEvent("Subscription Connection Error", properties, devMode).catch((error) => {
+        if (devMode) {
+            console.error("[Glomo-RN-SDK] Event tracking error on subscription connection error:", error);
+        }
+    });
+}
+
+/**
+ * Tracks when subscription checkout onSdkError callback is invoked
+ */
+export function trackSubscriptionSdkError(
+    errors: Array<SdkError>,
+    orderId?: string,
+    publicKey?: string,
+    devMode: boolean = false,
+    mockMode: boolean = false,
+    checkoutUrl?: string
+): void {
+    const properties = {
+        ...buildCommonProperties(orderId, publicKey, devMode, mockMode, checkoutUrl, "subscriptions"),
+        subscriptionId: orderId,
+        errors,
+        errorCount: errors.length,
+    };
+    trackEvent("Subscription SDK Error", properties, devMode).catch((error) => {
+        if (devMode) {
+            console.error("[Glomo-RN-SDK] Event tracking error on subscription SDK error:", error);
+        }
+    });
+}
+
+// ---------------------------------------------------------------------------
+// Unsupported Functionality Telemetry
+// ---------------------------------------------------------------------------
+
+/**
+ * Internal telemetry - fires when a merchant uses functionality that is
+ * unsupported in the current context or deprecated.
+ * Fires at most once per detection site (callers use a ref guard).
+ */
+export function trackUseOfUnsupportedFunctionality(
+    name: string,
+    orderId: string | undefined,
+    publicKey: string,
+    devMode: boolean,
+    mockMode: boolean,
+    checkoutUrl: string
+): void {
+    const properties = {
+        ...buildCommonProperties(orderId, publicKey, devMode, mockMode, checkoutUrl),
+        name,
+    };
+    trackEvent("Use of Unsupported Functionality", properties, devMode).catch((error) => {
+        if (devMode) {
+            console.error("[Glomo-RN-SDK] Event tracking error on unsupported functionality:", error);
+        }
+    });
+}
+
+// ---------------------------------------------------------------------------
+// Checkout Analytics Tracker Map
+// ---------------------------------------------------------------------------
+
+/**
+ * Internal tracker map interface.
+ * Each flow (standard, subscription) provides its own implementation.
+ * useStandardCheckout calls through this map at every analytics call site.
+ * Not exported to merchants via index.ts.
+ */
+export interface CheckoutAnalyticsTrackers {
+    trackStartAttempt: typeof trackStandardStartAttempt;
+    trackStartSuccess: typeof trackStandardStartSuccess;
+    trackStartFailure: typeof trackStandardStartFailure;
+    trackWindowOpen: typeof trackStandardWindowOpen;
+    trackWindowClose: typeof trackStandardWindowClose;
+    trackInvalidMessageReceived: typeof trackStandardInvalidMessageReceived;
+    trackPaymentSuccess: typeof trackStandardPaymentSuccess;
+    trackPaymentFailure: typeof trackStandardPaymentFailure;
+    trackPaymentTerminate: typeof trackStandardPaymentTerminate;
+    trackConnectionError: typeof trackStandardConnectionError;
+    trackSdkError: typeof trackStandardSdkError;
+    trackBankTransferSubmitted: typeof trackStandardBankTransferSubmitted;
+    trackPayViaBankCompleted: typeof trackStandardPayViaBankCompleted;
+}
+
+/** Standard checkout tracker map - delegates to trackStandard* functions */
+export const standardCheckoutTrackers: CheckoutAnalyticsTrackers = {
+    trackStartAttempt: trackStandardStartAttempt,
+    trackStartSuccess: trackStandardStartSuccess,
+    trackStartFailure: trackStandardStartFailure,
+    trackWindowOpen: trackStandardWindowOpen,
+    trackWindowClose: trackStandardWindowClose,
+    trackInvalidMessageReceived: trackStandardInvalidMessageReceived,
+    trackPaymentSuccess: trackStandardPaymentSuccess,
+    trackPaymentFailure: trackStandardPaymentFailure,
+    trackPaymentTerminate: trackStandardPaymentTerminate,
+    trackConnectionError: trackStandardConnectionError,
+    trackSdkError: trackStandardSdkError,
+    trackBankTransferSubmitted: trackStandardBankTransferSubmitted,
+    trackPayViaBankCompleted: trackStandardPayViaBankCompleted,
+};
+
+/** Subscription checkout tracker map - delegates to trackSubscription* functions, no-ops for bank transfer */
+export const subscriptionCheckoutTrackers: CheckoutAnalyticsTrackers = {
+    trackStartAttempt: trackSubscriptionStartAttempt,
+    trackStartSuccess: trackSubscriptionStartSuccess,
+    trackStartFailure: trackSubscriptionStartFailure,
+    trackWindowOpen: trackSubscriptionWindowOpen,
+    trackWindowClose: trackSubscriptionWindowClose,
+    trackInvalidMessageReceived: trackSubscriptionInvalidMessageReceived,
+    trackPaymentSuccess: trackSubscriptionPaymentSuccess,
+    trackPaymentFailure: trackSubscriptionPaymentFailure,
+    trackPaymentTerminate: trackSubscriptionPaymentTerminate,
+    trackConnectionError: trackSubscriptionConnectionError,
+    trackSdkError: trackSubscriptionSdkError,
+    trackBankTransferSubmitted: (...args) => {
+        const devMode = args[2];
+        if (devMode) {
+            console.warn("[Glomo-RN-SDK] Unexpected bank transfer event in subscription flow");
+        }
+    },
+    trackPayViaBankCompleted: (...args) => {
+        const devMode = args[3];
+        if (devMode) {
+            console.warn("[Glomo-RN-SDK] Unexpected pay via bank completed event in subscription flow");
+        }
+    },
+};

package/src/utils/device-compliance.ts

@@ -13,7 +13,6 @@
  */
 function getJailMonkey(): { isJailBroken: () => boolean } | null {
     try {
-        // eslint-disable-next-line @typescript-eslint/no-require-imports
         const JailMonkey = require("jail-monkey");
         if (JailMonkey && typeof JailMonkey.isJailBroken === "function") {
             return JailMonkey;