Update persistence of generated keys for transient contexts. (#60)

Author: kinyoklion

package.json

@@ -27,6 +27,7 @@
     "@babel/preset-env": "^7.6.3",
     "@babel/runtime": "7.6.3",
     "@rollup/plugin-replace": "^2.2.0",
+    "@types/jest": "^27.4.1",
     "babel-eslint": "^10.1.0",
     "babel-jest": "^25.1.0",
     "cross-env": "^5.1.4",

src/TransientContextProcessor.js

@@ -0,0 +1,101 @@
+const { v1: uuidv1 } = require('uuid');
+const { getContextKinds } = require('./context');
+
+const errors = require('./errors');
+const messages = require('./messages');
+const utils = require('./utils');
+
+const ldUserIdKey = 'ld:$anonUserId';
+
+/**
+ * Create an object which can process a context and populate any required keys
+ * for transient objects.
+ *
+ * @param {Object} persistentStorage The persistent storage from which to store
+ * and access persisted transient context keys.
+ * @returns A TransientContextProcessor.
+ */
+function TransientContextProcessor(persistentStorage) {
+  function getContextKeyIdString(kind) {
+    if (kind === undefined || kind === null || kind === 'user') {
+      return ldUserIdKey;
+    }
+    return `ld:$contextKey:${kind}`;
+  }
+
+  function getCachedContextKey(kind) {
+    return persistentStorage.get(getContextKeyIdString(kind));
+  }
+
+  function setCachedContextKey(id, kind) {
+    return persistentStorage.set(getContextKeyIdString(kind), id);
+  }
+
+  /**
+   * Process a single kind context, or a single context within a multi-kind context.
+   * @param {string} kind The kind of the context. Independent because the kind is not prevent
+   * within a context in a multi-kind context.
+   * @param {Object} context
+   * @returns {Promise} a promise that resolves to a processed contexts, or rejects
+   * a context which cannot be processed.
+   */
+  function processSingleKindContext(kind, context) {
+    // We are working on a copy of an original context, so we want to re-assign
+    // versus duplicating it again.
+
+    /* eslint-disable no-param-reassign */
+    if (context.key !== null && context.key !== undefined) {
+      context.key = context.key.toString();
+      return Promise.resolve(context);
+    }
+
+    const transient = ((kind === undefined || kind === null) && context.anonymous) || (kind && context.transient);
+    // If it has no kind, then it is a legacy style user and is transient if 'anonymous' is set.
+    // If it has a kind, then the attribute would be 'transient'.
+
+    // The context did not have a key, so the context needs to be transient, if it
+    // is not transient, then it is not valid.
+    if (transient) {
+      // If the key doesn't exist, then the persistent storage will resolve
+      // with undefined.
+      return getCachedContextKey(kind).then(cachedId => {
+        if (cachedId) {
+          context.key = cachedId;
+          return context;
+        } else {
+          const id = uuidv1();
+          context.key = id;
+          return setCachedContextKey(id, kind).then(() => context);
+        }
+      });
+    } else {
+      return Promise.reject(new errors.LDInvalidUserError(messages.invalidUser()));
+    }
+    /* eslint-enable no-param-reassign */
+  }
+
+  /**
+   * Process the context, returning a Promise that resolves to the processed context, or rejects if there is an error.
+   * @param {Object} context
+   * @returns {Promise} A promise which resolves to a processed context, or a rejection if the context cannot be
+   * processed. The context should still be checked for overall validity after being processed.
+   */
+  this.processContext = context => {
+    if (!context) {
+      return Promise.reject(new errors.LDInvalidUserError(messages.userNotSpecified()));
+    }
+
+    const processedContext = utils.clone(context);
+
+    if (context.kind === 'multi') {
+      const kinds = getContextKinds(processedContext);
+
+      return Promise.all(kinds.map(kind => processSingleKindContext(kind, processedContext[kind]))).then(
+        () => processedContext
+      );
+    }
+    return processSingleKindContext(context.kind, processedContext);
+  };
+}
+
+module.exports = TransientContextProcessor;

src/UserValidator.js

@@ -498,7 +498,11 @@ describe('LDClient', () => {
       });
     });
 
