prebid.js 8.0.0 → 8.2.0

package/modules/userId/index.js

@@ -130,7 +130,7 @@ import {find, includes} from '../../src/polyfill.js';
 import {config} from '../../src/config.js';
 import * as events from '../../src/events.js';
 import {getGlobal} from '../../src/prebidGlobal.js';
-import adapterManager, {gdprDataHandler} from '../../src/adapterManager.js';
+import adapterManager, {gdprDataHandler, gppDataHandler} from '../../src/adapterManager.js';
 import CONSTANTS from '../../src/constants.json';
 import {module, ready as hooksReady} from '../../src/hook.js';
 import {buildEidPermissions, createEidsArray, USER_IDS_CONFIG} from './eids.js';
@@ -195,6 +195,9 @@ let initializedSubmodules;
 /** @type {SubmoduleConfig[]} */
 let configRegistry = [];
 
+/** @type {Object} */
+let idPriority = {};
+
 /** @type {Submodule[]} */
 let submoduleRegistry = [];
 
@@ -406,7 +409,7 @@ function storedConsentDataMatchesConsentData(storedConsentData, consentData) {
  * @param {SubmoduleContainer[]} submodules
  * @param {function} cb - callback for after processing is done.
  */
-function processSubmoduleCallbacks(submodules, cb) {
+function processSubmoduleCallbacks(submodules, cb, allModules) {
   cb = uidMetrics().fork().startTiming('userId.callbacks.total').stopBefore(cb);
   const done = delayExecution(() => {
     clearTimeout(timeoutID);
@@ -422,7 +425,7 @@ function processSubmoduleCallbacks(submodules, cb) {
         }
         // cache decoded value (this is copied to every adUnit bid)
         submodule.idObj = submodule.submodule.decode(idObj, submodule.config);
-        updatePPID(submodule.idObj);
+        updatePPID(getCombinedSubmoduleIds(allModules));
       } else {
         logInfo(`${MODULE_NAME}: ${submodule.submodule.name} - request id responded with an empty value`);
       }
@@ -447,14 +450,7 @@ function getCombinedSubmoduleIds(submodules) {
   if (!Array.isArray(submodules) || !submodules.length) {
     return {};
   }
-  const combinedSubmoduleIds = submodules.filter(i => isPlainObject(i.idObj) && Object.keys(i.idObj).length).reduce((carry, i) => {
-    Object.keys(i.idObj).forEach(key => {
-      carry[key] = i.idObj[key];
-    });
-    return carry;
-  }, {});
-
-  return combinedSubmoduleIds;
+  return getPrioritizedCombinedSubmoduleIds(submodules)
 }
 
 /**
@@ -466,9 +462,14 @@ function getSubmoduleId(submodules, sourceName) {
   if (!Array.isArray(submodules) || !submodules.length) {
     return {};
   }
-  const submodule = submodules.filter(sub => isPlainObject(sub.idObj) &&
-    Object.keys(sub.idObj).length && USER_IDS_CONFIG[Object.keys(sub.idObj)[0]]?.source === sourceName);
-  return !isEmpty(submodule) ? submodule[0].idObj : [];
+
+  const prioritisedIds = getPrioritizedCombinedSubmoduleIds(submodules);
+  const eligibleIdName = Object.keys(prioritisedIds).find(idName => {
+    const config = USER_IDS_CONFIG[idName];
+    return config?.source === sourceName || (isFn(config?.getSource) && config.getSource() === sourceName);
+  });
+
+  return eligibleIdName ? {[eligibleIdName]: prioritisedIds[eligibleIdName]} : [];
 }
 
 /**
@@ -480,15 +481,38 @@ function getCombinedSubmoduleIdsForBidder(submodules, bidder) {
   if (!Array.isArray(submodules) || !submodules.length || !bidder) {
     return {};
   }
-  return submodules
+  const eligibleSubmodules = submodules
     .filter(i => !i.config.bidders || !isArray(i.config.bidders) || includes(i.config.bidders, bidder))
+
+  return getPrioritizedCombinedSubmoduleIds(eligibleSubmodules);
+}
+
+/**
+ * @param {SubmoduleContainer[]} submodules
+ */
+function getPrioritizedCombinedSubmoduleIds(submodules) {
+  const combinedIdStates = submodules
     .filter(i => isPlainObject(i.idObj) && Object.keys(i.idObj).length)
     .reduce((carry, i) => {
       Object.keys(i.idObj).forEach(key => {
-        carry[key] = i.idObj[key];
+        const maybeCurrentIdPriority = idPriority[key]?.indexOf(i.submodule.name);
+        const currentIdPriority = isNumber(maybeCurrentIdPriority) ? maybeCurrentIdPriority : -1;
+        const currentIdState = {priority: currentIdPriority, value: i.idObj[key]};
+        if (carry[key]) {
+          const winnerIdState = currentIdState.priority > carry[key].priority ? currentIdState : carry[key];
+          carry[key] = winnerIdState;
+        } else {
+          carry[key] = currentIdState;
+        }
       });
       return carry;
     }, {});
+
+  const result = {};
+  Object.keys(combinedIdStates).forEach(key => {
+    result[key] = combinedIdStates[key].value
+  });
+  return result;
 }
 
 /**
@@ -550,10 +574,13 @@ function idSystemInitializer({delay = GreedyPromise.timeout} = {}) {
   function timeGdpr() {
     return gdprDataHandler.promise.finally(initMetrics.startTiming('userId.init.gdpr'));
   }
+  function timeGpp() {
+    return gppDataHandler.promise.finally(initMetrics.startTiming('userId.init.gpp'))
+  }
 
   let done = cancelAndTry(
     GreedyPromise.all([hooksReady, startInit.promise])
-      .then(timeGdpr)
+      .then(() => GreedyPromise.all([timeGdpr(), timeGpp()]).then(([gdpr]) => gdpr))
       .then(checkRefs((consentData) => {
         initSubmodules(initModules, allModules, consentData);
       }))
@@ -561,7 +588,7 @@ function idSystemInitializer({delay = GreedyPromise.timeout} = {}) {
       .then(checkRefs(() => {
         const modWithCb = initModules.filter(item => isFn(item.callback));
         if (modWithCb.length) {
-          return new GreedyPromise((resolve) => processSubmoduleCallbacks(modWithCb, resolve));
+          return new GreedyPromise((resolve) => processSubmoduleCallbacks(modWithCb, resolve, initModules));
         }
       }))
   );
@@ -600,7 +627,7 @@ function idSystemInitializer({delay = GreedyPromise.timeout} = {}) {
               return sm.callback != null;
             });
             if (cbModules.length) {
-              return new GreedyPromise((resolve) => processSubmoduleCallbacks(cbModules, resolve));
+              return new GreedyPromise((resolve) => processSubmoduleCallbacks(cbModules, resolve, initModules));
             }
           }))
       );
@@ -783,7 +810,7 @@ function getUserIdsAsync() {
   );
 }
 
-function populateSubmoduleId(submodule, consentData, storedConsentData, forceRefresh) {
+function populateSubmoduleId(submodule, consentData, storedConsentData, forceRefresh, allSubmodules) {
   // There are two submodule configuration types to handle: storage or value
   // 1. storage: retrieve user id data from cookie/html storage or with the submodule's getId method
   // 2. value: pass directly to bids
@@ -832,7 +859,7 @@ function populateSubmoduleId(submodule, consentData, storedConsentData, forceRef
       if (response.id) { submodule.idObj = submodule.submodule.decode(response.id, submodule.config); }
     }
   }
-  updatePPID(submodule.idObj);
+  updatePPID(getCombinedSubmoduleIds(allSubmodules));
 }
 
 function updatePPID(userIds = getUserIds()) {
@@ -879,7 +906,7 @@ function initSubmodules(dest, submodules, consentData, forceRefresh = false) {
     const initialized = submodules.reduce((carry, submodule) => {
       return submoduleMetrics(submodule.submodule.name).measureTime('init', () => {
         try {
-          populateSubmoduleId(submodule, consentData, storedConsentData, forceRefresh);
+          populateSubmoduleId(submodule, consentData, storedConsentData, forceRefresh, submodules);
           carry.push(submodule);
         } catch (e) {
           logError(`Error in userID module '${submodule.submodule.name}':`, e);
@@ -1010,6 +1037,25 @@ function updateSubmodules() {
   }
 }
 
+/**
+ * This function will update the idPriority according to the provided configuration
+ * @param {Object} idPriorityConfig
+ * @param {SubmoduleContainer[]} submodules
+ */
+function updateIdPriority(idPriorityConfig, submodules) {
+  if (idPriorityConfig) {
+    const result = {};
+    const aliasToName = new Map(submodules.map(s => s.submodule.aliasName ? [s.submodule.aliasName, s.submodule.name] : []));
+    Object.keys(idPriorityConfig).forEach(key => {
+      const priority = isArray(idPriorityConfig[key]) ? [...idPriorityConfig[key]].reverse() : []
+      result[key] = priority.map(s => aliasToName.has(s) ? aliasToName.get(s) : s);
+    });
+    idPriority = result;
+  } else {
+    idPriority = {};
+  }
+}
+
 export function requestDataDeletion(next, ...args) {
   logInfo('UserID: received data deletion request; deleting all stored IDs...')
   submodules.forEach(submodule => {
@@ -1069,13 +1115,16 @@ export function init(config, {delay = GreedyPromise.timeout} = {}) {
   configListener = config.getConfig('userSync', conf => {
     // Note: support for 'usersync' was dropped as part of Prebid.js 4.0
     const userSync = conf.userSync;
-    ppidSource = userSync.ppid;
-    if (userSync && userSync.userIds) {
-      configRegistry = userSync.userIds;
-      syncDelay = isNumber(userSync.syncDelay) ? userSync.syncDelay : DEFAULT_SYNC_DELAY;
-      auctionDelay = isNumber(userSync.auctionDelay) ? userSync.auctionDelay : NO_AUCTION_DELAY;
-      updateSubmodules();
-      initIdSystem({ready: true});
+    if (userSync) {
+      ppidSource = userSync.ppid;
+      if (userSync.userIds) {
+        configRegistry = userSync.userIds;
+        syncDelay = isNumber(userSync.syncDelay) ? userSync.syncDelay : DEFAULT_SYNC_DELAY;
+        auctionDelay = isNumber(userSync.auctionDelay) ? userSync.auctionDelay : NO_AUCTION_DELAY;
+        updateSubmodules();
+        updateIdPriority(userSync.idPriority, submodules);
+        initIdSystem({ready: true});
+      }
     }
   });
 

package/modules/userId/userId.md

@@ -5,6 +5,9 @@ Example showing `cookie` storage for user id data for each of the submodules
 ```
 pbjs.setConfig({
     userSync: {
+        idPriority: {
+            uid2: ['uid2', 'liveIntentId']
+        }
         userIds: [{
             name: "33acrossId",
             storage: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prebid.js",
-  "version": "8.0.0",
+  "version": "8.2.0",
   "description": "Header Bidding Management Library",
   "main": "src/prebid.js",
   "scripts": {

package/src/activities/params.js

@@ -1,4 +1,5 @@
 import {MODULE_TYPE_BIDDER} from './modules.js';
+import {hook} from '../hook.js';
 
 /**
  * Component ID - who is trying to perform the activity?
@@ -54,6 +55,8 @@ export function activityParamsBuilder(resolveAlias) {
     if (moduleType === MODULE_TYPE_BIDDER) {
       defaults[ACTIVITY_PARAM_ADAPTER_CODE] = resolveAlias(moduleName);
     }
-    return Object.assign(defaults, params);
+    return buildActivityParams(Object.assign(defaults, params));
   }
 }
+
+export const buildActivityParams = hook('sync', params => params);

package/test/spec/libraries/cmp/cmpClient_spec.js

@@ -0,0 +1,233 @@
+import {cmpClient} from '../../../../libraries/cmp/cmpClient.js';
+
+describe('cmpClient', () => {
+  function mockWindow(props = {}) {
+    let listeners = [];
+    const win = {
+      addEventListener: sinon.stub().callsFake((evt, listener) => {
+        evt === 'message' && listeners.push(listener)
+      }),
+      postMessage: sinon.stub().callsFake((msg) => {
+        listeners.forEach(ln => ln({data: msg}))
+      }),
+      ...props,
+    };
+    win.top = win.parent?.top || win;
+    return win;
+  }
+
+  it('should return undefined when there is no CMP', () => {
+    expect(cmpClient({apiName: 'missing'}, mockWindow())).to.not.exist;
+  });
+
+  it('should return undefined when parent is inaccessible', () => {
+    const win = mockWindow();
+    win.top = mockWindow();
+    expect(cmpClient({apiName: 'missing'}, win)).to.not.exist;
+  })
+
+  describe('direct access', () => {
+    let mockApiFn;
+    beforeEach(() => {
+      mockApiFn = sinon.stub();
+    })
+    Object.entries({
+      'on same frame': () => mockWindow({mockApiFn}),
+      'on parent frame': () => mockWindow({parent: mockWindow({parent: mockWindow({parent: mockWindow(), mockApiFn})})}),
+    }).forEach(([t, mkWindow]) => {
+      describe(t, () => {
+        let win, mkClient;
+        beforeEach(() => {
+          win = mkWindow();
+          mkClient = (opts) => cmpClient(Object.assign({apiName: 'mockApiFn'}, opts), win)
+        });
+
+        it('should mark client function as direct', () => {
+          expect(mkClient().isDirect).to.equal(true);
+        });
+
+        it('should find and call the CMP api function', () => {
+          mkClient()({command: 'mockCmd'});
+          sinon.assert.calledWith(mockApiFn, 'mockCmd');
+        });
+
+        describe('should return a promise that', () => {
+          let cbResult;
+          beforeEach(() => {
+            cbResult = [];
+            mockApiFn.callsFake((cmd, callback) => {
+              if (typeof callback === 'function') {
+                callback.apply(this, cbResult);
+              }
+              return 'val'
+            })
+          })
+          Object.entries({
+            callback: [sinon.stub(), 'undefined', undefined],
+            'no callback': [undefined, 'api return value', 'val']
+          }).forEach(([t, [callback, tResult, expectedResult]]) => {
+            describe(`when ${t} is provided`, () => {
+              Object.entries({
+                'no success flag': undefined,
+                'success is set': true
+              }).forEach(([t, success]) => {
+                it(`resolves to ${tResult} (${t})`, (done) => {
+                  cbResult = ['cbVal', success];
+                  mkClient()({callback}).then((val) => {
+                    expect(val).to.equal(expectedResult);
+                    done();
+                  })
+                })
+              });
+            })
+          });
+
+          it('rejects to undefined when callback is provided and success = false', () => {
+            cbResult = ['cbVal', false];
+            mkClient()({callback: sinon.stub()}).catch(val => {
+              expect(val).to.equal('cbVal');
+              done();
+            })
+          });
+
+          it('rejects when CMP api throws', (done) => {
+            mockApiFn.reset();
+            const e = new Error();
+            mockApiFn.throws(e);
+            mkClient()({}).catch(val => {
+              expect(val).to.equal(e);
+              done();
+            });
+          })
+        })
+
+        it('should use apiArgs to choose and order the arguments to pass to the API fn', () => {
+          mkClient({apiArgs: ['parameter', 'command']})({
+            command: 'mockCmd',
+            parameter: 'mockParam',
+            callback() {}
+          });
+          sinon.assert.calledWith(mockApiFn, 'mockParam', 'mockCmd');
+        });
+      })
+    })
+  })
+
+  describe('postMessage access', () => {
+    let messenger, win, response;
+    beforeEach(() => {
+      response = {};
+      messenger = sinon.stub().callsFake((msg) => {
+        if (msg.mockApiCall) {
+          win.postMessage({mockApiReturn: {callId: msg.mockApiCall.callId, ...response}});
+        }
+      });
+    });
+
+    function mkClient(options) {
+      return cmpClient(Object.assign({apiName: 'mockApi'}, options), win);
+    }
+
+    Object.entries({
+      'on same frame': () => {
+        win = mockWindow({frames: {mockApiLocator: true}});
+        win.addEventListener('message', (evt) => messenger(evt.data));
+      },
+      'on parent frame': () => {
+        win = mockWindow({parent: mockWindow({frames: {mockApiLocator: true}})})
+        win.parent.addEventListener('message', evt => messenger(evt.data))
+      }
+    }).forEach(([t, setup]) => {
+      describe(t, () => {
+        beforeEach(setup);
+
+        it('should mark client as not direct', () => {
+          expect(mkClient().isDirect).to.equal(false);
+        });
+
+        it('should find and message the CMP frame', () => {
+          mkClient()({command: 'mockCmd', parameter: 'param'});
+          sinon.assert.calledWithMatch(messenger, {
+            mockApiCall: {
+              command: 'mockCmd',
+              parameter: 'param'
+            }
+          })
+        });
+
+        it('should use apiArgs to choose what to include in the message payload', () => {
+          mkClient({apiArgs: ['command']})({
+            command: 'cmd',
+            parameter: 'param'
+          });
+          sinon.assert.calledWithMatch(messenger, sinon.match((arg) => {
+            return arg.mockApiCall.command === 'cmd' &&
+              !arg.mockApiCall.hasOwnProperty('parameter');
+          }))
+        });
+
+        it('should not include callback in the payload, but still run it on response', () => {
+          const cb = sinon.stub();
+          mkClient({apiArgs: ['command', 'callback']})({
+            command: 'cmd',
+            callback: cb
+          });
+          sinon.assert.calledWithMatch(messenger, sinon.match(arg => !arg.mockApiCall.hasOwnProperty('callback')));
+          sinon.assert.called(cb);
+        });
+
+        it('should use callbackArgs to decide what to pass to callback', () => {
+          const cb = sinon.stub();
+          response = {a: 'one', b: 'two'};
+          mkClient({callbackArgs: ['a', 'b']})({callback: cb});
+          sinon.assert.calledWith(cb, 'one', 'two');
+        })
+
+        describe('should return a promise that', () => {
+          beforeEach(() => {
+            response = {returnValue: 'val'}
+          })
+          Object.entries({
+            'callback': [sinon.stub(), 'undefined', undefined],
+            'no callback': [undefined, 'response returnValue', 'val'],
+          }).forEach(([t, [callback, tResult, expectedResult]]) => {
+            describe(`when ${t} is provided`, () => {
+              Object.entries({
+                'no success flag': {},
+                'with success flag': {success: true}
+              }).forEach(([t, resp]) => {
+                it(`resolves to ${tResult} (${t})`, () => {
+                  Object.assign(response, resp);
+                  mkClient()({callback}).then((val) => {
+                    expect(val).to.equal(expectedResult);
+                  })
+                })
+              });
+
+              it(`rejects to ${tResult} when success = false`, (done) => {
+                response.success = false;
+                mkClient()({callback}).catch((err) => {
+                  expect(err).to.equal(expectedResult);
+                  done();
+                });
+              });
+            })
+          });
+        });
+
+        it('should re-use callback for messages with same callId', () => {
+          messenger.reset();
+          let callId;
+          messenger.callsFake((msg) => { if (msg.mockApiCall) callId = msg.mockApiCall.callId });
+          const callback = sinon.stub();
+          mkClient()({callback});
+          expect(callId).to.exist;
+          win.postMessage({mockApiReturn: {callId, returnValue: 'a'}});
+          win.postMessage({mockApiReturn: {callId, returnValue: 'b'}});
+          sinon.assert.calledWith(callback, 'a');
+          sinon.assert.calledWith(callback, 'b');
+        })
+      });
+    });
+  });
+});