prebid.js 8.1.0 → 8.3.0

package/modules/vidazooBidAdapter.js

@@ -1,4 +1,4 @@
-import {_each, deepAccess, parseSizesInput, parseUrl, uniques, isFn} from '../src/utils.js';
+import {_each, chunk, deepAccess, isFn, parseSizesInput, parseUrl, uniques, isArray} from '../src/utils.js';
 import {registerBidder} from '../src/adapters/bidderFactory.js';
 import {BANNER, VIDEO} from '../src/mediaTypes.js';
 import {getStorageManager} from '../src/storageManager.js';
@@ -48,7 +48,7 @@ function isBidRequestValid(bid) {
   return !!(extractCID(params) && extractPID(params));
 }
 
-function buildRequest(bid, topWindowUrl, sizes, bidderRequest, bidderTimeout) {
+function buildRequestData(bid, topWindowUrl, sizes, bidderRequest, bidderTimeout) {
   const {
     params,
     bidId,
@@ -69,9 +69,7 @@ function buildRequest(bid, topWindowUrl, sizes, bidderRequest, bidderTimeout) {
   const dealId = getNextDealId(hashUrl);
   const uniqueDealId = getUniqueDealId(hashUrl);
   const sId = getVidazooSessionId();
-  const cId = extractCID(params);
   const pId = extractPID(params);
-  const subDomain = extractSubDomain(params);
   const ptrace = getCacheOpt();
   const isStorageAllowed = bidderSettings.get(BIDDER_CODE, 'storageAllowed');
 
@@ -153,17 +151,46 @@ function buildRequest(bid, topWindowUrl, sizes, bidderRequest, bidderTimeout) {
     data.gppSid = bidderRequest.ortb2.regs.gpp_sid;
   }
 
+  _each(ext, (value, key) => {
+    data['ext.' + key] = value;
+  });
+
+  return data;
+}
+
+function buildRequest(bid, topWindowUrl, sizes, bidderRequest, bidderTimeout) {
+  const {params} = bid;
+  const cId = extractCID(params);
+  const subDomain = extractSubDomain(params);
+  const data = buildRequestData(bid, topWindowUrl, sizes, bidderRequest, bidderTimeout);
   const dto = {
     method: 'POST',
     url: `${createDomain(subDomain)}/prebid/multi/${cId}`,
     data: data
   };
+  return dto;
+}
 
-  _each(ext, (value, key) => {
-    dto.data['ext.' + key] = value;
+function buildSingleRequest(bidRequests, bidderRequest, topWindowUrl, bidderTimeout) {
+  const {params} = bidRequests[0];
+  const cId = extractCID(params);
+  const subDomain = extractSubDomain(params);
+  const data = bidRequests.map(bid => {
+    const sizes = parseSizesInput(bid.sizes);
+    return buildRequestData(bid, topWindowUrl, sizes, bidderRequest, bidderTimeout)
+  });
+  const CHUNK_SIZE = Math.min(10, config.getConfig('vidazoo.chunkSize') || 10);
+
+  const chunkedData = chunk(data, CHUNK_SIZE);
+  return chunkedData.map(chunk => {
+    return {
+      method: 'POST',
+      url: `${createDomain(subDomain)}/prebid/multi/${cId}`,
+      data: {
+        bids: chunk
+      }
+    };
   });
-
-  return dto;
 }
 
 function appendUserIdsToRequestPayload(payloadRef, userIds) {
@@ -193,12 +220,33 @@ function buildRequests(validBidRequests, bidderRequest) {
   // TODO: does the fallback make sense here?
   const topWindowUrl = bidderRequest.refererInfo.page || bidderRequest.refererInfo.topmostLocation;
   const bidderTimeout = config.getConfig('bidderTimeout');
+
+  const singleRequestMode = config.getConfig('vidazoo.singleRequest');
+
   const requests = [];
-  validBidRequests.forEach(validBidRequest => {
-    const sizes = parseSizesInput(validBidRequest.sizes);
-    const request = buildRequest(validBidRequest, topWindowUrl, sizes, bidderRequest, bidderTimeout);
-    requests.push(request);
-  });
+
+  if (singleRequestMode) {
+    // We need to split the requests into banner and video requests
+    const bannerBidRequests = validBidRequests.filter(bid => isArray(bid.mediaTypes) ? bid.mediaTypes.includes(BANNER) : bid.mediaTypes[BANNER] !== undefined);
+    if (bannerBidRequests.length > 0) {
+      const singleRequests = buildSingleRequest(bannerBidRequests, bidderRequest, topWindowUrl, bidderTimeout);
+      requests.push(...singleRequests);
+    }
+
+    // Video Logic
+    const videoBidRequests = validBidRequests.filter(bid => bid.mediaTypes[VIDEO] !== undefined);
+    videoBidRequests.forEach(validBidRequest => {
+      const sizes = parseSizesInput(validBidRequest.sizes);
+      const request = buildRequest(validBidRequest, topWindowUrl, sizes, bidderRequest, bidderTimeout);
+      requests.push(request);
+    });
+  } else {
+    validBidRequests.forEach(validBidRequest => {
+      const sizes = parseSizesInput(validBidRequest.sizes);
+      const request = buildRequest(validBidRequest, topWindowUrl, sizes, bidderRequest, bidderTimeout);
+      requests.push(request);
+    });
+  }
   return requests;
 }
 
@@ -206,13 +254,15 @@ function interpretResponse(serverResponse, request) {
   if (!serverResponse || !serverResponse.body) {
     return [];
   }
-  const {bidId} = request.data;
+
+  const singleRequestMode = config.getConfig('vidazoo.singleRequest');
+  const reqBidId = deepAccess(request, 'data.bidId');
   const {results} = serverResponse.body;
 
   let output = [];
 
   try {
-    results.forEach(result => {
+    results.forEach((result, i) => {
       const {
         creativeId,
         ad,
@@ -221,6 +271,7 @@ function interpretResponse(serverResponse, request) {
         width,
         height,
         currency,
+        bidId,
         advertiserDomains,
         metaData,
         mediaType = BANNER
@@ -230,7 +281,7 @@ function interpretResponse(serverResponse, request) {
       }
 
       const response = {
-        requestId: bidId,
+        requestId: (singleRequestMode && bidId) ? bidId : reqBidId,
         cpm: price,
         width: width,
         height: height,
@@ -264,6 +315,7 @@ function interpretResponse(serverResponse, request) {
       }
       output.push(response);
     });
+
     return output;
   } catch (e) {
     return [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prebid.js",
-  "version": "8.1.0",
+  "version": "8.3.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');
+        })
+      });
+    });
+  });
+});