-    it('returns an error and does not update flags when identify is called with invalid user', async () => {
+    it.each([
+      { country: 'US' }, // Legacy user with no key, and not anonymous.
+      { kind: 'user' }, // A single kind that is not transient and has no key.
+      { kind: 'multi', app: { transient: true }, org: {}, user: { key: 'yes' } }, // Multi kind with 1 non-transient context without a key.
+    ])('returns an error and does not update flags when identify is called with invalid contexts', async badContext => {
       const flags0 = { 'enable-foo': { value: false } };
       const flags1 = { 'enable-foo': { value: true } };
       await withServers(async (baseConfig, pollServer) => {
@@ -516,8 +520,7 @@ describe('LDClient', () => {
           expect(client.variation('enable-foo')).toBe(false);
           expect(pollServer.requests.length()).toEqual(1);
 
-          const userWithNoKey = { country: 'US' };
-          await expect(client.identify(userWithNoKey)).rejects.toThrow();
+          await expect(client.identify(badContext)).rejects.toThrow();
 
           expect(client.variation('enable-foo')).toBe(false);
           expect(pollServer.requests.length()).toEqual(1);

src/__tests__/LDClient-test.js

@@ -0,0 +1,115 @@
+import TransientContextProcessor from '../TransientContextProcessor';
+
+describe('TransientContextProcessor', () => {
+  let localStorage;
+  let logger;
+  let uv;
+
+  beforeEach(() => {
+    localStorage = {};
+    logger = {
+      warn: jest.fn(),
+    };
+    uv = new TransientContextProcessor(localStorage, logger);
+  });
+
+  it('rejects null user', async () => {
+    await expect(uv.processContext(null)).rejects.toThrow();
+  });
+
+  it('leaves user with string key unchanged', async () => {
+    const u = { key: 'someone', name: 'me' };
+    expect(await uv.processContext(u)).toEqual(u);
+  });
+
+  it('stringifies non-string key', async () => {
+    const u0 = { key: 123, name: 'me' };
+    const u1 = { key: '123', name: 'me' };
+    expect(await uv.processContext(u0)).toEqual(u1);
+  });
+
+  it('uses cached key for anonymous user', async () => {
+    const cachedKey = 'thing';
+    let storageKey;
+    localStorage.get = async key => {
+      storageKey = key;
+      return cachedKey;
+    };
+    const u = { anonymous: true };
+    expect(await uv.processContext(u)).toEqual({ key: cachedKey, anonymous: true });
+    expect(storageKey).toEqual('ld:$anonUserId');
+  });
+
+  it('generates and stores key for anonymous user', async () => {
+    let storageKey;
+    let storedValue;
+    localStorage.get = async () => null;
+    localStorage.set = async (key, value) => {
+      storageKey = key;
+      storedValue = value;
+    };
+    const u0 = { anonymous: true };
+    const u1 = await uv.processContext(u0);
+    expect(storedValue).toEqual(expect.anything());
+    expect(u1).toEqual({ key: storedValue, anonymous: true });
+    expect(storageKey).toEqual('ld:$anonUserId');
+  });
+
+  it('generates and stores a key for each transient context in a multi-kind context', async () => {
+    const context = {
+      kind: 'multi',
+      user: { transient: true },
+      org: { transient: true },
+      app: { key: 'app' },
+    };
+
+    const storage = {};
+    localStorage.get = async key => storage[key];
+    localStorage.set = async (key, value) => {
+      storage[key] = value;
+    };
+
+    const processed = await uv.processContext(context);
+    expect(processed.user.key).toBeDefined();
+    expect(processed.user.key).not.toEqual(processed.org.key);
+    expect(processed.org.key).toBeDefined();
+    expect(processed.app.key).toEqual('app');
+  });
+
+  it('uses cached keys for context kinds that have already been generated', async () => {
+    const context = {
+      kind: 'multi',
+      user: { transient: true },
+      org: { transient: true },
+      another: { transient: true },
+      app: { key: 'app' },
+    };
+
+    const storage = {
+      'ld:$contextKey:org': 'cachedOrgKey',
+      'ld:$anonUserId': 'cachedUserKey',
+    };
+    localStorage.get = async key => storage[key];
+    localStorage.set = async (key, value) => {
+      storage[key] = value;
+    };
+
+    const processed = await uv.processContext(context);
+    expect(processed.user.key).toEqual('cachedUserKey');
+    expect(processed.org.key).toEqual('cachedOrgKey');
+    expect(processed.another.key).toBeDefined();
+    expect(processed.app.key).toEqual('app');
+  });
+
+  it.each([{ anonymous: true }, { kind: 'user', transient: true }, { kind: 'multi', user: { transient: true } }])(
+    'uses the same key to store any user context (legacy, single, multi)',
+    async context => {
+      const storage = {};
+      localStorage.get = async key => expect(key).toEqual('ld:$anonUserId');
+      localStorage.set = async (key, value) => {
+        storage[key] = value;
+      };
+      await uv.processContext(context);
+    }
+  );
+});