kewa-react-native 1.0.0

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "kewa-react-native",
+  "version": "1.0.0",
+  "description": "Kewa Mobile SDK for tracking events in mobile app",
+  "keywords": [
+    "react-native",
+    "analytics",
+    "tracking",
+    "user-behavior",
+    "mobile-analytics"
+  ],
+  "homepage": "https://github.com/TopChunks/kewa-react-native.git#readme",
+  "bugs": {
+    "url": "https://github.com/TopChunks/kewa-react-native/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/TopChunks/kewa-react-native.git"
+  },
+  "license": "MIT",
+  "author": "Topchunks Solutions Pvt Ltd",
+  "type": "commonjs",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "directories": {
+    "lib": "lib"
+  },
+  "files": [
+    "lib",
+    "src",
+    "package.json",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "build:watch": "tsc -w",
+    "test": "jest",
+    "lint": "eslint src --ext .ts,.tsx",
+    "prepare": "npm run build"
+  },
+  "dependencies": {
+    "@react-native-async-storage/async-storage": "^1.19.0",
+    "@react-native-community/netinfo": "^9.4.0",
+    "react-native-device-info": "^14.0.4"
+  },
+  "devDependencies": {
+    "@types/react": "^18.2.0",
+    "@types/react-native": "^0.72.0",
+    "@typescript-eslint/eslint-plugin": "^5.0.0",
+    "@typescript-eslint/parser": "^5.0.0",
+    "eslint": "^8.0.0",
+    "jest": "^29.0.0",
+    "typescript": "^5.0.0"
+  },
+  "peerDependencies": {
+    "react": ">=16.8.0",
+    "react-native": ">=0.60.0"
+  }
+}

package/src/KewaProvider.tsx

@@ -0,0 +1,87 @@
+import React, { createContext, useContext, useEffect, ReactNode } from 'react';
+
+import { KewaAnalytics } from './core/KewaAnalytics';
+import { KewaConfig, ContactData, BaseEventData, UserLoginEvent, UserRegistrationEvent, ScreenViewEvent } from './types';
+
+export interface KewaContextValue {
+  trackEvent: (eventName: string, eventData?: BaseEventData, contactData?: ContactData) => Promise<void>;
+  setUserProperties: (properties: ContactData) => Promise<void>;
+  trackLogin: (userData: Partial<UserLoginEvent>) => Promise<void>;
+  trackLogout: () => Promise<void>;
+  trackRegistration: (userData: Partial<UserRegistrationEvent>) => Promise<void>;
+  trackScreenView: (screenName: string, additionalData?: Partial<ScreenViewEvent>) => Promise<void>;
+  trackError: (error: Error, context?: Record<string, any>, isFatal?: boolean) => Promise<void>;
+  reset: () => Promise<void>;
+  getKtcId: () => Promise<string | null>;
+  getDeviceId: () => Promise<string | null>;
+  getUserProperties: () => Promise<ContactData>;
+  isSDKInitialized: () => boolean;
+}
+
+const KewaContext = createContext<KewaContextValue | null>(null);
+
+interface KewaProviderProps {
+  config: KewaConfig;
+  children: ReactNode;
+  kewa?: KewaAnalytics;
+}
+
+const defaultKewaInstance = new KewaAnalytics();
+
+function createContextValue(kewa: KewaAnalytics): KewaContextValue {
+  return {
+    trackEvent: kewa.trackEvent.bind(kewa),
+    setUserProperties: kewa.setUserProperties.bind(kewa),
+    trackLogin: kewa.trackLogin.bind(kewa),
+    trackLogout: kewa.trackLogout.bind(kewa),
+    trackRegistration: kewa.trackRegistration.bind(kewa),
+    trackScreenView: kewa.trackScreenView.bind(kewa),
+    trackError: kewa.trackError.bind(kewa),
+    reset: kewa.reset.bind(kewa),
+    getKtcId: kewa.getKtcId.bind(kewa),
+    getDeviceId: kewa.getDeviceId.bind(kewa),
+    getUserProperties: kewa.getUserProperties.bind(kewa),
+    isSDKInitialized: kewa.isSDKInitialized.bind(kewa),
+  };
+}
+
+export function KewaProvider({ config, children, kewa }: KewaProviderProps) {
+  const instance = kewa ?? defaultKewaInstance;
+  const value = createContextValue(instance);
+
+  useEffect(() => {
+    instance.init(config);
+
+    return () => {
+      instance.cleanup();
+    };
+  }, [
+    instance,
+    config.appUrl,
+    config.apiKey,
+    config.projectId,
+    config.disableTracking,
+    config.disableEventTracking,
+    config.disableAppStateTracking,
+    config.disableScreenViewTracking,
+    config.enableDebugLogging,
+  ]);
+
+  return (
+    <KewaContext.Provider value={value}>
+      {children}
+    </KewaContext.Provider>
+  );
+}
+
+export function useKewa(): KewaContextValue {
+  const context = useContext(KewaContext);
+  if (!context) {
+    throw new Error('useKewa must be used within a KewaProvider');
+  }
+  return context;
+}
+
+export function getDefaultKewaInstance(): KewaAnalytics {
+  return defaultKewaInstance;
+}

