@axyle/expo-sdk 1.0.0

package/dist/storage.js

@@ -0,0 +1,210 @@
+"use strict";
+/**
+ * Storage layer using AsyncStorage for persistence
+ * Handles event queue, user IDs, session data, and preferences
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Storage = void 0;
+const async_storage_1 = __importDefault(require("@react-native-async-storage/async-storage"));
+const constants_1 = require("./constants");
+const utils_1 = require("./utils");
+class Storage {
+    /**
+     * Get all queued events
+     */
+    static async getQueuedEvents() {
+        try {
+            const data = await async_storage_1.default.getItem(constants_1.STORAGE_KEYS.EVENTS_QUEUE);
+            if (!data)
+                return [];
+            return JSON.parse(data);
+        }
+        catch (error) {
+            console.error('[Axyle] Failed to get queued events:', error);
+            return [];
+        }
+    }
+    /**
+     * Save events to queue
+     */
+    static async saveQueuedEvents(events) {
+        try {
+            await async_storage_1.default.setItem(constants_1.STORAGE_KEYS.EVENTS_QUEUE, (0, utils_1.safeStringify)(events));
+        }
+        catch (error) {
+            console.error('[Axyle] Failed to save queued events:', error);
+        }
+    }
+    /**
+     * Add event to queue
+     */
+    static async addEventToQueue(event) {
+        try {
+            const events = await this.getQueuedEvents();
+            events.push(event);
+            await this.saveQueuedEvents(events);
+        }
+        catch (error) {
+            console.error('[Axyle] Failed to add event to queue:', error);
+        }
+    }
+    /**
+     * Remove events from queue
+     */
+    static async removeEventsFromQueue(eventIds) {
+        try {
+            const events = await this.getQueuedEvents();
+            const filtered = events.filter((e) => !eventIds.includes(e.id));
+            await this.saveQueuedEvents(filtered);
+        }
+        catch (error) {
+            console.error('[Axyle] Failed to remove events from queue:', error);
+        }
+    }
+    /**
+     * Clear all queued events
+     */
+    static async clearQueue() {
+        try {
+            await async_storage_1.default.removeItem(constants_1.STORAGE_KEYS.EVENTS_QUEUE);
+        }
+        catch (error) {
+            console.error('[Axyle] Failed to clear queue:', error);
+        }
+    }
+    /**
+     * Get anonymous ID (create if doesn't exist)
+     */
+    static async getAnonymousId() {
+        try {
+            let anonymousId = await async_storage_1.default.getItem(constants_1.STORAGE_KEYS.ANONYMOUS_ID);
+            if (!anonymousId) {
+                // Generate new anonymous ID
+                anonymousId = `anon_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+                await async_storage_1.default.setItem(constants_1.STORAGE_KEYS.ANONYMOUS_ID, anonymousId);
+            }
+            return anonymousId;
+        }
+        catch (error) {
+            console.error('[Axyle] Failed to get anonymous ID:', error);
+            // Fallback to in-memory ID
+            return `anon_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        }
+    }
+    /**
+     * Get user ID
+     */
+    static async getUserId() {
+        try {
+            return await async_storage_1.default.getItem(constants_1.STORAGE_KEYS.USER_ID);
+        }
+        catch (error) {
+            console.error('[Axyle] Failed to get user ID:', error);
+            return null;
+        }
+    }
+    /**
+     * Set user ID
+     */
+    static async setUserId(userId) {
+        try {
+            await async_storage_1.default.setItem(constants_1.STORAGE_KEYS.USER_ID, userId);
+        }
+        catch (error) {
+            console.error('[Axyle] Failed to set user ID:', error);
+        }
+    }
+    /**
+     * Clear user ID (on reset/logout)
+     */
+    static async clearUserId() {
+        try {
+            await async_storage_1.default.removeItem(constants_1.STORAGE_KEYS.USER_ID);
+        }
+        catch (error) {
+            console.error('[Axyle] Failed to clear user ID:', error);
+        }
+    }
+    /**
+     * Get session data
+     */
+    static async getSessionData() {
+        try {
+            const data = await async_storage_1.default.getItem(constants_1.STORAGE_KEYS.SESSION_DATA);
+            if (!data)
+                return null;
+            return JSON.parse(data);
+        }
+        catch (error) {
+            console.error('[Axyle] Failed to get session data:', error);
+            return null;
+        }
+    }
+    /**
+     * Save session data
+     */
+    static async saveSessionData(session) {
+        try {
+            await async_storage_1.default.setItem(constants_1.STORAGE_KEYS.SESSION_DATA, (0, utils_1.safeStringify)(session));
+        }
+        catch (error) {
+            console.error('[Axyle] Failed to save session data:', error);
+        }
+    }
+    /**
+     * Clear session data
+     */
+    static async clearSessionData() {
+        try {
+            await async_storage_1.default.removeItem(constants_1.STORAGE_KEYS.SESSION_DATA);
+        }
+        catch (error) {
+            console.error('[Axyle] Failed to clear session data:', error);
+        }
+    }
+    /**
+     * Check if user has opted out
+     */
+    static async isOptedOut() {
+        try {
+            const value = await async_storage_1.default.getItem(constants_1.STORAGE_KEYS.OPT_OUT);
+            return value === 'true';
+        }
+        catch (error) {
+            console.error('[Axyle] Failed to check opt-out status:', error);
+            return false;
+        }
+    }
+    /**
+     * Set opt-out status
+     */
+    static async setOptOut(optOut) {
+        try {
+            await async_storage_1.default.setItem(constants_1.STORAGE_KEYS.OPT_OUT, optOut ? 'true' : 'false');
+        }
+        catch (error) {
+            console.error('[Axyle] Failed to set opt-out status:', error);
+        }
+    }
+    /**
+     * Clear all analytics data
+     */
+    static async clearAll() {
+        try {
+            await async_storage_1.default.multiRemove([
+                constants_1.STORAGE_KEYS.EVENTS_QUEUE,
+                constants_1.STORAGE_KEYS.USER_ID,
+                constants_1.STORAGE_KEYS.SESSION_DATA,
+                constants_1.STORAGE_KEYS.OPT_OUT,
+                // Keep anonymous ID for continuity
+            ]);
+        }
+        catch (error) {
+            console.error('[Axyle] Failed to clear all data:', error);
+        }
+    }
+}
+exports.Storage = Storage;

