PBJS support for stored responses

modules/prebidServerBidAdapter/index.js

@@ -11,6 +11,7 @@ import events from '../../src/events';
 import includes from 'core-js/library/fn/array/includes';
 import { S2S_VENDORS } from './config.js';
 import { ajax } from '../../src/ajax';
+import find from 'core-js/library/fn/array/find';
 
 const getConfig = config.getConfig;
 
@@ -492,6 +493,12 @@ const OPEN_RTB_PROTOCOL = {
 
       Object.assign(imp, mediaTypes);
 
+      // if storedAuctionResponse has been set, pass SRID
+      const storedAuctionResponseBid = find(bidRequests[0].bids, bid => (bid.adUnitCode === adUnit.code && typeof bid.storedAuctionResponse === 'number'));
+      if (storedAuctionResponseBid) {
+        utils.deepSetValue(imp, 'ext.prebid.storedauctionresponse.id', storedAuctionResponseBid.storedAuctionResponse.toString());
+      }
+
       if (imp.banner || imp.video || imp.native) {
         imps.push(imp);
       }

modules/rubiconBidAdapter.js

@@ -276,6 +276,11 @@ export const spec = {
         utils.deepSetValue(data.imp[0].ext, 'context.data.adslot', pbAdSlot);
       }
 
+      // if storedAuctionResponse has been set, pass SRID
+      if (typeof bidRequest.storedAuctionResponse === 'number') {
+        utils.deepSetValue(data.imp[0], 'ext.prebid.storedauctionresponse.id', bidRequest.storedAuctionResponse.toString());
+      }
+
       return {
         method: 'POST',
         url: VIDEO_ENDPOINT,

src/adapterManager.js

@@ -68,7 +68,8 @@ function getBids({bidderCode, auctionId, bidderRequestId, adUnits, labels, src})
           bid = Object.assign({}, bid, getDefinedParams(adUnit, [
             'fpd',
             'mediaType',
-            'renderer'
+            'renderer',
+            'storedAuctionResponse'
           ]));
 
           let {

src/auction.js

@@ -120,7 +120,7 @@ export function newAuction({adUnits, adUnitCodes, callback, cbTimeout, labels, a
   let _winningBids = [];
   let _timelyBidders = new Set();
 
-  function addBidRequests(bidderRequests) { _bidderRequests = _bidderRequests.concat(bidderRequests) };
+  function addBidRequests(bidderRequests) { _bidderRequests = _bidderRequests.concat(bidderRequests); }
   function addBidReceived(bidsReceived) { _bidsReceived = _bidsReceived.concat(bidsReceived); }
   function addNoBid(noBid) { _noBids = _noBids.concat(noBid); }
 
@@ -213,62 +213,73 @@ export function newAuction({adUnits, adUnitCodes, callback, cbTimeout, labels, a
 
     let bidRequests = adapterManager.makeBidRequests(_adUnits, _auctionStart, _auctionId, _timeout, _labels);
     utils.logInfo(`Bids Requested for Auction with id: ${_auctionId}`, bidRequests);
-    bidRequests.forEach(bidRequest => {
-      addBidRequests(bidRequest);
-    });
-
-    let requests = {};
 
     if (bidRequests.length < 1) {
       utils.logWarn('No valid bid requests returned for auction');
       auctionDone();
     } else {
-      let call = {
-        bidRequests,
-        run: () => {
-          startAuctionTimer();
-
-          _auctionStatus = AUCTION_IN_PROGRESS;
-
-          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, {
-            request(source, origin) {
-              increment(outstandingRequests, origin);
-              increment(requests, source);
-
-              if (!sourceInfo[source]) {
-                sourceInfo[source] = {
-                  SRA: true,
-                  origin
-                };
-              }
-              if (requests[source] > 1) {
-                sourceInfo[source].SRA = false;
-              }
-            },
-            done(origin) {
-              outstandingRequests[origin]--;
-              if (queuedCalls[0]) {
-                if (runIfOriginHasCapacity(queuedCalls[0])) {
-                  queuedCalls.shift();
-                }
+      addBidderRequests.call({
+        dispatch: addBidderRequestsCallback,
+        context: this
+      }, bidRequests);
+    }
+  }
+
+  /**
+   * callback executed after addBidderRequests completes
+   * @param {BidRequest[]} bidRequests
+   */
+  function addBidderRequestsCallback(bidRequests) {
+    bidRequests.forEach(bidRequest => {
+      addBidRequests(bidRequest);
+    });
+
+    let requests = {};
+    let call = {
+      bidRequests,
+      run: () => {
+        startAuctionTimer();
+
+        _auctionStatus = AUCTION_IN_PROGRESS;
+
+        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, {
+          request(source, origin) {
+            increment(outstandingRequests, origin);
+            increment(requests, source);
+
+            if (!sourceInfo[source]) {
+              sourceInfo[source] = {
+                SRA: true,
+                origin
+              };
+            }
+            if (requests[source] > 1) {
+              sourceInfo[source].SRA = false;
+            }
+          },
+          done(origin) {
+            outstandingRequests[origin]--;
+            if (queuedCalls[0]) {
+              if (runIfOriginHasCapacity(queuedCalls[0])) {
+                queuedCalls.shift();
               }
             }
-          }, _timeout, onTimelyResponse);
-        }
-      };
-
-      if (!runIfOriginHasCapacity(call)) {
-        utils.logWarn('queueing auction due to limited endpoint capacity');
-        queuedCalls.push(call);
+          }
+        }, _timeout, onTimelyResponse);
       }
+    };
+
+    if (!runIfOriginHasCapacity(call)) {
+      utils.logWarn('queueing auction due to limited endpoint capacity');
+      queuedCalls.push(call);
     }
 
     function runIfOriginHasCapacity(call) {
@@ -344,6 +355,10 @@ export const addBidResponse = hook('async', function(adUnitCode, bid) {
   this.dispatch.call(this.bidderRequest, adUnitCode, bid);
 }, 'addBidResponse');
 
+export const addBidderRequests = hook('sync', function(bidderRequests) {
+  this.dispatch.call(this.context, bidderRequests);
+}, 'addBidderRequests');
+
 export const bidsBackCallback = hook('async', function (adUnits, callback) {
   if (callback) {
     callback();

src/debugging.js

@@ -1,11 +1,12 @@
 
 import { config } from './config';
 import { logMessage as utilsLogMessage, logWarn as utilsLogWarn } from './utils';
-import { addBidResponse } from './auction';
+import { addBidderRequests, addBidResponse } from './auction';
 
 const OVERRIDE_KEY = '$$PREBID_GLOBAL$$:debugging';
 
-export let boundHook;
+export let addBidResponseBound;
+export let addBidderRequestsBound;
 
 function logMessage(msg) {
   utilsLogMessage('DEBUG: ' + msg);
@@ -15,52 +16,113 @@ function logWarn(msg) {
   utilsLogWarn('DEBUG: ' + msg);
 }
 
-function removeHook() {
-  addBidResponse.getHooks({hook: boundHook}).remove()
+function addHooks(overrides) {
+  addBidResponseBound = addBidResponseHook.bind(overrides);
+  addBidResponse.before(addBidResponseBound, 5);
+
+  addBidderRequestsBound = addBidderRequestsHook.bind(overrides);
+  addBidderRequests.before(addBidderRequestsBound, 5);
+}
+
+function removeHooks() {
+  addBidResponse.getHooks({hook: addBidResponseBound}).remove();
+  addBidderRequests.getHooks({hook: addBidderRequestsBound}).remove();
 }
 
-function enableOverrides(overrides, fromSession = false) {
+export function enableOverrides(overrides, fromSession = false) {
   config.setConfig({'debug': true});
+  removeHooks();
+  addHooks(overrides);
   logMessage(`bidder overrides enabled${fromSession ? ' from session' : ''}`);
-
-  removeHook();
-
-  boundHook = addBidResponseHook.bind(overrides);
-  addBidResponse.before(boundHook, 5);
 }
 
 export function disableOverrides() {
-  removeHook();
+  removeHooks();
   logMessage('bidder overrides disabled');
 }
 
+/**
+ * @param {{bidder:string, adUnitCode:string}} overrideObj
+ * @param {string} bidderCode
+ * @param {string} adUnitCode
+ * @returns {boolean}
+ */
+export function bidExcluded(overrideObj, bidderCode, adUnitCode) {
+  if (overrideObj.bidder && overrideObj.bidder !== bidderCode) {
+    return true;
+  }
+  if (overrideObj.adUnitCode && overrideObj.adUnitCode !== adUnitCode) {
+    return true;
+  }
+  return false;
+}
+
+/**
+ * @param {string[]} bidders
+ * @param {string} bidderCode
+ * @returns {boolean}
+ */
+export function bidderExcluded(bidders, bidderCode) {
+  return (Array.isArray(bidders) && bidders.indexOf(bidderCode) === -1);
+}
+
+/**
+ * @param {Object} overrideObj
+ * @param {Object} bidObj
+ * @param {Object} bidType
+ * @returns {Object} bidObj with overridden properties
+ */
+export function applyBidOverrides(overrideObj, bidObj, bidType) {
+  return Object.keys(overrideObj).filter(key => (['adUnitCode', 'bidder'].indexOf(key) === -1)).reduce(function(result, key) {
+    logMessage(`bidder overrides changed '${result.adUnitCode}/${result.bidderCode}' ${bidType}.${key} from '${result[key]}' to '${overrideObj[key]}'`);
+    result[key] = overrideObj[key];
+    return result;
+  }, bidObj);
+}
+
 export function addBidResponseHook(next, adUnitCode, bid) {
-  let overrides = this;
-  if (Array.isArray(overrides.bidders) && overrides.bidders.indexOf(bid.bidderCode) === -1) {
+  const overrides = this;
+
+  if (bidderExcluded(overrides.bidders, bid.bidderCode)) {
     logWarn(`bidder '${bid.bidderCode}' excluded from auction by bidder overrides`);
     return;
   }
 
   if (Array.isArray(overrides.bids)) {
-    overrides.bids.forEach(overrideBid => {
-      if (overrideBid.bidder && overrideBid.bidder !== bid.bidderCode) {
-        return;
-      }
-      if (overrideBid.adUnitCode && overrideBid.adUnitCode !== adUnitCode) {
-        return;
+    overrides.bids.forEach(function(overrideBid) {
+      if (!bidExcluded(overrideBid, bid.bidderCode, adUnitCode)) {
+        applyBidOverrides(overrideBid, bid, 'bidder');
       }
+    });
+  }
 
-      bid = Object.assign({}, bid);
+  next(adUnitCode, bid);
+}
 
-      Object.keys(overrideBid).filter(key => ['bidder', 'adUnitCode'].indexOf(key) === -1).forEach((key) => {
-        let value = overrideBid[key];
-        logMessage(`bidder overrides changed '${adUnitCode}/${bid.bidderCode}' bid.${key} from '${bid[key]}' to '${value}'`);
-        bid[key] = value;
+export function addBidderRequestsHook(next, bidderRequests) {
+  const overrides = this;
+
+  const includedBidderRequests = bidderRequests.filter(function(bidderRequest) {
+    if (bidderExcluded(overrides.bidders, bidderRequest.bidderCode)) {
+      logWarn(`bidRequest '${bidderRequest.bidderCode}' excluded from auction by bidder overrides`);
+      return false;
+    }
+    return true;
+  });
+
+  if (Array.isArray(overrides.bidRequests)) {
+    includedBidderRequests.forEach(function(bidderRequest) {
+      overrides.bidRequests.forEach(function(overrideBid) {
+        bidderRequest.bids.forEach(function(bid) {
+          if (!bidExcluded(overrideBid, bidderRequest.bidderCode, bid.adUnitCode)) {
+            applyBidOverrides(overrideBid, bid, 'bidRequest');
+          }
+        });
       });
     });
   }
 
-  next(adUnitCode, bid);
+  next(includedBidderRequests);
 }
 
 export function getConfig(debugging) {