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

package/changes.json

@@ -0,0 +1,30 @@
+{
+  "bumped": {
+    "async": {
+      "from": "^3.2.4",
+      "to": "^3.2.6"
+    },
+    "launchdarkly-eventsource": {
+      "from": "1.4.4",
+      "to": "^2.2.0"
+    },
+    "lru-cache": {
+      "from": "^6.0.0",
+      "to": "^11.2.7"
+    },
+    "node-cache": {
+      "from": "^5.1.0",
+      "to": "^5.1.2"
+    },
+    "semver": {
+      "from": "^7.5.4",
+      "to": "^7.7.4"
+    },
+    "uuid": {
+      "from": "^8.3.2",
+      "to": "^13.0.0"
+    }
+  },
+  "timestamp": "2026-03-17T22:56:41.641Z",
+  "totalUpdated": 6
+}

package/configuration.js

@@ -0,0 +1,235 @@
+const InMemoryFeatureStore = require('./feature_store');
+const loggers = require('./loggers');
+const messages = require('./messages');
+
+module.exports = (function () {
+  const defaults = function () {
+    return {
+      baseUri: 'https://app.launchdarkly.com',
+      streamUri: 'https://stream.launchdarkly.com',
+      eventsUri: 'https://events.launchdarkly.com',
+      stream: true,
+      streamInitialReconnectDelay: 1,
+      sendEvents: true,
+      timeout: 5,
+      capacity: 10000,
+      flushInterval: 5,
+      pollInterval: 30,
+      offline: false,
+      useLdd: false,
+      allAttributesPrivate: false,
+      privateAttributes: [],
+      contextKeysCapacity: 1000,
+      contextKeysFlushInterval: 300,
+      diagnosticOptOut: false,
+      diagnosticRecordingInterval: 900,
+      featureStore: InMemoryFeatureStore(),
+    };
+  };
+
+  const typesForPropertiesWithNoDefault = {
+    // Add a value here if we add a configuration property whose type cannot be determined by looking
+    // in baseDefaults (for instance, the default is null but if the value isn't null it should be a
+    // string). The allowable values are 'boolean', 'string', 'number', 'object', 'function', 'array' or
+    // 'factory' (the last one means it can be either a function or an object).
+    bigSegments: 'object',
+    eventProcessor: 'object',
+    featureStore: 'object',
+    logger: 'object', // LDLogger
+    proxyAgent: 'object',
+    proxyAuth: 'string',
+    proxyHost: 'string',
+    proxyPort: 'number',
+    proxyScheme: 'string',
+    tlsParams: 'object', // LDTLSOptions
+    updateProcessor: 'factory', // gets special handling in validation
+    wrapperName: 'string',
+    wrapperVersion: 'string',
+  };
+
+  /**
+   * Expression to validate characters that are allowed in tag keys and values.
+   */
+  const allowedTagCharacters = /^(\w|\.|-)+$/;
+
+  /**
+   * Verify that a value meets the requirements for a tag value.
+   * @param {Object} config
+   * @param {string} tagValue
+   */
+  function validateTagValue(name, config, tagValue) {
+    if (typeof tagValue !== 'string' || !tagValue.match(allowedTagCharacters)) {
+      config.logger.warn(messages.invalidTagValue(name));
+      return undefined;
+    }
+    if (tagValue.length > 64) {
+      config.logger.warn(messages.tagValueTooLong(name));
+      return undefined;
+    }
+    return tagValue;
+  }
+
+  const optionsWithValidatorsOrConversions = {
+    // Add a value here if we add a configuration property which requires custom validation
+    // and/or type conversion.
+    // The validator should log a message for any validation issues encountered.
+    // The validator should return undefined, or the validated value.
+
+    application: (name, config, value) => {
+      const validated = {};
+      if (value.id) {
+        validated.id = validateTagValue(`${name}.id`, config, value.id);
+      }
+      if (value.version) {
+        validated.version = validateTagValue(`${name}.version`, config, value.version);
+      }
+      return validated;
+    },
+  };
+
+  /* eslint-disable camelcase */
+  const deprecatedOptions = {
+    userKeysCapacity: 'contextKeysCapacity',
+    userKeysFlushInterval: 'contextKeysFlushInterval',
+  };
+  /* eslint-enable camelcase */
+
+  function checkDeprecatedOptions(configIn) {
+    const config = configIn;
+    Object.keys(deprecatedOptions).forEach(oldName => {
+      if (config[oldName] !== undefined) {
+        const newName = deprecatedOptions[oldName];
+        config.logger.warn(messages.deprecated(oldName, newName));
+        if (config[newName] === undefined) {
+          config[newName] = config[oldName];
+        }
+        delete config[oldName];
+      }
+    });
+  }
+
+  function applyDefaults(config, defaults) {
+    // This works differently from Object.assign() in that it will *not* override a default value
+    // if the provided value is explicitly set to null.
+    const ret = Object.assign({}, config);
+    Object.keys(defaults).forEach(name => {
+      if (ret[name] === undefined || ret[name] === null) {
+        ret[name] = defaults[name];
+      }
+    });
+    return ret;
+  }
+
+  function canonicalizeUri(uri) {
+    return uri.replace(/\/+$/, '');
+  }
+
+  function validateTypesAndNames(configIn, defaultConfig) {
+    const config = configIn;
+    const typeDescForValue = value => {
+      if (value === null || value === undefined) {
+        return undefined;
+      }
+      if (Array.isArray(value)) {
+        return 'array';
+      }
+      const t = typeof value;
+      if (t === 'boolean' || t === 'string' || t === 'number') {
+        return t;
+      }
+      return 'object';
+    };
+
+    Object.keys(config).forEach(name => {
+      const value = config[name];
+      if (value !== null && value !== undefined) {
+        const defaultValue = defaultConfig[name];
+        const typeDesc = typesForPropertiesWithNoDefault[name];
+        const validator = optionsWithValidatorsOrConversions[name];
+        if (defaultValue === undefined && typeDesc === undefined && validator === undefined) {
+          config.logger.warn(messages.unknownOption(name));
+        } else if (validator !== undefined) {
+          const validated = validator(name, config, config[name]);
+          if (validated !== undefined) {
+            config[name] = validated;
+          } else {
+            delete config[name];
+          }
+        } else {
+          const expectedType = typeDesc || typeDescForValue(defaultValue);
+          const actualType = typeDescForValue(value);
+          if (actualType !== expectedType) {
+            if (expectedType === 'factory' && (typeof value === 'function' || typeof value === 'object')) {
+              // for some properties, we allow either a factory function or an instance
+              return;
+            }
+            if (expectedType === 'boolean') {
+              config[name] = !!value;
+              config.logger.warn(messages.wrongOptionTypeBoolean(name, actualType));
+            } else {
+              config.logger.warn(messages.wrongOptionType(name, expectedType, actualType));
+              config[name] = defaultConfig[name];
+            }
+          }
+        }
+      }
+    });
+  }
+
+  function enforceMinimum(configIn, name, min) {
+    const config = configIn;
+    if (config[name] < min) {
+      config.logger.warn(messages.optionBelowMinimum(name, config[name], min));
+      config[name] = min;
+    }
+  }
+
+  function validate(options) {
+    let config = Object.assign({}, options || {});
+
+    const fallbackLogger = loggers.basicLogger({ level: 'info' });
+    config.logger = config.logger ? loggers.safeLogger(config.logger, fallbackLogger) : fallbackLogger;
+
+    checkDeprecatedOptions(config);
+
+    const defaultConfig = defaults();
+    config = applyDefaults(config, defaultConfig);
+
+    validateTypesAndNames(config, defaultConfig);
+
+    config.baseUri = canonicalizeUri(config.baseUri);
+    config.streamUri = canonicalizeUri(config.streamUri);
+    config.eventsUri = canonicalizeUri(config.eventsUri);
+
+    enforceMinimum(config, 'pollInterval', 30);
+    enforceMinimum(config, 'diagnosticRecordingInterval', 60);
+
+    return config;
+  }
+
+  /**
+   * Get tags for the specified configuration.
+   *
+   * If any additional tags are added to the configuration, then the tags from
+   * this method should be extended with those.
+   * @param {Object} config The already valiated configuration.
+   * @returns {Object} The tag configuration.
+   */
+  function getTags(config) {
+    const tags = {};
+    if (config.application && config.application.id !== undefined && config.application.id !== null) {
+      tags['application-id'] = [config.application.id];
+    }
+    if (config.application && config.application.version !== undefined && config.application.id !== null) {
+      tags['application-version'] = [config.application.version];
+    }
+
+    return tags;
+  }
+
+  return {
+    validate,
+    defaults,
+    getTags,
+  };
+})();

