wolves-js-client 1.0.5 → 1.0.7

package/dist/EventLogger.d.ts

@@ -5,10 +5,29 @@ export declare class EventLogger {
     private flushIntervalId;
     private network;
     private maxQueueSize;
-    constructor(network: Network);
+    private sdkKey;
+    constructor(sdkKey: string, network: Network);
+    /**
+     * Safely flush events for a specific sdkKey without throwing.
+     * This is used internally and can be called even after client destruction.
+     */
+    private static safeFlushAndForget;
     enqueue(event: WolvesEvent): void;
     flush(): Promise<void>;
+    /**
+     * Start the event logger and register it in the global map.
+     * This should be called when the client is initialized.
+     * If an existing logger with the same sdkKey exists, it will be flushed first.
+     */
     start(): void;
+    /**
+     * Reset the event queue. Any pending events will be lost.
+     * Called when switching users to clear any user-specific events.
+     */
     reset(): void;
+    /**
+     * Stop the event logger, flush all pending events, and remove from global map.
+     * This ensures all events are sent before the client is destroyed.
+     */
     stop(): Promise<void>;
 }

package/dist/EventLogger.js

@@ -13,20 +13,34 @@ exports.EventLogger = void 0;
 const Log_1 = require("./Log");
 const DEFAULT_QUEUE_SIZE = 100;
 const DEFAULT_FLUSH_INTERVAL_MS = 10000;
+/**
+ * Global map of EventLoggers by sdkKey.
+ * This ensures events can still be sent even after a client is destroyed,
+ * as long as there are pending events in the queue.
+ */
+const EVENT_LOGGER_MAP = {};
 class EventLogger {
-    constructor(network) {
+    constructor(sdkKey, network) {
         this.queue = [];
         this.flushIntervalId = null;
         this.maxQueueSize = DEFAULT_QUEUE_SIZE;
+        this.sdkKey = sdkKey;
         this.network = network;
-        this.start();
+    }
+    /**
+     * Safely flush events for a specific sdkKey without throwing.
+     * This is used internally and can be called even after client destruction.
+     */
+    static safeFlushAndForget(sdkKey) {
+        var _a;
+        (_a = EVENT_LOGGER_MAP[sdkKey]) === null || _a === void 0 ? void 0 : _a.flush().catch(() => {
+            // noop - errors already logged in flush
+        });
     }
     enqueue(event) {
         this.queue.push(event);
         if (this.queue.length >= this.maxQueueSize) {
-            this.flush().catch((e) => {
-                Log_1.Log.error('Failed to flush events', e);
-            });
+            EventLogger.safeFlushAndForget(this.sdkKey);
         }
     }
     flush() {
@@ -50,24 +64,59 @@ class EventLogger {
             }
         });
     }
+    /**
+     * Start the event logger and register it in the global map.
+     * This should be called when the client is initialized.
+     * If an existing logger with the same sdkKey exists, it will be flushed first.
+     */
     start() {
         if (this.flushIntervalId) {
             return;
         }
+        // If there's an existing logger with the same sdkKey, flush it first
+        const existingLogger = EVENT_LOGGER_MAP[this.sdkKey];
+        if (existingLogger && existingLogger !== this) {
+            // Stop the old logger's interval to prevent it from continuing to flush
+            if (existingLogger.flushIntervalId) {
+                clearInterval(existingLogger.flushIntervalId);
+                existingLogger.flushIntervalId = null;
+            }
+            // Flush remaining events from the old logger
+            existingLogger.flush().catch(() => {
+                // noop - errors already logged in flush
+            });
+        }
+        // Register this logger in the global map (replaces any existing)
+        EVENT_LOGGER_MAP[this.sdkKey] = this;
         this.flushIntervalId = setInterval(() => {
-            this.flush();
+            EventLogger.safeFlushAndForget(this.sdkKey);
         }, DEFAULT_FLUSH_INTERVAL_MS);
     }
+    /**
+     * Reset the event queue. Any pending events will be lost.
+     * Called when switching users to clear any user-specific events.
+     */
     reset() {
+        // Attempt to flush any remaining events before resetting
+        this.flush().catch(() => {
+            // noop - we're resetting anyway
+        });
         this.queue = [];
     }
+    /**
+     * Stop the event logger, flush all pending events, and remove from global map.
+     * This ensures all events are sent before the client is destroyed.
+     */
     stop() {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.flushIntervalId) {
                 clearInterval(this.flushIntervalId);
                 this.flushIntervalId = null;
             }
+            // Flush all pending events before stopping
             yield this.flush();
+            // Remove from global map after ensuring all events are sent
+            delete EVENT_LOGGER_MAP[this.sdkKey];
         });
     }
 }

package/dist/Network.d.ts

@@ -1,10 +1,12 @@
 import { WolvesUser } from './WolvesUser';
 export declare const API_LOCAL = "http://localhost:8000/api";
 export declare const API_DEV = "https://wolves-nova-dev.azurewebsites.net/api";
