prebid.js 5.16.0 → 5.20.0

package/modules/browsiRtdProvider.js

@@ -15,21 +15,27 @@
  * @property {?string} keyName
  */
 
-import { deepClone, logError, isGptPubadsDefined } from '../src/utils.js';
+import { deepClone, logError, isGptPubadsDefined, isNumber, isFn, deepSetValue } from '../src/utils.js';
 import {submodule} from '../src/hook.js';
 import {ajaxBuilder} from '../src/ajax.js';
 import {loadExternalScript} from '../src/adloader.js';
 import {getStorageManager} from '../src/storageManager.js';
 import find from 'core-js-pure/features/array/find.js';
+import {getGlobal} from '../src/prebidGlobal.js';
+import includes from 'core-js-pure/features/array/includes.js';
 
 const storage = getStorageManager();
 
 /** @type {ModuleParams} */
 let _moduleParams = {};
 /** @type {null|Object} */
-let _predictionsData = null;
+let _browsiData = null;
 /** @type {string} */
 const DEF_KEYNAME = 'browsiViewability';
+/** @type {null | function} */
+let _dataReadyCallback = null;
+/** @type {null|Object} */
+let _ic = {};
 
 /**
  * add browsi script to page
@@ -78,29 +84,49 @@ export function collectData() {
   getPredictionsFromServer(`//${_moduleParams.url}/prebid?${toUrlParams(predictorData)}`);
 }
 
+/**
+ * wait for data from server
+ * call callback when data is ready
+ * @param {function} callback
+ */
+function waitForData(callback) {
+  if (_browsiData) {
+    _dataReadyCallback = null;
+    callback(_browsiData);
+  } else {
+    _dataReadyCallback = callback;
+  }
+}
+
 export function setData(data) {
-  _predictionsData = data;
+  _browsiData = data;
+  if (isFn(_dataReadyCallback)) {
+    _dataReadyCallback(_browsiData);
+    _dataReadyCallback = null;
+  }
 }
 
