kewa-react-native 1.0.0

package/src/utils/NetworkManager.ts

@@ -0,0 +1,85 @@
+import NetInfo from '@react-native-community/netinfo';
+import { ContactData, KewaEvent, KewaResponse } from '../types';
+import { StorageManager } from './StorageManager';
+
+export class NetworkManager {
+  private appUrl: string = '';
+  private apiKey: string = '';
+  private projectId: string = '';
+  private isOnline: boolean = true;
+  private unsubscribe: (() => void) | null = null;
+
+  constructor(appUrl: string, apiKey: string, projectId: string) {
+    this.appUrl = appUrl.replace(/\/$/, '');
+    this.apiKey = apiKey;
+    this.projectId = projectId;
+    this.setupNetworkMonitoring();
+  }
+
+  private getTrackUrl(): string {
+    return `${this.appUrl}/t/${this.projectId}/mtc/event/track`;
+  }
+
+  private getContactUrl(): string {
+    return `${this.appUrl}/t/${this.projectId}/mtc`;
+  }
+
+  private setupNetworkMonitoring(): void {
+    this.unsubscribe = NetInfo.addEventListener(state => {
+      this.isOnline = state.isConnected ?? true;
+    });
+  }
+
+  async sendEvent(event: KewaEvent): Promise<KewaResponse> {
+    const eventPayload = {
+      event: event.eventName,
+      timestamp: event.timestamp,
+      data: event.eventData,
+      contact: event.contactData,
+      kewa_device_id: event.deviceId,
+      device: event.deviceInfo,
+    };
+
+    return this.post(this.getTrackUrl(), eventPayload);
+  }
+
+  async updateContact(contact: ContactData): Promise<KewaResponse> {
+    const ktcId = await StorageManager.getKtcId();
+    const deviceId = await StorageManager.getDeviceId();
+    return this.post(this.getContactUrl(), { contact, mtc_id: ktcId, kewa_device_id: deviceId });
+  }
+
+  private async post(url: string, body: Record<string, unknown>): Promise<KewaResponse> {
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'secret': `${this.apiKey}`,
+        'User-Agent': 'Kewa-SDK/1.0.0',
+      },
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Kewa Analytics SDK: HTTP error! status: ${response.status}`);
+    }
+
+    const responseData: KewaResponse = await response.json();
+
+    if (!responseData.success) {
+      throw new Error('Kewa Analytics SDK: Responded with an error ' + responseData.message);
+    }
+
+    return responseData;
+  }
+
+  getNetworkStatus(): boolean {
+    return this.isOnline;
+  }
+
+  cleanup(): void {
+    if (this.unsubscribe) {
+      this.unsubscribe();
+    }
+  }
+}

package/src/utils/StorageManager.ts

@@ -0,0 +1,121 @@
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import { ContactData, KewaEvent } from '../types';
+import { KEWA_CONSTANTS } from '../utils/constants';
+
+export class StorageManager {
+  static async getKtcId(): Promise<string | null> {
+    try {
+      return await AsyncStorage.getItem(KEWA_CONSTANTS.STORAGE_KEYS.KTC_ID);
+    } catch (error) {
+      console.error('Failed to get ktc_id:', error);
+      return null;
+    }
+  }
+
+  static async setKtcId(ktcId: string): Promise<void> {
+    try {
+      await AsyncStorage.setItem(KEWA_CONSTANTS.STORAGE_KEYS.KTC_ID, ktcId);
+    } catch (error) {
+      console.error('Failed to set ktc_id:', error);
+    }
+  }
+
+  static async removeKtcId(): Promise<void> {
+    try {
+      await AsyncStorage.removeItem(KEWA_CONSTANTS.STORAGE_KEYS.KTC_ID);
+    } catch (error) {
+      console.error('Failed to remove ktc_id:', error);
+    }
+  }
+
+  static async getDeviceId(): Promise<string | null> {
+    try {
+      return await AsyncStorage.getItem(KEWA_CONSTANTS.STORAGE_KEYS.DEVICE_ID);
+    } catch (error) {
+      console.error('Failed to get device_id:', error);
+      return null;
+    }
+  }
+
+  static async setDeviceId(deviceId: string): Promise<void> {
+    try {
+      await AsyncStorage.setItem(KEWA_CONSTANTS.STORAGE_KEYS.DEVICE_ID, deviceId);
+    } catch (error) {
+      console.error('Failed to set device_id:', error);
+    }
+  }
+
+  static async removeDeviceId(): Promise<void> {
+    try {
+      await AsyncStorage.removeItem(KEWA_CONSTANTS.STORAGE_KEYS.DEVICE_ID);
+    } catch (error) {
+      console.error('Failed to remove device_id:', error);
+    }
+  }
+
+  static async getUserProperties(): Promise<ContactData> {
+    try {
+      const props = await AsyncStorage.getItem(KEWA_CONSTANTS.STORAGE_KEYS.USER_PROPERTIES);
+      return props ? JSON.parse(props) : {};
+    } catch (error) {
+      console.error('Kewa Analytics SDK: Failed to get user properties:', error);
+      return {};
+    }
+  }
+
+  static async setUserProperties(properties: ContactData): Promise<void> {
+    try {
+      await AsyncStorage.setItem(
+        KEWA_CONSTANTS.STORAGE_KEYS.USER_PROPERTIES,
+        JSON.stringify(properties)
+      );
+    } catch (error) {
+      console.error('Kewa Analytics SDK: Failed to set user properties:', error);
+    }
+  }
+
+  static async removeUserProperties(): Promise<void> {
+    try {
+      await AsyncStorage.removeItem(KEWA_CONSTANTS.STORAGE_KEYS.USER_PROPERTIES);
+    } catch (error) {
+      console.error('Kewa Analytics SDK: Failed to remove user properties:', error);
+    }
+  }
+
+  static async getQueuedEvents(): Promise<KewaEvent[]> {
+    try {
+      const events = await AsyncStorage.getItem(KEWA_CONSTANTS.STORAGE_KEYS.QUEUED_EVENTS);
+      return events ? JSON.parse(events) : [];
+    } catch (error) {
+      console.error('Kewa Analytics SDK: Failed to get queued events:', error);
+      return [];
+    }
+  }
+
+  static async setQueuedEvents(events: KewaEvent[]): Promise<void> {
+    try {
+      // Limit queue size
+      const limitedEvents = events.slice(-KEWA_CONSTANTS.DEFAULTS.MAX_QUEUE_SIZE);
+      await AsyncStorage.setItem(
+        KEWA_CONSTANTS.STORAGE_KEYS.QUEUED_EVENTS,
+        JSON.stringify(limitedEvents)
+      );
+    } catch (error) {
+      console.error('Kewa Analytics SDK: Failed to set queued events:', error);
+    }
+  }
+
+  static async addQueuedEvent(event: KewaEvent): Promise<void> {
+    const events = await this.getQueuedEvents();
+    events.push(event);
+    await this.setQueuedEvents(events);
+  }
+
+  static async clearQueuedEvents(): Promise<void> {
+    try {
+      await AsyncStorage.removeItem(KEWA_CONSTANTS.STORAGE_KEYS.QUEUED_EVENTS);
+    } catch (error) {
+      console.error('Kewa Analytics SDK: Failed to clear queued events:', error);
+    }
+  }
+}

package/src/utils/constants.ts

@@ -0,0 +1,26 @@
+export const KEWA_CONSTANTS = {
+  STORAGE_KEYS: {
+    KTC_ID: 'kewa_ktc_id',
+    DEVICE_ID: 'kewa_device_id',
+    QUEUED_EVENTS: 'kewa_queued_events',
+    USER_PROPERTIES: 'kewa_user_properties',
+  },
+  EVENTS: {
+    APP_LAUNCH: 'app_launch',
+    APP_FOREGROUND: 'app_foreground',
+    APP_BACKGROUND: 'app_background',
+    USER_LOGIN: 'user_login',
+    USER_LOGOUT: 'user_logout',
+    USER_REGISTRATION: 'user_registration',
+    SCREEN_VIEW: 'screen_view',
+    ERROR: 'error',
+    BUTTON_PRESS: 'button_press',
+    FORM_SUBMIT: 'form_submit',
+  },
+  DEFAULTS: {
+    BATCH_SIZE: 10,
+    MAX_QUEUE_SIZE: 100,
+    RETRY_ATTEMPTS: 3,
+    RETRY_DELAY_MS: 1000,
+  },
+} as const;

package/src/utils/debug.ts

@@ -0,0 +1,15 @@
+let debugEnabled = false;
+
+export function setDebugLogging(enabled: boolean): void {
+  debugEnabled = enabled;
+}
+
+export function isDebugLoggingEnabled(): boolean {
+  return debugEnabled;
+}
+
+export function kewaDebug(...args: unknown[]): void {
+  if (debugEnabled) {
+    console.log('[Kewa]', ...args);
+  }
+}