@launchdarkly/js-client-sdk-common 1.17.2 → 1.18.1

package/dist/cjs/index.cjs

@@ -21,18 +21,17 @@ function _interopNamespaceDefault(e) {
 
 var jsSdkCommon__namespace = /*#__PURE__*/_interopNamespaceDefault(jsSdkCommon);
 
-exports.DataSourceState = void 0;
-(function (DataSourceState) {
-    DataSourceState["Initializing"] = "INITIALIZING";
-    DataSourceState["Valid"] = "VALID";
-    DataSourceState["Interrupted"] = "INTERRUPTED";
-    DataSourceState["SetOffline"] = "SET_OFFLINE";
-    DataSourceState["Closed"] = "CLOSED";
-    // TODO: SDK-702 - Implement network availability behaviors
-    // NetworkUnavailable,
-})(exports.DataSourceState || (exports.DataSourceState = {}));
+// This is a temporary compat for react native. We should remove this once we
+// major version react native SDK.
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+const DataSourceState = {
+    Initializing: 'INITIALIZING',
+    Valid: 'VALID',
+    Interrupted: 'INTERRUPTED',
+    SetOffline: 'SET_OFFLINE',
+    Closed: 'CLOSED',
+};
 
-// eslint-disable-next-line max-classes-per-file
 function isOk(status) {
     return status >= 200 && status <= 299;
 }
@@ -43,38 +42,6 @@ class LDRequestError extends Error {
         this.name = 'LaunchDarklyRequestError';
     }
 }
-/**
- * Note: The requestor is implemented independently from polling such that it can be used to
- * make a one-off request.
- */
-class Requestor {
-    constructor(_requests, _uri, _headers, _method, _body) {
-        this._requests = _requests;
-        this._uri = _uri;
-        this._headers = _headers;
-        this._method = _method;
-        this._body = _body;
-    }
-    async requestPayload() {
-        let status;
-        try {
-            const res = await this._requests.fetch(this._uri, {
-                method: this._method,
-                headers: this._headers,
-                body: this._body,
-            });
-            if (isOk(res.status)) {
-                return await res.text();
-            }
-            // Assigning so it can be thrown after the try/catch.
-            status = res.status;
-        }
-        catch (err) {
-            throw new LDRequestError(err?.message);
-        }
-        throw new LDRequestError(`Unexpected status code: ${status}`, status);
-    }
-}
 function makeRequestor(plainContextString, serviceEndpoints, paths, requests, encoding, baseHeaders, baseQueryParams, withReasons, useReport, secureModeHash) {
     let body;
     let method = 'GET';
@@ -95,7 +62,27 @@ function makeRequestor(plainContextString, serviceEndpoints, paths, requests, en
         parameters.push({ key: 'h', value: secureModeHash });
     }
     const uri = jsSdkCommon.getPollingUri(serviceEndpoints, path, parameters);
-    return new Requestor(requests, uri, headers, method, body);
+    return {
+        async requestPayload() {
+            let status;
+            try {
+                const res = await requests.fetch(uri, {
+                    method,
+                    headers,
+                    body,
+                });
+                if (isOk(res.status)) {
+                    return await res.text();
+                }
+                // Assigning so it can be thrown after the try/catch.
+                status = res.status;
+            }
+            catch (err) {
+                throw new LDRequestError(err?.message);
+            }
+            throw new LDRequestError(`Unexpected status code: ${status}`, status);
+        },
+    };
 }
 
 const duplicateExecutionError = new Error('Task has already been executed or shed. This is likely an implementation error. The task will not be executed again.');
@@ -1339,6 +1326,10 @@ class LDEmitter {
         this._listeners = new Map();
     }
     on(name, listener) {
+        if (typeof name !== 'string') {
+            this._logger?.warn('Only string event names are supported.');
+            return;
+        }
         if (!this._listeners.has(name)) {
             this._listeners.set(name, [listener]);
         }
@@ -1949,117 +1940,135 @@ function safeRegisterDebugOverridePlugins(logger, debugOverride, plugins) {
     });
 }
 
