riuve-rn 1.0.0

package/dist/core/ApiClient.js

@@ -0,0 +1,184 @@
+"use strict";
+/**
+ * API Client - Handles HTTP requests with retry logic
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiClient = void 0;
+const constants_1 = require("../constants");
+const logger_1 = require("../utils/logger");
+const retry_1 = require("../utils/retry");
+const fetchWithTimeout_1 = require("../utils/fetchWithTimeout");
+class ApiClient {
+    constructor(baseUrl, apiKey, maxRetries, retryDelay, timeout = 10000) {
+        this.baseUrl = baseUrl.replace(/\/$/, ''); // Remove trailing slash
+        this.apiKey = apiKey;
+        this.maxRetries = maxRetries;
+        this.retryDelay = retryDelay;
+        this.timeout = timeout;
+    }
+    /**
+     * Updates the API client configuration
+     */
+    updateConfig(baseUrl, apiKey, maxRetries, retryDelay, timeout = 10000) {
+        this.baseUrl = baseUrl.replace(/\/$/, '');
+        this.apiKey = apiKey;
+        this.maxRetries = maxRetries;
+        this.retryDelay = retryDelay;
+        this.timeout = timeout;
+    }
+    /**
+     * Initialize endpoint
+     */
+    async initialize(request) {
+        return this.post(constants_1.API_ENDPOINTS.INITIALIZE, {
+            ...request,
+            api_key: this.apiKey,
+        });
+    }
+    /**
+     * Identify endpoint
+     */
+    async identify(request) {
+        return this.post(constants_1.API_ENDPOINTS.IDENTIFY, {
+            ...request,
+            api_key: this.apiKey,
+        });
+    }
+    /**
+     * Track endpoint
+     */
+    async track(request) {
+        return this.post(constants_1.API_ENDPOINTS.TRACK, {
+            ...request,
+            api_key: this.apiKey,
+        });
+    }
+    /**
+     * Set FCM token endpoint
+     */
+    async setFcmToken(request) {
+        return this.post(constants_1.API_ENDPOINTS.FCM_TOKEN, {
+            ...request,
+            api_key: this.apiKey,
+        });
+    }
+    /**
+     * Generic POST request with retry logic
+     */
+    async post(endpoint, data) {
+        const url = `${this.baseUrl}${endpoint}`;
+        return (0, retry_1.retryWithBackoff)(async () => this.makeRequest(url, data), this.maxRetries, this.retryDelay, (error) => {
+            const errorType = this.classifyError(error);
+            return (0, retry_1.shouldRetry)(errorType);
+        });
+    }
+    /**
+     * Makes the actual HTTP request
+     */
+    async makeRequest(url, data) {
+        const startTime = Date.now();
+        const endpoint = url.replace(this.baseUrl, '');
+        // Extract event count if this is a track request
+        const eventCount = data.events ? data.events.length : undefined;
+        try {
+            logger_1.logger.info(`Making HTTP request: POST ${endpoint}`);
+            if (eventCount !== undefined) {
+                logger_1.logger.info(`  Event count: ${eventCount}`);
+            }
+            logger_1.logger.info(`  URL: ${url}`);
+            const response = await (0, fetchWithTimeout_1.fetchWithTimeout)(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(data),
+            }, this.timeout);
+            const responseTime = Date.now() - startTime;
+            // Handle non-OK responses
+            if (!response.ok) {
+                const errorData = await this.parseErrorResponse(response);
+                const error = new Error(errorData.message || `HTTP ${response.status}`);
+                error.status = response.status;
+                error.errorData = errorData;
+                logger_1.logger.error(`HTTP request failed: POST ${endpoint}`);
+                logger_1.logger.error(`  Status: ${response.status} ${response.statusText}`);
+                logger_1.logger.error(`  Response time: ${responseTime}ms`);
+                logger_1.logger.error(`  Error: ${errorData.message || errorData.error || 'Unknown error'}`);
+                if (errorData.details) {
+                    logger_1.logger.error(`  Details: ${JSON.stringify(errorData.details, null, 2)}`);
+                }
+                if (eventCount !== undefined) {
+                    logger_1.logger.error(`  Events not processed: ${eventCount} events`);
+                }
+                throw error;
+            }
+            // Parse successful response
+            const responseData = await response.json();
+            logger_1.logger.info(`HTTP request successful: POST ${endpoint}`);
+            logger_1.logger.info(`  Status: ${response.status} ${response.statusText}`);
+            logger_1.logger.info(`  Response time: ${responseTime}ms`);
+            if (eventCount !== undefined && responseData.processed !== undefined) {
+                logger_1.logger.info(`  Events processed: ${responseData.processed}/${eventCount}`);
+            }
+            return responseData;
+        }
+        catch (error) {
+            const responseTime = Date.now() - startTime;
+            // Only log if it's not already logged above (non-HTTP errors)
+            if (!error.status) {
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                logger_1.logger.error(`HTTP request failed: POST ${endpoint} (${responseTime}ms)`);
+                logger_1.logger.error(`  Error: ${errorMsg}`);
+                if (eventCount !== undefined) {
+                    logger_1.logger.error(`  Events not sent: ${eventCount} events`);
+                }
+            }
+            throw error;
+        }
+    }
+    /**
+     * Parses error response from API
+     */
+    async parseErrorResponse(response) {
+        try {
+            const errorData = await response.json();
+            return {
+                error: errorData.error || 'Unknown error',
+                message: errorData.message,
+                code: errorData.code,
+                status: response.status,
+            };
+        }
+        catch {
+            return {
+                error: constants_1.ERROR_MESSAGES.NETWORK_ERROR,
+                status: response.status,
+            };
+        }
+    }
+    /**
+     * Classifies an error into an ErrorType
+     */
+    classifyError(error) {
+        const { ErrorType } = require('../types');
+        // Network errors (no connection)
+        if (error.message?.includes('Network request failed') || error.message?.includes('fetch')) {
+            return ErrorType.NETWORK_ERROR;
+        }
+        // Timeout errors
+        if (error.message?.includes('timeout')) {
+            return ErrorType.TIMEOUT_ERROR;
+        }
+        // HTTP status-based classification
+        if (error.status) {
+            if (error.status >= 500) {
+                return ErrorType.SERVER_ERROR;
+            }
+            else if (error.status >= 400) {
+                return ErrorType.CLIENT_ERROR;
+            }
+        }
+        return ErrorType.UNKNOWN_ERROR;
+    }
+}
+exports.ApiClient = ApiClient;