package/dist/transport.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Transport layer for sending events to the analytics API
+ * Handles batching, retry logic with exponential backoff
+ */
+import { AnalyticsEvent } from "./types";
+export interface TransportConfig {
+    apiKey: string;
+    baseUrl: string;
+    debug: boolean;
+}
+export declare class Transport {
+    private config;
+    private logger;
+    constructor(config: TransportConfig, logger: any);
+    /**
+     * Send a batch of events to the API
+     * Returns the IDs of successfully sent events
+     */
+    sendBatch(events: AnalyticsEvent[]): Promise<string[]>;
+    /**
+     * Send a single batch with retry logic
+     */
+    private sendBatchWithRetry;
+    /**
+     * Make HTTP request to the API
+     */
+    private makeRequest;
+    /**
+     * Split events into batches based on size and count limits
+     */
+    private createBatches;
+    /**
+     * Update API key
+     */
+    updateApiKey(apiKey: string): void;
+    /**
+     * Update base URL - disabled, always uses production server
+     * This method is kept for backward compatibility but does nothing
+     */
+    updateBaseUrl(_baseUrl: string): void;
+}

package/dist/transport.js

@@ -0,0 +1,158 @@
+"use strict";
+/**
+ * Transport layer for sending events to the analytics API
+ * Handles batching, retry logic with exponential backoff
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Transport = void 0;
+const constants_1 = require("./constants");
+const utils_1 = require("./utils");
+class Transport {
+    constructor(config, logger) {
+        this.config = config;
+        this.logger = logger;
+    }
+    /**
+     * Send a batch of events to the API
+     * Returns the IDs of successfully sent events
+     */
+    async sendBatch(events) {
+        if (events.length === 0)
+            return [];
+        // Split into smaller batches if needed
+        const batches = this.createBatches(events);
+        const sentEventIds = [];
+        for (const batch of batches) {
+            try {
+                const success = await this.sendBatchWithRetry(batch);
+                if (success) {
+                    sentEventIds.push(...batch.map((e) => e.id));
+                }
+            }
+            catch (error) {
+                this.logger.error("Failed to send batch after retries:", error);
+                // Continue with next batch even if this one fails
+            }
+        }
+        return sentEventIds;
+    }
+    /**
+     * Send a single batch with retry logic
+     */
+    async sendBatchWithRetry(events) {
+        let attempt = 0;
+        while (attempt < constants_1.RETRY_CONFIG.maxRetries) {
+            try {
+                const response = await this.makeRequest(events);
+                if (response.ok) {
+                    this.logger.log(`Successfully sent ${events.length} events`);
+                    return true;
+                }
+                // Get error details for better debugging
+                const errorText = await response.text().catch(() => "Unknown error");
+                this.logger.error(`API error ${response.status}:`, errorText);
+                // Check if error is retryable
+                if (response.status >= 400 && response.status < 500) {
+                    // Client error - don't retry
+                    this.logger.error(`Client error ${response.status}, not retrying`);
+                    return false;
+                }
+                // Server error - retry with backoff
+                this.logger.warn(`Server error ${response.status}, retrying...`);
+            }
+            catch (error) {
+                this.logger.warn(`Network error on attempt ${attempt + 1}:`, error);
+                if (error instanceof Error) {
+                    this.logger.warn(`Error details: ${error.message}`);
+                }
+            }
+            // Calculate backoff delay
+            if (attempt < constants_1.RETRY_CONFIG.maxRetries - 1) {
+                const delay = (0, utils_1.calculateBackoff)(attempt, constants_1.RETRY_CONFIG.initialDelay, constants_1.RETRY_CONFIG.maxDelay, constants_1.RETRY_CONFIG.backoffMultiplier);
+                this.logger.log(`Waiting ${delay}ms before retry...`);
+                await (0, utils_1.sleep)(delay);
+            }
+            attempt++;
+        }
+        return false;
+    }
+    /**
+     * Make HTTP request to the API
+     */
+    async makeRequest(events) {
+        const url = `${this.config.baseUrl}/api/events`;
+        this.logger.log(`Sending ${events.length} events to ${url}`);
+        try {
+            const requestBody = {
+                events,
+                sentAt: new Date().toISOString(),
+            };
+            const response = await fetch(url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "X-API-Key": this.config.apiKey,
+                },
+                body: JSON.stringify(requestBody),
+            });
+            if (!response.ok) {
+                const errorText = await response.text().catch(() => "Unknown error");
+                this.logger.error(`API request failed: ${response.status} ${response.statusText}`, errorText);
+            }
+            else {
+                this.logger.log(`API request successful: ${response.status}`);
+            }
+            return response;
+        }
+        catch (error) {
+            this.logger.error("Network error sending events:", error);
+            throw error;
+        }
+    }
+    /**
+     * Split events into batches based on size and count limits
+     */
+    createBatches(events) {
+        const batches = [];
+        let currentBatch = [];
+        let currentBatchSize = 0;
+        for (const event of events) {
+            const eventSize = (0, utils_1.getObjectSize)(event);
+            // Check if adding this event would exceed limits
+            if (currentBatch.length >= constants_1.MAX_EVENTS_PER_BATCH ||
+                currentBatchSize + eventSize > constants_1.MAX_BATCH_SIZE) {
+                // Start new batch
+                if (currentBatch.length > 0) {
+                    batches.push(currentBatch);
+                }
+                currentBatch = [event];
+                currentBatchSize = eventSize;
+            }
+            else {
+                // Add to current batch
+                currentBatch.push(event);
+                currentBatchSize += eventSize;
+            }
+        }
+        // Add final batch
+        if (currentBatch.length > 0) {
+            batches.push(currentBatch);
+        }
+        return batches;
+    }
+    /**
+     * Update API key
+     */
+    updateApiKey(apiKey) {
+        this.config.apiKey = apiKey;
+    }
+    /**
+     * Update base URL - disabled, always uses production server
+     * This method is kept for backward compatibility but does nothing
+     */
+    updateBaseUrl(_baseUrl) {
+        // baseUrl is not configurable - always uses production server
+        // This method is kept for backward compatibility but does nothing
+    }
+}
+exports.Transport = Transport;

