UserID module: autoRefresh and retainConfig flags

modules/userId/index.js

@@ -142,7 +142,9 @@ import {
   isPlainObject,
   logError,
   logInfo,
-  logWarn
+  logWarn,
+  deepEqual,
+  findBy,
 } from '../../src/utils.js';
 import {getPPID as coreGetPPID} from '../../src/adserver.js';
 import {defer, PbPromise, delay} from '../../src/utils/promise.js';
@@ -1124,35 +1126,53 @@ function updateEIDConfig(submodules) {
   ).forEach(([key, submodules]) => EID_CONFIG.set(key, submodules[0].eids[key]))
 }
 
+export function generateSubmoduleContainers(options, configs, prevSubmodules = submodules, registry = submoduleRegistry) {
+  const {autoRefresh, retainConfig} = options;
+  const normalizer = (val) => (val || '').toLowerCase();
+  return registry
+    .reduce((acc, submodule) => {
+      const {name, aliasName} = submodule;
+      const submoduleConfig = findBy(configs, 'name', [name, aliasName], null, normalizer);
+
+      if (!submoduleConfig) {
+        if (!retainConfig) return acc;
+        const previousSubmodule = findBy(prevSubmodules, 'config.name', [name, aliasName], normalizer);
+        return previousSubmodule ? [...acc, previousSubmodule] : acc;
+      }
+
+      const newSubmoduleContainer = {
+        submodule,
+        config: {
+          ...submoduleConfig,
+          name: submodule.name
+        },
+        callback: undefined,
+        idObj: undefined,
+        storageMgr: getStorageManager({moduleType: MODULE_TYPE_UID, moduleName: submoduleConfig.name})
+      };
+
+      if (autoRefresh) {
+        const previousSubmodule = findBy(prevSubmodules, 'config.name', [name, aliasName], normalizer);
+        newSubmoduleContainer.refreshIds = !previousSubmodule || !deepEqual(newSubmoduleContainer.config, previousSubmodule.config);
+      }
+
+      return [...acc, newSubmoduleContainer];
+    }, []);
+}
+
 /**
  * update submodules by validating against existing configs and storage types
  */