package/dist/core/DeviceInfo.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Device Information Collector
+ *
+ * Uses the adapter pattern to automatically select the best device info implementation
+ * based on available modules (Native > Expo > Fallback)
+ */
+import type { DeviceInfo as DeviceInfoType } from '../types';
+declare class DeviceInfoCollector {
+    private adapter;
+    private cachedInfo;
+    /**
+     * Collects device information
+     * Uses cached value if available, otherwise collects fresh data
+     */
+    collect(): Promise<DeviceInfoType>;
+    /**
+     * Gets the cached device info without re-collecting
+     */
+    get(): DeviceInfoType | null;
+    /**
+     * Clears the cached device info
+     */
+    clearCache(): void;
+}
+export declare const deviceInfoCollector: DeviceInfoCollector;
+export {};
+//# sourceMappingURL=DeviceInfo.d.ts.map

package/dist/core/DeviceInfo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DeviceInfo.d.ts","sourceRoot":"","sources":["../../src/core/DeviceInfo.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,UAAU,IAAI,cAAc,EAAE,MAAM,UAAU,CAAC;AAI7D,cAAM,mBAAmB;IACvB,OAAO,CAAC,OAAO,CAA0B;IACzC,OAAO,CAAC,UAAU,CAA+B;IAEjD;;;OAGG;IACG,OAAO,IAAI,OAAO,CAAC,cAAc,CAAC;IA0CxC;;OAEG;IACH,GAAG,IAAI,cAAc,GAAG,IAAI;IAI5B;;OAEG;IACH,UAAU,IAAI,IAAI;CAGnB;AAED,eAAO,MAAM,mBAAmB,qBAA4B,CAAC"}

package/dist/core/DeviceInfo.js

