prebid.js 6.7.0 → 6.11.0

package/src/auction.js

@@ -58,8 +58,8 @@
  */
 
 import {
-  flatten, timestamp, adUnitsFilter, deepAccess, getBidRequest, getValue, parseUrl, generateUUID,
-  logMessage, bind, logError, logInfo, logWarn, isEmpty, _each, isFn, isEmptyStr, isAllowZeroCpmBidsEnabled
+  flatten, timestamp, adUnitsFilter, deepAccess, getValue, parseUrl, generateUUID,
+  logMessage, bind, logError, logInfo, logWarn, isEmpty, _each, isFn, isEmptyStr
 } from './utils.js';
 import { getPriceBucketString } from './cpmBucketManager.js';
 import { getNativeTargeting } from './native.js';
@@ -72,6 +72,8 @@ import find from 'core-js-pure/features/array/find.js';
 import includes from 'core-js-pure/features/array/includes.js';
 import { OUTSTREAM } from './video.js';
 import { VIDEO } from './mediaTypes.js';
+import {auctionManager} from './auctionManager.js';
+import {bidderSettings} from './bidderSettings.js';
 
 const { syncUsers } = userSync;
 
@@ -249,12 +251,7 @@ export function newAuction({adUnits, adUnitCodes, callback, cbTimeout, labels, a
         events.emit(CONSTANTS.EVENTS.AUCTION_INIT, getProperties());
 
         let callbacks = auctionCallbacks(auctionDone, this);
-        adapterManager.callBids(_adUnits, bidRequests, function(...args) {
-          addBidResponse.apply({
-            dispatch: callbacks.addBidResponse,
-            bidderRequest: this
-          }, args)
-        }, callbacks.adapterDone, {
+        adapterManager.callBids(_adUnits, bidRequests, callbacks.addBidResponse, callbacks.adapterDone, {
           request(source, origin) {
             increment(outstandingRequests, origin);
             increment(requests, source);
@@ -344,6 +341,7 @@ export function newAuction({adUnits, adUnitCodes, callback, cbTimeout, labels, a
     addWinningBid,
     setBidTargeting,
     getWinningBids: () => _winningBids,
+    getAuctionStart: () => _auctionStart,
     getTimeout: () => _timeout,
     getAuctionId: () => _auctionId,
     getAuctionStatus: () => _auctionStatus,
@@ -351,12 +349,13 @@ export function newAuction({adUnits, adUnitCodes, callback, cbTimeout, labels, a
     getAdUnitCodes: () => _adUnitCodes,
     getBidRequests: () => _bidderRequests,
     getBidsReceived: () => _bidsReceived,
-    getNoBids: () => _noBids
+    getNoBids: () => _noBids,
+
   }
 }
 
-export const addBidResponse = hook('async', function(adUnitCode, bid) {
-  this.dispatch.call(this.bidderRequest, adUnitCode, bid);
+export const addBidResponse = hook('sync', function(adUnitCode, bid) {
+  this.dispatch.call(null, adUnitCode, bid);
 }, 'addBidResponse');
 
 export const addBidderRequests = hook('sync', function(bidderRequests) {
@@ -369,11 +368,37 @@ export const bidsBackCallback = hook('async', function (adUnits, callback) {
   }
 }, 'bidsBackCallback');
 
-export function auctionCallbacks(auctionDone, auctionInstance) {
+export function auctionCallbacks(auctionDone, auctionInstance, {index = auctionManager.index} = {}) {
   let outstandingBidsAdded = 0;
   let allAdapterCalledDone = false;
   let bidderRequestsDone = new Set();
   let bidResponseMap = {};
+  const ready = {};
+
+  function waitFor(requestId, result) {
+    if (ready[requestId] == null) {
+      ready[requestId] = Promise.resolve();
+    }
+    ready[requestId] = ready[requestId].then(() => Promise.resolve(result).catch(() => {}))
+  }
+
+  function guard(bidderRequest, fn) {
+    let timeout = bidderRequest.timeout;
+    if (timeout == null || timeout > auctionInstance.getTimeout()) {
+      timeout = auctionInstance.getTimeout();
+    }
+    const timeRemaining = auctionInstance.getAuctionStart() + timeout - Date.now();
+    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)
+      ]).then(fn);
+    } else {
+      fn();
+    }
+  }
 
   function afterBidAdded() {
     outstandingBidsAdded--;
@@ -382,18 +407,16 @@ export function auctionCallbacks(auctionDone, auctionInstance) {
     }
   }
 
-  function addBidResponse(adUnitCode, bid) {
-    let bidderRequest = this;
-
+  function handleBidResponse(adUnitCode, bid) {
     bidResponseMap[bid.requestId] = true;
 
     outstandingBidsAdded++;
     let auctionId = auctionInstance.getAuctionId();
 
-    let bidResponse = getPreparedBidForAuction({adUnitCode, bid, bidderRequest, auctionId});
+    let bidResponse = getPreparedBidForAuction({adUnitCode, bid, auctionId});
 
     if (bidResponse.mediaType === 'video') {
-      tryAddVideoBid(auctionInstance, bidResponse, bidderRequest, afterBidAdded);
+      tryAddVideoBid(auctionInstance, bidResponse, afterBidAdded);
     } else {
       addBidToAuction(auctionInstance, bidResponse);
       afterBidAdded();
@@ -429,8 +452,15 @@ export function auctionCallbacks(auctionDone, auctionInstance) {
   }
 
   return {
-    addBidResponse,
-    adapterDone
+    addBidResponse: function (adUnit, bid) {
+      const bidderRequest = index.getBidderRequest(bid);
+      waitFor((bidderRequest && bidderRequest.bidderRequestId) || '', addBidResponse.call({
+        dispatch: handleBidResponse,
+      }, adUnit, bid));
+    },
+    adapterDone: function () {
+      guard(this, adapterDone.bind(this))
+    }
   }
 }
 
@@ -442,9 +472,7 @@ export function doCallbacksIfTimedout(auctionInstance, bidResponse) {
 
 // Add a bid to the auction.
 export function addBidToAuction(auctionInstance, bidResponse) {
-  let bidderRequests = auctionInstance.getBidRequests();
-  let bidderRequest = find(bidderRequests, bidderRequest => bidderRequest.bidderCode === bidResponse.bidderCode);
-  setupBidTargeting(bidResponse, bidderRequest);
+  setupBidTargeting(bidResponse);
 
   events.emit(CONSTANTS.EVENTS.BID_RESPONSE, bidResponse);
   auctionInstance.addBidReceived(bidResponse);
@@ -453,18 +481,20 @@ export function addBidToAuction(auctionInstance, bidResponse) {
 }
 
 // Video bids may fail if the cache is down, or there's trouble on the network.
-function tryAddVideoBid(auctionInstance, bidResponse, bidRequests, afterBidAdded) {
+function tryAddVideoBid(auctionInstance, bidResponse, afterBidAdded, {index = auctionManager.index} = {}) {
   let addBid = true;
 
-  const bidderRequest = getBidRequest(bidResponse.originalRequestId || bidResponse.requestId, [bidRequests]);
-  const videoMediaType =
-  bidderRequest && deepAccess(bidderRequest, 'mediaTypes.video');
+  const videoMediaType = deepAccess(
+    index.getMediaTypes({
+      requestId: bidResponse.originalRequestId || bidResponse.requestId,
+      transactionId: bidResponse.transactionId
+    }), 'video');
   const context = videoMediaType && deepAccess(videoMediaType, 'context');
 
   if (config.getConfig('cache.url') && context !== OUTSTREAM) {
     if (!bidResponse.videoCacheKey || config.getConfig('cache.ignoreBidderCacheKey')) {
       addBid = false;
-      callPrebidCache(auctionInstance, bidResponse, afterBidAdded, bidderRequest);
+      callPrebidCache(auctionInstance, bidResponse, afterBidAdded, videoMediaType);
     } else if (!bidResponse.vastUrl) {
       logError('videoCacheKey specified but not required vastUrl for video bid');
       addBid = false;
@@ -476,7 +506,7 @@ function tryAddVideoBid(auctionInstance, bidResponse, bidRequests, afterBidAdded
   }
 }
 
-export const callPrebidCache = hook('async', function(auctionInstance, bidResponse, afterBidAdded, bidderRequest) {
+export const callPrebidCache = hook('async', function(auctionInstance, bidResponse, afterBidAdded, videoMediaType) {
   store([bidResponse], function (error, cacheIds) {
     if (error) {
       logWarn(`Failed to save to the video cache: ${error}. Video bid must be discarded.`);
@@ -497,13 +527,14 @@ export const callPrebidCache = hook('async', function(auctionInstance, bidRespon
         afterBidAdded();
       }
     }
-  }, bidderRequest);
+  });
 }, 'callPrebidCache');
 
 // Postprocess the bids so that all the universal properties exist, no matter which bidder they came from.
 // This should be called before addBidToAuction().
-function getPreparedBidForAuction({adUnitCode, bid, bidderRequest, auctionId}) {
-  const start = bidderRequest.start;
+function getPreparedBidForAuction({adUnitCode, bid, auctionId}, {index = auctionManager.index} = {}) {
+  const bidderRequest = index.getBidderRequest(bid);
+  const start = (bidderRequest && bidderRequest.start) || bid.requestTimestamp;
 
   let bidObject = Object.assign({}, bid, {
     auctionId,
@@ -523,14 +554,12 @@ function getPreparedBidForAuction({adUnitCode, bid, bidderRequest, auctionId}) {
   events.emit(CONSTANTS.EVENTS.BID_ADJUSTMENT, bidObject);
 
   // a publisher-defined renderer can be used to render bids
-  const bidReq = bidderRequest.bids && find(bidderRequest.bids, bid => bid.adUnitCode == adUnitCode && bid.bidId == bidObject.requestId);
-  const adUnitRenderer = bidReq && bidReq.renderer;
+  const adUnitRenderer = index.getAdUnit(bidObject).renderer;
 
   // a publisher can also define a renderer for a mediaType
   const bidObjectMediaType = bidObject.mediaType;
-  const bidMediaType = bidReq &&
-        bidReq.mediaTypes &&
-        bidReq.mediaTypes[bidObjectMediaType];
+  const mediaTypes = index.getMediaTypes(bidObject)
+  const bidMediaType = mediaTypes && mediaTypes[bidObjectMediaType];
 
   var mediaTypeRenderer = bidMediaType && bidMediaType.renderer;
 
@@ -549,7 +578,7 @@ function getPreparedBidForAuction({adUnitCode, bid, bidderRequest, auctionId}) {
   }
 
   // Use the config value 'mediaTypeGranularity' if it has been defined for mediaType, else use 'customPriceBucket'
-  const mediaTypeGranularity = getMediaTypeGranularity(bid.mediaType, bidReq, config.getConfig('mediaTypePriceGranularity'));
+  const mediaTypeGranularity = getMediaTypeGranularity(bid.mediaType, mediaTypes, config.getConfig('mediaTypePriceGranularity'));
   const priceStringsObj = getPriceBucketString(
     bidObject.cpm,
     (typeof mediaTypeGranularity === 'object') ? mediaTypeGranularity : config.getConfig('customPriceBucket'),
@@ -565,12 +594,11 @@ function getPreparedBidForAuction({adUnitCode, bid, bidderRequest, auctionId}) {
   return bidObject;
 }
 
-function setupBidTargeting(bidObject, bidderRequest) {
+function setupBidTargeting(bidObject) {
   let keyValues;
-  const cpmCheck = (isAllowZeroCpmBidsEnabled(bidObject.bidderCode)) ? bidObject.cpm >= 0 : bidObject.cpm > 0;
+  const cpmCheck = (bidderSettings.get(bidObject.bidderCode, 'allowZeroCpmBids') === true) ? bidObject.cpm >= 0 : bidObject.cpm > 0;
   if (bidObject.bidderCode && (cpmCheck || bidObject.dealId)) {
-    let bidReq = find(bidderRequest.bids, bid => bid.adUnitCode === bidObject.adUnitCode && bid.bidId === bidObject.requestId);
-    keyValues = getKeyValueTargetingPairs(bidObject.bidderCode, bidObject, bidReq);
+    keyValues = getKeyValueTargetingPairs(bidObject.bidderCode, bidObject);
   }
 
   // use any targeting provided as defaults, otherwise just set from getKeyValueTargetingPairs
@@ -579,14 +607,14 @@ function setupBidTargeting(bidObject, bidderRequest) {
 
 /**
  * @param {MediaType} mediaType
- * @param {Bid} [bidReq]
+ * @param mediaTypes media types map from adUnit
  * @param {MediaTypePriceGranularity} [mediaTypePriceGranularity]
  * @returns {(Object|string|undefined)}
  */
-export function getMediaTypeGranularity(mediaType, bidReq, mediaTypePriceGranularity) {
+export function getMediaTypeGranularity(mediaType, mediaTypes, mediaTypePriceGranularity) {
   if (mediaType && mediaTypePriceGranularity) {
     if (mediaType === VIDEO) {
-      const context = deepAccess(bidReq, `mediaTypes.${VIDEO}.context`, 'instream');
+      const context = deepAccess(mediaTypes, `${VIDEO}.context`, 'instream');
       if (mediaTypePriceGranularity[`${VIDEO}-${context}`]) {
         return mediaTypePriceGranularity[`${VIDEO}-${context}`];
       }
@@ -597,14 +625,14 @@ export function getMediaTypeGranularity(mediaType, bidReq, mediaTypePriceGranula
 
 /**
  * This function returns the price granularity defined. It can be either publisher defined or default value
- * @param {string} mediaType
- * @param {BidRequest} bidReq
+ * @param bid bid response object
+ * @param index
  * @returns {string} granularity
  */
-export const getPriceGranularity = (mediaType, bidReq) => {
+export const getPriceGranularity = (bid, {index = auctionManager.index} = {}) => {
   // Use the config value 'mediaTypeGranularity' if it has been set for mediaType, else use 'priceGranularity'
-  const mediaTypeGranularity = getMediaTypeGranularity(mediaType, bidReq, config.getConfig('mediaTypePriceGranularity'));
-  const granularity = (typeof mediaType === 'string' && mediaTypeGranularity) ? ((typeof mediaTypeGranularity === 'string') ? mediaTypeGranularity : 'custom') : config.getConfig('priceGranularity');
+  const mediaTypeGranularity = getMediaTypeGranularity(bid.mediaType, index.getMediaTypes(bid), config.getConfig('mediaTypePriceGranularity'));
+  const granularity = (typeof bid.mediaType === 'string' && mediaTypeGranularity) ? ((typeof mediaTypeGranularity === 'string') ? mediaTypeGranularity : 'custom') : config.getConfig('priceGranularity');
   return granularity;
 }
 
@@ -614,19 +642,19 @@ export const getPriceGranularity = (mediaType, bidReq) => {
  * @returns {function}
  */
 export const getPriceByGranularity = (granularity) => {
-  return (bid, bidReq) => {
-    granularity = granularity || getPriceGranularity(bid.mediaType, bidReq);
-    if (granularity === CONSTANTS.GRANULARITY_OPTIONS.AUTO) {
+  return (bid) => {
+    const bidGranularity = granularity || getPriceGranularity(bid);
+    if (bidGranularity === CONSTANTS.GRANULARITY_OPTIONS.AUTO) {
       return bid.pbAg;
-    } else if (granularity === CONSTANTS.GRANULARITY_OPTIONS.DENSE) {
+    } else if (bidGranularity === CONSTANTS.GRANULARITY_OPTIONS.DENSE) {
       return bid.pbDg;
-    } else if (granularity === CONSTANTS.GRANULARITY_OPTIONS.LOW) {
+    } else if (bidGranularity === CONSTANTS.GRANULARITY_OPTIONS.LOW) {
       return bid.pbLg;
-    } else if (granularity === CONSTANTS.GRANULARITY_OPTIONS.MEDIUM) {
+    } else if (bidGranularity === CONSTANTS.GRANULARITY_OPTIONS.MEDIUM) {
       return bid.pbMg;
-    } else if (granularity === CONSTANTS.GRANULARITY_OPTIONS.HIGH) {
+    } else if (bidGranularity === CONSTANTS.GRANULARITY_OPTIONS.HIGH) {
       return bid.pbHg;
-    } else if (granularity === CONSTANTS.GRANULARITY_OPTIONS.CUSTOM) {
+    } else if (bidGranularity === CONSTANTS.GRANULARITY_OPTIONS.CUSTOM) {
       return bid.pbCg;
     }
   }
@@ -642,6 +670,34 @@ export const getAdvertiserDomain = () => {
   }
 }
 
+// factory for key value objs
+function createKeyVal(key, value) {
+  return {
+    key,
+    val: (typeof value === 'function')
+      ? function (bidResponse, bidReq) {
+        return value(bidResponse, bidReq);
+      }
+      : function (bidResponse) {
+        return getValue(bidResponse, value);
+      }
+  };
+}
+
+function defaultAdserverTargeting() {
+  const TARGETING_KEYS = CONSTANTS.TARGETING_KEYS;
+  return [
+    createKeyVal(TARGETING_KEYS.BIDDER, 'bidderCode'),
+    createKeyVal(TARGETING_KEYS.AD_ID, 'adId'),
+    createKeyVal(TARGETING_KEYS.PRICE_BUCKET, getPriceByGranularity()),
+    createKeyVal(TARGETING_KEYS.SIZE, 'size'),
+    createKeyVal(TARGETING_KEYS.DEAL, 'dealId'),
+    createKeyVal(TARGETING_KEYS.SOURCE, 'source'),
+    createKeyVal(TARGETING_KEYS.FORMAT, 'mediaType'),
+    createKeyVal(TARGETING_KEYS.ADOMAIN, getAdvertiserDomain()),
+  ]
+}
+
 /**
  * @param {string} mediaType
  * @param {string} bidderCode
@@ -649,40 +705,16 @@ export const getAdvertiserDomain = () => {
  * @returns {*}
  */
 export function getStandardBidderSettings(mediaType, bidderCode) {
-  // factory for key value objs
-  function createKeyVal(key, value) {
-    return {
-      key,
-      val: (typeof value === 'function')
-        ? function (bidResponse, bidReq) {
-          return value(bidResponse, bidReq);
-        }
-        : function (bidResponse) {
-          return getValue(bidResponse, value);
-        }
-    };
-  }
   const TARGETING_KEYS = CONSTANTS.TARGETING_KEYS;
+  const standardSettings = Object.assign({}, bidderSettings.settingsFor(null));
 
-  let bidderSettings = $$PREBID_GLOBAL$$.bidderSettings;
-  if (!bidderSettings[CONSTANTS.JSON_MAPPING.BD_SETTING_STANDARD]) {
-    bidderSettings[CONSTANTS.JSON_MAPPING.BD_SETTING_STANDARD] = {};
-  }
-  if (!bidderSettings[CONSTANTS.JSON_MAPPING.BD_SETTING_STANDARD][CONSTANTS.JSON_MAPPING.ADSERVER_TARGETING]) {
-    bidderSettings[CONSTANTS.JSON_MAPPING.BD_SETTING_STANDARD][CONSTANTS.JSON_MAPPING.ADSERVER_TARGETING] = [
-      createKeyVal(TARGETING_KEYS.BIDDER, 'bidderCode'),
-      createKeyVal(TARGETING_KEYS.AD_ID, 'adId'),
-      createKeyVal(TARGETING_KEYS.PRICE_BUCKET, getPriceByGranularity()),
-      createKeyVal(TARGETING_KEYS.SIZE, 'size'),
-      createKeyVal(TARGETING_KEYS.DEAL, 'dealId'),
-      createKeyVal(TARGETING_KEYS.SOURCE, 'source'),
-      createKeyVal(TARGETING_KEYS.FORMAT, 'mediaType'),
-      createKeyVal(TARGETING_KEYS.ADOMAIN, getAdvertiserDomain()),
-    ]
+  if (!standardSettings[CONSTANTS.JSON_MAPPING.ADSERVER_TARGETING]) {
+    standardSettings[CONSTANTS.JSON_MAPPING.ADSERVER_TARGETING] = defaultAdserverTargeting();
   }
 
   if (mediaType === 'video') {
-    const adserverTargeting = bidderSettings[CONSTANTS.JSON_MAPPING.BD_SETTING_STANDARD][CONSTANTS.JSON_MAPPING.ADSERVER_TARGETING];
+    const adserverTargeting = standardSettings[CONSTANTS.JSON_MAPPING.ADSERVER_TARGETING].slice();
+    standardSettings[CONSTANTS.JSON_MAPPING.ADSERVER_TARGETING] = adserverTargeting;
 
     // Adding hb_uuid + hb_cache_id
     [TARGETING_KEYS.UUID, TARGETING_KEYS.CACHE_ID].forEach(targetingKeyVal => {
@@ -692,7 +724,7 @@ export function getStandardBidderSettings(mediaType, bidderCode) {
     });
 
     // Adding hb_cache_host
-    if (config.getConfig('cache.url') && (!bidderCode || deepAccess(bidderSettings, `${bidderCode}.sendStandardTargeting`) !== false)) {
+    if (config.getConfig('cache.url') && (!bidderCode || bidderSettings.get(bidderCode, 'sendStandardTargeting') !== false)) {
       const urlInfo = parseUrl(config.getConfig('cache.url'));
 
       if (typeof find(adserverTargeting, targetingKeyVal => targetingKeyVal.key === TARGETING_KEYS.CACHE_HOST) === 'undefined') {
@@ -703,33 +735,30 @@ export function getStandardBidderSettings(mediaType, bidderCode) {
       }
     }
   }
-  return bidderSettings[CONSTANTS.JSON_MAPPING.BD_SETTING_STANDARD];
+  return standardSettings;
 }
 
-export function getKeyValueTargetingPairs(bidderCode, custBidObj, bidReq) {
+export function getKeyValueTargetingPairs(bidderCode, custBidObj, {index = auctionManager.index} = {}) {
   if (!custBidObj) {
     return {};
   }
-
+  const bidRequest = index.getBidRequest(custBidObj);
   var keyValues = {};
-  var bidderSettings = $$PREBID_GLOBAL$$.bidderSettings;
 
   // 1) set the keys from "standard" setting or from prebid defaults
-  if (bidderSettings) {
-    // initialize default if not set
-    const standardSettings = getStandardBidderSettings(custBidObj.mediaType, bidderCode);
-    setKeys(keyValues, standardSettings, custBidObj, bidReq);
-
-    // 2) set keys from specific bidder setting override if they exist
-    if (bidderCode && bidderSettings[bidderCode] && bidderSettings[bidderCode][CONSTANTS.JSON_MAPPING.ADSERVER_TARGETING]) {
-      setKeys(keyValues, bidderSettings[bidderCode], custBidObj, bidReq);
-      custBidObj.sendStandardTargeting = bidderSettings[bidderCode].sendStandardTargeting;
-    }
+  // initialize default if not set
+  const standardSettings = getStandardBidderSettings(custBidObj.mediaType, bidderCode);
+  setKeys(keyValues, standardSettings, custBidObj, bidRequest);
+
+  // 2) set keys from specific bidder setting override if they exist
+  if (bidderCode && bidderSettings.getOwn(bidderCode, CONSTANTS.JSON_MAPPING.ADSERVER_TARGETING)) {
+    setKeys(keyValues, bidderSettings.ownSettingsFor(bidderCode), custBidObj, bidRequest);
+    custBidObj.sendStandardTargeting = bidderSettings.get(bidderCode, 'sendStandardTargeting');
   }
 
   // set native key value targeting
   if (custBidObj['native']) {
-    keyValues = Object.assign({}, keyValues, getNativeTargeting(custBidObj, bidReq));
+    keyValues = Object.assign({}, keyValues, getNativeTargeting(custBidObj));
   }
 
   return keyValues;
@@ -776,19 +805,13 @@ function setKeys(keyValues, bidderSettings, custBidObj, bidReq) {
 export function adjustBids(bid) {
   let code = bid.bidderCode;
   let bidPriceAdjusted = bid.cpm;
-  let bidCpmAdjustment;
-  if ($$PREBID_GLOBAL$$.bidderSettings) {
-    if (code && $$PREBID_GLOBAL$$.bidderSettings[code] && typeof $$PREBID_GLOBAL$$.bidderSettings[code].bidCpmAdjustment === 'function') {
-      bidCpmAdjustment = $$PREBID_GLOBAL$$.bidderSettings[code].bidCpmAdjustment;
-    } else if ($$PREBID_GLOBAL$$.bidderSettings[CONSTANTS.JSON_MAPPING.BD_SETTING_STANDARD] && typeof $$PREBID_GLOBAL$$.bidderSettings[CONSTANTS.JSON_MAPPING.BD_SETTING_STANDARD].bidCpmAdjustment === 'function') {
-      bidCpmAdjustment = $$PREBID_GLOBAL$$.bidderSettings[CONSTANTS.JSON_MAPPING.BD_SETTING_STANDARD].bidCpmAdjustment;
-    }
-    if (bidCpmAdjustment) {
-      try {
-        bidPriceAdjusted = bidCpmAdjustment(bid.cpm, Object.assign({}, bid));
-      } catch (e) {
-        logError('Error during bid adjustment', 'bidmanager.js', e);
-      }
+  const bidCpmAdjustment = bidderSettings.get(code || null, 'bidCpmAdjustment');
+
+  if (bidCpmAdjustment && typeof bidCpmAdjustment === 'function') {
+    try {
+      bidPriceAdjusted = bidCpmAdjustment(bid.cpm, Object.assign({}, bid));
+    } catch (e) {
+      logError('Error during bid adjustment', 'bidmanager.js', e);
     }
   }
 

package/src/auctionIndex.js

@@ -0,0 +1,85 @@
+/**
+ * Retrieves request-related bid data.
+ * All methods are designed to work with Bid (response) objects returned by bid adapters.
+ */
+export function AuctionIndex(getAuctions) {
+  Object.assign(this, {
+    /**
+     * @param auctionId
+     * @returns {*} Auction instance for `auctionId`
+     */
+    getAuction({auctionId}) {
+      if (auctionId != null) {
+        return getAuctions()
+          .find(auction => auction.getAuctionId() === auctionId);
+      }
+    },
+    /**
+     * NOTE: you should prefer {@link #getMediaTypes} for looking up bid media types.
+     * @param transactionId
+     * @returns adUnit object for `transactionId`
+     */
+    getAdUnit({transactionId}) {
+      if (transactionId != null) {
+        return getAuctions()
+          .flatMap(a => a.getAdUnits())
+          .find(au => au.transactionId === transactionId);
+      }
+    },
+    /**
+     * @param transactionId
+     * @param requestId?
+     * @returns {*} mediaTypes object from bidRequest (through requestId) falling back to the adUnit (through transactionId).
+     *
+     * The bidRequest is given precedence because its mediaTypes can differ from the adUnit's (if bidder-specific labels are in use).
+     * Bids that have no associated request do not have labels either, and use the adUnit's mediaTypes.
+     */
+    getMediaTypes({transactionId, requestId}) {
+      if (requestId != null) {
+        const req = this.getBidRequest({requestId});
+        if (req != null && (transactionId == null || req.transactionId === transactionId)) {
+          return req.mediaTypes;
+        }
+      } else if (transactionId != null) {
+        const au = this.getAdUnit({transactionId});
+        if (au != null) {
+          return au.mediaTypes;
+        }
+      }
+    },
+    /**
+     * @param requestId?
+     * @param bidderRequestId?
+     * @returns {*} bidderRequest that matches both requestId and bidderRequestId (if either or both are provided).
+     *
+     * NOTE: Bid responses are not guaranteed to have a corresponding request.
+     */
+    getBidderRequest({requestId, bidderRequestId}) {
+      if (requestId != null || bidderRequestId != null) {
+        let bers = getAuctions().flatMap(a => a.getBidRequests());
+        if (bidderRequestId != null) {
+          bers = bers.filter(ber => ber.bidderRequestId === bidderRequestId);
+        }
+        if (requestId == null) {
+          return bers[0];
+        } else {
+          return bers.find(ber => ber.bids && ber.bids.find(br => br.bidId === requestId) != null)
+        }
+      }
+    },
+    /**
+     * @param requestId
+     * @returns {*} bidRequest object for requestId
+     *
+     * NOTE: Bid responses are not guaranteed to have a corresponding request.
+     */
+    getBidRequest({requestId}) {
+      if (requestId != null) {
+        return getAuctions()
+          .flatMap(a => a.getBidRequests())
+          .flatMap(ber => ber.bids)
+          .find(br => br && br.bidId === requestId);
+      }
+    }
+  });
+}

package/src/auctionManager.js

@@ -22,6 +22,7 @@
 import { uniques, flatten, logWarn } from './utils.js';
 import { newAuction, getStandardBidderSettings, AUCTION_COMPLETED } from './auction.js';
 import find from 'core-js-pure/features/array/find.js';
+import {AuctionIndex} from './auctionIndex.js';
 
 const CONSTANTS = require('./constants.json');
 
@@ -123,6 +124,8 @@ export function newAuctionManager() {
     _auctions.push(auction);
   }
 
+  auctionManager.index = new AuctionIndex(() => _auctions);
+
   return auctionManager;
 }
 

package/src/bidderSettings.js

@@ -0,0 +1,69 @@
+import {deepAccess, mergeDeep} from './utils.js';
+import {getGlobal} from './prebidGlobal.js';
+
+const CONSTANTS = require('./constants.json');
+
+export class ScopedSettings {
+  constructor(getSettings, defaultScope) {
+    this.getSettings = getSettings;
+    this.defaultScope = defaultScope;
+  }
+
+  /**
+   * Get setting value at `path` under the given scope, falling back to the default scope if needed.
+   * If `scope` is `null`, get the setting's default value.
+   * @param scope {String|null}
+   * @param path {String}
+   * @returns {*}
+   */
+  get(scope, path) {
+    let value = this.getOwn(scope, path);
+    if (typeof value === 'undefined') {
+      value = this.getOwn(null, path);
+    }
+    return value;
+  }
+
+  /**
+   * Get the setting value at `path` *without* falling back to the default value.
+   * @param scope {String}
+   * @param path {String}
+   * @returns {*}
+   */
+  getOwn(scope, path) {
+    scope = this.#resolveScope(scope);
+    return deepAccess(this.getSettings(), `${scope}.${path}`)
+  }
+
+  /**
+   * @returns {string[]} all existing scopes except the default one.
+   */
+  getScopes() {
+    return Object.keys(this.getSettings()).filter((scope) => scope !== this.defaultScope);
+  }
+
+  /**
+   * @returns all settings in the given scope, merged with the settings for the default scope.
+   */
+  settingsFor(scope) {
+    return mergeDeep({}, this.ownSettingsFor(null), this.ownSettingsFor(scope));
+  }
+
+  /**
+   * @returns all settings in the given scope, *without* any of the default settings.
+   */
+  ownSettingsFor(scope) {
+    scope = this.#resolveScope(scope);
+    return this.getSettings()[scope] || {};
+  }
+
+  #resolveScope(scope) {
+    if (scope == null) {
+      return this.defaultScope;
+    } else {
+      return scope;
+    }
+  }
+}
+
+export const bidderSettings = new ScopedSettings(() => getGlobal().bidderSettings || {}, CONSTANTS.JSON_MAPPING.BD_SETTING_STANDARD);