launchdarkly-js-sdk-common 4.3.2 → 5.0.0-alpha.1

package/src/__tests__/context-test.js

@@ -0,0 +1,93 @@
+const { checkContext, getContextKinds, getCanonicalKey } = require('../context');
+
+describe.each([{ key: 'test' }, { kind: 'user', key: 'test' }, { kind: 'multi', user: { key: 'test' } }])(
+  'given a context which contains a single kind',
+  context => {
+    it('should get the context kind', () => {
+      expect(getContextKinds(context)).toEqual(['user']);
+    });
+
+    it('should be valid', () => {
+      expect(checkContext(context, false)).toBeTruthy();
+    });
+  }
+);
+
+describe('given a valid multi-kind context', () => {
+  const context = {
+    kind: 'multi',
+    user: {
+      key: 'user',
+    },
+    org: {
+      key: 'org',
+    },
+  };
+
+  it('should get a list of the kinds', () => {
+    expect(getContextKinds(context).sort()).toEqual(['org', 'user']);
+  });
+
+  it('should be valid', () => {
+    expect(checkContext(context, false)).toBeTruthy();
+  });
+});
+
+// A sample of invalid characters.
+const invalidSampleChars = [
+  ...`#$%&'()*+,/:;<=>?@[\\]^\`{|}~ ¡¢£¤¥¦§¨©ª«¬­®¯°±²
+³´µ¶·¸¹º»¼½¾¿À汉字`,
+];
+const badKinds = invalidSampleChars.map(char => ({ kind: char, key: 'test' }));
+
+describe.each([
+  {}, // An empty object is not a valid context.
+  { key: '' }, // If allowLegacyKey is not true, then this should be invalid.
+  { kind: 'kind', key: 'kind' }, // The kind cannot be kind.
+  { kind: 'user' }, // The context needs to have a key.
+  { kind: 'org', key: '' }, // For a non-legacy context the key cannot be empty.
+  { kind: ' ', key: 'test' }, // Kind cannot be whitespace only.
+  { kind: 'cat dog', key: 'test' }, // Kind cannot contain whitespace
+  { kind: '~!@#$%^&*()_+', key: 'test' }, // Special characters are not valid.
+  ...badKinds,
+])('given invalid contexts', context => {
+  it('should not be valid', () => {
+    expect(checkContext(context, false)).toBeFalsy();
+  });
+});
+
+const validChars = ['0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_.'];
+const goodKinds = validChars.map(char => [{ kind: char, key: 'test' }, false]);
+
+describe.each([
+  [{ key: '' }, true], // Allow a legacy context with an empty key.
+  ...goodKinds,
+])('given valid contexts', (context, allowLegacyKey) => {
+  it('should be valid and can get context kinds', () => {
+    expect(checkContext(context, allowLegacyKey)).toBeTruthy();
+    expect(getContextKinds(context)).toEqual([context.kind || 'user']);
+  });
+});
+
+describe('when determining canonical keys', () => {
+  it.each([
+    [{ key: 'test' }, 'test'],
+    [{ kind: 'user', key: 'test' }, 'test'],
+    [{ kind: 'org', key: 'orgtest' }, 'org:orgtest'],
+    [{ kind: 'multi', user: { key: 'usertest' } }, 'user:usertest'],
+    [{ kind: 'multi', user: { key: 'usertest' }, org: { key: 'orgtest' } }, 'org:orgtest:user:usertest'],
+    [{ kind: 'multi', user: { key: 'user:test' }, org: { key: 'org:test' } }, 'org:org%3Atest:user:user%3Atest'],
+    [{ kind: 'multi', user: { key: 'user%test' }, org: { key: 'org%test' } }, 'org:org%25test:user:user%25test'],
+    [
+      { kind: 'multi', user: { key: 'user%:test' }, org: { key: 'org%:test' } },
+      'org:org%25%3Atest:user:user%25%3Atest',
+    ],
+  ])('produces a canonical key for valid  contexts', (context, canonicalKey) => {
+    expect(getCanonicalKey(context)).toEqual(canonicalKey);
+  });
+
+  it('does not break with an null/undefined context', () => {
+    expect(getCanonicalKey(undefined)).toBeUndefined();
+    expect(getCanonicalKey(null)).toBeUndefined();
+  });
+});

package/src/__tests__/diagnosticEvents-test.js