package/context.js

@@ -0,0 +1,98 @@
+/**
+ * Validate a context kind.
+ * @param {string} kind
+ * @returns true if the kind is valid.
+ */
+function validKind(kind) {
+  return typeof kind === 'string' && kind !== 'kind' && kind.match(/^(\w|\.|-)+$/);
+}
+
+/**
+ * Validate a context key.
+ * @param {string} key
+ * @returns true if the key is valid.
+ */
+function validKey(key) {
+  return key !== undefined && key !== null && key !== '' && typeof key === 'string';
+}
+
+/**
+ * Perform a check of basic context requirements.
+ * @param {Object} context
+ * @param {boolean} allowLegacyKey If true, then a legacy user can have an
+ * empty or non-string key. A legacy user is a context without a kind.
+ * @returns true if the context meets basic requirements.
+ */
+function checkContext(context, allowLegacyKey) {
+  if (context) {
+    if (allowLegacyKey && (context.kind === undefined || context.kind === null)) {
+      return context.key !== undefined && context.key !== null;
+    }
+    const key = context.key;
+    const kind = context.kind === undefined ? 'user' : context.kind;
+    const kindValid = validKind(kind);
+    const keyValid = kind === 'multi' || validKey(key);
+    if (kind === 'multi') {
+      const kinds = Object.keys(context).filter(key => key !== 'kind');
+      return keyValid && kinds.every(key => validKind(key)) && kinds.every(key => validKey(context[key].key));
+    }
+    return keyValid && kindValid;
+  }
+  return false;
+}
+
+/**
+ * The partial URL encoding is needed because : is a valid character in context keys.
+ *
+ * Partial encoding is the replacement of all colon (:) characters with the URL
+ * encoded equivalent (%3A) and all percent (%) characters with the URL encoded
+ * equivalent (%25).
+ * @param {string} key The key to encode.
+ * @returns {string} Partially URL encoded key.
+ */
+function encodeKey(key) {
+  if (key.includes('%') || key.includes(':')) {
+    return key.replace(/%/g, '%25').replace(/:/g, '%3A');
+  }
+  return key;
+}
+
+/**
+ * For a given context get a list of context kinds.
+ * @param {Object} context
+ * @returns A list of kinds in the context.
+ */
+function getContextKinds(context) {
+  if (context) {
+    if (context.kind === null || context.kind === undefined) {
+      return ['user'];
+    }
+    if (context.kind !== 'multi') {
+      return [context.kind];
+    }
+    return Object.keys(context).filter(kind => kind !== 'kind');
+  }
+  return [];
+}
+
+function getCanonicalKey(context) {
+  if (context) {
+    if ((context.kind === undefined || context.kind === null || context.kind === 'user') && context.key) {
+      return context.key;
+    } else if (context.kind !== 'multi' && context.key) {
+      return `${context.kind}:${encodeKey(context.key)}`;
+    } else if (context.kind === 'multi') {
+      return Object.keys(context)
+        .sort()
+        .filter(key => key !== 'kind')
+        .map(key => `${key}:${encodeKey(context[key].key)}`)
+        .join(':');
+    }
+  }
+}
+
+module.exports = {
+  checkContext,
+  getContextKinds,
+  getCanonicalKey,
+};

