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

package/test_data.js

@@ -0,0 +1,323 @@
+const dataKind = require('./versioned_data_kind');
+const { promisify } = require('util');
+
+function TestData() {
+  const existingFlagBuilders = {};
+  const currentFlags = {};
+  const currentSegments = {};
+  const dataSourceImpls = [];
+
+  function makeInitData() {
+    return {
+      [dataKind.features.namespace]: { ...currentFlags },
+      [dataKind.segments.namespace]: { ...currentSegments },
+    };
+  }
+
+  const td = config => {
+    const featureStore = config.featureStore;
+
+    const tds = {
+      start: start,
+      stop: stop,
+      initialized: () => true,
+      close: stop,
+      upsert: upsert,
+    };
+
+    function start(cb = () => {}) {
+      featureStore.init(makeInitData(), cb);
+    }
+
+    function stop() {
+      dataSourceImpls.splice(dataSourceImpls.indexOf(this));
+    }
+
+    function upsert(kind, value, cb = () => {}) {
+      featureStore.upsert(kind, value, cb);
+    }
+
+    dataSourceImpls.push(tds);
+
+    return tds;
+  };
+
+  td.flag = flagName => {
+    if (existingFlagBuilders[flagName]) {
+      return existingFlagBuilders[flagName].copy();
+    } else {
+      return new TestDataFlagBuilder(flagName).booleanFlag();
+    }
+  };
+
+  td.update = flagBuilder => {
+    const oldItem = currentFlags[flagBuilder._key];
+    const oldVersion = oldItem ? oldItem.version : 0;
+    const newFlag = flagBuilder.build(oldVersion + 1);
+    currentFlags[flagBuilder._key] = newFlag;
+    existingFlagBuilders[flagBuilder._key] = flagBuilder.copy();
+
+    return Promise.all(dataSourceImpls.map(impl => promisify(impl.upsert)(dataKind.features, newFlag)));
+  };
+
+  function usePreconfiguredItem(kind, item, current) {
+    const oldItem = current[item.key];
+    const newItem = { ...item, version: oldItem ? oldItem.version + 1 : item.version };
+    /* eslint-disable no-param-reassign */
+    current[item.key] = newItem;
+    /* eslint-enable no-param-reassign */
+
+    return Promise.all(dataSourceImpls.map(impl => promisify(impl.upsert)(kind, newItem)));
+  }
+
+  td.usePreconfiguredFlag = flag => usePreconfiguredItem(dataKind.features, flag, currentFlags);
+
+  td.usePreconfiguredSegment = segment => usePreconfiguredItem(dataKind.segments, segment, currentSegments);
+
+  return td;
+}
+
+function TestDataFlagBuilder(flagName) {
+  this._key = flagName;
+  this._on = true;
+  this._variations = [];
+}
+
+const TRUE_VARIATION_INDEX = 0;
+const FALSE_VARIATION_INDEX = 1;
+
+function variationForBoolean(aBool) {
+  return aBool ? TRUE_VARIATION_INDEX : FALSE_VARIATION_INDEX;
+}
+
+TestDataFlagBuilder.prototype.copy = function () {
+  const to = new TestDataFlagBuilder(this._key);
+  to._variations = [...this._variations];
+  to._offVariation = this._offVariation;
+  to._on = this._on;
+  to._fallthroughVariation = this._fallthroughVariation;
+  to._targetsByVariation = !this._targetsByVariation ? null : new Map(this._targetsByVariation);
+  to._rules = !this._rules ? null : this._rules.map(r => r.copy(this));
+  return to;
+};
+
+TestDataFlagBuilder.prototype.isBooleanFlag = function () {
+  return (
+    this._variations.length === 2 &&
+    this._variations[TRUE_VARIATION_INDEX] === true &&
+    this._variations[FALSE_VARIATION_INDEX] === false
+  );
+};
+
+TestDataFlagBuilder.prototype.booleanFlag = function () {
+  if (this.isBooleanFlag()) {
+    return this;
+  } else {
+    return this.variations(true, false).fallthroughVariation(TRUE_VARIATION_INDEX).offVariation(FALSE_VARIATION_INDEX);
+  }
+};
+
+TestDataFlagBuilder.prototype.on = function (aBool) {
+  this._on = aBool;
+  return this;
+};
+
+TestDataFlagBuilder.prototype.fallthroughVariation = function (variation) {
+  if (typeof variation === 'boolean') {
+    this.booleanFlag().fallthroughVariation(variationForBoolean(variation));
+  } else {
+    this._fallthroughVariation = variation;
+  }
+  return this;
+};
+
+TestDataFlagBuilder.prototype.offVariation = function (variation) {
+  if (typeof variation === 'boolean') {
+    this.booleanFlag().offVariation(variationForBoolean(variation));
+  } else {
+    this._offVariation = variation;
+  }
+  return this;
+};
+
+TestDataFlagBuilder.prototype.variations = function (...values) {
+  this._variations = [...values];
+  return this;
+};
+
+TestDataFlagBuilder.prototype.clearAllTargets = function () {
+  this._targetsByVariation = null;
+  return this;
+};
+
+TestDataFlagBuilder.prototype.clearRules = function () {
+  this._rules = null;
+  return this;
+};
+
+TestDataFlagBuilder.prototype.variationForAll = function (variation) {
+  return this.on(true).clearRules().clearAllTargets().fallthroughVariation(variation);
+};
+
+TestDataFlagBuilder.prototype.valueForAll = function (value) {
+  return this.variations(value).variationForAll(0);
+};
+
+TestDataFlagBuilder.prototype.variationForContext = function (contextKind, contextKey, variation) {
+  if (typeof variation === 'boolean') {
+    return this.booleanFlag().variationForContext(contextKind, contextKey, variationForBoolean(variation));
+  }
+
+  if (!this._targetsByVariation) {
+    this._targetsByVariation = new Map();
+  }
+
+  this._variations.forEach((_, i) => {
+    if (i === variation) {
+      //If there is nothing set at the current variation then set it to the empty array
+      const targetsForVariation = this._targetsByVariation.get(i) || new Map();
+
+      if (!targetsForVariation.has(contextKind)) {
+        targetsForVariation.set(contextKind, []);
+      }
+      const exists = targetsForVariation.get(contextKind).indexOf(contextKey) !== -1;
+      // Add context to current variation set if they arent already there
+      if (!exists) {
+        targetsForVariation.get(contextKind).push(contextKey);
+      }
+
+      this._targetsByVariation.set(i, targetsForVariation);
+    } else {
+      // remove user from other variation set if necessary
+      const targetsForVariation = this._targetsByVariation.get(i);
+      if (targetsForVariation) {
+        const targetsForContextKind = targetsForVariation.get(contextKind);
+        if (targetsForContextKind) {
+          const targetIndex = targetsForContextKind.indexOf(contextKey);
+          if (targetIndex !== -1) {
+            targetsForContextKind.splice(targetIndex, 1);
+            if (!targetsForContextKind.length) {
+              targetsForVariation.delete(contextKind);
+            }
+          }
+        }
+        if (!targetsForVariation.size) {
+          this._targetsByVariation.delete(i);
+        }
+      }
+    }
+  });
+
+  return this;
+};
+
+TestDataFlagBuilder.prototype.variationForUser = function (key, variation) {
+  return this.variationForContext('user', key, variation);
+};
+
+TestDataFlagBuilder.prototype.addRule = function (flagRuleBuilder) {
+  if (!this._rules) {
+    this._rules = [];
+  }
+  this._rules.push(flagRuleBuilder);
+};
+
+TestDataFlagBuilder.prototype.ifMatch = function (contextKind, attribute, ...values) {
+  const flagRuleBuilder = new TestDataRuleBuilder(this);
+  return flagRuleBuilder.andMatch(contextKind, attribute, ...values);
+};
+
+TestDataFlagBuilder.prototype.ifNotMatch = function (contextKind, attribute, ...values) {
+  const flagRuleBuilder = new TestDataRuleBuilder(this);
+  return flagRuleBuilder.andNotMatch(contextKind, attribute, ...values);
+};
+
+TestDataFlagBuilder.prototype.build = function (version) {
+  const baseFlagObject = {
+    key: this._key,
+    version: version,
+    on: this._on,
+    offVariation: this._offVariation,
+    fallthrough: {
+      variation: this._fallthroughVariation,
+    },
+    variations: [...this._variations],
+  };
+
+  if (this._targetsByVariation) {
+    const contextTargets = [];
+    for (const [variation, contextTargetsForVariation] of this._targetsByVariation) {
+      for (const [contextKind, values] of contextTargetsForVariation) {
+        contextTargets.push({
+          contextKind,
+          values,
+          variation,
+        });
+      }
+    }
+    baseFlagObject.contextTargets = contextTargets;
+  }
+
+  if (this._rules) {
+    baseFlagObject.rules = this._rules.map((rule, i) => rule.build(i));
+  }
+
+  return baseFlagObject;
+};
+
+/* TestDataRuleBuilder */
+function TestDataRuleBuilder(flagBuilder) {
+  this._flagBuilder = flagBuilder;
+  this._clauses = [];
+  this._variation = null;
+}
+
+TestDataRuleBuilder.prototype.andMatch = function (contextKind, attribute, ...values) {
+  this._clauses.push({
+    contextKind,
+    attribute: attribute,
+    op: 'in',
+    values: values,
+    negate: false,
+  });
+  return this;
+};
+
+TestDataRuleBuilder.prototype.andNotMatch = function (contextKind, attribute, ...values) {
+  this._clauses.push({
+    contextKind,
+    attribute: attribute,
+    op: 'in',
+    values: values,
+    negate: true,
+  });
+  return this;
+};
+
+TestDataRuleBuilder.prototype.thenReturn = function (variation) {
+  if (typeof variation === 'boolean') {
+    this._flagBuilder.booleanFlag();
+    return this.thenReturn(variationForBoolean(variation));
+  }
+
+  this._variation = variation;
+  this._flagBuilder.addRule(this);
+  return this._flagBuilder;
+};
+
+TestDataRuleBuilder.prototype.build = function (id) {
+  return {
+    id: 'rule' + id,
+    variation: this._variation,
+    clauses: this._clauses,
+  };
+};
+
+TestDataRuleBuilder.prototype.copy = function (flagBuilder) {
+  const flagRuleBuilder = new TestDataRuleBuilder(flagBuilder);
+  flagRuleBuilder._clauses = JSON.parse(JSON.stringify(this._clauses));
+  flagRuleBuilder._variation = JSON.parse(JSON.stringify(this._variation));
+  return flagRuleBuilder;
+};
+
+module.exports = TestData;

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "strict": true,
+    "lib": [
+      "dom",
+      "es6"
+    ]
+  },
+  "files": [
+    "index.d.ts",
+    "test-types.ts"
+  ]
+}