@@ -0,0 +1,69 @@
+"use strict";
+/**
+ * Device Information Collector
+ *
+ * Uses the adapter pattern to automatically select the best device info implementation
+ * based on available modules (Native > Expo > Fallback)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deviceInfoCollector = void 0;
+const deviceInfo_1 = require("../adapters/deviceInfo");
+const logger_1 = require("../utils/logger");
+const Storage_1 = require("./Storage");
+class DeviceInfoCollector {
+    constructor() {
+        this.adapter = (0, deviceInfo_1.getDeviceInfoAdapter)();
+        this.cachedInfo = null;
+    }
+    /**
+     * Collects device information
+     * Uses cached value if available, otherwise collects fresh data
+     */
+    async collect() {
+        // Return cached info if available
+        if (this.cachedInfo) {
+            return this.cachedInfo;
+        }
+        // Try to load from storage
+        const storedInfo = await Storage_1.storage.get('DEVICE_INFO');
+        if (storedInfo) {
+            this.cachedInfo = storedInfo;
+            return storedInfo;
+        }
+        // Collect fresh device info using adapter
+        logger_1.logger.debug('Collecting device information...');
+        try {
+            const deviceInfo = await this.adapter.collect();
+            // Cache and store the info
+            this.cachedInfo = deviceInfo;
+            await Storage_1.storage.set('DEVICE_INFO', deviceInfo);
+            logger_1.logger.debug('Device info collected');
+            return deviceInfo;
+        }
+        catch (error) {
+            logger_1.logger.error('Failed to collect device info:', error);
+            // Return fallback device info
+            const fallbackInfo = {
+                os_version: 'unknown',
+                device_model: 'unknown',
+                app_version: '1.0.0',
+                locale: 'en-US',
+                platform: 'android',
+            };
+            return fallbackInfo;
+        }
+    }
+    /**
+     * Gets the cached device info without re-collecting
+     */
+    get() {
+        return this.cachedInfo;
+    }
+    /**
+     * Clears the cached device info
+     */
+    clearCache() {
+        this.cachedInfo = null;
+    }
+}
+exports.deviceInfoCollector = new DeviceInfoCollector();

package/dist/core/EventQueue.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Event Queue - Manages batching logic
+ */
+import type { Event } from '../types';
+export type FlushCallback = (events: Event[]) => Promise<void>;
+export declare class EventQueue {
+    private queue;
+    private timer;
+    private readonly maxSize;
+    private readonly maxTime;
+    private readonly maxQueueSize;
+    private flushCallback;
+    constructor(maxSize: number, maxTime: number, maxQueueSize: number);
+    /**
+     * Sets the callback to be called when flush is triggered
+     */
+    setFlushCallback(callback: FlushCallback): void;
+    /**
+     * Adds an event to the queue
+     */
+    enqueue(event: Event): Promise<void>;
+    /**
+     * Removes and returns up to `count` events from the queue
+     */
+    dequeue(count: number): Event[];
+    /**
+     * Returns the current size of the queue
+     */
+    size(): number;
+    /**
+     * Returns all events in the queue without removing them
+     */
+    peek(): Event[];
+    /**
+     * Clears all events from the queue
+     */
+    clear(): Promise<void>;
+    /**
+     * Checks if the queue size has reached the threshold
+     */
+    private checkSizeThreshold;
+    /**
+     * Starts or restarts the flush timer
+     */
+    private startTimer;
+    /**
+     * Stops the flush timer
+     */
+    private stopTimer;
+    /**
+     * Flushes the queue by calling the flush callback
+     */
+    flush(): Promise<void>;
+    /**
+     * Validates UUID format (8-4-4-4-12 hex characters)
+     */
+    private isValidUUID;
+    /**
+     * Loads the queue from storage
+     */
+    loadFromStorage(): Promise<void>;
+    /**
+     * Saves the queue to storage
+     */
+    saveToStorage(): Promise<void>;
+    /**
+     * Cleanup method to stop timers
+     */
+    destroy(): void;
+}
+//# sourceMappingURL=EventQueue.d.ts.map

package/dist/core/EventQueue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventQueue.d.ts","sourceRoot":"","sources":["../../src/core/EventQueue.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAMtC,MAAM,MAAM,aAAa,GAAG,CAAC,MAAM,EAAE,KAAK,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;AAE/D,qBAAa,UAAU;IACrB,OAAO,CAAC,KAAK,CAAe;IAC5B,OAAO,CAAC,KAAK,CAA+B;IAC5C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;IACtC,OAAO,CAAC,aAAa,CAA8B;gBAEvC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM;IAMlE;;OAEG;IACH,gBAAgB,CAAC,QAAQ,EAAE,aAAa,GAAG,IAAI;IAI/C;;OAEG;IACG,OAAO,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC;IA2B1C;;OAEG;IACH,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,EAAE;IAM/B;;OAEG;IACH,IAAI,IAAI,MAAM;IAId;;OAEG;IACH,IAAI,IAAI,KAAK,EAAE;IAIf;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAO5B;;OAEG;YACW,kBAAkB;IAOhC;;OAEG;IACH,OAAO,CAAC,UAAU;IAgBlB;;OAEG;IACH,OAAO,CAAC,SAAS;IAOjB;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IA2C5B;;OAEG;IACH,OAAO,CAAC,WAAW;IAKnB;;OAEG;IACG,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;IAsCtC;;OAEG;IACG,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC;IASpC;;OAEG;IACH,OAAO,IAAI,IAAI;CAIhB"}

