prebid.js 7.4.0 → 7.7.0

package/modules/userId/index.js

@@ -152,7 +152,7 @@ import {
   isEmpty
 } from '../../src/utils.js';
 import {getPPID as coreGetPPID} from '../../src/adserver.js';
-import {promiseControls} from '../../src/utils/promise.js';
+import {defer, GreedyPromise} from '../../src/utils/promise.js';
 import {hasPurpose1Consent} from '../../src/utils/gpdr.js';
 
 const MODULE_NAME = 'User ID';
@@ -504,15 +504,11 @@ function addIdDataToAdUnitBids(adUnits, submodules) {
   });
 }
 
-function delayFor(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
 const INIT_CANCELED = {};
 
-function idSystemInitializer({delay = delayFor} = {}) {
-  const startInit = promiseControls();
-  const startCallbacks = promiseControls();
+function idSystemInitializer({delay = GreedyPromise.timeout} = {}) {
+  const startInit = defer();
+  const startCallbacks = defer();
   let cancel;
   let initialized = false;
 
@@ -520,8 +516,8 @@ function idSystemInitializer({delay = delayFor} = {}) {
     if (cancel != null) {
       cancel.reject(INIT_CANCELED);
     }
-    cancel = promiseControls();
-    return Promise.race([promise, cancel.promise]);
+    cancel = defer();
+    return GreedyPromise.race([promise, cancel.promise]);
   }
 
   // grab a reference to global vars so that the promise chains remain isolated;
@@ -540,7 +536,7 @@ function idSystemInitializer({delay = delayFor} = {}) {
   }
 
   let done = cancelAndTry(
-    Promise.all([hooksReady, startInit.promise])
+    GreedyPromise.all([hooksReady, startInit.promise])
       .then(() => gdprDataHandler.promise)
       .then(checkRefs((consentData) => {
         initSubmodules(initModules, allModules, consentData);
@@ -549,7 +545,7 @@ function idSystemInitializer({delay = delayFor} = {}) {
       .then(checkRefs(() => {
         const modWithCb = initModules.filter(item => isFn(item.callback));
         if (modWithCb.length) {
-          return new Promise((resolve) => processSubmoduleCallbacks(modWithCb, resolve));
+          return new GreedyPromise((resolve) => processSubmoduleCallbacks(modWithCb, resolve));
         }
       }))
   );
@@ -573,7 +569,7 @@ function idSystemInitializer({delay = delayFor} = {}) {
         });
       }
     }
-    if (refresh) {
+    if (refresh && initialized) {
       done = cancelAndTry(
         done
           .catch(() => null)
@@ -588,7 +584,7 @@ function idSystemInitializer({delay = delayFor} = {}) {
               return sm.callback != null;
             });
             if (cbModules.length) {
-              return new Promise((resolve) => processSubmoduleCallbacks(cbModules, resolve));
+              return new GreedyPromise((resolve) => processSubmoduleCallbacks(cbModules, resolve));
             }
           }))
       );
@@ -621,8 +617,8 @@ function getPPID() {
  * @param {Object} reqBidsConfigObj required; This is the same param that's used in pbjs.requestBids.
  * @param {function} fn required; The next function in the chain, used by hook.js
  */
-export function requestBidsHook(fn, reqBidsConfigObj, {delay = delayFor} = {}) {
-  Promise.race([
+export function requestBidsHook(fn, reqBidsConfigObj, {delay = GreedyPromise.timeout} = {}) {
+  GreedyPromise.race([
     getUserIdsAsync(),
     delay(auctionDelay)
   ]).then(() => {
@@ -767,7 +763,16 @@ function refreshUserIds({submoduleNames} = {}, callback) {
  */
 
 function getUserIdsAsync() {
-  return initIdSystem().then(() => getUserIds(), (e) => e === INIT_CANCELED ? getUserIdsAsync() : Promise.reject(e));
+  return initIdSystem().then(
+    () => getUserIds(),
+    (e) =>
+      e === INIT_CANCELED
+        // there's a pending refresh - because GreedyPromise runs this synchronously, we are now in the middle
+        // of canceling the previous init, before the refresh logic has had a chance to run.
+        // Use a "normal" Promise to clear the stack and let it complete (or this will just recurse infinitely)
+        ? Promise.resolve().then(getUserIdsAsync)
+        : GreedyPromise.reject(e)
+  );
 }
 
 /**
@@ -914,6 +919,8 @@ function updateSubmodules() {
     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));
 
   submodules.splice(0, submodules.length);
@@ -949,6 +956,17 @@ export function attachIdSystem(submodule) {
   if (!find(submoduleRegistry, i => i.name === submodule.name)) {
     submoduleRegistry.push(submodule);
     updateSubmodules();
+    // TODO: a test case wants this to work even if called after init (the setConfig({userId}))
+    // so we trigger a refresh. But is that even possible outside of tests?
+    initIdSystem({refresh: true, submoduleNames: [submodule.name]});
+  }
+}
+
+function normalizePromise(fn) {
+  // for public methods that return promises, make sure we return a "normal" one - to avoid
+  // exposing confusing stack traces
+  return function() {
+    return Promise.resolve(fn.apply(this, arguments));
   }
 }
 
@@ -957,7 +975,7 @@ export function attachIdSystem(submodule) {
  * so a callback is added to fire after the consentManagement module.
  * @param {{getConfig:function}} config
  */
-export function init(config, {delay = delayFor} = {}) {
+export function init(config, {delay = GreedyPromise.timeout} = {}) {
   ppidSource = undefined;
   submodules = [];
   configRegistry = [];
@@ -1002,10 +1020,10 @@ export function init(config, {delay = delayFor} = {}) {
   // exposing getUserIds function in global-name-space so that userIds stored in Prebid can be used by external codes.
   (getGlobal()).getUserIds = getUserIds;
   (getGlobal()).getUserIdsAsEids = getUserIdsAsEids;
-  (getGlobal()).getEncryptedEidsForSource = getEncryptedEidsForSource;
+  (getGlobal()).getEncryptedEidsForSource = normalizePromise(getEncryptedEidsForSource);
   (getGlobal()).registerSignalSources = registerSignalSources;
-  (getGlobal()).refreshUserIds = refreshUserIds;
-  (getGlobal()).getUserIdsAsync = getUserIdsAsync;
+  (getGlobal()).refreshUserIds = normalizePromise(refreshUserIds);
+  (getGlobal()).getUserIdsAsync = normalizePromise(getUserIdsAsync);
   (getGlobal()).getUserIdsAsEidBySource = getUserIdsAsEidBySource;
 }
 

package/package.json

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

package/src/auction.js

@@ -76,6 +76,7 @@ import {bidderSettings} from './bidderSettings.js';
 import * as events from './events.js'
 import adapterManager from './adapterManager.js';
 import CONSTANTS from './constants.json';
+import {GreedyPromise} from './utils/promise.js';
 
 const { syncUsers } = userSync;
 
@@ -384,9 +385,9 @@ export function auctionCallbacks(auctionDone, auctionInstance, {index = auctionM
 
   function waitFor(requestId, result) {
     if (ready[requestId] == null) {
-      ready[requestId] = Promise.resolve();
+      ready[requestId] = GreedyPromise.resolve();
     }
-    ready[requestId] = ready[requestId].then(() => Promise.resolve(result).catch(() => {}))
+    ready[requestId] = ready[requestId].then(() => GreedyPromise.resolve(result).catch(() => {}))
   }
 
   function guard(bidderRequest, fn) {
@@ -398,9 +399,9 @@ export function auctionCallbacks(auctionDone, auctionInstance, {index = auctionM
     const wait = ready[bidderRequest.bidderRequestId];
     const orphanWait = ready['']; // also wait for "orphan" responses that are not associated with any request
     if ((wait != null || orphanWait != null) && timeRemaining > 0) {
-      Promise.race([
-        new Promise((resolve) => setTimeout(resolve, timeRemaining)),
-        Promise.resolve(orphanWait).then(() => wait)
+      GreedyPromise.race([
+        GreedyPromise.timeout(timeRemaining),
+        GreedyPromise.resolve(orphanWait).then(() => wait)
       ]).then(fn);
     } else {
       fn();

package/src/consentHandler.js

@@ -1,10 +1,10 @@
 import {isStr, timestamp} from './utils.js';
+import {defer, GreedyPromise} from './utils/promise.js';
 
 export class ConsentHandler {
   #enabled;
   #data;
-  #promise;
-  #resolve;
+  #defer;
   #ready;
   generatedTime;
 
@@ -12,17 +12,17 @@ export class ConsentHandler {
     this.reset();
   }
 
+  #resolve(data) {
+    this.#ready = true;
+    this.#data = data;
+    this.#defer.resolve(data);
+  }
+
   /**
    * reset this handler (mainly for tests)
    */
   reset() {
-    this.#promise = new Promise((resolve) => {
-      this.#resolve = (data) => {
-        this.#ready = true;
-        this.#data = data;
-        resolve(data);
-      };
-    });
+    this.#defer = defer();
     this.#enabled = false;
     this.#data = null;
     this.#ready = false;
@@ -56,12 +56,12 @@ export class ConsentHandler {
    */
   get promise() {
     if (this.#ready) {
-      return Promise.resolve(this.#data);
+      return GreedyPromise.resolve(this.#data);
     }
     if (!this.#enabled) {
       this.#resolve(null);
     }
-    return this.#promise;
+    return this.#defer.promise;
   }
 
   setConsentData(data, time = timestamp()) {

package/src/debugging.js

@@ -4,6 +4,7 @@ import {getGlobal} from './prebidGlobal.js';
 import {logMessage, prefixLog} from './utils.js';
 import {createBid} from './bidfactory.js';
 import {loadExternalScript} from './adloader.js';
+import {GreedyPromise} from './utils/promise.js';
 
 export const DEBUG_KEY = '__$$PREBID_GLOBAL$$_debugging__';
 
@@ -12,7 +13,7 @@ function isDebuggingInstalled() {
 }
 
 function loadScript(url) {
-  return new Promise((resolve) => {
+  return new GreedyPromise((resolve) => {
     loadExternalScript(url, 'debugging', resolve);
   });
 }
@@ -21,7 +22,8 @@ export function debuggingModuleLoader({alreadyInstalled = isDebuggingInstalled,
   let loading = null;
   return function () {
     if (loading == null) {
-      loading = new Promise((resolve, reject) => {
+      loading = new GreedyPromise((resolve, reject) => {
+        // run this in a 0-delay timeout to give installedModules time to be populated
         setTimeout(() => {
           if (alreadyInstalled()) {
             resolve();
@@ -44,7 +46,7 @@ export function debuggingControls({load = debuggingModuleLoader(), hook = getHoo
   let promise = null;
   let enabled = false;
   function waitForDebugging(next, ...args) {
-    return (promise || Promise.resolve()).then(() => next.apply(this, args))
+    return (promise || GreedyPromise.resolve()).then(() => next.apply(this, args))
   }
   function enable() {
     if (!enabled) {

package/src/hook.js

@@ -1,11 +1,11 @@
 import funHooks from 'fun-hooks/no-eval/index.js';
-import {promiseControls} from './utils/promise.js';
+import {defer} from './utils/promise.js';
 
 export let hook = funHooks({
   ready: funHooks.SYNC | funHooks.ASYNC | funHooks.QUEUE
 });
 
-const readyCtl = promiseControls();
+const readyCtl = defer();
 hook.ready = (() => {
   const ready = hook.ready;
   return function () {

package/src/storageManager.js

@@ -48,7 +48,7 @@ export function newStorageManager({gvlid, moduleName, bidderCode, moduleType} =
       let hookDetails = {
         hasEnforcementHook: false
       }
-      validateStorageEnforcement(gvlid, bidderCode || moduleName, moduleType, hookDetails, function(result) {
+      validateStorageEnforcement(gvlid, bidderCode || moduleName, hookDetails, function(result) {
         if (result && result.hasEnforcementHook) {
           value = cb(result);
         } else {
@@ -303,7 +303,7 @@ export function newStorageManager({gvlid, moduleName, bidderCode, moduleType} =
 /**
  * This hook validates the storage enforcement if gdprEnforcement module is included
  */
-export const validateStorageEnforcement = hook('async', function(gvlid, moduleName, moduleType, hookDetails, callback) {
+export const validateStorageEnforcement = hook('async', function(gvlid, moduleName, hookDetails, callback) {
   callback(hookDetails);
 }, 'validateStorageEnforcement');
 
@@ -322,13 +322,12 @@ export function getCoreStorageManager(moduleName) {
  * @param {Number=} gvlid? Vendor id - required for proper GDPR integration
  * @param {string=} bidderCode? - required for bid adapters
  * @param {string=} moduleName? module name
- * @param {string=} moduleType? module type
  */
-export function getStorageManager({gvlid, moduleName, bidderCode, moduleType} = {}) {
+export function getStorageManager({gvlid, moduleName, bidderCode} = {}) {
   if (arguments.length > 1 || (arguments.length > 0 && !isPlainObject(arguments[0]))) {
     throw new Error('Invalid invocation for getStorageManager')
   }
-  return newStorageManager({gvlid, moduleName, bidderCode, moduleType});
+  return newStorageManager({gvlid, moduleName, bidderCode});
 }
 
 export function resetData() {

package/src/utils/promise.js

@@ -1,36 +1,111 @@
 const SUCCESS = 0;
 const FAIL = 1;
-const RESULT = 2;
 
 /**
- * @returns a {promise, resolve, reject} trio where `promise` is resolved by calling `resolve` or `reject`.
+ * A version of Promise that runs callbacks synchronously when it can (i.e. after it's been fulfilled or rejected).
  */
-export function promiseControls({promiseFactory = (resolver) => new Promise(resolver)} = {}) {
-  const status = {};
+export class GreedyPromise extends Promise {
+  #result;
+  #callbacks;
+  #parent = null;
+
+  /**
+   * Convenience wrapper for setTimeout; takes care of returning an already fulfilled GreedyPromise when the delay is zero.
+   *
+   * @param {Number} delayMs delay in milliseconds
+   * @returns {GreedyPromise} a promise that resolves (to undefined) in `delayMs` milliseconds
+   */
+  static timeout(delayMs = 0) {
+    return new GreedyPromise((resolve) => {
+      delayMs === 0 ? resolve() : setTimeout(resolve, delayMs);
+    });
+  }
 
-  function finisher(slot) {
-    return function (val) {
-      if (typeof status[slot] === 'function') {
-        status[slot](val);
-      } else if (!status[slot]) {
-        status[slot] = true;
-        status[RESULT] = val;
+  constructor(resolver) {
+    const result = [];
+    const callbacks = [];
+    function handler(type, resolveFn) {
+      return function (value) {
+        if (!result.length) {
+          result.push(type, value);
+          while (callbacks.length) callbacks.shift()();
+          resolveFn(value);
+        }
+      }
+    }
+    super(
+      typeof resolver !== 'function'
+        ? resolver // let super throw an error
+        : (resolve, reject) => {
+          const rejectHandler = handler(FAIL, reject);
+          const resolveHandler = (() => {
+            const done = handler(SUCCESS, resolve);
+            return value =>
+              typeof value?.then === 'function' ? value.then(done, rejectHandler) : done(value);
+          })();
+          try {
+            resolver(resolveHandler, rejectHandler);
+          } catch (e) {
+            rejectHandler(e);
+          }
+        }
+    );
+    this.#result = result;
+    this.#callbacks = callbacks;
+  }
+  then(onSuccess, onError) {
+    if (typeof onError === 'function') {
+      // if an error handler is provided, attach a dummy error handler to super,
+      // and do the same for all promises without an error handler that precede this one in a chain.
+      // This is to avoid unhandled rejection events / warnings for errors that were, in fact, handled;
+      // since we are not using super's callback mechanisms we need to make it aware of this separately.
+      let node = this;
+      while (node) {
+        super.then.call(node, null, () => null);
+        const next = node.#parent;
+        node.#parent = null; // since we attached a handler already, we are no longer interested in what will happen later in the chain
+        node = next;
       }
     }
+    const result = this.#result;
+    const res = new GreedyPromise((resolve, reject) => {
+      const continuation = () => {
+        let value = result[1];
+        let [handler, resolveFn] = result[0] === SUCCESS ? [onSuccess, resolve] : [onError, reject];
+        if (typeof handler === 'function') {
+          try {
+            value = handler(value);
+          } catch (e) {
+            reject(e);
+            return;
+          }
+          resolveFn = resolve;
+        }
+        resolveFn(value);
+      }
+      result.length ? continuation() : this.#callbacks.push(continuation);
+    });
+    res.#parent = this;
+    return res;
   }
+}
+
+/**
+ * @returns a {promise, resolve, reject} trio where `promise` is resolved by calling `resolve` or `reject`.
+ */
+export function defer({promiseFactory = (resolver) => new GreedyPromise(resolver)} = {}) {
+  function invoker(delegate) {
+    return (val) => delegate(val);
+  }
+
+  let resolveFn, rejectFn;
 
   return {
     promise: promiseFactory((resolve, reject) => {
-      if (status[SUCCESS] != null) {
-        resolve(status[RESULT]);
-      } else if (status[FAIL] != null) {
-        reject(status[RESULT]);
-      } else {
-        status[SUCCESS] = resolve;
-        status[FAIL] = reject;
-      }
+      resolveFn = resolve;
+      rejectFn = reject;
     }),
-    resolve: finisher(SUCCESS),
-    reject: finisher(FAIL)
+    resolve: invoker(resolveFn),
+    reject: invoker(rejectFn)
   }
 }

package/src/utils.js

@@ -2,6 +2,7 @@ import { config } from './config.js';
 import clone from 'just-clone';
 import {find, includes} from './polyfill.js';
 import CONSTANTS from './constants.json';
+import {GreedyPromise} from './utils/promise.js';
 export { default as deepAccess } from 'dlv/index.js';
 export { default as deepSetValue } from 'dset';
 
@@ -487,7 +488,7 @@ export function hasOwn(objectToCheck, propertyToCheckFor) {
 * @param {HTMLElement} [doc]
 * @param {HTMLElement} [target]
 * @param {Boolean} [asLastChildChild]
-* @return {HTMLElement}
+* @return {HTML Element}
 */
 export function insertElement(elm, doc, target, asLastChildChild) {
   doc = doc || document;
@@ -517,7 +518,7 @@ export function insertElement(elm, doc, target, asLastChildChild) {
  */
 export function waitForElementToLoad(element, timeout) {
   let timer = null;
-  return new Promise((resolve) => {
+  return new GreedyPromise((resolve) => {
     const onLoad = function() {
       element.removeEventListener('load', onLoad);
       element.removeEventListener('error', onLoad);

package/test/helpers/consentData.js

@@ -1,6 +1,7 @@
 import {gdprDataHandler} from 'src/adapterManager.js';
+import {GreedyPromise} from '../../src/utils/promise.js';
 
 export function mockGdprConsent(sandbox, getConsentData = () => null) {
-  sandbox.stub(gdprDataHandler, 'promise').get(() => Promise.resolve(getConsentData()));
+  sandbox.stub(gdprDataHandler, 'promise').get(() => GreedyPromise.resolve(getConsentData()));
   sandbox.stub(gdprDataHandler, 'getConsentData').callsFake(getConsentData)
 }

package/test/spec/auctionmanager_spec.js

@@ -21,7 +21,6 @@ import {auctionManager} from '../../src/auctionManager.js';
 import 'modules/debugging/index.js' // some tests look for debugging side effects
 import {AuctionIndex} from '../../src/auctionIndex.js';
 import {expect} from 'chai';
-import {synchronizePromise} from '../helpers/syncPromise.js';
 
 var assert = require('assert');
 
@@ -134,7 +133,7 @@ function mockAjaxBuilder() {
 }
 
 describe('auctionmanager.js', function () {
-  let indexAuctions, indexStub, promiseSandbox;
+  let indexAuctions, indexStub
 
   before(() => {
     // hooks are global and their side effects depend on what has been loaded
@@ -150,13 +149,10 @@ describe('auctionmanager.js', function () {
     indexAuctions = [];
     indexStub = sinon.stub(auctionManager, 'index');
     indexStub.get(() => new AuctionIndex(() => indexAuctions));
-    promiseSandbox = sinon.createSandbox();
-    synchronizePromise(promiseSandbox);
   });
 
   afterEach(() => {
     indexStub.restore();
-    promiseSandbox.restore();
   });
 
   describe('getKeyValueTargetingPairs', function () {
@@ -1458,7 +1454,6 @@ describe('auctionmanager.js', function () {
       }
 
       beforeEach(() => {
-        promiseSandbox.restore();
         bids = [
           mockBid({bidderCode: BIDDER_CODE1}),
           mockBid({bidderCode: BIDDER_CODE})

package/test/spec/debugging_spec.js

@@ -1,6 +1,6 @@
 import {ready, loadSession, getConfig, reset, debuggingModuleLoader, debuggingControls} from '../../src/debugging.js';
 import {getGlobal} from '../../src/prebidGlobal.js';
-import {promiseControls} from '../../src/utils/promise.js';
+import {defer} from '../../src/utils/promise.js';
 import funHooks from 'fun-hooks/no-eval/index.js';
 
 describe('Debugging', () => {
@@ -67,7 +67,7 @@ describe('Debugging', () => {
     let debugging, loader, hook, hookRan;
 
     beforeEach(() => {
-      loader = promiseControls();
+      loader = defer();
       hookRan = false;
       hook = funHooks()('sync', () => { hookRan = true });
       debugging = debuggingControls({load: sinon.stub().returns(loader.promise), hook});