@seekora-ai/search-sdk 0.2.7 → 0.2.12

package/dist/src/event-queue.d.ts

@@ -1,195 +0,0 @@
-/**
- * Event Queue for Seekora SDK
- *
- * Provides offline event buffering, automatic retry with exponential backoff,
- * and localStorage persistence for resilient analytics tracking.
- */
-import type { ExtendedEventPayload } from './client';
-import type { Logger } from './logger';
-/**
- * Queued event with metadata for retry logic
- */
-export interface QueuedEvent {
-    /** Unique ID for this queued event */
-    id: string;
-    /** The event payload */
-    payload: ExtendedEventPayload;
-    /** Timestamp when the event was queued */
-    queuedAt: number;
-    /** Number of retry attempts */
-    retryCount: number;
-    /** Next retry timestamp (for exponential backoff) */
-    nextRetryAt: number;
-    /** Whether this is a batch event */
-    isBatch: boolean;
-}
-/**
- * Event queue configuration
- */
-export interface EventQueueConfig {
-    /**
-     * Maximum number of events to store in the queue
-     * @default 1000
-     */
-    maxQueueSize?: number;
-    /**
-     * Maximum number of retry attempts per event
-     * @default 5
-     */
-    maxRetries?: number;
-    /**
-     * Base delay for exponential backoff (ms)
-     * @default 1000
-     */
-    baseRetryDelay?: number;
-    /**
-     * Maximum delay between retries (ms)
-     * @default 60000 (1 minute)
-     */
-    maxRetryDelay?: number;
-    /**
-     * Flush interval for automatic queue processing (ms)
-     * Set to 0 to disable automatic flushing
-     * @default 5000 (5 seconds)
-     */
-    flushInterval?: number;
-    /**
-     * Batch size for sending events
-     * @default 10
-     */
-    batchSize?: number;
-    /**
-     * Storage key for localStorage persistence
-     * @default 'seekora_event_queue'
-     */
-    storageKey?: string;
-    /**
-     * Enable localStorage persistence
-     * @default true
-     */
-    enablePersistence?: boolean;
-    /**
-     * Maximum age of queued events before they are discarded (ms)
-     * @default 86400000 (24 hours)
-     */
-    maxEventAge?: number;
-}
-/**
- * Function type for sending events to the backend
- */
-export type EventSender = (events: ExtendedEventPayload[]) => Promise<void>;
-/**
- * EventQueue class for resilient event tracking
- */
-export declare class EventQueue {
-    private config;
-    private queue;
-    private isOnline;
-    private isFlushing;
-    private flushTimer;
-    private logger;
-    private sender;
-    constructor(config?: EventQueueConfig);
-    /**
-     * Set the logger instance
-     */
-    setLogger(logger: Logger): void;
-    /**
-     * Set the event sender function
-     */
-    setSender(sender: EventSender): void;
-    /**
-     * Check if running in browser environment
-     */
-    private isBrowser;
-    /**
-     * Setup network status listeners
-     */
-    private setupNetworkListeners;
-    /**
-     * Setup beforeunload handler to persist queue
-     */
-    private setupBeforeUnloadHandler;
-    /**
-     * Start the automatic flush timer
-     */
-    private startFlushTimer;
-    /**
-     * Stop the automatic flush timer
-     */
-    stopFlushTimer(): void;
-    /**
-     * Log a message using the configured logger
-     */
-    private log;
-    /**
-     * Enqueue a single event
-     */
-    enqueue(payload: ExtendedEventPayload): void;
-    /**
-     * Enqueue a batch of events
-     */
-    enqueueBatch(payloads: ExtendedEventPayload[]): void;
-    /**
-     * Internal enqueue implementation
-     */
-    private enqueueInternal;
-    /**
-     * Flush the queue - send pending events to the backend
-     */
-    flush(): Promise<void>;
-    /**
-     * Create batches from events
-     */
-    private createBatches;
-    /**
-     * Send a batch of events
-     */
-    private sendBatch;
-    /**
-     * Persist queue to localStorage
-     */
-    persist(): void;
-    /**
-     * Restore queue from localStorage
-     */
-    private restore;
-    /**
-     * Get current queue size
-     */
-    size(): number;
-    /**
-     * Check if queue is empty
-     */
-    isEmpty(): boolean;
-    /**
-     * Check if currently online
-     */
-    getOnlineStatus(): boolean;
-    /**
-     * Clear the queue
-     */
-    clear(): void;
-    /**
-     * Get queue statistics
-     */
-    getStats(): {
-        queueSize: number;
-        isOnline: boolean;
-        isFlushing: boolean;
-        oldestEventAge: number | null;
-        pendingRetries: number;
-    };
-    /**
-     * Destroy the queue and cleanup resources
-     */
-    destroy(): void;
-}
-/**
- * Get or create the default event queue
- */
-export declare function getDefaultEventQueue(config?: EventQueueConfig): EventQueue;
-/**
- * Create a new event queue instance
- */
-export declare function createEventQueue(config?: EventQueueConfig): EventQueue;