+export declare const API_PROD = "https://wolves-nova.azurewebsites.net/api";
+export type ApiEnvironment = 'local' | 'dev' | 'prod';
 export declare class Network {
     private sdkKey;
     private api;
-    constructor(sdkKey: string, api?: string);
+    constructor(sdkKey: string, apiEnv?: ApiEnvironment);
     fetchConfig(user: WolvesUser, sinceTime?: number, retries?: number, backoff?: number): Promise<any>;
     sendEvents(events: any[], retries?: number, backoff?: number): Promise<void>;
 }

package/dist/Network.js

@@ -9,17 +9,30 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Network = exports.API_DEV = exports.API_LOCAL = void 0;
+exports.Network = exports.API_PROD = exports.API_DEV = exports.API_LOCAL = void 0;
 const Log_1 = require("./Log");
 const WolvesMetadata_1 = require("./WolvesMetadata");
 const RETRYABLE_CODES = [408, 500, 502, 503, 504, 522, 524, 599];
-// API endpoints - switch between local and production
+// API endpoints
 exports.API_LOCAL = 'http://localhost:8000/api';
 exports.API_DEV = 'https://wolves-nova-dev.azurewebsites.net/api';
+exports.API_PROD = 'https://wolves-nova.azurewebsites.net/api';
+const API_ENDPOINTS = {
+    local: exports.API_LOCAL,
+    dev: exports.API_DEV,
+    prod: exports.API_PROD,
+};
+const VALID_ENVIRONMENTS = ['local', 'dev', 'prod'];
+function validateAndGetEndpoint(apiEnv) {
+    if (!VALID_ENVIRONMENTS.includes(apiEnv)) {
+        throw new Error(`Invalid apiEnv: "${apiEnv}". Must be one of: ${VALID_ENVIRONMENTS.join(', ')}`);
+    }
+    return API_ENDPOINTS[apiEnv];
+}
 class Network {
-    constructor(sdkKey, api = exports.API_DEV) {
+    constructor(sdkKey, apiEnv = 'prod') {
         this.sdkKey = sdkKey;
-        this.api = api;
+        this.api = validateAndGetEndpoint(apiEnv);
     }
     fetchConfig(user_1, sinceTime_1) {
         return __awaiter(this, arguments, void 0, function* (user, sinceTime, retries = 2, backoff = 1000) {

package/dist/Store.d.ts

@@ -3,6 +3,9 @@ export type ExperimentConfig = {
     value: Record<string, any>;
     experiment_id?: string;
     group?: string;
+    group_name?: string;
+    is_user_in_experiment?: boolean;
+    is_experiment_active?: boolean;
 };
 export type InitializeResponse = {
     dynamic_configs: Record<string, ExperimentConfig>;

package/dist/Types.d.ts

@@ -17,5 +17,7 @@ export type Experiment = {
     value: Record<string, unknown>;
     experimentID: string;
     groupName: string | null;
+    isExperimentActive: boolean;
+    isUserInExperiment: boolean;
     get: <T>(key: string, defaultValue: T) => T;
 };

package/dist/WolvesClient.d.ts

@@ -23,7 +23,7 @@ export declare class WolvesClient {
     private logger;
     private loadingStatus;
     private initializePromise;
-    constructor(sdkKey: string, user: WolvesUser);
+    constructor(sdkKey: string, user: WolvesUser, apiEnv?: string);
     /**
      * Returns the current loading status of the client.
      */
@@ -105,6 +105,14 @@ export declare class WolvesClient {
      */
     getExperimentForTest(experimentName: string, groupName: string): Experiment;
     logEvent(eventName: string, value?: string | number, metadata?: Record<string, string>): void;
+    /**
+     * Manually flush all pending events to the server.
+     * This is useful when you want to ensure events are sent immediately,
+     * such as before navigating away from a page.
+     *
+     * @returns Promise that resolves when all events have been sent
+     */
+    flush(): Promise<void>;
     shutdown(): Promise<void>;
     private logExposure;
 }

package/dist/WolvesClient.js

@@ -22,14 +22,14 @@ function createUpdateDetails(success, source, duration, error, warnings = []) {
     return { success, source, duration, error, warnings };
 }
 class WolvesClient {
-    constructor(sdkKey, user) {
+    constructor(sdkKey, user, apiEnv = 'prod') {
         this.loadingStatus = 'Uninitialized';
         this.initializePromise = null;
         this.sdkKey = sdkKey;
         this.user = user;
-        this.network = new Network_1.Network(sdkKey);
+        this.network = new Network_1.Network(sdkKey, apiEnv);
         this.store = new Store_1.Store(sdkKey);
-        this.logger = new EventLogger_1.EventLogger(this.network);
+        this.logger = new EventLogger_1.EventLogger(sdkKey, this.network);
     }
     /**
      * Returns the current loading status of the client.
@@ -267,13 +267,23 @@ class WolvesClient {
         this.user = user;
     }
     getExperiment(experimentName) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e;
         const { config, details } = this.store.getExperiment(experimentName);
+        // Check if experiment is in prestart state (setup status on server)
+        const isExperimentActive = (_a = config === null || config === void 0 ? void 0 : config.is_experiment_active) !== null && _a !== void 0 ? _a : true;
+        const isUserInExperiment = (_b = config === null || config === void 0 ? void 0 : config.is_user_in_experiment) !== null && _b !== void 0 ? _b : true;
+        const isPrestart = !isExperimentActive && (config === null || config === void 0 ? void 0 : config.group) === 'prestart';
+        // For prestart experiments, log the prestart state
+        if (isPrestart) {
+            Log_1.Log.info(`Experiment "${experimentName}" is in prestart state`);
+        }
         const experiment = {
             name: experimentName,
-            value: (_a = config === null || config === void 0 ? void 0 : config.value) !== null && _a !== void 0 ? _a : {},
-            experimentID: (_b = config === null || config === void 0 ? void 0 : config.experiment_id) !== null && _b !== void 0 ? _b : '',
-            groupName: (_c = config === null || config === void 0 ? void 0 : config.group) !== null && _c !== void 0 ? _c : null,
+            value: (_c = config === null || config === void 0 ? void 0 : config.value) !== null && _c !== void 0 ? _c : {},
+            experimentID: (_d = config === null || config === void 0 ? void 0 : config.experiment_id) !== null && _d !== void 0 ? _d : '',
+            groupName: (_e = config === null || config === void 0 ? void 0 : config.group) !== null && _e !== void 0 ? _e : null,
+            isExperimentActive,
+            isUserInExperiment,
             get: (key, defaultValue) => {
                 var _a;
                 const val = (_a = config === null || config === void 0 ? void 0 : config.value) === null || _a === void 0 ? void 0 : _a[key];
@@ -293,20 +303,28 @@ class WolvesClient {
      * The experiment ID is retrieved from the store config.
      */
     getExperimentForTest(experimentName, groupName) {
-        var _a;
+        var _a, _b, _c;
         const { config, details } = this.store.getExperiment(experimentName);
         const experimentId = (_a = config === null || config === void 0 ? void 0 : config.experiment_id) !== null && _a !== void 0 ? _a : '';
+        const isExperimentActive = (_b = config === null || config === void 0 ? void 0 : config.is_experiment_active) !== null && _b !== void 0 ? _b : true;
+        const isUserInExperiment = (_c = config === null || config === void 0 ? void 0 : config.is_user_in_experiment) !== null && _c !== void 0 ? _c : true;
         const experiment = {
             name: experimentName,
             value: {},
             experimentID: experimentId,
             groupName: groupName,
+            isExperimentActive,
+            isUserInExperiment,
             get: (_key, defaultValue) => {
                 return defaultValue;
             }
         };
         // Log exposure with the specified group and experiment ID from store
-        this.logExposure(experimentName, { group: groupName, experiment_id: experimentId, value: {} }, details);
+        this.logExposure(experimentName, {
+            group: groupName,
+            experiment_id: experimentId,
+            value: {}
+        }, details);
         return experiment;
     }
     logEvent(eventName, value, metadata) {
@@ -319,6 +337,18 @@ class WolvesClient {
         };
         this.logger.enqueue(event);
     }
+    /**
+     * Manually flush all pending events to the server.
+     * This is useful when you want to ensure events are sent immediately,
+     * such as before navigating away from a page.
+     *
+     * @returns Promise that resolves when all events have been sent
+     */
+    flush() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.logger.flush();
+        });
+    }
     shutdown() {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.logger.stop();

package/dist/WolvesMetadata.d.ts

@@ -1,4 +1,4 @@
-export declare const SDK_VERSION = "1.0.5";
+export declare const SDK_VERSION = "1.0.7";
 export declare const SDK_TYPE = "wolves-js-client";
 export type WolvesMetadata = {
     readonly [key: string]: string | undefined | null;

package/dist/WolvesMetadata.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WolvesMetadataProvider = exports.SDK_TYPE = exports.SDK_VERSION = void 0;
-exports.SDK_VERSION = '1.0.5';
+exports.SDK_VERSION = '1.0.7';
 exports.SDK_TYPE = 'wolves-js-client';
 let metadata = {
     sdk_version: exports.SDK_VERSION,

package/dist/index.d.ts

@@ -8,3 +8,4 @@ export type { WolvesMetadata } from './WolvesMetadata';
 export { Storage } from './StorageProvider';
 export type { StorageProvider } from './StorageProvider';
 export type { DataSource, DataAdapterResult } from './Store';
+export type { ApiEnvironment } from './Network';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wolves-js-client",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "A Wolves JavaScript Client SDK",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",