package/update_queue.js

@@ -0,0 +1,28 @@
+function UpdateQueue() {
+  const updateQueue = [];
+  this.enqueue = (updateFn, fnArgs, cb) => {
+    updateQueue.push([updateFn, fnArgs, cb]);
+    if (updateQueue.length === 1) {
+      // if nothing else is in progress, we can start this one right away
+      executePendingUpdates();
+    }
+  };
+  function executePendingUpdates() {
+    if (updateQueue.length > 0) {
+      const entry = updateQueue[0];
+      const fn = entry[0];
+      const args = entry[1];
+      const cb = entry[2];
+      const newCb = () => {
+        updateQueue.shift();
+        if (updateQueue.length > 0) {
+          setImmediate(executePendingUpdates);
+        }
+        cb && cb();
+      };
+      fn.apply(null, args.concat([newCb]));
+    }
+  }
+}
+
+module.exports = UpdateQueue;

package/utils/__tests__/httpUtils-test.js

@@ -0,0 +1,39 @@
+const httpUtils = require('../httpUtils');
+const packageJson = require('../../package.json');
+
+it('sets SDK key', () => {
+  const h = httpUtils.getDefaultHeaders('my-sdk-key', {});
+  expect(h).toMatchObject({ authorization: 'my-sdk-key' });
+});
+
+it('sets user agent', () => {
+  const h = httpUtils.getDefaultHeaders('my-sdk-key', {});
+  expect(h).toMatchObject({ 'user-agent': 'NodeJSClient/' + packageJson.version });
+});
+
+it('does not include wrapper header by default', () => {
+  const h = httpUtils.getDefaultHeaders('my-sdk-key', {});
+  expect(h['x-launchdarkly-wrapper']).toBeUndefined();
+});
+
+it('sets wrapper header with name only', () => {
+  const h = httpUtils.getDefaultHeaders('my-sdk-key', { wrapperName: 'my-wrapper' });
+  expect(h).toMatchObject({ 'x-launchdarkly-wrapper': 'my-wrapper' });
+});
+
+it('sets wrapper header with name and version', () => {
+  const h = httpUtils.getDefaultHeaders('my-sdk-key', { wrapperName: 'my-wrapper', wrapperVersion: '2.0' });
+  expect(h).toMatchObject({ 'x-launchdarkly-wrapper': 'my-wrapper/2.0' });
+});
+
+it('sets the X-LaunchDarkly-Tags header with valid tags.', () => {
+  const h = httpUtils.getDefaultHeaders('my-sdk-key', {
+    application: {
+      id: 'test-application',
+      version: 'test-version',
+    },
+  });
+  expect(h).toMatchObject({
+    'x-launchdarkly-tags': 'application-id/test-application application-version/test-version',
+  });
+});