package/dist/src/event-queue.js

@@ -1,424 +0,0 @@
-"use strict";
-/**
- * Event Queue for Seekora SDK
- *
- * Provides offline event buffering, automatic retry with exponential backoff,
- * and localStorage persistence for resilient analytics tracking.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventQueue = void 0;
-exports.getDefaultEventQueue = getDefaultEventQueue;
-exports.createEventQueue = createEventQueue;
-const utils_1 = require("./utils");
-/**
- * Default configuration
- */
-const DEFAULT_CONFIG = {
-    maxQueueSize: 1000,
-    maxRetries: 5,
-    baseRetryDelay: 1000,
-    maxRetryDelay: 60000,
-    flushInterval: 5000,
-    batchSize: 10,
-    storageKey: 'seekora_event_queue',
-    enablePersistence: true,
-    maxEventAge: 86400000, // 24 hours
-};
-/**
- * EventQueue class for resilient event tracking
- */
-class EventQueue {
-    constructor(config = {}) {
-        this.queue = [];
-        this.isOnline = true;
-        this.isFlushing = false;
-        this.flushTimer = null;
-        this.logger = null;
-        this.sender = null;
-        this.config = { ...DEFAULT_CONFIG, ...config };
-        // Check online status
-        if (typeof navigator !== 'undefined') {
-            this.isOnline = navigator.onLine;
-        }
-        // Restore queue from storage
-        if (this.config.enablePersistence) {
-            this.restore();
-        }
-        // Setup network listeners
-        this.setupNetworkListeners();
-        // Start flush timer
-        if (this.config.flushInterval > 0) {
-            this.startFlushTimer();
-        }
-        // Setup beforeunload handler for persistence
-        this.setupBeforeUnloadHandler();
-    }
-    /**
-     * Set the logger instance
-     */
-    setLogger(logger) {
-        this.logger = logger;
-    }
-    /**
-     * Set the event sender function
-     */
-    setSender(sender) {
-        this.sender = sender;
-    }
-    /**
-     * Check if running in browser environment
-     */
-    isBrowser() {
-        return typeof window !== 'undefined' && typeof localStorage !== 'undefined';
-    }
-    /**
-     * Setup network status listeners
-     */
-    setupNetworkListeners() {
-        if (typeof window === 'undefined')
-            return;
-        window.addEventListener('online', () => {
-            this.isOnline = true;
-            this.log('verbose', 'Network online, triggering flush');
-            this.flush();
-        });
-        window.addEventListener('offline', () => {
-            this.isOnline = false;
-            this.log('verbose', 'Network offline, pausing flush');
-        });
-    }
-    /**
-     * Setup beforeunload handler to persist queue
-     */
-    setupBeforeUnloadHandler() {
-        if (typeof window === 'undefined')
-            return;
-        window.addEventListener('beforeunload', () => {
-            this.persist();
-        });
-        // Also handle visibility change for mobile
-        document.addEventListener('visibilitychange', () => {
-            if (document.visibilityState === 'hidden') {
-                this.persist();
-            }
-        });
-    }
-    /**
-     * Start the automatic flush timer
-     */
-    startFlushTimer() {
-        if (this.flushTimer) {
-            clearInterval(this.flushTimer);
-        }
-        this.flushTimer = setInterval(() => {
-            this.flush();
-        }, this.config.flushInterval);
-    }
-    /**
-     * Stop the automatic flush timer
-     */
-    stopFlushTimer() {
-        if (this.flushTimer) {
-            clearInterval(this.flushTimer);
-            this.flushTimer = null;
-        }
-    }
-    /**
-     * Log a message using the configured logger
-     */
-    log(level, message, data) {
-        if (!this.logger)
-            return;
-        switch (level) {
-            case 'verbose':
-                this.logger.verbose(message, data);
-                break;
-            case 'info':
-                this.logger.info(message, data);
-                break;
-            case 'warn':
-                this.logger.warn(message, data);
-                break;
-            case 'error':
-                this.logger.error(message, data);
-                break;
-        }
-    }
-    /**
-     * Enqueue a single event
-     */
-    enqueue(payload) {
-        this.enqueueInternal(payload, false);
-    }
-    /**
-     * Enqueue a batch of events
-     */
-    enqueueBatch(payloads) {
-        payloads.forEach(payload => {
-            this.enqueueInternal(payload, true);
-        });
-    }
-    /**
-     * Internal enqueue implementation
-     */
-    enqueueInternal(payload, isBatch) {
-        // Check queue size limit
-        if (this.queue.length >= this.config.maxQueueSize) {
-            // Remove oldest events to make room
-            const removeCount = Math.ceil(this.config.maxQueueSize * 0.1); // Remove 10%
-            this.queue.splice(0, removeCount);
-            this.log('warn', `Queue full, removed ${removeCount} oldest events`);
-        }
-        const now = Date.now();
-        const event = {
-            id: (0, utils_1.generateUUID)(),
-            payload,
-            queuedAt: now,
-            retryCount: 0,
-            nextRetryAt: now,
-            isBatch,
-        };
-        this.queue.push(event);
-        this.log('verbose', 'Event enqueued', { id: event.id, queueSize: this.queue.length });
-        // Try to flush immediately if online
-        if (this.isOnline && !this.isFlushing) {
-            this.flush();
-        }
-    }
-    /**
-     * Flush the queue - send pending events to the backend
-     */
-    async flush() {
-        // Skip if already flushing, offline, or no sender
-        if (this.isFlushing || !this.isOnline || !this.sender) {
-            return;
-        }
-        // Skip if queue is empty
-        if (this.queue.length === 0) {
-            return;
-        }
-        this.isFlushing = true;
-        this.log('verbose', 'Starting queue flush', { queueSize: this.queue.length });
-        try {
-            const now = Date.now();
-            // Filter events that are ready to be sent
-            const readyEvents = this.queue.filter(event => {
-                // Check if event is too old
-                if (now - event.queuedAt > this.config.maxEventAge) {
-                    return false;
-                }
-                // Check if event is ready for retry
-                return event.nextRetryAt <= now;
-            });
-            // Remove expired events
-            this.queue = this.queue.filter(event => now - event.queuedAt <= this.config.maxEventAge);
-            if (readyEvents.length === 0) {
-                this.log('verbose', 'No events ready for sending');
-                return;
-            }
-            // Process events in batches
-            const batches = this.createBatches(readyEvents);
-            for (const batch of batches) {
-                await this.sendBatch(batch);
-            }
-            // Persist after successful flush
-            if (this.config.enablePersistence) {
-                this.persist();
-            }
-        }
-        catch (error) {
-            this.log('error', 'Queue flush failed', { error: error.message });
-        }
-        finally {
-            this.isFlushing = false;
-        }
-    }
-    /**
-     * Create batches from events
-     */
-    createBatches(events) {
-        const batches = [];
-        for (let i = 0; i < events.length; i += this.config.batchSize) {
-            batches.push(events.slice(i, i + this.config.batchSize));
-        }
-        return batches;
-    }
-    /**
-     * Send a batch of events
-     */
-    async sendBatch(batch) {
-        if (!this.sender)
-            return;
-        const payloads = batch.map(event => event.payload);
-        const eventIds = batch.map(event => event.id);
-        try {
-            await this.sender(payloads);
-            // Success - remove events from queue
-            this.queue = this.queue.filter(event => !eventIds.includes(event.id));
-            this.log('verbose', 'Batch sent successfully', {
-                count: batch.length,
-                remainingQueueSize: this.queue.length
-            });
-        }
-        catch (error) {
-            // Failure - update retry counts
-            const now = Date.now();
-            for (const event of batch) {
-                const queuedEvent = this.queue.find(e => e.id === event.id);
-                if (!queuedEvent)
-                    continue;
-                queuedEvent.retryCount++;
-                if (queuedEvent.retryCount >= this.config.maxRetries) {
-                    // Max retries reached - remove from queue
-                    this.queue = this.queue.filter(e => e.id !== event.id);
-                    this.log('warn', 'Event discarded after max retries', {
-                        id: event.id,
-                        retryCount: queuedEvent.retryCount
-                    });
-                }
-                else {
-                    // Calculate next retry with exponential backoff
-                    const delay = Math.min(this.config.baseRetryDelay * Math.pow(2, queuedEvent.retryCount), this.config.maxRetryDelay);
-                    queuedEvent.nextRetryAt = now + delay;
-                    this.log('verbose', 'Event scheduled for retry', {
-                        id: event.id,
-                        retryCount: queuedEvent.retryCount,
-                        nextRetryIn: delay
-                    });
-                }
-            }
-            this.log('warn', 'Batch send failed, events scheduled for retry', {
-                count: batch.length,
-                error: error.message
-            });
-        }
-    }
-    /**
-     * Persist queue to localStorage
-     */
-    persist() {
-        if (!this.isBrowser() || !this.config.enablePersistence)
-            return;
-        try {
-            const data = JSON.stringify(this.queue);
-            localStorage.setItem(this.config.storageKey, data);
-            this.log('verbose', 'Queue persisted to localStorage', {
-                queueSize: this.queue.length
-            });
-        }
-        catch (error) {
-            this.log('warn', 'Failed to persist queue', { error: error.message });
-        }
-    }
-    /**
-     * Restore queue from localStorage
-     */
-    restore() {
-        if (!this.isBrowser())
-            return;
-        try {
-            const data = localStorage.getItem(this.config.storageKey);
-            if (!data)
-                return;
-            const storedQueue = JSON.parse(data);
-            const now = Date.now();
-            // Filter out expired events
-            this.queue = storedQueue.filter(event => now - event.queuedAt <= this.config.maxEventAge);
-            // Reset nextRetryAt for all events to now (give them a fresh start)
-            this.queue.forEach(event => {
-                event.nextRetryAt = now;
-            });
-            this.log('info', 'Queue restored from localStorage', {
-                storedCount: storedQueue.length,
-                restoredCount: this.queue.length
-            });
-        }
-        catch (error) {
-            this.log('warn', 'Failed to restore queue', { error: error.message });
-            // Clear corrupted data
-            try {
-                localStorage.removeItem(this.config.storageKey);
-            }
-            catch {
-                // Ignore
-            }
-        }
-    }
-    /**
-     * Get current queue size
-     */
-    size() {
-        return this.queue.length;
-    }
-    /**
-     * Check if queue is empty
-     */
-    isEmpty() {
-        return this.queue.length === 0;
-    }
-    /**
-     * Check if currently online
-     */
-    getOnlineStatus() {
-        return this.isOnline;
-    }
-    /**
-     * Clear the queue
-     */
-    clear() {
-        this.queue = [];
-        if (this.isBrowser() && this.config.enablePersistence) {
-            try {
-                localStorage.removeItem(this.config.storageKey);
-            }
-            catch {
-                // Ignore
-            }
-        }
-        this.log('info', 'Queue cleared');
-    }
-    /**
-     * Get queue statistics
-     */
-    getStats() {
-        const now = Date.now();
-        const oldestEvent = this.queue[0];
-        return {
-            queueSize: this.queue.length,
-            isOnline: this.isOnline,
-            isFlushing: this.isFlushing,
-            oldestEventAge: oldestEvent ? now - oldestEvent.queuedAt : null,
-            pendingRetries: this.queue.filter(e => e.retryCount > 0).length,
-        };
-    }
-    /**
-     * Destroy the queue and cleanup resources
-     */
-    destroy() {
-        this.stopFlushTimer();
-        this.persist();
-        this.queue = [];
-        this.sender = null;
-        this.logger = null;
-    }
-}
-exports.EventQueue = EventQueue;
-/**
- * Default event queue instance
- */
-let defaultQueue = null;
-/**
- * Get or create the default event queue
- */
-function getDefaultEventQueue(config) {
-    if (!defaultQueue) {
-        defaultQueue = new EventQueue(config);
-    }
-    return defaultQueue;
-}
-/**
- * Create a new event queue instance
- */
-function createEventQueue(config) {
-    return new EventQueue(config);
-}