@@ -101,7 +101,6 @@ describe('DiagnosticsManager', () => {
   };
   const defaultConfigInEvent = {
     allAttributesPrivate: false,
-    autoAliasingOptOut: false,
     bootstrapMode: false,
     customBaseURI: false,
     customEventsURI: false,
@@ -110,7 +109,6 @@ describe('DiagnosticsManager', () => {
     eventsCapacity: defaultConfig.eventCapacity,
     eventsFlushIntervalMillis: defaultConfig.flushInterval,
     fetchGoalsDisabled: false,
-    inlineUsersInEvents: false,
     reconnectTimeMillis: defaultConfig.streamReconnectDelay,
     sendEventsOnlyForVariation: false,
     streamingDisabled: true,
@@ -196,12 +194,10 @@ describe('DiagnosticsManager', () => {
         [{ eventCapacity: 222 }, { eventsCapacity: 222 }],
         [{ flushInterval: 2222 }, { eventsFlushIntervalMillis: 2222 }],
         [{ fetchGoals: false }, { fetchGoalsDisabled: true }],
-        [{ inlineUsersInEvents: true }, { inlineUsersInEvents: true }],
         [{ streamReconnectDelay: 2222 }, { reconnectTimeMillis: 2222 }],
         [{ sendEventsOnlyForVariation: true }, { sendEventsOnlyForVariation: true }],
         [{ streaming: true }, { streamingDisabled: false }],
         [{ hash: 'x' }, { usingSecureMode: true }],
-        [{ autoAliasingOptOut: true }, { autoAliasingOptOut: true }],
       ];
       for (const i in configAndResultValues) {
         const configOverrides = configAndResultValues[i][0];

package/src/__tests__/utils-test.js

@@ -1,10 +1,4 @@
-import {
-  appendUrlPath,
-  base64URLEncode,
-  getLDUserAgentString,
-  wrapPromiseCallback,
-  chunkUserEventsForUrl,
-} from '../utils';
+import { appendUrlPath, base64URLEncode, getLDUserAgentString, wrapPromiseCallback, chunkEventsForUrl } from '../utils';
 
 import * as stubPlatform from './stubPlatform';
 
@@ -70,13 +64,13 @@ describe('utils', () => {
     });
   });
 
-  describe('chunkUserEventsForUrl', () => {
+  describe('chunkEventsForUrl', () => {
     it('should properly chunk the list of events', () => {
       const user = { key: 'foo' };
       const event = { kind: 'identify', key: user.key };
       const eventLength = base64URLEncode(JSON.stringify(event)).length;
       const events = [event, event, event, event, event];
-      const chunks = chunkUserEventsForUrl(eventLength * 2, events);
+      const chunks = chunkEventsForUrl(eventLength * 2, events);
       expect(chunks).toEqual([[event, event], [event, event], [event]]);
     });
   });

package/src/attributeReference.js

@@ -0,0 +1,143 @@
+/**
+ * Take a key string and escape the characters to allow it to be used as a reference.
+ * @param {string} key
+ * @returns {string} The processed key.
+ */
+function processEscapeCharacters(key) {
+  return key.replace(/~/g, '~0').replace(/\//g, '~1');
+}
+
+/**
+ * @param {string} reference The reference to get the components of.
+ * @returns {string[]} The components of the reference. Escape characters will be converted to their representative values.
+ */
+function getComponents(reference) {
+  const referenceWithoutPrefix = reference.startsWith('/') ? reference.substring(1) : reference;
+  return referenceWithoutPrefix
+    .split('/')
+    .map(component => (component.indexOf('~') >= 0 ? component.replace(/~1/g, '/').replace(/~0/g, '~') : component));
+}
+
+/**
+ * @param {string} reference The reference to check if it is a literal.
+ * @returns true if the reference is a literal.
+ */
+function isLiteral(reference) {
+  return !reference.startsWith('/');
+}
+
+/**
+ * Compare two references and determine if they are equivalent.
+ * @param {string} a
+ * @param {string} b
+ */
+function compare(a, b) {
+  const aIsLiteral = isLiteral(a);
+  const bIsLiteral = isLiteral(b);
+  if (aIsLiteral && bIsLiteral) {
+    return a === b;
+  }
+  if (aIsLiteral) {
+    const bComponents = getComponents(b);
+    if (bComponents.length !== 1) {
+      return false;
+    }
+    return a === bComponents[0];
+  }
+  if (bIsLiteral) {
+    const aComponents = getComponents(a);
+    if (aComponents.length !== 1) {
+      return false;
+    }
+    return b === aComponents[0];
+  }
+  return a === b;
+}
+
+/**
+ * @param {string} a
+ * @param {string} b
+ * @returns The two strings joined by '/'.
+ */
+function join(a, b) {
+  return `${a}/${b}`;
+}
+
+/**
+ * There are cases where a field could have been named with a preceeding '/'.
+ * If that attribute was private, then the literal would appear to be a reference.
+ * This method can be used to convert a literal to a reference in such situations.
+ * @param {string} literal The literal to convert to a reference.
+ * @returns A literal which has been converted to a reference.
+ */
+function literalToReference(literal) {
+  return `/${processEscapeCharacters(literal)}`;
+}
+
+/**
+ * Clone an object excluding the values referenced by a list of references.
+ * @param {Object} target The object to clone.
+ * @param {string[]} references A list of references from the cloned object.
+ * @returns {{cloned: Object, excluded: string[]}} The cloned object and a list of excluded values.
+ */
+function cloneExcluding(target, references) {
+  const stack = [];
+  const cloned = {};
+  const excluded = [];
+
+  stack.push(
+    ...Object.keys(target).map(key => ({
+      key,
+      ptr: literalToReference(key),
+      source: target,
+      parent: cloned,
+      visited: [target],
+    }))
+  );
+
+  while (stack.length) {
+    const item = stack.pop();
+    if (!references.some(ptr => compare(ptr, item.ptr))) {
+      const value = item.source[item.key];
+
+      // Handle null because it overlaps with object, which we will want to handle later.
+      if (value === null) {
+        item.parent[item.key] = value;
+      } else if (Array.isArray(value)) {
+        item.parent[item.key] = [...value];
+      } else if (typeof value === 'object') {
+        //Arrays and null must already be handled.
+
+        //Prevent cycles by not visiting the same object
+        //with in the same branch. Parallel branches
+        //may contain the same object.
+        if (item.visited.includes(value)) {
+          continue;
+        }
+
+        item.parent[item.key] = {};
+
+        stack.push(
+          ...Object.keys(value).map(key => ({
+            key,
+            ptr: join(item.ptr, processEscapeCharacters(key)),
+            source: value,
+            parent: item.parent[item.key],
+            visited: [...item.visited, value],
+          }))
+        );
+      } else {
+        item.parent[item.key] = value;
+      }
+    } else {
+      excluded.push(item.ptr);
+    }
+  }
+  return { cloned, excluded: excluded.sort() };
+}
+
+module.exports = {
+  cloneExcluding,
+  compare,
+  literalToReference,
+};

package/src/configuration.js

@@ -20,8 +20,6 @@ const baseOptionDefs = {
   streaming: { type: 'boolean' }, // default for this is undefined, which is different from false
   sendLDHeaders: { default: true },
   requestHeaderTransform: { type: 'function' },
-  inlineUsersInEvents: { default: false },
-  allowFrequentDuplicateEvents: { default: false },
   sendEventsOnlyForVariation: { default: false },
   useReport: { default: false },
   evaluationReasons: { default: false },
@@ -30,14 +28,13 @@ const baseOptionDefs = {
   samplingInterval: { default: 0, minimum: 0 },
   streamReconnectDelay: { default: 1000, minimum: 0 },
   allAttributesPrivate: { default: false },
-  privateAttributeNames: { default: [] },
+  privateAttributes: { default: [] },
   bootstrap: { type: 'string|object' },
   diagnosticRecordingInterval: { default: 900000, minimum: 2000 },
   diagnosticOptOut: { default: false },
   wrapperName: { type: 'string' },
   wrapperVersion: { type: 'string' },
   stateProvider: { type: 'object' }, // not a public option, used internally
-  autoAliasingOptOut: { default: false },
   application: { validator: applicationConfigValidator },
   inspectors: { default: [] },
 };
@@ -79,10 +76,9 @@ function validate(options, emitter, extraOptionDefs, logger) {
   const optionDefs = utils.extend({ logger: { default: logger } }, baseOptionDefs, extraOptionDefs);
 
   const deprecatedOptions = {
-    // The property name is the deprecated name, and the property value is the preferred name if
-    // any, or null/undefined if there is no replacement. This should be removed, along with
-    // the option, in the next major version.
-    allowFrequentDuplicateEvents: undefined,
+    // As of the latest major version, there are no deprecated options. Next time we deprecate
+    // something, add an item here where the property name is the deprecated name, and the
+    // property value is the preferred name if any, or null/undefined if there is no replacement.
   };
 
   function checkDeprecatedOptions(config) {

package/src/context.js

@@ -0,0 +1,96 @@
+/**
+ * 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|\.|-)+$/);
+}
+
+/**
+ * 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' || (key !== undefined && key !== null && key !== '');
+    if (kind === 'multi') {
+      const kinds = Object.keys(context).filter(key => key !== 'kind');
+      return (
+        keyValid &&
+        kinds.every(key => validKind(key)) &&
+        kinds.every(key => {
+          const contextKey = context[key].key;
+          return contextKey !== undefined && contextKey !== null && contextKey !== '';
+        })
+      );
+    }
+    return keyValid && kindValid;
+  }
+  return false;
+}
+
+/**
+ * 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 [];
+}
+
+/**
+ * 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;
+}
+
+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/src/diagnosticEvents.js

@@ -195,14 +195,12 @@ function DiagnosticsManager(
       reconnectTimeMillis: config.streamReconnectDelay,
       streamingDisabled: !streamingEnabled,
       allAttributesPrivate: !!config.allAttributesPrivate,
-      inlineUsersInEvents: !!config.inlineUsersInEvents,
       diagnosticRecordingIntervalMillis: config.diagnosticRecordingInterval,
       // The following extra properties are only provided by client-side JS SDKs:
       usingSecureMode: !!config.hash,
       bootstrapMode: !!config.bootstrap,
       fetchGoalsDisabled: !config.fetchGoals,
       sendEventsOnlyForVariation: !!config.sendEventsOnlyForVariation,
-      autoAliasingOptOut: !!config.autoAliasingOptOut,
     };
     // Client-side JS SDKs do not have the following properties which other SDKs have:
     // connectTimeoutMillis