package/context_filter.js

@@ -0,0 +1,137 @@
+const AttributeReference = require('./attribute_reference');
+
+function ContextFilter(config) {
+  const filter = {};
+
+  const allAttributesPrivate = config.allAttributesPrivate;
+  const privateAttributes = config.privateAttributes || [];
+
+  // These attributes cannot be removed via a private attribute.
+  const protectedAttributes = ['key', 'kind', '_meta', 'anonymous'];
+
+  const legacyTopLevelCopyAttributes = ['name', 'ip', 'firstName', 'lastName', 'email', 'avatar', 'country'];
+
+  /**
+   * For the given context and configuration get a list of attributes to filter.
+   * @param {Object} context
+   * @returns {string[]} A list of the attributes to filter.
+   */
+  const getAttributesToFilter = context =>
+    (allAttributesPrivate
+      ? Object.keys(context)
+      : [...privateAttributes, ...((context._meta && context._meta.privateAttributes) || [])]
+    ).filter(attr => !protectedAttributes.some(protectedAttr => AttributeReference.compare(attr, protectedAttr)));
+
+  /**
+   * @param {Object} context
+   * @returns {Object} A copy of the context with private attributes removed,
+   * and the redactedAttributes meta populated.
+   */
+  const filterSingleKind = context => {
+    if (typeof context !== 'object' || context === null || Array.isArray(context)) {
+      return undefined;
+    }
+
+    const { cloned, excluded } = AttributeReference.cloneExcluding(context, getAttributesToFilter(context));
+    cloned.key = String(cloned.key);
+    if (excluded.length) {
+      if (!cloned._meta) {
+        cloned._meta = {};
+      }
+      cloned._meta.redactedAttributes = excluded;
+    }
+    if (cloned._meta) {
+      delete cloned._meta['privateAttributes'];
+      if (Object.keys(cloned._meta).length === 0) {
+        delete cloned._meta;
+      }
+    }
+    // Make sure anonymous is boolean if present.
+    // Null counts as present, and would be falsy, which is the default.
+    if (cloned.anonymous !== undefined) {
+      cloned.anonymous = !!cloned.anonymous;
+    }
+
+    return cloned;
+  };
+
+  /**
+   * @param {Object} context
+   * @returns {Object} A copy of the context with the private attributes removed,
+   * and the redactedAttributes meta populated for each sub-context.
+   */
+  const filterMultiKind = context => {
+    const filtered = {
+      kind: context.kind,
+    };
+    const contextKeys = Object.keys(context);
+
+    for (const contextKey of contextKeys) {
+      if (contextKey !== 'kind') {
+        const filteredContext = filterSingleKind(context[contextKey]);
+        if (filteredContext) {
+          filtered[contextKey] = filteredContext;
+        }
+      }
+    }
+    return filtered;
+  };
+
+  /**
+   * Convert the LDUser object into an LDContext object.
+   * @param {Object} user The LDUser to produce an LDContext for.
+   * @returns {Object} A single kind context based on the provided user.
+   */
+  const legacyToSingleKind = user => {
+    const filtered = {
+      /* Destructure custom items into the top level.
+         Duplicate keys will be overridden by previously
+         top level items.
+      */
+      ...(user.custom || {}),
+
+      // Implicity a user kind.
+      kind: 'user',
+
+      key: user.key,
+    };
+
+    if (user.anonymous !== undefined) {
+      filtered.anonymous = !!user.anonymous;
+    }
+
+    // Copy top level keys and convert them to strings.
+    // Remove keys that may have been destructured from `custom`.
+    for (const key of legacyTopLevelCopyAttributes) {
+      delete filtered[key];
+      if (user[key] !== undefined && user[key] !== null) {
+        filtered[key] = String(user[key]);
+      }
+    }
+
+    if (user.privateAttributeNames !== undefined && user.privateAttributeNames !== null) {
+      filtered._meta = filtered._meta || {};
+      // If any private attributes started with '/' we need to convert them to references, otherwise the '/' will
+      // cause the literal to incorrectly be treated as a reference.
+      filtered._meta.privateAttributes = user.privateAttributeNames.map(literal =>
+        literal.startsWith('/') ? AttributeReference.literalToReference(literal) : literal
+      );
+    }
+
+    return filtered;
+  };
+
+  filter.filter = context => {
+    if (context.kind === undefined || context.kind === null) {
+      return filterSingleKind(legacyToSingleKind(context));
+    } else if (context.kind === 'multi') {
+      return filterMultiKind(context);
+    } else {
+      return filterSingleKind(context);
+    }
+  };
+
+  return filter;
+}
+
+module.exports = ContextFilter;