package/utils/__tests__/wrapPromiseCallback-test.js

@@ -0,0 +1,33 @@
+const wrapPromiseCallback = require('../wrapPromiseCallback');
+
+describe('wrapPromiseCallback', () => {
+  it('should resolve to the value', () => {
+    const promise = wrapPromiseCallback(Promise.resolve('woohoo'));
+    return expect(promise).resolves.toBe('woohoo');
+  });
+
+  it('should reject with the error', () => {
+    const error = new Error('something went wrong');
+    const promise = wrapPromiseCallback(Promise.reject(error));
+    return expect(promise).rejects.toBe(error);
+  });
+
+  it('should call the callback with a value if the promise resolves', done => {
+    const promise = wrapPromiseCallback(Promise.resolve('woohoo'), (error, value) => {
+      expect(promise).toBeUndefined();
+      expect(error).toBeNull();
+      expect(value).toBe('woohoo');
+      done();
+    });
+  });
+
+  it('should call the callback with an error if the promise rejects', done => {
+    const actualError = new Error('something went wrong');
+    const promise = wrapPromiseCallback(Promise.reject(actualError), (error, value) => {
+      expect(promise).toBeUndefined();
+      expect(error).toBe(actualError);
+      expect(value).toBeNull();
+      done();
+    });
+  });
+});