-function sendDataToModule(adUnitsCodes) {
+function getRTD(auc) {
   try {
-    const _predictions = (_predictionsData && _predictionsData.p) || {};
-    return adUnitsCodes.reduce((rp, adUnitCode) => {
-      if (!adUnitCode) {
+    const _bp = (_browsiData && _browsiData.p) || {};
+    return auc.reduce((rp, uc) => {
+      _ic[uc] = _ic[uc] || 0;
+      const _c = _ic[uc];
+      if (!uc) {
         return rp
       }
-      const adSlot = getSlotByCode(adUnitCode);
-      const identifier = adSlot ? getMacroId(_predictionsData['pmd'], adSlot) : adUnitCode;
-      const predictionData = _predictions[identifier];
-      rp[adUnitCode] = getKVObject(-1, _predictionsData['kn']);
-      if (!predictionData) {
+      const adSlot = getSlotByCode(uc);
+      const identifier = adSlot ? getMacroId(_browsiData['pmd'], adSlot) : uc;
+      const _pd = _bp[identifier];
+      rp[uc] = getKVObject(-1);
+      if (!_pd) {
         return rp
       }
-      if (predictionData.p) {
-        if (!isIdMatchingAdUnit(adSlot, predictionData.w)) {
+      if (_pd.ps) {
+        if (!isIdMatchingAdUnit(adSlot, _pd.w)) {
           return rp;
         }
-        rp[adUnitCode] = getKVObject(predictionData.p, _predictionsData.kn);
+        rp[uc] = getKVObject(getCurrentData(_pd.ps, _c));
       }
       return rp;
     }, {});
@@ -109,6 +135,31 @@ function sendDataToModule(adUnitsCodes) {
   }
 }
 
+/**
+ * get prediction
+ * return -1 if prediction not found
+ * @param {object} predictionObject
+ * @param {number} _c
+ * @return {number}
+ */
+export function getCurrentData(predictionObject, _c) {
+  if (!predictionObject || !isNumber(_c)) {
+    return -1;
+  }
+  if (isNumber(predictionObject[_c])) {
+    return predictionObject[_c];
+  }
+  if (Object.keys(predictionObject).length > 1) {
+    while (_c > 0) {
+      _c--;
+      if (isNumber(predictionObject[_c])) {
+        return predictionObject[_c];
+      }
+    }
+  }
+  return -1;
+}
+
 /**
  * get all slots on page
  * @return {Object[]} slot GoogleTag slots
@@ -122,12 +173,16 @@ function getAllSlots() {
  * @param {string?} keyName
  * @return {Object} key:value
  */
-function getKVObject(p, keyName) {
+function getKVObject(p) {
   const prValue = p < 0 ? 'NA' : (Math.floor(p * 10) / 10).toFixed(2);
   let prObject = {};
-  prObject[((_moduleParams['keyName'] || keyName || DEF_KEYNAME).toString())] = prValue.toString();
+  prObject[getKey()] = prValue.toString();
   return prObject;
 }
+
+function getKey() {
+  return ((_moduleParams['keyName'] || (_browsiData && _browsiData['kn']) || DEF_KEYNAME).toString())
+}
 /**
  * check if placement id matches one of given ad units
  * @param {Object} slot google slot
@@ -238,6 +293,28 @@ function toUrlParams(data) {
     .join('&');
 }
 
+function setBidRequestsData(bidObj, callback) {
+  let adUnitCodes = bidObj.adUnitCodes;
+  let adUnits = bidObj.adUnits || getGlobal().adUnits || [];
+  if (adUnitCodes) {
+    adUnits = adUnits.filter(au => includes(adUnitCodes, au.code));
+  } else {
+    adUnitCodes = adUnits.map(au => au.code);
+  }
+  waitForData(() => {
+    const data = getRTD(adUnitCodes);
+    if (data) {
+      adUnits.forEach(adUnit => {
+        const adUnitCode = adUnit.code;
+        if (data[adUnitCode]) {
+          deepSetValue(adUnit, 'ortb2Imp.ext.data.browsi', {[getKey()]: data[adUnitCode][getKey()]});
+        }
+      });
+    }
+    callback();
+  })
+}
+
 /** @type {RtdSubmodule} */
 export const browsiSubmodule = {
   /**
@@ -250,10 +327,21 @@ export const browsiSubmodule = {
    * @function
    * @param {string[]} adUnitsCodes
    */
-  getTargetingData: sendDataToModule,
+  getTargetingData: getTargetingData,
   init: init,
+  getBidRequestData: setBidRequestsData
 };
 
+function getTargetingData(uc) {
+  const targetingData = getRTD(uc);
+  uc.forEach(auc => {
+    if (isNumber(_ic[auc])) {
+      _ic[auc] = _ic[auc] + 1;
+    }
+  });
+  return targetingData;
+}
+
 function init(moduleConfig) {
   _moduleParams = moduleConfig.params;
   if (_moduleParams && _moduleParams.siteKey && _moduleParams.pubKey && _moduleParams.url) {

package/modules/cleanioRtdProvider.js

@@ -0,0 +1,192 @@
+/**
+ * This module adds clean.io provider to the real time data module
+ * The {@link module:modules/realTimeData} module is required
+ * The module will wrap bid responses markup in clean.io agent script for protection
+ * @module modules/cleanioRtdProvider
+ * @requires module:modules/realTimeData
+ */
+
+import { submodule } from '../src/hook.js';
+import { logError, generateUUID, insertElement } from '../src/utils.js';
+
+// ============================ MODULE STATE ===============================
+
+/**
+ * @type {function(): void}
+ * Page-wide initialization step / strategy
+ */
+let onModuleInit = () => {};
+
+/**
+ * @type {function(Object): void}
+ * Bid response mutation step / strategy.
+ */
+let onBidResponse = () => {};
+
+/**
+ * @type {number}
+ * 0 for unknown, 1 for preloaded, -1 for error.
+ */
+let preloadStatus = 0;
+
+// ============================ MODULE LOGIC ===============================
+
+/**
+ * Page initialization step which just preloads the script, to be available whenever we start processing the bids.
+ * @param {string} scriptURL The script URL to preload
+ */
+function pageInitStepPreloadScript(scriptURL) {
+  const linkElement = document.createElement('link');
+  linkElement.rel = 'preload';
+  linkElement.as = 'script';
+  linkElement.href = scriptURL;
+  linkElement.onload = () => { preloadStatus = 1; };
+  linkElement.onerror = () => { preloadStatus = -1; };
+  insertElement(linkElement);
+}
+
+/**
+ * Page initialization step which adds the protector script to the whole page. With that, there is no need wrapping bids, and the coverage is better.
+ * @param {string} scriptURL The script URL to add to the page for protection
+ */
+function pageInitStepProtectPage(scriptURL) {
+  const scriptElement = document.createElement('script');
+  scriptElement.type = 'text/javascript';
+  scriptElement.src = scriptURL;
+  insertElement(scriptElement);
+}
+
+/**
+ * Bid processing step which alters the ad HTML to contain bid-specific information, which can be used to identify the creative later.
+ * @param {Object} bidResponse Bid response data
+ */
+function bidWrapStepAugmentHtml(bidResponse) {
+  bidResponse.ad = `<!-- pbad://creativeId=${bidResponse.creativeId || ''}&bidderCode=${bidResponse.bidderCode || ''}&cpm=${bidResponse.cpm || ''} -->\n${bidResponse.ad}`;
+}
+
+/**
+ * Bid processing step which applies creative protection by wrapping the ad HTML.
+ * @param {string} scriptURL
+ * @param {number} requiredPreload
+ * @param {Object} bidResponse
+ */
+function bidWrapStepProtectByWrapping(scriptURL, requiredPreload, bidResponse) {
+  // Still prepend bid info, it's always helpful to have creative data in its payload
+  bidWrapStepAugmentHtml(bidResponse);
+
+  // If preloading failed, or if configuration requires us to finish preloading -
+  // we should not process this bid any further
+  if (preloadStatus < requiredPreload) {
+    return;
+  }
+
+  const sid = generateUUID();
+  bidResponse.ad = `
+    <script type="text/javascript"
+      src="${scriptURL}"
+      data-api-integration-mode="prebid"
+      data-api-session-uuid="${sid}">
+    </script>
+    <script type="text/javascript">
+      var ad = "${encodeURIComponent(bidResponse.ad)}";
+      var agent = window["${sid}"];
+      if (agent && typeof agent.put === "function") {
+        agent.put(ad);
+      }
+      else {
+        document.open();
+        document.write(decodeURIComponent(ad));
+        document.close();
+      }
+    </script>
+  `;
+}
+
+/**
+ * Custom error class to differentiate validation errors
+ */
+class ConfigError extends Error { }
+
+/**
+ * The function to be called upon module init. Depending on the passed config, initializes properly init/bid steps or throws ConfigError.
+ * @param {Object} config
+ */
+function readConfig(config) {
+  if (!config.params) {
+    throw new ConfigError('Missing config parameters for clean.io RTD module provider.');
+  }
+
+  if (typeof config.params.cdnUrl !== 'string' || !/^https?:\/\//.test(config.params.cdnUrl)) {
+    throw new ConfigError('Parameter "cdnUrl" is a required string parameter, which should start with "http(s)://".');
+  }
+
+  if (typeof config.params.protectionMode !== 'string') {
+    throw new ConfigError('Parameter "protectionMode" is a required string parameter.');
+  }
+
+  const scriptURL = config.params.cdnUrl;
+
+  switch (config.params.protectionMode) {
+    case 'full':
+      onModuleInit = () => pageInitStepProtectPage(scriptURL);
+      onBidResponse = (bidResponse) => bidWrapStepAugmentHtml(bidResponse);
+      break;
+
+    case 'bids':
+      onModuleInit = () => pageInitStepPreloadScript(scriptURL);
+      onBidResponse = (bidResponse) => bidWrapStepProtectByWrapping(scriptURL, 0, bidResponse);
+      break;
+
+    case 'bids-nowait':
+      onModuleInit = () => pageInitStepPreloadScript(scriptURL);
+      onBidResponse = (bidResponse) => bidWrapStepProtectByWrapping(scriptURL, 1, bidResponse);
+      break;
+
+    default:
+      throw new ConfigError('Parameter "protectionMode" must be one of "full" | "bids" | "bids-nowait".');
+  }
+}
+
+// ============================ MODULE REGISTRATION ===============================
+
+/**
+ * The function which performs submodule registration.
+ */
+function beforeInit() {
+  submodule('realTimeData', /** @type {RtdSubmodule} */ ({
+    name: 'clean.io',
+
+    init: (config, userConsent) => {
+      try {
+        readConfig(config);
+        onModuleInit();
+        return true;
+      } catch (err) {
+        if (err instanceof ConfigError) {
+          logError(err.message);
+        }
+        return false;
+      }
+    },
+
+    onBidResponseEvent: (bidResponse, config, userConsent) => {
+      onBidResponse(bidResponse);
+    }
+  }));
+}
+
+/**
+ * Exporting local (and otherwise encapsulated to this module) functions
+ * for testing purposes
+ */
+export const __TEST__ = {
+  pageInitStepPreloadScript,
+  pageInitStepProtectPage,
+  bidWrapStepAugmentHtml,
+  bidWrapStepProtectByWrapping,
+  ConfigError,
+  readConfig,
+  beforeInit,
+}
+
+beforeInit();

package/modules/cleanioRtdProvider.md

@@ -0,0 +1,59 @@
+# Overview
+
+```
+Module Name: clean.io Rtd provider
+Module Type: Rtd Provider
+Maintainer: nick@clean.io
+```
+
+The clean.io Realtime module provides effective anti-malvertising solution for publishers, including, but not limited to,
+blocking unwanted 0- and 1-click redirects, deceptive ads or those with malicious landing pages, and various types of affiliate fraud.
+
+Using this module requires prior agreement with [clean.io](https://clean.io) to obtain the necessary distribution key.
+
+
+# Integration
+
+clean.io Realtime module can be built just like any other prebid module:
+
+```
+gulp build --modules=cleanioRtdProvider,...
+```
+
+
+# Configuration
+
+When built into prebid.js, this module can be configured through the following `pbjs.setConfig` call:
+
+```javascript
+pbjs.setConfig({
+    realTimeData: {
+        dataProviders: [{
+            name: 'clean.io',
+            params: {
+                cdnUrl: 'https://abc1234567890.cloudfront.net/script.js', ///< Contact clean.io to get your own CDN URL
+                protectionMode: 'full', ///< Supported modes are 'full', 'bids' and 'bids-nowait', see below.
+            }
+        }]
+    }
+});
+```
+
+
+## Configuration parameters
+
+{: .table .table-bordered .table-striped }
+| Name | Type  | Scope | Description |
+| :------------ | :------------ | :------------ |:------------ |
+| ``cdnUrl`` | ``string`` | Required | CDN URL of the script, which is to be used for protection. |
+| ``protectionMode`` | ``'full' \| 'bids' \| 'bids-nowait'`` | Required | Integration mode. Please refer to the "Integration modes" section for details. |
+
+
+## Integration modes
+
+{: .table .table-bordered .table-striped }
+| Integration Mode | Parameter Value | Description |
+| :------------ | :------------ | :------------ |
+| Full page protection | ``'full'`` | Preferred mode. The module will add the protector agent script directly to the page, and it will protect all placements. This mode will make the most out of various behavioral detection mechanisms, and will also prevent typical malicious behaviors. Please note that in this mode, depending on Prebid library naming, Chrome may mistakenly tag non-ad-related content as ads: https://chromium.googlesource.com/chromium/src/+/refs/heads/main/docs/ad_tagging.md. |
+| Bids-only protection | ``'bids'`` | The module will protect specific bid responses, more specifically, the HTML representing ad payload, by wrapping it into the agent script. Please note that in this mode, ads delivered directly, outside of Prebid integration, will not be protected, since the module can only access the ads coming through Prebid. |
+| Bids-only protection with no delay on bid rendering | ``'bids-nowait'`` | Same as above, but in this mode, the script will also *not* wrap those bid responses, which arrived prior to successful preloading of agent script. |

package/modules/codefuelBidAdapter.js

@@ -0,0 +1,183 @@
+import { deepAccess, isArray } from '../src/utils.js';
+import { config } from '../src/config.js';
+import {registerBidder} from '../src/adapters/bidderFactory.js';
+import { BANNER } from '../src/mediaTypes.js';
+const BIDDER_CODE = 'codefuel';
+const CURRENCY = 'USD';
+
+export const spec = {
+  code: BIDDER_CODE,
+  supportedMediaTypes: [ BANNER ],
+  aliases: ['ex'], // short code
+  /**
+         * Determines whether or not the given bid request is valid.
+         *
+         * @param {BidRequest} bid The bid params to validate.
+         * @return boolean True if this is a valid bid, and false otherwise.
+         */
+  isBidRequestValid: function(bid) {
+    if (bid.nativeParams) {
+      return false;
+    }
+    return !!(bid.params.placementId || (bid.params.member && bid.params.invCode));
+  },
+  /**
+         * Make a server request from the list of BidRequests.
+         *
+         * @param {validBidRequests[]} - an array of bids
+         * @return ServerRequest Info describing the request to the server.
+         */
+  buildRequests: function(validBidRequests, bidderRequest) {
+    const page = bidderRequest.refererInfo.referer;
+    const domain = getDomainFromURL(page)
+    const ua = navigator.userAgent;
+    const devicetype = getDeviceType()
+    const publisher = setOnAny(validBidRequests, 'params.publisher');
+    const cur = CURRENCY;
+    // const endpointUrl = 'http://localhost:5000/prebid'
+    const endpointUrl = config.getConfig('codefuel.bidderUrl');
+    const timeout = bidderRequest.timeout;
+
+    validBidRequests.forEach(bid => bid.netRevenue = 'net');
+
+    const imps = validBidRequests.map((bid, idx) => {
+      const imp = {
+        id: idx + 1 + ''
+      }
+
+      if (bid.params.tagid) {
+        imp.tagid = bid.params.tagid
+      }
+
+      if (bid.sizes) {
+        imp.banner = {
+          format: transformSizes(bid.sizes)
+        }
+      }
+
+      return imp;
+    });
+
+    const request = {
+      id: bidderRequest.auctionId,
+      site: { page, domain, publisher },
+      device: { ua, devicetype },
+      source: { fd: 1 },
+      cur: [cur],
+      tmax: timeout,
+      imp: imps,
+    };
+
+    return {
+      method: 'POST',
+      url: endpointUrl,
+      data: request,
+      bids: validBidRequests,
+      options: {
+        withCredentials: false
+      }
+    };
+  },
+  /**
+         * Unpack the response from the server into a list of bids.
+         *
+         * @param {ServerResponse} serverResponse A successful response from the server.
+         * @return {Bid[]} An array of bids which were nested inside the server.
+         */
+  interpretResponse: (serverResponse, { bids }) => {
+    if (!serverResponse.body) {
+      return [];
+    }
+    const { seatbid, cur } = serverResponse.body;
+
+    const bidResponses = flatten(seatbid.map(seat => seat.bid)).reduce((result, bid) => {
+      result[bid.impid - 1] = bid;
+      return result;
+    }, []);
+
+    return bids.map((bid, id) => {
+      const bidResponse = bidResponses[id];
+      if (bidResponse) {
+        const bidObject = {
+          requestId: bid.bidId,
+          cpm: bidResponse.price,
+          creativeId: bidResponse.crid,
+          ttl: 360,
+          netRevenue: true,
+          currency: cur,
+          mediaType: BANNER,
+          ad: bidResponse.adm,
+          width: bidResponse.w,
+          height: bidResponse.h,
+          meta: { advertiserDomains: bid.adomain ? bid.adomain : [] }
+        };
+        return bidObject;
+      }
+    }).filter(Boolean);
+  },
+
+  /**
+     * Register the user sync pixels which should be dropped after the auction.
+     *
+     * @param {SyncOptions} syncOptions Which user syncs are allowed?
+     * @param {ServerResponse[]} serverResponses List of server's responses.
+     * @return {UserSync[]} The user syncs which should be dropped.
+     */
+  getUserSyncs: function(syncOptions, serverResponses, gdprConsent, uspConsent) {
+    return [];
+  }
+
+}
+registerBidder(spec);
+
+function getDomainFromURL(url) {
+  let anchor = document.createElement('a');
+  anchor.href = url;
+  return anchor.hostname;
+}
+
+function getDeviceType() {
+  if ((/ipad|android 3.0|xoom|sch-i800|playbook|tablet|kindle/i.test(navigator.userAgent.toLowerCase()))) {
+    return 5; // 'tablet'
+  }
+  if ((/iphone|ipod|android|blackberry|opera|mini|windows\sce|palm|smartphone|iemobile/i.test(navigator.userAgent.toLowerCase()))) {
+    return 4; // 'mobile'
+  }
+  return 2; // 'desktop'
+}
+
+function setOnAny(collection, key) {
+  for (let i = 0, result; i < collection.length; i++) {
+    result = deepAccess(collection[i], key);
+    if (result) {
+      return result;
+    }
+  }
+}
+
+function flatten(arr) {
+  return [].concat(...arr);
+}
+
+/* Turn bid request sizes into ut-compatible format */
+function transformSizes(requestSizes) {
+  if (!isArray(requestSizes)) {
+    return [];
+  }
+
+  if (requestSizes.length === 2 && !isArray(requestSizes[0])) {
+    return [{
+      w: parseInt(requestSizes[0], 10),
+      h: parseInt(requestSizes[1], 10)
+    }];
+  } else if (isArray(requestSizes[0])) {
+    return requestSizes.map(item =>
+      ({
+        w: parseInt(item[0], 10),
+        h: parseInt(item[1], 10)
+      })
+    );
+  }
+
+  return [];
+}