package/dist/src/index.d.ts

@@ -1,14 +0,0 @@
-/**
- * Seekora Search SDK
- *
- * Main entry point for the SDK
- */
-export { SeekoraClient, type SeekoraClientConfig, type SearchOptions, type SearchResponse, type SearchContext, type ExtendedEventPayload, type QuerySuggestionsFullResponse } from './client';
-export type { SeekoraEnvironment } from './config';
-export { ENVIRONMENTS, getBaseUrl, getEnvironment, type EnvironmentConfig } from './config';
-export { Logger, createLogger, getLogLevelFromEnv, type LogLevel, type LoggerConfig } from './logger';
-export { loadConfig, loadConfigFromFile, loadConfigFromEnv, type FileConfig } from './config-loader';
-export { ContextCollector, collectBrowserContext, getDefaultContextCollector, type BrowserContext, type ContextCollectorConfig } from './context-collector';
-export { EventQueue, createEventQueue, getDefaultEventQueue, type QueuedEvent, type EventQueueConfig, type EventSender } from './event-queue';
-export * from '../generated';
-export { SeekoraClient as default } from './client';

package/dist/src/index.js

@@ -1,48 +0,0 @@
-"use strict";
-/**
- * Seekora Search SDK
- *
- * Main entry point for the SDK
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = exports.getDefaultEventQueue = exports.createEventQueue = exports.EventQueue = exports.getDefaultContextCollector = exports.collectBrowserContext = exports.ContextCollector = exports.loadConfigFromEnv = exports.loadConfigFromFile = exports.loadConfig = exports.getLogLevelFromEnv = exports.createLogger = exports.Logger = exports.getEnvironment = exports.getBaseUrl = exports.ENVIRONMENTS = exports.SeekoraClient = void 0;
-var client_1 = require("./client");
-Object.defineProperty(exports, "SeekoraClient", { enumerable: true, get: function () { return client_1.SeekoraClient; } });
-var config_1 = require("./config");
-Object.defineProperty(exports, "ENVIRONMENTS", { enumerable: true, get: function () { return config_1.ENVIRONMENTS; } });
-Object.defineProperty(exports, "getBaseUrl", { enumerable: true, get: function () { return config_1.getBaseUrl; } });
-Object.defineProperty(exports, "getEnvironment", { enumerable: true, get: function () { return config_1.getEnvironment; } });
-var logger_1 = require("./logger");
-Object.defineProperty(exports, "Logger", { enumerable: true, get: function () { return logger_1.Logger; } });
-Object.defineProperty(exports, "createLogger", { enumerable: true, get: function () { return logger_1.createLogger; } });
-Object.defineProperty(exports, "getLogLevelFromEnv", { enumerable: true, get: function () { return logger_1.getLogLevelFromEnv; } });
-var config_loader_1 = require("./config-loader");
-Object.defineProperty(exports, "loadConfig", { enumerable: true, get: function () { return config_loader_1.loadConfig; } });
-Object.defineProperty(exports, "loadConfigFromFile", { enumerable: true, get: function () { return config_loader_1.loadConfigFromFile; } });
-Object.defineProperty(exports, "loadConfigFromEnv", { enumerable: true, get: function () { return config_loader_1.loadConfigFromEnv; } });
-var context_collector_1 = require("./context-collector");
-Object.defineProperty(exports, "ContextCollector", { enumerable: true, get: function () { return context_collector_1.ContextCollector; } });
-Object.defineProperty(exports, "collectBrowserContext", { enumerable: true, get: function () { return context_collector_1.collectBrowserContext; } });
-Object.defineProperty(exports, "getDefaultContextCollector", { enumerable: true, get: function () { return context_collector_1.getDefaultContextCollector; } });
-var event_queue_1 = require("./event-queue");
-Object.defineProperty(exports, "EventQueue", { enumerable: true, get: function () { return event_queue_1.EventQueue; } });
-Object.defineProperty(exports, "createEventQueue", { enumerable: true, get: function () { return event_queue_1.createEventQueue; } });
-Object.defineProperty(exports, "getDefaultEventQueue", { enumerable: true, get: function () { return event_queue_1.getDefaultEventQueue; } });
-__exportStar(require("../generated"), exports);
-// Default export
-var client_2 = require("./client");
-Object.defineProperty(exports, "default", { enumerable: true, get: function () { return client_2.SeekoraClient; } });