react-native-edgee 1.0.5 → 1.0.6

package/README.md

@@ -254,7 +254,7 @@ function SomeComponent() {
 <summary><strong>Expo Router</strong></summary>
 
 ```typescript
-import { EdgeeAutoTracker } from 'react-native-edgee';
+import { EdgeeAutoTracker } from 'react-native-edgee/expo-router';
 
 export default function RootLayout() {
   return (
@@ -335,6 +335,89 @@ import { clearContextCache } from 'react-native-edgee';
 clearContextCache();
 ```
 
+## 🧪 Testing with EdgeeTestApp
+
+The repository includes a test app (`EdgeeTestApp/`) that allows you to quickly test the SDK functionality without integrating it into your own app.
+
+### Running the Test App
+
+1. **Navigate to the test app directory:**
+   ```bash
+   cd EdgeeTestApp
+   ```
+
+2. **Install dependencies:**
+   ```bash
+   npm install
+   # or
+   yarn install
+   ```
+
+3. **For iOS - Install pods:**
+   ```bash
+   cd ios && pod install && cd ..
+   ```
+
+4. **Start Metro bundler:**
+   ```bash
+   npm start
+   # or
+   yarn start
+   ```
+
+5. **Run the app:**
+   ```bash
+   # iOS
+   npm run ios
+   # or
+   yarn ios
+
+   # Android
+   npm run android
+   # or
+   yarn android
+   ```
+
+### Using the Test App
+
+The test app provides a simple UI to test all SDK features:
+
+1. **Set Edgee Host**: Enter your Edgee endpoint URL (defaults to `https://demo.edgee.app`)
+   - Click "Init" to initialize the SDK with your host
+
+2. **Test Events**:
+   - **Track Event**: Enter an event name and click "Track Event" to send a track event
+   - **Screen Event**: Click "Screen Event" to track a screen view
+   - **User Event**: Click "User Event" to send user identification data
+
+3. **Test Consent Management**:
+   - Click "Pending", "Granted", or "Denied" to set consent status
+   - Click "Get Consent" to view the current consent status
+
+4. **Monitor Status**: The status bar at the bottom shows the result of each action
+
+### Features Demonstrated
+
+- ✅ SDK initialization with custom host
+- ✅ Event tracking (track, screen, user)
+- ✅ Consent management (pending, granted, denied)
+- ✅ Native module availability detection
+- ✅ Debug logging (enabled by default in test app)
+
+### Debug Mode
+
+The test app has debug mode enabled by default, so you'll see detailed logs in Metro CLI:
+- Event tracking logs
+- Consent status changes
+- Native context collection
+- API request/response details
+
+### Notes
+
+- The test app uses the local `react-native-edgee` package via `file:..` in `package.json`
+- Make sure you've built the SDK (`npm run build` in the root directory) before running the test app
+- Native modules are automatically available if you've set up the platform correctly
+
 ## 🔍 Troubleshooting
 
 ### Common Issues
@@ -423,4 +506,4 @@ MIT
 ## 🆘 Support
 
 - **Issues**: [GitHub Issues](https://github.com/edgee-cloud/react-native-edgee/issues)
-- **Documentation**: [Edgee Docs](https://docs.edgee.cloud)
+- **Documentation**: [Edgee Docs](https://docs.edgee.cloud)

package/dist/api.d.ts

@@ -28,5 +28,12 @@ export type EdgeeScreenEvent = {
 export type EdgeeEvent = EdgeeTrackEvent | EdgeeUserEvent | EdgeeScreenEvent;
 export declare const createTrackEvent: (params: Omit<EdgeeTrackEvent, "type">) => EdgeeTrackEvent;
 export declare const createUserEvent: (params: Omit<EdgeeUserEvent, "type">) => EdgeeUserEvent;
-export declare const uploadEvent: (url: string, config: EdgeeConfig, event: EdgeeEvent) => Promise<Response>;
+/**
+ * Sends a payload to the Edgee API with proper headers and handles the response
+ */
+export declare const sendPayload: (config: EdgeeConfig, payload: any) => Promise<void>;
+/**
+ * Sends an event to the Edgee API
+ */
+export declare const uploadEvent: (config: EdgeeConfig, event: EdgeeEvent) => Promise<void>;
 export {};

package/dist/api.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.uploadEvent = exports.createUserEvent = exports.createTrackEvent = void 0;
+exports.uploadEvent = exports.sendPayload = exports.createUserEvent = exports.createTrackEvent = void 0;
+const edgee_store_1 = require("./core/edgee-store");
+const utils_1 = require("./core/utils");
 var EventType;
 (function (EventType) {
     EventType["Track"] = "track";
@@ -21,91 +23,157 @@ const createUserEvent = (params) => {
     };
 };
 exports.createUserEvent = createUserEvent;
-const uploadEvent = async (url, config, event) => {
-    const eventToSend = event;
-    if (eventToSend.type === "track") {
-        const event = {
-            data_collection: {
-                context: eventToSend.context,
-                events: [
-                    {
-                        type: "track",
-                        data: {
-                            name: eventToSend.name,
-                            properties: eventToSend.data,
-                        },
-                        components: eventToSend.components,
-                    },
-                ],
-            },
-        };
-        if (config.debug) {
-            // eslint-disable-next-line no-console
-            console.log("[Edgee RN] sending", { url, event });
-        }
-        return await fetch(url, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                ...(config.debug ? { "Edgee-Debug": "true" } : {}),
+/**
+ * Builds the event payload structure for API requests
+ */
+const buildEventPayload = (event) => {
+    const basePayload = {
+        data_collection: {
+            context: event.context,
+            events: [],
+        },
+    };
+    if (event.type === EventType.Track) {
+        basePayload.data_collection.events.push({
+            type: "track",
+            data: {
+                name: event.name,
+                properties: event.data,
             },
-            body: JSON.stringify(event),
+            components: event.components,
         });
     }
-    else if (eventToSend.type === "user") {
-        const event = {
-            data_collection: {
-                context: eventToSend.context,
-                events: [
-                    {
-                        type: "user",
-                        data: eventToSend.data,
-                        components: eventToSend.components,
-                    },
-                ],
-            },
-        };
-        if (config.debug) {
-            // eslint-disable-next-line no-console
-            console.log("[Edgee RN] sending", { url, event });
-        }
-        return await fetch(url, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                ...(config.debug ? { "Edgee-Debug": "true" } : {}),
-            },
-            body: JSON.stringify(event),
+    else if (event.type === EventType.User) {
+        basePayload.data_collection.events.push({
+            type: "user",
+            data: event.data,
+            components: event.components,
         });
     }
-    else if (eventToSend.type === "screen") {
-        const event = {
-            data_collection: {
-                context: eventToSend.context,
-                events: [
-                    {
-                        type: "track",
-                        data: { ...eventToSend.data, screen_name: eventToSend.name },
-                        components: eventToSend.components,
-                    },
-                ],
-            },
-        };
-        if (config.debug) {
-            // eslint-disable-next-line no-console
-            console.log("[Edgee RN] sending", { url, event });
-        }
-        return await fetch(url, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                ...(config.debug ? { "Edgee-Debug": "true" } : {}),
-            },
-            body: JSON.stringify(event),
+    else if (event.type === EventType.Screen) {
+        basePayload.data_collection.events.push({
+            type: "track",
+            data: { ...event.data, screen_name: event.name },
+            components: event.components,
         });
     }
     else {
-        throw new Error("Invalid event type");
+        throw new Error(`Invalid event type: ${event.type}`);
+    }
+    return basePayload;
+};
+/**
+ * Builds the Edgee-Cookie header string from edgeeId and userId
+ * Similar to the JS SDK cookie reconstruction logic
+ */
+const buildCookieHeader = async (config) => {
+    const cookies = [];
+    const { edgeeId, userId } = await edgee_store_1.edgeeStore.getContext();
+    if (edgeeId) {
+        cookies.push(`${config.cookieName}=${edgeeId}`);
+    }
+    if (userId) {
+        cookies.push(`${config.cookieName}_u=${userId}`);
+    }
+    return cookies.length > 0 ? cookies.join("; ") : undefined;
+};
+/**
+ * Builds headers for API requests including Edgee-Cookie header
+ */
+const buildHeaders = async (config) => {
+    const headers = {
+        "Content-Type": "application/json",
+    };
+    if (config.debug) {
+        headers["Edgee-Debug"] = "1";
     }
+    // Build and add Edgee-Cookie header from store
+    const cookieHeader = await buildCookieHeader(config);
+    if (cookieHeader) {
+        headers["Edgee-Cookie"] = cookieHeader;
+    }
+    return headers;
+};
+/**
+ * Sends a payload to the Edgee API with proper headers and handles the response
+ */
+const sendPayload = async (config, payload) => {
+    const headers = await buildHeaders(config);
+    const url = `${config.host}/_edgee/event`;
+    const response = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(payload),
+    });
+    try {
+        const text = await response.text().catch(() => "");
+        if (text) {
+            try {
+                const data = JSON.parse(text);
+                await handleResponse(data, config);
+            }
+            catch (parseError) {
+                (0, utils_1.logError)("[Debug] Parsing response from Fetch to JSON failed.", parseError);
+            }
+        }
+    }
+    catch (error) {
+        (0, utils_1.logError)("[Debug] Failed to handle response.", error);
+    }
+    return;
+};
+exports.sendPayload = sendPayload;
+/**
+ * Sends an event to the Edgee API
+ */
+const uploadEvent = async (config, event) => {
+    const payload = buildEventPayload(event);
+    await (0, exports.sendPayload)(config, payload);
+    return;
 };
 exports.uploadEvent = uploadEvent;
+/**
+ * Handles response data: stores IDs, handles cookies, and logs events
+ * Similar to the JS SDK handleResponse function
+ */
+const handleResponse = async (data, config) => {
+    let events = data;
+    // Store edgeeId and userId from response
+    // Convert to string if needed (API might return numbers)
+    if (data.e) {
+        const edgeeId = String(data.e);
+        await edgee_store_1.edgeeStore.setEdgeeId(edgeeId);
+        if (config.debug) {
+            (0, utils_1.log)(config, `Set edgeeId: ${edgeeId}`);
+        }
+    }
+    if (data.u) {
+        const userId = String(data.u);
+        await edgee_store_1.edgeeStore.setUserId(userId);
+        if (config.debug) {
+            (0, utils_1.log)(config, `Set userId: ${userId}`);
+        }
+    }
+    // Handle cookies array (data.c)
+    // Note: In React Native, we don't have browser cookies, but we log them if debug is enabled
+    if (data.c && Array.isArray(data.c) && data.c.length > 0) {
+        for (const cookie of data.c) {
+            if (cookie.name && cookie.value) {
+                (0, utils_1.log)(config, "○ Set cookie: " + cookie.name + "=" + cookie.value);
+            }
+            // In React Native, cookies are typically handled by the app's cookie store
+            // If needed, you could store them in AsyncStorage or another storage mechanism
+        }
+    }
+    // Extract events if present
+    if (data.events) {
+        events = data.events;
+    }
+    // Log events if debug is enabled (matching JS SDK format)
+    if (events && Array.isArray(events) && events.length > 0) {
+        for (let i = 0; i < events.length; i++) {
+            (0, utils_1.log)(config, "○ " + events[i].type + " event (client):", events[i]);
+        }
+    }
+    return events;
+};

package/dist/consent.d.ts

@@ -1,4 +1,4 @@
-import type { ConsentStatus } from "./index";
+export type ConsentStatus = "granted" | "denied" | "pending";
 /**
  * Simple consent manager that works with existing EdgeeClient
  * Stores consent status and provides utilities for consent management
@@ -35,10 +35,6 @@ export declare class EdgeeConsent {
      * Check if consent is pending
      */
     isPending(): boolean;
-    /**
-     * Check if we should allow tracking
-     */
-    canTrack(): boolean;
     /**
      * Listen for consent changes
      */
@@ -54,43 +50,3 @@ export declare class EdgeeConsent {
  * This allows you to manage consent across your app without passing it around
  */
 export declare const edgeeConsent: EdgeeConsent;
-/**
- * Consent utilities
- */
-export declare const ConsentUtils: {
-    /**
-     * Initialize consent (call this once in your app)
-     */
-    init(): Promise<void>;
-    /**
-     * Set consent status
-     */
-    setConsent(status: ConsentStatus): Promise<void>;
-    /**
-     * Get current consent
-     */
-    getConsent(): ConsentStatus | null;
-    /**
-     * Check if can track
-     */
-    canTrack(): boolean;
-    /**
-     * Check consent status
-     */
-    hasConsent(): boolean;
-    isGranted(): boolean;
-    isDenied(): boolean;
-    isPending(): boolean;
-    /**
-     * Listen for changes
-     */
-    onChange(callback: (status: ConsentStatus | null) => void): () => void;
-    /**
-     * Reset consent
-     */
-    reset(): Promise<void>;
-    /**
-     * Send consent event to Edgee using the new consent method
-     */
-    sendConsentEvent(edgeeClient: any, status: ConsentStatus): Promise<void>;
-};

package/dist/consent.js

@@ -3,8 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConsentUtils = exports.edgeeConsent = exports.EdgeeConsent = void 0;
+exports.edgeeConsent = exports.EdgeeConsent = void 0;
 const async_storage_1 = __importDefault(require("@react-native-async-storage/async-storage"));
+const utils_1 = require("./core/utils");
 const CONSENT_STORAGE_KEY = "_edgee_consent";
 /**
  * Simple consent manager that works with existing EdgeeClient
@@ -32,7 +33,7 @@ class EdgeeConsent {
             this.initialized = true;
         }
         catch (error) {
-            console.warn("[Edgee Consent] Failed to load:", error);
+            (0, utils_1.logError)("Failed to load consent", error);
             this.initialized = true;
         }
     }
@@ -52,12 +53,12 @@ class EdgeeConsent {
                     callback(status);
                 }
                 catch (error) {
-                    console.warn("[Edgee Consent] Callback error:", error);
+                    (0, utils_1.logError)("Callback error", error);
                 }
             });
         }
         catch (error) {
-            console.warn("[Edgee Consent] Failed to store:", error);
+            (0, utils_1.logError)("Failed to store consent", error);
         }
     }
     /**
@@ -90,12 +91,6 @@ class EdgeeConsent {
     isPending() {
         return this.consentStatus === "pending";
     }
-    /**
-     * Check if we should allow tracking
-     */
-    canTrack() {
-        return this.initialized && this.consentStatus === "granted";
-    }
     /**
      * Listen for consent changes
      */
@@ -122,12 +117,12 @@ class EdgeeConsent {
                     callback(null);
                 }
                 catch (error) {
-                    console.warn("[Edgee Consent] Callback error:", error);
+                    (0, utils_1.logError)("Callback error", error);
                 }
             });
         }
         catch (error) {
-            console.warn("[Edgee Consent] Failed to clear:", error);
+            (0, utils_1.logError)("Failed to clear consent", error);
         }
     }
     isValidStatus(status) {
@@ -141,80 +136,3 @@ exports.EdgeeConsent = EdgeeConsent;
  * This allows you to manage consent across your app without passing it around
  */
 exports.edgeeConsent = new EdgeeConsent();
-/**
- * Consent utilities
- */
-exports.ConsentUtils = {
-    /**
-     * Initialize consent (call this once in your app)
-     */
-    async init() {
-        return exports.edgeeConsent.init();
-    },
-    /**
-     * Set consent status
-     */
-    async setConsent(status) {
-        return exports.edgeeConsent.setConsent(status);
-    },
-    /**
-     * Get current consent
-     */
-    getConsent() {
-        return exports.edgeeConsent.getConsent();
-    },
-    /**
-     * Check if can track
-     */
-    canTrack() {
-        return exports.edgeeConsent.canTrack();
-    },
-    /**
-     * Check consent status
-     */
-    hasConsent() {
-        return exports.edgeeConsent.hasConsent();
-    },
-    isGranted() {
-        return exports.edgeeConsent.isGranted();
-    },
-    isDenied() {
-        return exports.edgeeConsent.isDenied();
-    },
-    isPending() {
-        return exports.edgeeConsent.isPending();
-    },
-    /**
-     * Listen for changes
-     */
-    onChange(callback) {
-        return exports.edgeeConsent.onChange(callback);
-    },
-    /**
-     * Reset consent
-     */
-    async reset() {
-        return exports.edgeeConsent.reset();
-    },
-    /**
-     * Send consent event to Edgee using the new consent method
-     */
-    async sendConsentEvent(edgeeClient, status) {
-        try {
-            // Use the new consent method if available
-            if (edgeeClient.consent) {
-                await edgeeClient.consent(status);
-            }
-            else {
-                // Fallback: use track event with special consent flag
-                await edgeeClient.track("_consent_update", {
-                    consent_status: status,
-                    timestamp: Date.now(),
-                });
-            }
-        }
-        catch (error) {
-            console.warn("[Edgee Consent] Failed to send consent event:", error);
-        }
-    },
-};

package/dist/core/context.d.ts

@@ -1,3 +1,4 @@
+import { EdgeeConfig } from "..";
 export interface EdgeeClientContext {
     screen_width: number;
     screen_height: number;
@@ -38,4 +39,4 @@ export interface EdgeeFullContext {
 /**
  * Get comprehensive context including native device information
  */
-export declare const getContext: (collectDeviceId?: boolean) => Promise<EdgeeFullContext>;
+export declare const getContext: (config: EdgeeConfig) => Promise<EdgeeFullContext>;

package/dist/core/context.js

@@ -3,21 +3,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getContext = void 0;
 const react_native_1 = require("react-native");
 const native_context_1 = require("../native-context");
+const utils_1 = require("./utils");
 /**
  * Get comprehensive context including native device information
  */
-const getContext = async (collectDeviceId = false) => {
+const getContext = async (config) => {
     const initialUrl = await react_native_1.Linking.getInitialURL();
     const nativeContext = await (0, native_context_1.getNativeContext)();
     const url = initialUrl || `${(nativeContext === null || nativeContext === void 0 ? void 0 : nativeContext.bundleId) || "app"}://`;
     let clientContext;
     if ((0, native_context_1.isNativeModuleAvailable)()) {
         try {
-            const nativeContext = await (0, native_context_1.getNativeContext)({ collectDeviceId });
+            const nativeContext = await (0, native_context_1.getNativeContext)({ collectDeviceId: config.collectDeviceId });
             clientContext = buildClientContextFromNative(nativeContext);
         }
         catch (error) {
-            console.warn("Failed to get native context, falling back to basic context:", error);
+            (0, utils_1.logError)("Failed to get native context", error);
             clientContext = getFallbackClientContext();
         }
     }

package/dist/core/edgee-store.d.ts

@@ -1,10 +1,9 @@
-import AsyncStorage from "@react-native-async-storage/async-storage";
 import { EdgeeEvent } from "../api";
 export declare class EdgeeStore {
     edgeeId: string | null;
     userId: string | null;
-    store: typeof AsyncStorage;
     pendingEvents: EdgeeEvent[];
+    initialized: boolean;
     constructor();
     init(): Promise<void>;
     getEdgeeId(): Promise<string | null>;
@@ -19,3 +18,8 @@ export declare class EdgeeStore {
     getPendingEvents(): Promise<EdgeeEvent[]>;
     clearEvents(): Promise<void>;
 }
+/**
+ * Global edgee store instance
+ * This allows you to manage the edgee store across your app without passing it around
+ */
+export declare const edgeeStore: EdgeeStore;