-function updateSubmodules() {
+function updateSubmodules(options = {}) {
   updateEIDConfig(submoduleRegistry);
   const configs = getValidSubmoduleConfigs(configRegistry);
   if (!configs.length) {
     return;
   }
-  // do this to avoid reprocessing submodules
-  // TODO: the logic does not match the comment - addedSubmodules is always a copy of submoduleRegistry
-  // (if it did it would not be correct - it's not enough to find new modules, as others may have been removed or changed)
-  const addedSubmodules = submoduleRegistry.filter(i => !find(submodules, j => j.name === i.name));
 
+  const updatedContainers = generateSubmoduleContainers(options, configs);
   submodules.splice(0, submodules.length);
-  // find submodule and the matching configuration, if found create and append a SubmoduleContainer
-  addedSubmodules.map(i => {
-    const submoduleConfig = find(configs, j => j.name && (j.name.toLowerCase() === i.name.toLowerCase() ||
-      (i.aliasName && j.name.toLowerCase() === i.aliasName.toLowerCase())));
-    if (submoduleConfig && i.name !== submoduleConfig.name) submoduleConfig.name = i.name;
-    return submoduleConfig ? {
-      submodule: i,
-      config: submoduleConfig,
-      callback: undefined,
-      idObj: undefined,
-      storageMgr: getStorageManager({moduleType: MODULE_TYPE_UID, moduleName: submoduleConfig.name}),
-    } : null;
-  }).filter(submodule => submodule !== null)
-    .forEach((sm) => submodules.push(sm));
+  submodules.push(...updatedContainers);
 
   if (submodules.length) {
     if (!addedStartAuctionHook()) {
@@ -1248,12 +1268,17 @@ export function init(config, {mkDelay = delay} = {}) {
     if (userSync) {
       ppidSource = userSync.ppid;
       if (userSync.userIds) {
+        const {autoRefresh = false, retainConfig = true} = userSync;
         configRegistry = userSync.userIds;
         syncDelay = isNumber(userSync.syncDelay) ? userSync.syncDelay : USERSYNC_DEFAULT_CONFIG.syncDelay
         auctionDelay = isNumber(userSync.auctionDelay) ? userSync.auctionDelay : USERSYNC_DEFAULT_CONFIG.auctionDelay;
-        updateSubmodules();
+        updateSubmodules({retainConfig, autoRefresh});
         updateIdPriority(userSync.idPriority, submoduleRegistry);
         initIdSystem({ready: true});
+        const submodulesToRefresh = submodules.filter(item => item.refreshIds);
+        if (submodulesToRefresh.length) {
+          refreshUserIds({submoduleNames: submodulesToRefresh.map(item => item.name)});
+        }
       }
     }
   });

src/utils.js

@@ -1378,3 +1378,11 @@ export function triggerNurlWithCpm(bid, cpm) {
     triggerPixel(bid.nurl);
   }
 }
+
+export function findBy(arr, field, values, thisArg, normalizer = (v) => v) {
+  function getFieldByNestedValue(obj, path) {
+    return path.split('.').reduce((acc, key) => acc?.[key], obj);
+  }
+  const pred = (item) => values.some(value => normalizer(value) === normalizer(getFieldByNestedValue(item, field)));
+  return arr && arr.find(pred, thisArg);
+}

test/spec/modules/userId_spec.js

@@ -38,6 +38,7 @@ import {MODULE_TYPE_UID} from '../../../src/activities/modules.js';
 import {ACTIVITY_ENRICH_EIDS} from '../../../src/activities/activities.js';
 import {ACTIVITY_PARAM_COMPONENT_NAME, ACTIVITY_PARAM_COMPONENT_TYPE} from '../../../src/activities/params.js';
 import {extractEids} from '../../../modules/prebidServerBidAdapter/bidderConfig.js';
+import {generateSubmoduleContainers} from '../../../modules/userId/index.js';
 
 let assert = require('chai').assert;
 let expect = require('chai').expect;
@@ -3150,4 +3151,72 @@ describe('User ID', function () {
       });
     })
   });