package/dist/core/EventQueue.js

@@ -0,0 +1,216 @@
+"use strict";
+/**
+ * Event Queue - Manages batching logic
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventQueue = void 0;
+const Storage_1 = require("./Storage");
+const logger_1 = require("../utils/logger");
+const constants_1 = require("../constants");
+const uuid_1 = require("../utils/uuid");
+class EventQueue {
+    constructor(maxSize, maxTime, maxQueueSize) {
+        this.queue = [];
+        this.timer = null;
+        this.flushCallback = null;
+        this.maxSize = maxSize;
+        this.maxTime = maxTime;
+        this.maxQueueSize = maxQueueSize;
+    }
+    /**
+     * Sets the callback to be called when flush is triggered
+     */
+    setFlushCallback(callback) {
+        this.flushCallback = callback;
+    }
+    /**
+     * Adds an event to the queue
+     */
+    async enqueue(event) {
+        const queueSizeBefore = this.queue.length;
+        // Check if queue is full
+        if (this.queue.length >= this.maxQueueSize) {
+            logger_1.logger.warn(constants_1.ERROR_MESSAGES.QUEUE_FULL);
+            logger_1.logger.warn(`  Queue size: ${this.queue.length}/${this.maxQueueSize}`);
+            logger_1.logger.warn(`  Removing oldest event: ${this.queue[0]?.name || 'unknown'}`);
+            // Remove oldest event
+            this.queue.shift();
+        }
+        this.queue.push(event);
+        logger_1.logger.info(`Event enqueued: ${event.name}`);
+        logger_1.logger.info(`  Queue size: ${queueSizeBefore} -> ${this.queue.length}/${this.maxQueueSize}`);
+        // Persist to storage
+        await this.saveToStorage();
+        // Check if we should flush
+        await this.checkSizeThreshold();
+        // Start/restart the timer
+        this.startTimer();
+    }
+    /**
+     * Removes and returns up to `count` events from the queue
+     */
+    dequeue(count) {
+        const events = this.queue.splice(0, count);
+        // Removed verbose debug logging for production
+        return events;
+    }
+    /**
+     * Returns the current size of the queue
+     */
+    size() {
+        return this.queue.length;
+    }
+    /**
+     * Returns all events in the queue without removing them
+     */
+    peek() {
+        return [...this.queue];
+    }
+    /**
+     * Clears all events from the queue
+     */
+    async clear() {
+        this.queue = [];
+        this.stopTimer();
+        await this.saveToStorage();
+        // Removed verbose info logging for production
+    }
+    /**
+     * Checks if the queue size has reached the threshold
+     */
+    async checkSizeThreshold() {
+        if (this.queue.length >= this.maxSize) {
+            logger_1.logger.debug(`Queue size threshold reached (${this.queue.length}/${this.maxSize}), flushing...`);
+            await this.flush();
+        }
+    }
+    /**
+     * Starts or restarts the flush timer
+     */
+    startTimer() {
+        // Stop existing timer
+        this.stopTimer();
+        // Don't start timer if queue is empty
+        if (this.queue.length === 0) {
+            return;
+        }
+        // Start new timer
+        this.timer = setTimeout(async () => {
+            logger_1.logger.debug(`Queue timeout reached (${this.maxTime}ms), flushing...`);
+            await this.flush();
+        }, this.maxTime);
+    }
+    /**
+     * Stops the flush timer
+     */
+    stopTimer() {
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+    }
+    /**
+     * Flushes the queue by calling the flush callback
+     */
+    async flush() {
+        if (this.queue.length === 0) {
+            logger_1.logger.debug('Queue is empty, nothing to flush');
+            return;
+        }
+        if (!this.flushCallback) {
+            logger_1.logger.warn('Flush callback not set, cannot flush queue');
+            return;
+        }
+        // Stop the timer during flush
+        this.stopTimer();
+        try {
+            // Get all events
+            const events = this.dequeue(this.queue.length);
+            logger_1.logger.info(`Flushing queue: ${events.length} events`);
+            const eventNames = events.map(e => e.name).join(', ');
+            logger_1.logger.info(`  Events: [${eventNames}]`);
+            // Call the flush callback
+            await this.flushCallback(events);
+            // Save updated queue to storage
+            await this.saveToStorage();
+            logger_1.logger.info(`Flushed ${events.length} events successfully`);
+            logger_1.logger.info(`  Remaining queue size: ${this.queue.length}`);
+        }
+        catch (error) {
+            logger_1.logger.error(`Failed to flush queue (${this.queue.length} events):`, error);
+            // Re-enqueue failed events
+            // Note: The BatchManager will handle this by storing failed batches
+            throw error;
+        }
+        finally {
+            // Restart timer if there are still events
+            if (this.queue.length > 0) {
+                this.startTimer();
+            }
+        }
+    }
+    /**
+     * Validates UUID format (8-4-4-4-12 hex characters)
+     */
+    isValidUUID(uuid) {
+        const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+        return uuidRegex.test(uuid);
+    }
+    /**
+     * Loads the queue from storage
+     */
+    async loadFromStorage() {
+        try {
+            const events = await Storage_1.storage.get('EVENT_QUEUE');
+            if (events && Array.isArray(events)) {
+                // Validate and fix event IDs
+                let fixedCount = 0;
+                this.queue = events.map((event) => {
+                    // Fix invalid event IDs
+                    if (!this.isValidUUID(event.id)) {
+                        logger_1.logger.warn(`Invalid event ID detected: ${event.id}. Generating new ID.`);
+                        fixedCount++;
+                        return {
+                            ...event,
+                            id: (0, uuid_1.generateUUID)(),
+                        };
+                    }
+                    return event;
+                });
+                if (fixedCount > 0) {
+                    logger_1.logger.info(`Fixed ${fixedCount} invalid event IDs in queue`);
+                    await this.saveToStorage();
+                }
+                logger_1.logger.info(`Loaded ${this.queue.length} events from storage`);
+                // Start timer if there are events
+                if (this.queue.length > 0) {
+                    this.startTimer();
+                }
+            }
+        }
+        catch (error) {
+            logger_1.logger.error('Failed to load queue from storage:', error);
+            this.queue = [];
+        }
+    }
+    /**
+     * Saves the queue to storage
+     */
+    async saveToStorage() {
+        try {
+            await Storage_1.storage.set('EVENT_QUEUE', this.queue);
+            // Removed verbose debug logging for production
+        }
+        catch (error) {
+            logger_1.logger.error('Failed to save queue to storage:', error);
+        }
+    }
+    /**
+     * Cleanup method to stop timers
+     */
+    destroy() {
+        this.stopTimer();
+        // Removed verbose info logging for production
+    }
+}
+exports.EventQueue = EventQueue;