package/src/core/EventManager.ts

@@ -0,0 +1,160 @@
+import { KewaEvent, KewaConfig, BaseEventData, DeviceInfo, ContactData } from '../types';
+import { StorageManager } from '../utils/StorageManager';
+import { NetworkManager } from '../utils/NetworkManager';
+import { KEWA_CONSTANTS } from '../utils/constants';
+import { kewaDebug } from '../utils/debug';
+
+export class EventManager {
+  private networkManager: NetworkManager;
+  private config: KewaConfig;
+  private isProcessingQueue: boolean = false;
+
+  constructor(networkManager: NetworkManager, config: KewaConfig) {
+    this.networkManager = networkManager;
+    this.config = config;
+  }
+
+  async processEvent(
+    eventName: string,
+    eventData: BaseEventData,
+    contactData: ContactData,
+    deviceId: string | null,
+    deviceInfo: DeviceInfo
+  ): Promise<void> {
+    const event: KewaEvent = {
+      eventName,
+      eventData: {
+        ...eventData,
+      },
+      contactData : contactData,
+      deviceId,
+      deviceInfo,
+      timestamp: eventData.timestamp || new Date().toISOString(),
+      metadata: {
+        eventId: this.generateEventId(),
+        attemptCount: 1,
+        queuedAt: new Date().toISOString(),
+      },
+    };
+
+    if (this.networkManager.getNetworkStatus()) {
+      try {
+        await this.sendEvent(event);
+      } catch (error) {
+        console.error('Failed to send event, queuing for retry:', error);
+        await StorageManager.addQueuedEvent(event);
+      }
+    } else {
+      await StorageManager.addQueuedEvent(event);
+    }
+  }
+
+  private async sendEvent(event: KewaEvent): Promise<void> {
+    try {
+
+      kewaDebug('Kewa Analytics SDK: Sending event:', event.eventName, {
+        eventData: event.eventData,
+        contactData: event.contactData,
+        deviceId: event.deviceId,
+      });
+
+      const response = await this.networkManager.sendEvent(event);
+
+      const ktcId = await StorageManager.getKtcId();
+      const deviceId = await StorageManager.getDeviceId();
+
+      kewaDebug('Kewa Analytics SDK: Event response:', event.eventName, response);
+
+      // Logout clears identity after send — do not persist ids from its response
+      if (event.eventName !== KEWA_CONSTANTS.EVENTS.USER_LOGOUT) {
+        if (response.id && response.id !== ktcId) {
+          await StorageManager.setKtcId(response.id);
+
+          kewaDebug('Kewa Analytics SDK: Updated ktc_id:', response.id);
+        }
+
+        if (response.device_id && response.device_id !== deviceId) {
+          await StorageManager.setDeviceId(response.device_id);
+          kewaDebug('Kewa Analytics SDK: Updated device_id:', response.device_id);
+        }
+      }
+
+    } catch (error) {
+      console.warn('Kewa Analytics SDK: Error sending event to kewa, queuing for retry:', error);
+      throw error;
+    }
+  }
+
+  async processAppStateEvent(
+    eventName: string,
+    eventData: BaseEventData,
+    contactData: ContactData,
+    deviceId: string | null,
+    deviceInfo: DeviceInfo,
+  ): Promise<void> {
+    const event: KewaEvent = {
+      eventName,
+      eventData: { ...eventData },
+      contactData,
+      deviceId,
+      deviceInfo,
+      timestamp: eventData.timestamp || new Date().toISOString(),
+      metadata: {
+        eventId: this.generateEventId(),
+        attemptCount: 1,
+        queuedAt: new Date().toISOString(),
+      },
+    };
+
+    if (this.networkManager.getNetworkStatus()) {
+      try {
+        await this.sendEvent(event);
+        return;
+      } catch (error) {
+        console.warn(`Failed to send ${eventName}, queuing for retry:`, error);
+      }
+    }
+
+    await StorageManager.addQueuedEvent(event);
+  }
+
+  async processQueuedEvents(): Promise<void> {
+    if (this.isProcessingQueue || !this.networkManager.getNetworkStatus()) {
+      return;
+    }
+
+    this.isProcessingQueue = true;
+
+    try {
+      const queuedEvents = await StorageManager.getQueuedEvents();
+      if (queuedEvents.length === 0) {
+        return;
+      }
+
+      kewaDebug(`Kewa Analytics SDK: Processing ${queuedEvents.length} queued events`);
+
+      //TODO: Consider batch processing if supported by backend
+
+      // Process events one by one
+      for (const event of queuedEvents) {
+        try {
+          await this.networkManager.sendEvent(event);
+        } catch (error) {
+          console.error('Kewa Analytics SDK: Failed to send event:', error);
+          // Keep the failed event in the queue for next retry
+          await StorageManager.addQueuedEvent(event);
+        }
+      }
+
+      // Clear all events after successful processing
+      await StorageManager.clearQueuedEvents();
+
+    } finally {
+      this.isProcessingQueue = false;
+    }
+  }
+
+  private generateEventId(): string {
+    return `event_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+}