+
+  describe('generateSubmoduleContainers', () => {
+    it('should properly map registry to submodule containers for empty previous submodule containers', () => {
+      const previousSubmoduleContainers = [];
+      const submoduleRegistry = [
+        sharedIdSystemSubmodule,
+        createMockIdSubmodule('mockId1Module', { id: { uid2: { id: 'uid2_value' } } }, null, null),
+        createMockIdSubmodule('mockId2Module', { id: { uid2: { id: 'uid2_value' } } }, null, null),
+      ];
+      const configRegistry = [{ name: 'sharedId' }];
+      const result = generateSubmoduleContainers({}, configRegistry, previousSubmoduleContainers, submoduleRegistry);
+      expect(result).to.have.lengthOf(1);
+      expect(result[0].submodule.name).to.eql('sharedId');
+    });
+
+    it('should properly map registry to submodule containers for non-empty previous submodule containers', () => {
+      const previousSubmoduleContainers = [
+        {submodule: {name: 'notSharedId'}, config: {name: 'notSharedId'}},
+        {submodule: {name: 'notSharedId2'}, config: {name: 'notSharedId2'}},
+      ];
+      const submoduleRegistry = [
+        sharedIdSystemSubmodule,
+        createMockIdSubmodule('mockId1Module', { id: { uid2: { id: 'uid2_value' } } }, null, null),
+        createMockIdSubmodule('mockId2Module', { id: { uid2: { id: 'uid2_value' } } }, null, null),
+      ];
+      const configRegistry = [{ name: 'sharedId' }];
+      const result = generateSubmoduleContainers({}, configRegistry, previousSubmoduleContainers, submoduleRegistry);
+      expect(result).to.have.lengthOf(1);
+      expect(result[0].submodule.name).to.eql('sharedId');
+    });
+
+    it('should properly map registry to submodule containers for retainConfig flag', () => {
+      const previousSubmoduleContainers = [
+        {submodule: {name: 'shouldBeKept'}, config: {name: 'shouldBeKept'}},
+      ];
+      const submoduleRegistry = [
+        sharedIdSystemSubmodule,
+        createMockIdSubmodule('shouldBeKept', { id: { uid2: { id: 'uid2_value' } } }, null, null),
+      ];
+      const configRegistry = [{ name: 'sharedId' }];
+      const result = generateSubmoduleContainers({retainConfig: true}, configRegistry, previousSubmoduleContainers, submoduleRegistry);
+      expect(result).to.have.lengthOf(2);
+      expect(result[0].submodule.name).to.eql('sharedId');
+      expect(result[1].submodule.name).to.eql('shouldBeKept');
+    });
+
+    it('should properly map registry to submodule containers for autoRefresh flag', () => {
+      const previousSubmoduleContainers = [
+        {submodule: {name: 'modified'}, config: {name: 'modified', auctionDelay: 300}},
+        {submodule: {name: 'unchanged'}, config: {name: 'unchanged', auctionDelay: 300}},
+      ];
+      const submoduleRegistry = [
+        createMockIdSubmodule('modified', { id: { uid2: { id: 'uid2_value' } } }, null, null),
+        createMockIdSubmodule('new', { id: { uid2: { id: 'uid2_value' } } }, null, null),
+        createMockIdSubmodule('unchanged', { id: { uid2: { id: 'uid2_value' } } }, null, null),
+      ];
+      const configRegistry = [
+        {name: 'modified', auctionDelay: 200},
+        {name: 'new'},
+        {name: 'unchanged', auctionDelay: 300},
+      ];
+      const result = generateSubmoduleContainers({autoRefresh: true}, configRegistry, previousSubmoduleContainers, submoduleRegistry);
+      expect(result).to.have.lengthOf(3);
+      const itemsWithRefreshIds = result.filter(item => item.refreshIds);
+      const submoduleNames = itemsWithRefreshIds.map(item => item.submodule.name);
+      expect(submoduleNames).to.deep.eql(['modified', 'new']);
+    });
+  });
 });

test/spec/utils_spec.js

@@ -4,7 +4,7 @@ import {TARGETING_KEYS} from 'src/constants.js';
 import * as utils from 'src/utils.js';
 import {binarySearch, deepEqual, encodeMacroURI, memoize, sizesToSizeTuples, waitForElementToLoad} from 'src/utils.js';
 import {convertCamelToUnderscore} from '../../libraries/appnexusUtils/anUtils.js';
-import { getWinDimensions, internal } from '../../src/utils.js';
+import { findBy, getWinDimensions, internal } from '../../src/utils.js';
 
 var assert = require('assert');
 
@@ -1352,4 +1352,34 @@ describe('getWinDimensions', () => {
     getWinDimensions();
     sinon.assert.calledTwice(resetWinDimensionsSpy);
   });
+
+  describe('findBy', () => {
+    it('should find item by one the values', () => {
+      const array = [
+        {id: 1, name: 'foo', field: 'field'},
+        {id: 2, name: 'bar', field: 'field'},
+      ];
+      const item = findBy(array, 'name', ['alias', 'bar'], null);
+      expect(item?.id).to.eql(2);
+    });
+
+    it('should find item using normalizer', () => {
+      const array = [
+        {id: 1, quantity: '1', field: 'field'},
+        {id: 2, quantity: '2', field: 'field'},
+      ];
+      const item = findBy(array, 'quantity', [2], null, (v) => Number(v));
+      expect(item?.id).to.eql(2);
+    });
+
+    it('should find item on nested level', () => {
+      const array = [
+        {id: 1, job: {name: 'EY'}, field: 'field'},
+        {id: 2, job: {name: 'KPMG'}, field: 'field'},
+        {id: 3, job: {name: 'PwC'}, field: 'field'},
+      ];
+      const item = findBy(array, 'job.name', ['kpmg'], null, (v) => v.toLowerCase());
+      expect(item?.id).to.eql(2);
+    });
+  });
 });