package/dist/core/Storage.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Storage Layer - AsyncStorage Wrapper
+ */
+import type { StorageKey, StorageValue } from '../types/storage';
+declare class Storage {
+    /**
+     * Sets a value in storage
+     */
+    set<K extends StorageKey>(key: K, value: StorageValue<K>): Promise<void>;
+    /**
+     * Gets a value from storage
+     */
+    get<K extends StorageKey>(key: K): Promise<StorageValue<K> | null>;
+    /**
+     * Removes a value from storage
+     */
+    remove(key: StorageKey): Promise<void>;
+    /**
+     * Clears all SDK-related storage
+     */
+    clear(): Promise<void>;
+    /**
+     * Checks if a key exists in storage
+     */
+    has(key: StorageKey): Promise<boolean>;
+}
+export declare const storage: Storage;
+export {};
+//# sourceMappingURL=Storage.d.ts.map

package/dist/core/Storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Storage.d.ts","sourceRoot":"","sources":["../../src/core/Storage.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAGjE,cAAM,OAAO;IACX;;OAEG;IACG,GAAG,CAAC,CAAC,SAAS,UAAU,EAC5B,GAAG,EAAE,CAAC,EACN,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,GACrB,OAAO,CAAC,IAAI,CAAC;IAYhB;;OAEG;IACG,GAAG,CAAC,CAAC,SAAS,UAAU,EAC5B,GAAG,EAAE,CAAC,GACL,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAiBlC;;OAEG;IACG,MAAM,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAW5C;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAW5B;;OAEG;IACG,GAAG,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC;CAQ7C;AAED,eAAO,MAAM,OAAO,SAAgB,CAAC"}