react-native-edgee 1.0.5 → 1.0.7

package/README.md

@@ -126,7 +126,7 @@ import { EdgeeClient } from 'react-native-edgee';
 // Create client instance
 export const edgee = new EdgeeClient({
   host: "https://your-edgee-host.com",
-  debug: __DEV__, // Enable debug logging in development
+  debug: false, // Set to true if you want to enable debugging
   collectDeviceId: false, // Set to true if you need unique device tracking
 });
 ```
@@ -134,24 +134,32 @@ export const edgee = new EdgeeClient({
 ### Track Events
 
 ```typescript
-// Track events (automatically includes rich native context)
-// Consent is handled transparently - no need to check before each call!
-edgee.track('App Launched', {
-  source: 'cold_start',
-  version: '1.0.0'
+// Track screen views
+edgee.screen({
+  screen_name: 'Home Screen',
+  screen_class: '/',
+  properties: {
+    category: 'main',
+    loaded_time: Date.now()
+  }
 });
 
-// Track user information
-edgee.user({
-  id: '123',
-  email: 'user@example.com',
-  plan: 'premium'
+// Track events 
+edgee.track({
+  name: 'App Launched', // event name
+  properties: {
+    source: 'cold_start',
+    version: '1.0.0'
+  }
 });
 
-// Track screen views
-edgee.screen('Home Screen', {
-  category: 'main',
-  loaded_time: Date.now()
+// Track user information
+edgee.user({
+  user_id: '123',
+  properties: {
+    email: 'user@example.com',
+    plan: 'premium'
+  }
 });
 ```
 
@@ -159,11 +167,10 @@ edgee.screen('Home Screen', {
 
 ```typescript
 // Set consent - all tracking calls automatically respect this setting
-await edgee.setConsent('granted'); // 'granted', 'denied', or 'pending'
+await edgee.consent('granted'); // 'granted', 'denied', or 'pending'
 
 // Check consent status
 console.log('Current consent:', edgee.getConsent());
-console.log('Can track:', edgee.canTrack());
 
 // Listen for consent changes
 const unsubscribe = edgee.onConsentChange((status) => {
@@ -200,98 +207,6 @@ With native modules enabled, each event automatically includes comprehensive con
 - Memory usage, storage info
 - Battery level and state (iOS)
 
-### Network Information
-- Connection type (WiFi, cellular, ethernet)
-- Carrier name and network codes
-- Radio technology (3G, 4G, 5G)
-
-### Privacy Information *(Optional)*
-- Advertising ID (with proper consent on iOS 14+)
-- Device ID (privacy-compliant, opt-in only)
-- Tracking authorization status
-
-## ⚛️ React Integration
-
-### Context Provider (Optional)
-
-```typescript
-import { EdgeeProvider, useEdgee } from 'react-native-edgee';
-
-// Wrap your app
-export default function App() {
-  return (
-    <EdgeeProvider host="https://your-edgee-host.com" debug={__DEV__}>
-      <YourApp />
-    </EdgeeProvider>
-  );
-}
-
-// Use in components
-function SomeComponent() {
-  const edgee = useEdgee();
-
-  const handleButtonPress = () => {
-    // Tracking automatically respects consent - no need to check!
-    edgee.track('Button Pressed', { button_id: 'cta_main' });
-  };
-
-  const handleConsentGrant = async () => {
-    await edgee.setConsent('granted');
-  };
-
-  return (
-    <View>
-      <Button onPress={handleButtonPress} title="Track Me" />
-      <Button onPress={handleConsentGrant} title="Grant Consent" />
-    </View>
-  );
-}
-```
-
-### Auto Screen Tracking
-
-<details>
-<summary><strong>Expo Router</strong></summary>
-
-```typescript
-import { EdgeeAutoTracker } from 'react-native-edgee';
-
-export default function RootLayout() {
-  return (
-    <>
-      <EdgeeAutoTracker edgee={edgee} />
-      <Stack>
-        <Stack.Screen name="index" />
-        <Stack.Screen name="profile" />
-      </Stack>
-    </>
-  );
-}
-```
-
-</details>
-
-<details>
-<summary><strong>React Navigation</strong></summary>
-
-```typescript
-import { navigation } from 'react-native-edgee';
-
-const navigationRef = useRef();
-
-return (
-  <NavigationContainer
-    ref={navigationRef}
-    onStateChange={() => {
-      navigation.trackScreenChange(navigationRef, edgee);
-    }}
-  >
-    {/* Your navigation structure */}
-  </NavigationContainer>
-);
-```
-
-</details>
 
 ## ⚙️ Configuration
 
@@ -300,88 +215,61 @@ interface EdgeeConfig {
   host: string;                    // Your Edgee endpoint URL (required)
   debug?: boolean;                 // Enable debug logging (default: false)
   collectDeviceId?: boolean;       // Collect unique device ID (default: false)
+  cookieName?: string              // Name of the cookie used by Edgee (it must be identical to the one on the console. Do not change it if you are unsure).
 }
 ```
 
-### Privacy Considerations
-
-- **Device ID Collection**: Only enable `collectDeviceId: true` if you need persistent device tracking
-- **iOS Advertising ID**: Automatically respects App Tracking Transparency (iOS 14+)
-- **GDPR/CCPA Compliance**: All sensitive data collection is optional and clearly documented
-
-## 🔧 Advanced Usage
-
-### Manual Native Context Access
-
-```typescript
-import { getNativeContext, isNativeModuleAvailable } from 'react-native-edgee';
-
-// Check if native modules are available
-if (isNativeModuleAvailable()) {
-  const context = await getNativeContext({ collectDeviceId: false });
-  console.log('Device model:', context.model);
-  console.log('Is tablet:', context.isTablet);
-  console.log('Network type:', context.networkType);
-  console.log('Total memory:', context.totalMemoryMB);
-}
-```
-
-### Context Caching
-
-```typescript
-import { clearContextCache } from 'react-native-edgee';
 
-// Clear cached context (useful for testing or when context might change)
-clearContextCache();
-```
+## 🧪 Testing with EdgeeTestApp
 
-## 🔍 Troubleshooting
+The repository includes a test app (`EdgeeTestApp/`) that allows you to quickly test the SDK functionality without integrating it into your own app.
 
-### Common Issues
+### Running the Test App
 
-<details>
-<summary><strong>"Module not found" Error</strong></summary>
+1. **Navigate to the test app directory:**
+   ```bash
+   cd EdgeeTestApp
+   ```
 
-**iOS:**
-```bash
-cd ios && rm -rf build && pod install && cd ..
-npx react-native run-ios
-```
+2. **Install dependencies:**
+   ```bash
+   npm install
+   # or
+   yarn install
+   ```
 
-**Android:**
-- Ensure `EdgeeReactNativePackage` is added to `MainApplication.java`
-- Clean build: `cd android && ./gradlew clean && cd ..`
+3. **For iOS - Install pods:**
+   ```bash
+   cd ios && pod install && cd ..
+   ```
 
-</details>
+4. **Start Metro bundler:**
+   ```bash
+   npm start
+   # or
+   yarn start
+   ```
 
-<details>
-<summary><strong>No Native Context in Events</strong></summary>
+Then type i to launch an iOS app, or a for Android
 
-1. Check if native modules are available:
-   ```typescript
-   console.log('Available:', isNativeModuleAvailable());
-   ```
+### Using the Test App
 
-2. If `false`, verify platform setup above
-3. In Expo Go, this is expected (use Expo Development Build)
+The test app provides a simple UI to test all SDK features:
 
-</details>
+1. **Set Edgee Host**: Enter your Edgee endpoint URL (defaults to `https://demo.edgee.app`)
+   - Click "Init" to initialize the SDK with your host
 
-<details>
-<summary><strong>Build Errors</strong></summary>
+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
 
-**Clean everything:**
-```bash
-# React Native CLI
-cd ios && rm -rf build && cd ..
-cd android && ./gradlew clean && cd ..
-npx react-native start --reset-cache
+3. **Test Consent Management**:
+   - Click "Pending", "Granted", or "Denied" to set consent status
+   - Click "Get Consent" to view the current consent status
 
-# Expo
-npx expo run:ios --clear-cache
-```
+4. **Monitor Status**: The status bar at the bottom shows the result of each action
 
-</details>
 
 ### Debug Mode
 
@@ -423,4 +311,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://www.edgee.cloud/docs)

package/dist/api.d.ts

@@ -6,27 +6,36 @@ declare enum EventType {
     Screen = "screen"
 }
 export type EdgeeTrackEvent = {
-    type: EventType.Track;
     name: string;
-    components: Record<string, boolean> | undefined;
-    data: object;
-    context: EdgeeFullContext;
+    screen_name?: string;
+    screen_class?: string;
+    properties?: object;
 };
 export type EdgeeUserEvent = {
-    type: EventType.User;
-    data: object;
-    components: Record<string, boolean> | undefined;
-    context: EdgeeFullContext;
+    user_id?: string;
+    anonymous_id?: string;
+    properties?: object;
 };
 export type EdgeeScreenEvent = {
-    type: EventType.Screen;
-    name: string;
+    screen_name: string;
+    screen_class?: string;
+    properties?: object;
+};
+export type EdgeeEvent = {
+    type: EventType.Track | EventType.User | EventType.Screen;
     data: object;
     components: Record<string, boolean> | undefined;
     context: EdgeeFullContext;
 };
-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>;
+export declare const createScreenEvent: (data: EdgeeScreenEvent, components: Record<string, boolean> | undefined, context: EdgeeFullContext) => EdgeeEvent;
+export declare const createTrackEvent: (data: EdgeeTrackEvent, components: Record<string, boolean> | undefined, context: EdgeeFullContext) => EdgeeEvent;
+export declare const createUserEvent: (data: EdgeeUserEvent, components: Record<string, boolean> | undefined, context: EdgeeFullContext) => EdgeeEvent;
+/**
+ * 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,111 +1,165 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.uploadEvent = exports.createUserEvent = exports.createTrackEvent = void 0;
+exports.uploadEvent = exports.sendPayload = exports.createUserEvent = exports.createTrackEvent = exports.createScreenEvent = void 0;
+const edgee_store_1 = require("./core/edgee-store");
+const utils_1 = require("./core/utils");
 var EventType;
 (function (EventType) {
     EventType["Track"] = "track";
     EventType["User"] = "user";
     EventType["Screen"] = "screen";
 })(EventType || (EventType = {}));
-const createTrackEvent = (params) => {
+const createScreenEvent = (data, components, context) => {
     return {
         type: EventType.Track,
-        ...params,
+        data: {
+            name: "screen_view",
+            ...data,
+        },
+        components,
+        context: context,
+    };
+};
+exports.createScreenEvent = createScreenEvent;
+const createTrackEvent = (data, components, context) => {
+    return {
+        type: EventType.Track,
+        data,
+        components,
+        context: context,
     };
 };
 exports.createTrackEvent = createTrackEvent;
-const createUserEvent = (params) => {
+const createUserEvent = (data, components, context) => {
     return {
         type: EventType.User,
-        ...params,
+        data,
+        components,
+        context: context,
     };
 };
 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 });
+/**
+ * Builds the event payload structure for API requests
+ */
+const buildEventPayload = (event) => {
+    const basePayload = {
+        data_collection: {
+            context: event.context,
+            events: [],
+        },
+    };
+    basePayload.data_collection.events.push({
+        type: event.type,
+        data: event.data,
+        components: event.components,
+    });
+    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;
+    }
+    else {
+        headers["Edgee-Cookie"] = "";
+    }
+    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);
+            }
         }
-        return await fetch(url, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                ...(config.debug ? { "Edgee-Debug": "true" } : {}),
-            },
-            body: JSON.stringify(event),
-        });
     }
-    else if (eventToSend.type === "user") {
-        const event = {
-            data_collection: {
-                context: eventToSend.context,
-                events: [
-                    {
-                        type: "user",
-                        data: eventToSend.data,
-                        components: eventToSend.components,
-                    },
-                ],
-            },
-        };
+    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) {
-            // eslint-disable-next-line no-console
-            console.log("[Edgee RN] sending", { url, event });
+            (0, utils_1.log)(config, `Set edgeeId: ${edgeeId}`);
         }
-        return await fetch(url, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                ...(config.debug ? { "Edgee-Debug": "true" } : {}),
-            },
-            body: JSON.stringify(event),
-        });
     }
-    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 (data.u) {
+        const userId = String(data.u);
+        await edgee_store_1.edgeeStore.setUserId(userId);
         if (config.debug) {
-            // eslint-disable-next-line no-console
-            console.log("[Edgee RN] sending", { url, event });
+            (0, utils_1.log)(config, `Set userId: ${userId}`);
         }
-        return await fetch(url, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                ...(config.debug ? { "Edgee-Debug": "true" } : {}),
-            },
-            body: JSON.stringify(event),
-        });
     }
-    else {
-        throw new Error("Invalid event type");
+    // 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;
 };
-exports.uploadEvent = uploadEvent;

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>;
-};