package/utils/asyncUtils.js

@@ -0,0 +1,32 @@
+const async = require('async');
+
+// The safeAsync functions allow us to use async collection functions as efficiently as possible
+// while avoiding stack overflows. When the async utilities call our iteratee, they provide a
+// callback for delivering a result. Calling that callback directly is efficient (we are not
+// really worried about blocking a thread by doing too many computations without yielding; our
+// flag evaluations are pretty fast, and if we end up having to do any I/O, that will cause us
+// to yield anyway)... but, if there are many items in the collection, it will result in too
+// many nested calls. So, we'll pick an arbitrary threshold of how many items can be in the
+// collection before we switch over to deferring the callbacks with setImmediate().
+
+const maxNestedCalls = 50;
+
+function safeIteratee(collection, iteratee) {
+  if (!collection || collection.length <= maxNestedCalls) {
+    return iteratee;
+  }
+  return (value, callback) => iteratee(value, (...args) => setImmediate(callback, ...args));
+}
+
+function safeAsyncEach(collection, iteratee, resultCallback) {
+  return async.each(collection, safeIteratee(collection, iteratee), resultCallback);
+}
+
+function safeAsyncEachSeries(collection, iteratee, resultCallback) {
+  return async.eachSeries(collection, safeIteratee(collection, iteratee), resultCallback);
+}
+
+module.exports = {
+  safeAsyncEach: safeAsyncEach,
+  safeAsyncEachSeries: safeAsyncEachSeries,
+};

package/utils/httpUtils.js