package/contract-tests/README.md

@@ -0,0 +1,7 @@
+# SDK contract test service
+
+This directory contains an implementation of the cross-platform SDK testing protocol defined by https://github.com/launchdarkly/sdk-test-harness. See that project's `README` for details of this protocol, and the kinds of SDK capabilities that are relevant to the contract tests. This code should not need to be updated unless the SDK has added or removed such capabilities.
+
+To run these tests locally, run `npm run contract-tests` from the SDK project root directory. This will start the test service, download the correct version of the test harness tool, and run the tests.
+
+Or, to test against an in-progress local version of the test harness, run `npm run contract-test-service` from the SDK project root directory; then, in the root directory of the `sdk-test-harness` project, build the test harness and run it from the command line.

package/contract-tests/index.js

@@ -0,0 +1,109 @@
+const express = require('express');
+const bodyParser = require('body-parser');
+
+const { Log } = require('./log');
+const { newSdkClientEntity, badCommandError } = require('./sdkClientEntity');
+
+const app = express();
+let server = null;
+
+const port = 8000;
+
+let clientCounter = 0;
+const clients = {};
+
+const mainLog = Log('service');
+
+app.use(bodyParser.json());
+
+app.get('/', (req, res) => {
+  res.header('Content-Type', 'application/json');
+  res.json({
+    capabilities: [
+      'server-side',
+      'all-flags-client-side-only',
+      'all-flags-details-only-for-tracked-flags',
+      'all-flags-with-reasons',
+      'tags',
+      'user-type',
+    ],
+  });
+});
+
+app.delete('/', (req, res) => {
+  mainLog.info('Test service has told us to exit');
+  res.status(204);
+  res.send();
+
+  // Defer the following actions till after the response has been sent
+  setTimeout(() => {
+    server.close(() => process.exit());
+    // We force-quit with process.exit because, even after closing the server, there could be some
+    // scheduled tasks lingering if an SDK instance didn't get cleaned up properly, and we don't want
+    // that to prevent us from quitting.
+  }, 1);
+});
+
+app.post('/', async (req, res) => {
+  const options = req.body;
+
+  clientCounter += 1;
+  const clientId = clientCounter.toString();
+  const resourceUrl = `/clients/${clientId}`;
+
+  try {
+    const client = await newSdkClientEntity(options);
+    clients[clientId] = client;
+
+    res.status(201);
+    res.set('Location', resourceUrl);
+  } catch (e) {
+    res.status(500);
+    const message = e.message || JSON.stringify(e);
+    mainLog.error('Error creating client: ' + message);
+    res.write(message);
+  }
+  res.send();
+});
+
+app.post('/clients/:id', async (req, res) => {
+  const client = clients[req.params.id];
+  if (!client) {
+    res.status(404);
+  } else {
+    try {
+      const respValue = await client.doCommand(req.body);
+      if (respValue) {
+        res.status(200);
+        res.write(JSON.stringify(respValue));
+      } else {
+        res.status(204);
+      }
+    } catch (e) {
+      const isBadRequest = e === badCommandError;
+      res.status(isBadRequest ? 400 : 500);
+      res.write(e.message || JSON.stringify(e));
+      if (!isBadRequest && e.stack) {
+        console.log(e.stack);
+      }
+    }
+  }
+  res.send();
+});
+
+app.delete('/clients/:id', async (req, res) => {
+  const client = clients[req.params.id];
+  if (!client) {
+    res.status(404);
+    res.send();
+  } else {
+    client.close();
+    delete clients[req.params.id];
+    res.status(204);
+    res.send();
+  }
+});
+
+server = app.listen(port, () => {
+  console.log('Listening on port %d', port);
+});

package/contract-tests/log.js

@@ -0,0 +1,23 @@
+const ld = require('launchdarkly-node-server-sdk');
+
+function Log(tag) {
+  function doLog(level, message) {
+    console.log(new Date().toISOString() + ` [${tag}] ${level}: ${message}`);
+  }
+  return {
+    info: message => doLog('info', message),
+    error: message => doLog('error', message),
+  };
+}
+
+function sdkLogger(tag) {
+  return ld.basicLogger({
+    level: 'debug',
+    destination: line => {
+      console.log(new Date().toISOString() + ` [${tag}.sdk] ${line}`);
+    },
+  });
+}
+
+module.exports.Log = Log;
+module.exports.sdkLogger = sdkLogger;

package/contract-tests/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "node-server-sdk-contract-tests",
+  "version": "0.0.0",
+  "main": "index.js",
+  "scripts": {
+    "start": "node index.js"
+  },
+  "author": "",
+  "license": "Apache-2.0",
+  "dependencies": {
+    "body-parser": "^1.19.0",
+    "express": "^4.17.1",
+    "launchdarkly-node-server-sdk": "file:.."
+  }
+}