-class DataSourceEventHandler {
-    constructor(_flagManager, _statusManager, _logger) {
-        this._flagManager = _flagManager;
-        this._statusManager = _statusManager;
-        this._logger = _logger;
-    }
-    async handlePut(context, flags) {
-        this._logger.debug(`Got PUT: ${Object.keys(flags)}`);
-        // mapping flags to item descriptors
-        const descriptors = Object.entries(flags).reduce((acc, [key, flag]) => {
-            acc[key] = { version: flag.version, flag };
-            return acc;
-        }, {});
-        await this._flagManager.init(context, descriptors);
-        this._statusManager.requestStateUpdate(exports.DataSourceState.Valid);
-    }
-    async handlePatch(context, patchFlag) {
-        this._logger.debug(`Got PATCH ${JSON.stringify(patchFlag, null, 2)}`);
-        this._flagManager.upsert(context, patchFlag.key, {
-            version: patchFlag.version,
-            flag: patchFlag,
-        });
-    }
-    async handleDelete(context, deleteFlag) {
-        this._logger.debug(`Got DELETE ${JSON.stringify(deleteFlag, null, 2)}`);
-        this._flagManager.upsert(context, deleteFlag.key, {
-            version: deleteFlag.version,
-            flag: {
-                ...deleteFlag,
-                deleted: true,
-                // props below are set to sensible defaults. they are irrelevant
-                // because this flag has been deleted.
-                flagVersion: 0,
-                value: undefined,
-                variation: 0,
-                trackEvents: false,
-            },
-        });
-    }
-    handleStreamingError(error) {
-        this._statusManager.reportError(error.kind, error.message, error.code, error.recoverable);
-    }
-    handlePollingError(error) {
-        this._statusManager.reportError(error.kind, error.message, error.status, error.recoverable);
-    }
+function readFlagsFromBootstrap(logger, data) {
+    // If the bootstrap data came from an older server-side SDK, we'll have just a map of keys to values.
+    // Newer SDKs that have an allFlagsState method will provide an extra "$flagsState" key that contains
+    // the rest of the metadata we want. We do it this way for backward compatibility with older JS SDKs.
+    const keys = Object.keys(data);
+    const metadataKey = '$flagsState';
+    const validKey = '$valid';
+    const metadata = data[metadataKey];
+    if (!metadata && keys.length) {
+        logger.warn('LaunchDarkly client was initialized with bootstrap data that did not include flag' +
+            ' metadata. Events may not be sent correctly.');
+    }
+    if (data[validKey] === false) {
+        logger.warn('LaunchDarkly bootstrap data is not available because the back end could not read the flags.');
+    }
+    const ret = {};
+    keys.forEach((key) => {
+        if (key !== metadataKey && key !== validKey) {
+            let flag;
+            if (metadata && metadata[key]) {
+                flag = {
+                    value: data[key],
+                    ...metadata[key],
+                };
+            }
+            else {
+                flag = {
+                    value: data[key],
+                    version: 0,
+                };
+            }
+            ret[key] = {
+                version: flag.version,
+                flag,
+            };
+        }
+    });
+    return ret;
 }
 
-/**
- * Tracks the current data source status and emits updates when the status changes.
- */
-class DataSourceStatusManager {
-    constructor(_emitter, timeStamper = () => Date.now()) {
-        this._emitter = _emitter;
-        this._state = exports.DataSourceState.Closed;
-        this._stateSinceMillis = timeStamper();
-        this._timeStamper = timeStamper;
-    }
-    get status() {
+function createDataSourceEventHandler(flagManager, statusManager, logger) {
+    return {
+        async handlePut(context, flags) {
+            logger.debug(`Got PUT: ${Object.keys(flags)}`);
+            // mapping flags to item descriptors
+            const descriptors = Object.entries(flags).reduce((acc, [key, flag]) => {
+                acc[key] = { version: flag.version, flag };
+                return acc;
+            }, {});
+            await flagManager.init(context, descriptors);
+            statusManager.requestStateUpdate('VALID');
+        },
+        async handlePatch(context, patchFlag) {
+            logger.debug(`Got PATCH ${JSON.stringify(patchFlag, null, 2)}`);
+            flagManager.upsert(context, patchFlag.key, {
+                version: patchFlag.version,
+                flag: patchFlag,
+            });
+        },
+        async handleDelete(context, deleteFlag) {
+            logger.debug(`Got DELETE ${JSON.stringify(deleteFlag, null, 2)}`);
+            flagManager.upsert(context, deleteFlag.key, {
+                version: deleteFlag.version,
+                flag: {
+                    ...deleteFlag,
+                    deleted: true,
+                    // props below are set to sensible defaults. they are irrelevant
+                    // because this flag has been deleted.
+                    flagVersion: 0,
+                    value: undefined,
+                    variation: 0,
+                    trackEvents: false,
+                },
+            });
+        },
+        handleStreamingError(error) {
+            statusManager.reportError(error.kind, error.message, error.code, error.recoverable);
+        },
+        handlePollingError(error) {
+            statusManager.reportError(error.kind, error.message, error.status, error.recoverable);
+        },
+    };
+}
+
+function createDataSourceStatusManager(emitter, timeStamper = () => Date.now()) {
+    let state = 'CLOSED';
+    let stateSinceMillis = timeStamper();
+    let errorInfo;
+    function getStatus() {
         return {
-            state: this._state,
-            stateSince: this._stateSinceMillis,
-            lastError: this._errorInfo,
+            state,
+            stateSince: stateSinceMillis,
+            lastError: errorInfo,
         };
     }
-    /**
-     * Updates the state of the manager.
-     *
-     * @param requestedState to track
-     * @param isError to indicate that the state update is a result of an error occurring.
-     */
-    _updateState(requestedState, isError = false) {
-        const newState = requestedState === exports.DataSourceState.Interrupted && this._state === exports.DataSourceState.Initializing // don't go to interrupted from initializing (recoverable errors when initializing are not noteworthy)
-            ? exports.DataSourceState.Initializing
+    function updateState(requestedState, isError = false) {
+        const newState = requestedState === 'INTERRUPTED' && state === 'INITIALIZING' // don't go to interrupted from initializing (recoverable errors when initializing are not noteworthy)
+            ? 'INITIALIZING'
             : requestedState;
-        const changedState = this._state !== newState;
+        const changedState = state !== newState;
         if (changedState) {
-            this._state = newState;
-            this._stateSinceMillis = this._timeStamper();
+            state = newState;
+            stateSinceMillis = timeStamper();
         }
         if (changedState || isError) {
-            this._emitter.emit('dataSourceStatus', this.status);
+            emitter.emit('dataSourceStatus', getStatus());
         }
     }
-    /**
-     * Requests the manager move to the provided state.  This request may be ignored
-     * if the current state cannot transition to the requested state.
-     * @param state that is requested
-     */
-    requestStateUpdate(state) {
-        this._updateState(state);
-    }
-    /**
-     * Reports a datasource error to this manager. Since the {@link DataSourceStatus} includes error
-     * information, it is possible that that a {@link DataSourceStatus} update is emitted with
-     * the same {@link DataSourceState}.
-     *
-     * @param kind of the error
-     * @param message for the error
-     * @param statusCode of the error if there was one
-     * @param recoverable to indicate that the error is anticipated to be recoverable
-     */
-    reportError(kind, message, statusCode, recoverable = false) {
-        const errorInfo = {
-            kind,
-            message,
-            statusCode,
-            time: this._timeStamper(),
-        };
-        this._errorInfo = errorInfo;
-        this._updateState(recoverable ? exports.DataSourceState.Interrupted : exports.DataSourceState.Closed, true);
-    }
+    return {
+        get status() {
+            return getStatus();
+        },
+        requestStateUpdate(requestedState) {
+            updateState(requestedState);
+        },
+        reportError(kind, message, statusCode, recoverable = false) {
+            errorInfo = {
+                kind,
+                message,
+                statusCode,
+                time: timeStamper(),
+            };
+            updateState(recoverable ? 'INTERRUPTED' : 'CLOSED', true);
+        },
+        // TODO: SDK-702 - Implement network availability behaviors
+        // setNetworkUnavailable() {
+        //   updateState(DataSourceState.NetworkUnavailable);
+        // },
+    };
 }
 
 function reportClosed(logger) {
@@ -2341,8 +2350,8 @@ class BaseDataManager {
         this.diagnosticsManager = diagnosticsManager;
         this.closed = false;
         this.logger = config.logger;
-        this.dataSourceStatusManager = new DataSourceStatusManager(emitter);
-        this._dataSourceEventHandler = new DataSourceEventHandler(flagManager, this.dataSourceStatusManager, this.config.logger);
+        this.dataSourceStatusManager = createDataSourceStatusManager(emitter);
+        this._dataSourceEventHandler = createDataSourceEventHandler(flagManager, this.dataSourceStatusManager, this.config.logger);
     }
     /**
      * Set additional connection parameters for requests polling/streaming.
@@ -2405,16 +2414,16 @@ class BaseDataManager {
         return {
             start: () => {
                 // update status before starting processor to ensure potential errors are reported after initializing
-                statusManager.requestStateUpdate(exports.DataSourceState.Initializing);
+                statusManager.requestStateUpdate('INITIALIZING');
                 processor.start();
             },
             stop: () => {
                 processor.stop();
-                statusManager.requestStateUpdate(exports.DataSourceState.Closed);
+                statusManager.requestStateUpdate('CLOSED');
             },
             close: () => {
                 processor.close();
-                statusManager.requestStateUpdate(exports.DataSourceState.Closed);
+                statusManager.requestStateUpdate('CLOSED');
             },
         };
     }
@@ -2426,9 +2435,10 @@ class BaseDataManager {
 
 exports.platform = jsSdkCommon__namespace;
 exports.BaseDataManager = BaseDataManager;
+exports.DataSourceState = DataSourceState;
 exports.LDClientImpl = LDClientImpl;
-exports.Requestor = Requestor;
 exports.makeRequestor = makeRequestor;
+exports.readFlagsFromBootstrap = readFlagsFromBootstrap;
 exports.safeRegisterDebugOverridePlugins = safeRegisterDebugOverridePlugins;
 Object.keys(jsSdkCommon).forEach(function (k) {
     if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {