@depup/launchdarkly-node-server-sdk 7.0.4-depup.0

package/feature_store_event_wrapper.js

@@ -0,0 +1,258 @@
+const dataKind = require('./versioned_data_kind');
+
+function NamespacedDataSet() {
+  let itemsByNamespace = {};
+
+  function get(namespace, key) {
+    const items = itemsByNamespace[namespace];
+    return items && items[key];
+  }
+
+  function set(namespace, key, value) {
+    let items = itemsByNamespace[namespace];
+    if (!items) {
+      items = {};
+      itemsByNamespace[namespace] = items;
+    }
+    items[key] = value;
+  }
+
+  function remove(namespace, key) {
+    const items = itemsByNamespace[namespace];
+    if (items) {
+      delete items[key];
+    }
+  }
+
+  function removeAll() {
+    itemsByNamespace = {};
+  }
+
+  function enumerate(callback) {
+    for (const [ns, items] of Object.entries(itemsByNamespace)) {
+      const keys = Object.keys(items).sort(); // sort to make tests determinate
+      for (const key of keys) {
+        callback(ns, key, items[key]);
+      }
+    }
+  }
+
+  function mergeFrom(otherSet) {
+    otherSet.enumerate(set);
+  }
+
+  return {
+    get: get,
+    set: set,
+    remove: remove,
+    removeAll: removeAll,
+    enumerate: enumerate,
+    mergeFrom: mergeFrom,
+    toString: () => JSON.stringify(itemsByNamespace),
+  };
+}
+
+function DependencyTracker() {
+  const dependenciesFrom = NamespacedDataSet();
+  const dependenciesTo = NamespacedDataSet();
+  // dependenciesFrom: for a given flag/segment key, what are the flags/segments it relies on
+  // dependenciesTo: for a given flag/segment key, what are the flags/segments that rely on it
+
+  function updateDependenciesFrom(namespace, key, newDependencySet) {
+    const oldDependencySet = dependenciesFrom.get(namespace, key);
+    oldDependencySet &&
+      oldDependencySet.enumerate((depNs, depKey) => {
+        const depsToThisDep = dependenciesTo.get(depNs, depKey);
+        depsToThisDep && depsToThisDep.remove(namespace, key);
+      });
+
+    dependenciesFrom.set(namespace, key, newDependencySet);
+    newDependencySet &&
+      newDependencySet.enumerate((depNs, depKey) => {
+        let depsToThisDep = dependenciesTo.get(depNs, depKey);
+        if (!depsToThisDep) {
+          depsToThisDep = NamespacedDataSet();
+          dependenciesTo.set(depNs, depKey, depsToThisDep);
+        }
+        depsToThisDep.set(namespace, key, true);
+      });
+  }
+
+  function updateModifiedItems(inDependencySet, modifiedNamespace, modifiedKey) {
+    if (!inDependencySet.get(modifiedNamespace, modifiedKey)) {
+      inDependencySet.set(modifiedNamespace, modifiedKey, true);
+      const affectedItems = dependenciesTo.get(modifiedNamespace, modifiedKey);
+      affectedItems &&
+        affectedItems.enumerate((ns, key) => {
+          updateModifiedItems(inDependencySet, ns, key);
+        });
+    }
+  }
+
+  function reset() {
+    dependenciesFrom.removeAll();
+    dependenciesTo.removeAll();
+  }
+
+  return {
+    updateDependenciesFrom: updateDependenciesFrom,
+    updateModifiedItems: updateModifiedItems,
+    reset: reset,
+  };
+}
+
+function FeatureStoreEventWrapper(featureStore, emitter) {
+  const dependencyTracker = DependencyTracker();
+
+  function hasEventListeners() {
+    // Before we do something that could generate a change event, we'll check whether anyone is
+    // currently listening for such events. If they're not, then we can skip the whole "query the
+    // old data so we can compare it to the new data and see if there was a change" step, which
+    // could be expensive with a persistent feature store.
+    return emitter.eventNames().some(name => name === 'update' || name.substring(0, 7) === 'update:'); // Node 6 may not have startsWith()
+  }
+
+  function addIfModified(namespace, key, oldValue, newValue, toDataSet) {
+    if (newValue && oldValue && newValue.version <= oldValue.version) {
+      return;
+    }
+    dependencyTracker.updateModifiedItems(toDataSet, namespace, key);
+  }
+
+  function sendChangeEvents(dataSet) {
+    dataSet.enumerate((namespace, key) => {
+      if (namespace === dataKind.features.namespace) {
+        const arg = { key: key };
+        setImmediate(() => {
+          emitter.emit('update', arg);
+        });
+        setImmediate(() => {
+          emitter.emit(`update:${key}`, arg);
+        });
+      }
+    });
+  }
+
+  function computeDependencies(kind, item) {
+    const ret = NamespacedDataSet();
+    if (kind === dataKind.features) {
+      for (const prereq of item.prerequisites || []) {
+        ret.set(dataKind.features.namespace, prereq.key, true);
+      }
+    }
+
+    if (kind === dataKind.features || kind === dataKind.segments) {
+      for (const rule of item.rules || []) {
+        for (const clause of rule.clauses || []) {
+          if (clause.op === 'segmentMatch') {
+            for (const value of clause.values) {
+              ret.set(dataKind.segments.namespace, value, true);
+            }
+          }
+        }
+      }
+    }
+    return ret;
+  }
+
+  return {
+    get: featureStore.get.bind(featureStore),
+    all: featureStore.all.bind(featureStore),
+    initialized: featureStore.initialized.bind(featureStore),
+    close: featureStore.close.bind(featureStore),
+
+    init: (newData, callback) => {
+      const checkForChanges = hasEventListeners();
+      const doInit = oldData => {
+        featureStore.init(newData, () => {
+          dependencyTracker.reset();
+
+          for (const [namespace, items] of Object.entries(newData)) {
+            const kind = dataKind[namespace];
+            for (const key of Object.keys(items || {})) {
+              const item = items[key];
+              dependencyTracker.updateDependenciesFrom(namespace, key, computeDependencies(kind, item));
+            }
+          }
+
+          if (checkForChanges) {
+            const updatedItems = NamespacedDataSet();
+            for (const namespace of Object.keys(newData)) {
+              const oldDataForKind = oldData[namespace];
+              const newDataForKind = newData[namespace];
+              const mergedData = Object.assign({}, oldDataForKind, newDataForKind);
+              for (const key of Object.keys(mergedData)) {
+                addIfModified(
+                  namespace,
+                  key,
+                  oldDataForKind && oldDataForKind[key],
+                  newDataForKind && newDataForKind[key],
+                  updatedItems
+                );
+              }
+            }
+            sendChangeEvents(updatedItems);
+          }
+
+          callback && callback();
+        });
+      };
+
+      if (checkForChanges) {
+        featureStore.all(dataKind.features, oldFlags => {
+          featureStore.all(dataKind.segments, oldSegments => {
+            const oldData = {};
+            oldData[dataKind.features.namespace] = oldFlags;
+            oldData[dataKind.segments.namespace] = oldSegments;
+            doInit(oldData);
+          });
+        });
+      } else {
+        doInit();
+      }
+    },
+
+    delete: (kind, key, version, callback) => {
+      const checkForChanges = hasEventListeners();
+      const doDelete = oldItem => {
+        featureStore.delete(kind, key, version, () => {
+          dependencyTracker.updateDependenciesFrom(kind.namespace, key, null);
+          if (checkForChanges) {
+            const updatedItems = NamespacedDataSet();
+            addIfModified(kind.namespace, key, oldItem, { version: version, deleted: true }, updatedItems);
+            sendChangeEvents(updatedItems);
+          }
+          callback && callback();
+        });
+      };
+      if (checkForChanges) {
+        featureStore.get(kind, key, doDelete);
+      } else {
+        doDelete();
+      }
+    },
+
+    upsert: (kind, newItem, callback) => {
+      const key = newItem.key;
+      const checkForChanges = hasEventListeners();
+      const doUpsert = oldItem => {
+        featureStore.upsert(kind, newItem, () => {
+          dependencyTracker.updateDependenciesFrom(kind.namespace, key, computeDependencies(kind, newItem));
+          if (checkForChanges) {
+            const updatedItems = NamespacedDataSet();
+            addIfModified(kind.namespace, key, oldItem, newItem, updatedItems);
+            sendChangeEvents(updatedItems);
+          }
+          callback && callback();
+        });
+      };
+      if (checkForChanges) {
+        featureStore.get(kind, key, doUpsert);
+      } else {
+        doUpsert();
+      }
+    },
+  };
+}
+
+module.exports = FeatureStoreEventWrapper;

package/file_data_source.js

@@ -0,0 +1,192 @@
+const fs = require('fs'),
+  dataKind = require('./versioned_data_kind'),
+  loggers = require('./loggers');
+
+let yamlAvailable;
+let yamlParser;
+
+/*
+  FileDataSource provides a way to use local files as a source of feature flag state, instead of
+  connecting to LaunchDarkly. This would typically be used in a test environment.
+
+  See documentation in index.d.ts.
+*/
+function FileDataSource(options) {
+  if (yamlAvailable === undefined) {
+    try {
+      const yaml = require('yaml');
+      yamlAvailable = true;
+      yamlParser = yaml.parse;
+    } catch (err) {
+      yamlAvailable = false;
+    }
+  }
+  // If the yaml package is available, we can use its parser for all files because
+  // every valid JSON document is also a valid YAML document.
+  const parseData = yamlAvailable ? yamlParser : JSON.parse;
+
+  const paths = (options && options.paths) || [];
+  const autoUpdate = !!options.autoUpdate;
+
+  return config => {
+    const logger = options.logger || config.logger || loggers.nullLogger();
+    const featureStore = config.featureStore;
+    const timestamps = {};
+    let watchers = [];
+    let pendingUpdate = false;
+    let inited = false;
+
+    function getFileTimestampPromise(path) {
+      return new Promise((resolve, reject) => {
+        fs.stat(path, (err, stat) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve(stat.mtimeMs || stat.mtime); // mtimeMs isn't always available; either of these values will work for  us
+          }
+        });
+      });
+    }
+
+    function loadFilePromise(path, allDataIn) {
+      const allData = allDataIn;
+      return new Promise((resolve, reject) =>
+        fs.readFile(path, 'utf8', (err, data) => (err ? reject(err) : resolve(data)))
+      )
+        .then(data => {
+          const parsed = parseData(data) || {};
+          const addItem = (kind, item) => {
+            if (!allData[kind.namespace]) {
+              allData[kind.namespace] = {};
+            }
+            if (allData[kind.namespace][item.key]) {
+              throw new Error('found duplicate key: "' + item.key + '"');
+            } else {
+              allData[kind.namespace][item.key] = item;
+            }
+          };
+          Object.keys(parsed.flags || {}).forEach(key => {
+            addItem(dataKind.features, parsed.flags[key]);
+          });
+          Object.keys(parsed.flagValues || {}).forEach(key => {
+            addItem(dataKind.features, makeFlagWithValue(key, parsed.flagValues[key]));
+          });
+          Object.keys(parsed.segments || {}).forEach(key => {
+            addItem(dataKind.segments, parsed.segments[key]);
+          });
+          logger.info('Loaded flags from ' + path);
+        })
+        .then(() => getFileTimestampPromise(path))
+        .then(timestamp => {
+          timestamps[path] = timestamp;
+        });
+    }
+
+    function loadAllPromise() {
+      pendingUpdate = false;
+      const allData = {};
+      let p = Promise.resolve();
+      for (let i = 0; i < paths.length; i++) {
+        (path => {
+          p = p
+            .then(() => loadFilePromise(path, allData))
+            .catch(e => {
+              throw new Error('Unable to load flags: ' + e + ' [' + path + ']');
+            });
+        })(paths[i]);
+      }
+      return p.then(() => initStorePromise(allData));
+    }
+
+    function initStorePromise(data) {
+      return new Promise(resolve =>
+        featureStore.init(data, () => {
+          inited = true;
+          resolve();
+        })
+      );
+    }
+
+    function makeFlagWithValue(key, value) {
+      return {
+        key: key,
+        on: true,
+        fallthrough: { variation: 0 },
+        variations: [value],
+      };
+    }
+
+    function maybeReloadForPath(path) {
+      if (pendingUpdate) {
+        return; // coalesce updates so we don't do multiple reloads if a whole set of files was just updated
+      }
+      const reload = () => {
+        loadAllPromise()
+          .then(() => {
+            logger.warn('Reloaded flags from file data');
+          })
+          .catch(() => {});
+      };
+      getFileTimestampPromise(path)
+        .then(timestamp => {
+          // We do this check of the modified time because there's a known issue with fs.watch()
+          // reporting multiple changes when really the file has only changed once.
+          if (timestamp !== timestamps[path]) {
+            pendingUpdate = true;
+            setTimeout(reload, 10);
+            // The 10ms delay above is arbitrary - we just don't want to have the number be zero,
+            // because in a case where multiple fs.watch events are fired off one after another,
+            // we want the reload to happen only after all of the event handlers have executed.
+          }
+        })
+        .catch(() => {
+          logger.warn('Unexpected error trying to get timestamp of file: ' + path);
+        });
+    }
+
+    function startWatching() {
+      paths.forEach(path => {
+        const watcher = fs.watch(path, { persistent: false }, () => {
+          maybeReloadForPath(path);
+        });
+        watchers.push(watcher);
+      });
+    }
+
+    function stopWatching() {
+      watchers.forEach(w => w.close());
+      watchers = [];
+    }
+
+    const fds = {};
+
+    fds.start = fn => {
+      const cb = fn || (() => {});
+
+      if (autoUpdate) {
+        startWatching();
+      }
+
+      loadAllPromise().then(
+        () => cb(),
+        err => cb(err)
+      );
+    };
+
+    fds.stop = () => {
+      if (autoUpdate) {
+        stopWatching();
+      }
+    };
+
+    fds.initialized = () => inited;
+
+    fds.close = () => {
+      fds.stop();
+    };
+
+    return fds;
+  };
+}
+
+module.exports = FileDataSource;

package/flags_state.js

@@ -0,0 +1,46 @@
+function FlagsStateBuilder(valid, withReasons) {
+  const builder = {};
+  const flagValues = {};
+  const flagMetadata = {};
+
+  builder.addFlag = (flag, value, variation, reason, trackEvents, trackReason, detailsOnlyIfTracked) => {
+    flagValues[flag.key] = value;
+    const meta = {};
+    if (variation !== undefined && variation !== null) {
+      meta.variation = variation;
+    }
+    const omitDetails =
+      detailsOnlyIfTracked &&
+      !trackEvents &&
+      !trackReason &&
+      (flag.debugEventsUntilDate === undefined || flag.debugEventsUntilDate === null);
+    if (!omitDetails) {
+      meta.version = flag.version;
+    }
+    if (reason && (trackReason || (withReasons && !omitDetails))) {
+      meta.reason = reason;
+    }
+    if (trackEvents) {
+      meta.trackEvents = true;
+    }
+    if (trackReason) {
+      meta.trackReason = true;
+    }
+    if (flag.debugEventsUntilDate !== undefined && flag.debugEventsUntilDate !== null) {
+      meta.debugEventsUntilDate = flag.debugEventsUntilDate;
+    }
+    flagMetadata[flag.key] = meta;
+  };
+
+  builder.build = () => ({
+    valid: valid,
+    allValues: () => flagValues,
+    getFlagValue: key => flagValues[key],
+    getFlagReason: key => (flagMetadata[key] ? flagMetadata[key].reason : null),
+    toJSON: () => Object.assign({}, flagValues, { $flagsState: flagMetadata, $valid: valid }),
+  });
+
+  return builder;
+}
+
+module.exports = FlagsStateBuilder;