launchdarkly-js-sdk-common 5.0.0-alpha.3 → 5.0.0-alpha.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "launchdarkly-js-sdk-common",
-  "version": "5.0.0-alpha.3",
+  "version": "5.0.0-alpha.5",
   "description": "LaunchDarkly SDK for JavaScript - common code",
   "author": "LaunchDarkly <team@launchdarkly.com>",
   "license": "Apache-2.0",

package/src/EventProcessor.js

@@ -4,6 +4,7 @@ const ContextFilter = require('./ContextFilter');
 const errors = require('./errors');
 const messages = require('./messages');
 const utils = require('./utils');
+const { getContextKeys } = require('./context');
 
 function EventProcessor(
   platform,
@@ -50,7 +51,7 @@ function EventProcessor(
       // identify events always have an inline context
       ret.context = contextFilter.filter(e.context);
     } else {
-      ret.contextKeys = getContextKeys(e);
+      ret.contextKeys = getContextKeysFromEvent(e);
       delete ret['context'];
     }
     if (e.kind === 'feature') {
@@ -60,26 +61,8 @@ function EventProcessor(
     return ret;
   }
 
-  function getContextKeys(event) {
-    const keys = {};
-    const context = event.context;
-    if (context !== undefined) {
-      if (context.kind === undefined) {
-        keys.user = String(context.key);
-      } else if (context.kind === 'multi') {
-        Object.entries(context)
-          .filter(([key]) => key !== 'kind')
-          .forEach(([key, value]) => {
-            if (value !== undefined && value.key !== undefined) {
-              keys[key] = value.key;
-            }
-          });
-      } else {
-        keys[context.kind] = String(context.key);
-      }
-      return keys;
-    }
-    return undefined;
+  function getContextKeysFromEvent(event) {
+    return getContextKeys(event.context, logger);
   }
 
   function addToOutbox(event) {

package/src/__tests__/context-test.js

@@ -1,4 +1,4 @@
-const { checkContext, getContextKinds, getCanonicalKey } = require('../context');
+const { checkContext, getContextKeys, 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',
@@ -91,3 +91,111 @@ describe('when determining canonical keys', () => {
     expect(getCanonicalKey(null)).toBeUndefined();
   });
 });
+
+describe('getContextKeys', () => {
+  it('returns undefined if argument is undefined', () => {
+    const context = undefined;
+    const keys = getContextKeys(context);
+    expect(keys).toBeUndefined();
+  });
+
+  it('works with legacy user without kind attribute', () => {
+    const user = {
+      key: 'legacy-user-key',
+      name: 'Test User',
+      custom: {
+        customAttribute1: true,
+      },
+    };
+    const keys = getContextKeys(user);
+    expect(keys).toEqual({ user: 'legacy-user-key' });
+  });
+
+  it('gets keys from multi context', () => {
+    const context = {
+      kind: 'multi',
+      user: {
+        key: 'test-user-key',
+        name: 'Test User',
+        isPremiumCustomer: true,
+      },
+      organization: {
+        key: 'test-organization-key',
+        name: 'Test Company',
+        industry: 'technology',
+      },
+    };
+    const keys = getContextKeys(context);
+    expect(keys).toEqual({ user: 'test-user-key', organization: 'test-organization-key' });
+  });
+
+  it('ignores undefined keys from multi context', () => {
+    const context = {
+      kind: 'multi',
+      user: {
+        key: 'test-user-key',
+        name: 'Test User',
+        isPremiumCustomer: true,
+      },
+      organization: {
+        name: 'Test Company',
+        industry: 'technology',
+      },
+      rogueAttribute: undefined,
+    };
+    const keys = getContextKeys(context);
+    expect(keys).toEqual({ user: 'test-user-key' });
+  });
+
+  it.only('ignores empty string and null keys from multi context', () => {
+    const context = {
+      kind: 'multi',
+      user: {
+        key: 'test-user-key',
+        name: 'Test User',
+        isPremiumCustomer: true,
+      },
+      organization: {
+        key: '',
+        name: 'Test Company',
+        industry: 'technology',
+      },
+      drone: {
+        key: null,
+        name: 'test-drone',
+      },
+    };
+    const keys = getContextKeys(context);
+    expect(keys).toEqual({ user: 'test-user-key' });
+  });
+
+  it('gets keys from single context', () => {
+    const context = {
+      kind: 'drone',
+      key: 'test-drone-key',
+      name: 'test-drone',
+    };
+    const keys = getContextKeys(context);
+    expect(keys).toEqual({ drone: 'test-drone-key' });
+  });
+
+  it('ignores kind when it is an empty string', () => {
+    const context = {
+      kind: '',
+      key: 'test-drone-key',
+      name: 'test-drone',
+    };
+    const keys = getContextKeys(context);
+    expect(keys).toEqual({});
+  });
+
+  it('ignores kind when it is null', () => {
+    const context = {
+      kind: null,
+      key: 'test-drone-key',
+      name: 'test-drone',
+    };
+    const keys = getContextKeys(context);
+    expect(keys).toEqual({});
+  });
+});

package/src/__tests__/utils-test.js

@@ -1,4 +1,4 @@
-import { appendUrlPath, base64URLEncode, getLDUserAgentString, wrapPromiseCallback, chunkEventsForUrl } from '../utils';
+import { appendUrlPath, base64URLEncode, chunkEventsForUrl, getLDUserAgentString, wrapPromiseCallback } from '../utils';
 
 import * as stubPlatform from './stubPlatform';
 

package/src/context.js

@@ -3,6 +3,8 @@
  * @param {string} kind
  * @returns true if the kind is valid.
  */
+const { commonBasicLogger } = require('./loggers');
+
 function validKind(kind) {
   return typeof kind === 'string' && kind !== 'kind' && kind.match(/^(\w|\.|-)+$/);
 }
@@ -89,8 +91,44 @@ function getCanonicalKey(context) {
   }
 }
 
+function getContextKeys(context, logger = commonBasicLogger()) {
+  if (!context) {
+    return undefined;
+  }
+
+  const keys = {};
+  const { kind, key } = context;
+
+  switch (kind) {
+    case typeof kind === 'undefined':
+      keys.user = `${key}`;
+      break;
+    case 'multi':
+      Object.entries(context)
+        .filter(([key]) => key !== 'kind')
+        .forEach(([key, value]) => {
+          if (value?.key) {
+            keys[key] = value.key;
+          }
+        });
+      break;
+    case null:
+      logger.warn(`null is not a valid context kind: ${context}`);
+      break;
+    case '':
+      logger.warn(`'' is not a valid context kind: ${context}`);
+      break;
+    default:
+      keys[kind] = `${key}`;
+      break;
+  }
+
+  return keys;
+}
+
 module.exports = {
   checkContext,
+  getContextKeys,
   getContextKinds,
   getCanonicalKey,
 };

package/src/index.js

@@ -14,7 +14,7 @@ const { commonBasicLogger } = require('./loggers');
 const utils = require('./utils');
 const errors = require('./errors');
 const messages = require('./messages');
-const { checkContext } = require('./context');
+const { checkContext, getContextKeys } = require('./context');
 const { InspectorTypes, InspectorManager } = require('./InspectorManager');
 
 const changeEvent = 'change';
@@ -809,4 +809,5 @@ module.exports = {
   errors,
   messages,
   utils,
+  getContextKeys,
 };

package/test-types.ts

@@ -91,3 +91,5 @@ var flagSetValue: ld.LDFlagValue = flagSet['key'];
 
 client.close(() => {});
 client.close().then(() => {});
+
+var contextKeys = ld.getContextKeys(user);

package/typings.d.ts

@@ -984,6 +984,11 @@ declare module 'launchdarkly-js-sdk-common' {
    */
   export type LDLogLevel = 'debug' | 'info' | 'warn' | 'error' | 'none';
 
+  export function getContextKeys(
+    context: LDContext,
+    logger?: LDLogger,
+  ): {[attribute: string]: string} | undefined;
+
   /**
    * Callback interface for collecting information about the SDK at runtime.
    *