@@ -0,0 +1,105 @@
+const http = require('http');
+const https = require('https');
+const url = require('url');
+const configuration = require('../configuration');
+
+const packageJson = require('../package.json');
+
+const userAgent = 'NodeJSClient/' + packageJson.version;
+
+function getDefaultHeaders(sdkKey, config) {
+  // Use lowercase header names for convenience in our test code, where we may be checking for headers in a
+  // real HTTP request that will be lowercased by the request API
+  const ret = {
+    authorization: sdkKey,
+    'user-agent': userAgent,
+  };
+  if (config.wrapperName) {
+    ret['x-launchdarkly-wrapper'] = config.wrapperVersion
+      ? config.wrapperName + '/' + config.wrapperVersion
+      : config.wrapperName;
+  }
+  const tags = configuration.getTags(config);
+  const tagKeys = Object.keys(tags);
+  if (tagKeys.length) {
+    ret['x-launchdarkly-tags'] = tagKeys
+      .sort()
+      .flatMap(key =>
+        Array.isArray(tags[key]) ? tags[key].sort().map(value => `${key}/${value}`) : [`${key}/${tags[key]}`]
+      )
+      .join(' ');
+  }
+  return ret;
+}
+
+// Convenience wrapper for making an HTTP/HTTPS request via Node's standard modules. Unlike http.request,
+// the callback takes (error, response, body) parameters instead of just (response).
+function httpRequest(requestUrl, options, body, config, callback) {
+  // Note: https.request allows a url parameter to be passed separately from options, but only in v10.9.0+, so
+  // we still have to parse the URL until our minimum Node version is increased.
+  const urlOpts = url.parse(requestUrl);
+  const isSecure = urlOpts.protocol === 'https:';
+  const allOptions = Object.assign(
+    {},
+    config && config.tlsParams,
+    urlOpts,
+    {
+      timeout: config && config.timeout ? config.timeout * 1000 : undefined,
+      agent: config && config.proxyAgent,
+    },
+    options
+  );
+  const req = (isSecure ? https : http).request(allOptions, resp => {
+    let body = '';
+    resp.on('data', chunk => {
+      body += chunk;
+    });
+    resp.on('end', () => {
+      callback(null, resp, body);
+    });
+  });
+  req.on('error', err => {
+    callback(err);
+  });
+  if (body !== null && body !== undefined) {
+    req.write(body);
+  }
+  req.end();
+}
+
+// Creates an in-memory etag cache and returns a wrapper for httpRequest that uses the cache. This is a
+// naive implementation that does not place a bound on the cache; the SDK will normally always be hitting
+// the same URL (the only time we don't is if we get an "indirect/put" stream event, but in that case we
+// deliberately do not use the cache).
+function httpWithETagCache() {
+  const cache = {};
+  return (requestUrl, options, body, config, callback) => {
+    const cacheEntry = cache[requestUrl];
+    const cachedEtag = cacheEntry && cacheEntry.etag;
+    let newOptions = options;
+    if (cachedEtag) {
+      const newHeaders = Object.assign({}, options && options.headers, { 'if-none-match': cachedEtag });
+      newOptions = Object.assign({}, options, { headers: newHeaders });
+    }
+    return httpRequest(requestUrl, newOptions, body, config, (err, resp, body) => {
+      if (err) {
+        callback(err);
+      } else {
+        if (resp.statusCode === 304 && cacheEntry) {
+          callback(null, resp, cacheEntry.body);
+        } else {
+          if (resp.headers['etag']) {
+            cache[requestUrl] = { etag: resp.headers['etag'], body };
+          }
+          callback(null, resp, body);
+        }
+      }
+    });
+  };
+}
+
+module.exports = {
+  getDefaultHeaders,
+  httpRequest,
+  httpWithETagCache,
+};

package/utils/stringifyAttrs.js

@@ -0,0 +1,14 @@
+module.exports = function stringifyAttrs(object, attrs) {
+  if (!object) {
+    return object;
+  }
+  let newObject;
+  for (const attr of attrs) {
+    const value = object[attr];
+    if (value !== undefined && typeof value !== 'string') {
+      newObject = newObject || Object.assign({}, object);
+      newObject[attr] = String(value);
+    }
+  }
+  return newObject || object;
+};

package/utils/wrapPromiseCallback.js

@@ -0,0 +1,36 @@
+/**
+ * Wrap a promise to invoke an optional callback upon resolution or rejection.
+ *
+ * This function assumes the callback follows the Node.js callback type: (err, value) => void
+ *
+ * If a callback is provided:
+ *   - if the promise is resolved, invoke the callback with (null, value)
+ *   - if the promise is rejected, invoke the callback with (error, null)
+ *
+ * @param {Promise<any>} promise
+ * @param {Function} callback
+ * @returns Promise<any> | undefined
+ */
+module.exports = function wrapPromiseCallback(promise, callback) {
+  const ret = promise.then(
+    value => {
+      if (callback) {
+        setImmediate(() => {
+          callback(null, value);
+        });
+      }
+      return value;
+    },
+    error => {
+      if (callback) {
+        setImmediate(() => {
+          callback(error, null);
+        });
+      } else {
+        return Promise.reject(error);
+      }
+    }
+  );
+
+  return !callback ? ret : undefined;
+};

package/versioned_data_kind.js

@@ -0,0 +1,34 @@
+/*
+  These objects denote the types of data that can be stored in the feature store and
+  referenced in the API.  If we add another storable data type in the future, as long as it
+  follows the same pattern (having "key", "version", and "deleted" properties), we only need
+  to add a corresponding constant here and the existing store should be able to handle it.
+
+  Note, for things to work correctly, the "namespace" property must match the key used in
+  module.exports.
+*/
+
+const features = {
+  namespace: 'features',
+  streamApiPath: '/flags/',
+  requestPath: '/sdk/latest-flags/',
+  priority: 1,
+  getDependencyKeys: flag => {
+    if (!flag.prerequisites || !flag.prerequisites.length) {
+      return [];
+    }
+    return flag.prerequisites.map(p => p.key);
+  },
+};
+
+const segments = {
+  namespace: 'segments',
+  streamApiPath: '/segments/',
+  requestPath: '/sdk/latest-segments/',
+  priority: 0,
+};
+
+module.exports = {
+  features: features,
+  segments: segments,
+};