package/dist/types.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Core type definitions for Axyle Analytics SDK
+ */
+/**
+ * SDK initialization accepts only the API key
+ * All other settings use internal defaults
+ */
+export type AxyleInitConfig = string | {
+    apiKey: string;
+};
+/**
+ * Internal configuration type with all settings
+ * Only apiKey comes from user, everything else uses defaults
+ */
+export interface InternalAxyleConfig {
+    apiKey: string;
+    userId: string;
+    environment: "dev" | "prod";
+    debug: boolean;
+    maxQueueSize: number;
+    flushInterval: number;
+    sessionTimeout: number;
+    baseUrl: string;
+}
+export interface EventProperties {
+    [key: string]: string | number | boolean | null | undefined;
+}
+export interface UserTraits {
+    [key: string]: string | number | boolean | null | undefined;
+}
+export interface AnalyticsEvent {
+    /** Unique event ID */
+    id: string;
+    /** Event name */
+    name: string;
+    /** Event properties */
+    properties: EventProperties;
+    /** Timestamp when event occurred */
+    timestamp: number;
+    /** User ID (anonymous or identified) */
+    userId: string;
+    /** Anonymous user ID (persists across sessions) */
+    anonymousId: string;
+    /** Session ID */
+    sessionId: string;
+    /** Device metadata */
+    context: EventContext;
+    /** Schema version */
+    schemaVersion: string;
+}
+export interface EventContext {
+    /** App information */
+    app: {
+        name: string;
+        version: string;
+        build: string;
+        namespace: string;
+    };
+    /** Device information */
+    device: {
+        id: string | null;
+        manufacturer: string | null;
+        model: string | null;
+        name: string | null;
+        type: "PHONE" | "TABLET" | "DESKTOP" | "TV" | "UNKNOWN";
+        brand: string | null;
+    };
+    /** OS information */
+    os: {
+        name: string;
+        version: string;
+    };
+    /** Screen information */
+    screen: {
+        width: number;
+        height: number;
+        density: number;
+    };
+    /** Locale */
+    locale: string;
+    /** Timezone */
+    timezone: string;
+    /** Network information (if available) */
+    network?: {
+        carrier: string | null;
+        wifi: boolean;
+    };
+    /** Environment */
+    environment: "dev" | "prod";
+}
+export interface SessionData {
+    sessionId: string;
+    startTime: number;
+    lastActivityTime: number;
+}
+export interface StorageKeys {
+    EVENTS_QUEUE: string;
+    ANONYMOUS_ID: string;
+    USER_ID: string;
+    SESSION_DATA: string;
+    OPT_OUT: string;
+}

package/dist/types.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Core type definitions for Axyle Analytics SDK
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Utility functions for the SDK
+ */
+/**
+ * Generate a UUID v4
+ */
+export declare function generateUUID(): string;
+/**
+ * Safely stringify an object, handling circular references
+ */
+export declare function safeStringify(obj: any): string;
+/**
+ * Calculate size of an object in bytes
+ */
+export declare function getObjectSize(obj: any): number;
+/**
+ * Validate event name
+ */
+export declare function isValidEventName(name: string): boolean;
+/**
+ * Sanitize event properties
+ */
+export declare function sanitizeProperties(properties: Record<string, any>): Record<string, any>;
+/**
+ * Create a logger that respects debug mode
+ */
+export declare function createLogger(debug: boolean): {
+    log: (...args: any[]) => void;
+    warn: (...args: any[]) => void;
+    error: (...args: any[]) => void;
+};
+/**
+ * Sleep for a given number of milliseconds
+ */
+export declare function sleep(ms: number): Promise<void>;
+/**
+ * Calculate exponential backoff delay
+ */
+export declare function calculateBackoff(attempt: number, initialDelay: number, maxDelay: number, multiplier: number): number;

package/dist/utils.js

@@ -0,0 +1,116 @@
+"use strict";
+/**
+ * Utility functions for the SDK
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateUUID = generateUUID;
+exports.safeStringify = safeStringify;
+exports.getObjectSize = getObjectSize;
+exports.isValidEventName = isValidEventName;
+exports.sanitizeProperties = sanitizeProperties;
+exports.createLogger = createLogger;
+exports.sleep = sleep;
+exports.calculateBackoff = calculateBackoff;
+/**
+ * Generate a UUID v4
+ */
+function generateUUID() {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+        const r = (Math.random() * 16) | 0;
+        const v = c === 'x' ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+}
+/**
+ * Safely stringify an object, handling circular references
+ */
+function safeStringify(obj) {
+    const seen = new WeakSet();
+    return JSON.stringify(obj, (key, value) => {
+        if (typeof value === 'object' && value !== null) {
+            if (seen.has(value)) {
+                return '[Circular]';
+            }
+            seen.add(value);
+        }
+        return value;
+    });
+}
+/**
+ * Calculate size of an object in bytes
+ */
+function getObjectSize(obj) {
+    return new Blob([safeStringify(obj)]).size;
+}
+/**
+ * Validate event name
+ */
+function isValidEventName(name) {
+    if (!name || typeof name !== 'string')
+        return false;
+    if (name.length === 0 || name.length > 255)
+        return false;
+    // Allow alphanumeric, spaces, underscores, hyphens
+    return /^[a-zA-Z0-9\s_-]+$/.test(name);
+}
+/**
+ * Sanitize event properties
+ */
+function sanitizeProperties(properties) {
+    const sanitized = {};
+    for (const [key, value] of Object.entries(properties)) {
+        // Skip invalid keys
+        if (!key || typeof key !== 'string' || key.length > 255)
+            continue;
+        // Only allow primitive types
+        if (typeof value === 'string' ||
+            typeof value === 'number' ||
+            typeof value === 'boolean' ||
+            value === null ||
+            value === undefined) {
+            sanitized[key] = value;
+        }
+        else if (typeof value === 'object') {
+            // Convert objects/arrays to JSON strings
+            try {
+                sanitized[key] = safeStringify(value);
+            }
+            catch (e) {
+                // Skip if can't stringify
+            }
+        }
+    }
+    return sanitized;
+}
+/**
+ * Create a logger that respects debug mode
+ */
+function createLogger(debug) {
+    return {
+        log: (...args) => {
+            if (debug)
+                console.log('[Axyle]', ...args);
+        },
+        warn: (...args) => {
+            if (debug)
+                console.warn('[Axyle]', ...args);
+        },
+        error: (...args) => {
+            if (debug)
+                console.error('[Axyle]', ...args);
+        },
+    };
+}
+/**
+ * Sleep for a given number of milliseconds
+ */
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Calculate exponential backoff delay
+ */
+function calculateBackoff(attempt, initialDelay, maxDelay, multiplier) {
+    const delay = initialDelay * Math.pow(multiplier, attempt);
+    return Math.min(delay, maxDelay);
+}