prebid.js 8.8.0 → 8.9.0

package/modules/pubmaticAnalyticsAdapter.js

@@ -283,7 +283,7 @@ function gatherPartnerBidsForAdUnitForLogger(adUnit, adUnitId, highestBid) {
         'ocpm': bid.bidResponse ? (bid.bidResponse.originalCpm || 0) : 0,
         'ocry': bid.bidResponse ? (bid.bidResponse.originalCurrency || CURRENCY_USD) : CURRENCY_USD,
         'piid': bid.bidResponse ? (bid.bidResponse.partnerImpId || EMPTY_STRING) : EMPTY_STRING,
-        'frv': (s2sBidders.indexOf(bid.bidder) > -1) ? undefined : (bid.bidResponse ? (bid.bidResponse.floorData ? bid.bidResponse.floorData.floorRuleValue : undefined) : undefined),
+        'frv': (bid.bidResponse ? (bid.bidResponse.floorData ? bid.bidResponse.floorData.floorRuleValue : undefined) : undefined),
         'md': bid.bidResponse ? getMetadata(bid.bidResponse.meta) : undefined
       });
     });
@@ -319,6 +319,17 @@ function getTgId() {
   return 0;
 }
 
+function getFloorFetchStatus(floorData) {
+  if (!floorData?.floorRequestData) {
+    return false;
+  }
+  const { location, fetchStatus } = floorData?.floorRequestData;
+  const isDataValid = location !== CONSTANTS.FLOOR_VALUES.NO_DATA;
+  const isFetchSuccessful = location === CONSTANTS.FLOOR_VALUES.FETCH && fetchStatus === CONSTANTS.FLOOR_VALUES.SUCCESS;
+  const isAdUnitOrSetConfig = location === CONSTANTS.FLOOR_VALUES.AD_UNIT || location === CONSTANTS.FLOOR_VALUES.SET_CONFIG;
+  return isDataValid && (isAdUnitOrSetConfig || isFetchSuccessful);
+}
+
 function executeBidsLoggerCall(e, highestCpmBids) {
   let auctionId = e.auctionId;
   let referrer = config.getConfig('pageUrl') || cache.auctions[auctionId].referer || '';
@@ -326,6 +337,8 @@ function executeBidsLoggerCall(e, highestCpmBids) {
   let floorData = auctionCache.floorData;
   let outputObj = { s: [] };
   let pixelURL = END_POINT_BID_LOGGER;
+  // will return true if floor data is present.
+  let fetchStatus = getFloorFetchStatus(auctionCache.floorData);
 
   if (!auctionCache) {
     return;
@@ -347,7 +360,7 @@ function executeBidsLoggerCall(e, highestCpmBids) {
   outputObj['dvc'] = {'plt': getDevicePlatform()};
   outputObj['tgid'] = getTgId();
 
-  if (floorData) {
+  if (floorData && fetchStatus) {
     outputObj['fmv'] = floorData.floorRequestData ? floorData.floorRequestData.modelVersion || undefined : undefined;
     outputObj['ft'] = floorData.floorResponseData ? (floorData.floorResponseData.enforcements.enforceJS == false ? 0 : 1) : undefined;
   }
@@ -362,7 +375,7 @@ function executeBidsLoggerCall(e, highestCpmBids) {
       'mt': getAdUnitAdFormats(origAdUnit),
       'sz': getSizesForAdUnit(adUnit, adUnitId),
       'ps': gatherPartnerBidsForAdUnitForLogger(adUnit, adUnitId, highestCpmBids.filter(bid => bid.adUnitCode === adUnitId)),
-      'fskp': floorData ? (floorData.floorRequestData ? (floorData.floorRequestData.skipped == false ? 0 : 1) : undefined) : undefined,
+      'fskp': (floorData && fetchStatus) ? (floorData.floorRequestData ? (floorData.floorRequestData.skipped == false ? 0 : 1) : undefined) : undefined,
     };
     slotsArray.push(slotObject);
     return slotsArray;

package/package.json

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

package/src/adapters/bidderFactory.js

@@ -25,7 +25,7 @@ import {useMetrics} from '../utils/perfMetrics.js';
 import {isActivityAllowed} from '../activities/rules.js';
 import {activityParams} from '../activities/activityParams.js';
 import {MODULE_TYPE_BIDDER} from '../activities/modules.js';
-import {ACTIVITY_TRANSMIT_TID} from '../activities/activities.js';
+import {ACTIVITY_TRANSMIT_TID, ACTIVITY_TRANSMIT_UFPD} from '../activities/activities.js';
 
 /**
  * This file aims to support Adapters during the Prebid 0.x -> 1.x transition.
@@ -454,6 +454,15 @@ export const processBidderRequests = hook('sync', function (spec, bids, bidderRe
     onRequest(request);
 
     const networkDone = requestMetrics.startTiming('net');
+
+    function getOptions(defaults) {
+      const ro = request.options;
+      return Object.assign(defaults, ro, {
+        browsingTopics: ro?.hasOwnProperty('browsingTopics') && !ro.browsingTopics
+          ? false
+          : isActivityAllowed(ACTIVITY_TRANSMIT_UFPD, activityParams(MODULE_TYPE_BIDDER, spec.code))
+      })
+    }
     switch (request.method) {
       case 'GET':
         ajax(
@@ -463,10 +472,10 @@ export const processBidderRequests = hook('sync', function (spec, bids, bidderRe
             error: onFailure
           },
           undefined,
-          Object.assign({
+          getOptions({
             method: 'GET',
             withCredentials: true
-          }, request.options)
+          })
         );
         break;
       case 'POST':
@@ -477,11 +486,11 @@ export const processBidderRequests = hook('sync', function (spec, bids, bidderRe
             error: onFailure
           },
           typeof request.data === 'string' ? request.data : JSON.stringify(request.data),
-          Object.assign({
+          getOptions({
             method: 'POST',
             contentType: 'text/plain',
             withCredentials: true
-          }, request.options)
+          })
         );
         break;
       default:

package/src/ajax.js

@@ -1,99 +1,138 @@
-import { config } from './config.js';
-import { logMessage, logError, parseUrl, buildUrl, _each } from './utils.js';
+import {config} from './config.js';
+import {buildUrl, logError, parseUrl} from './utils.js';
 
-const XHR_DONE = 4;
+export const dep = {
+  fetch: window.fetch.bind(window),
+  makeRequest: (r, o) => new Request(r, o),
+  timeout(timeout, resource) {
+    const ctl = new AbortController();
+    let cancelTimer = setTimeout(() => {
+      ctl.abort();
+      logError(`Request timeout after ${timeout}ms`, resource);
+      cancelTimer = null;
+    }, timeout);
+    return {
+      signal: ctl.signal,
+      done() {
+        cancelTimer && clearTimeout(cancelTimer)
+      }
+    }
+  }
+}
+
+const GET = 'GET';
+const POST = 'POST';
+const CTYPE = 'Content-Type';
 
 /**
- * Simple IE9+ and cross-browser ajax request function
- * Note: x-domain requests in IE9 do not support the use of cookies
- *
- * @param url string url
- * @param callback {object | function} callback
- * @param data mixed data
- * @param options object
+ * transform legacy `ajax` parameters into a fetch request.
+ * @returns {Request}
  */
-export const ajax = ajaxBuilder();
-
-export function ajaxBuilder(timeout = 3000, {request, done} = {}) {
-  return function(url, callback, data, options = {}) {
-    try {
-      let x;
-      let method = options.method || (data ? 'POST' : 'GET');
-      let parser = document.createElement('a');
-      parser.href = url;
-
-      let callbacks = typeof callback === 'object' && callback !== null ? callback : {
-        success: function() {
-          logMessage('xhr success');
-        },
-        error: function(e) {
-          logError('xhr error', null, e);
-        }
-      };
+export function toFetchRequest(url, data, options = {}) {
+  const method = options.method || (data ? POST : GET);
+  if (method === GET && data) {
+    const urlInfo = parseUrl(url, options);
+    Object.assign(urlInfo.search, data);
+    url = buildUrl(urlInfo);
+  }
+  const headers = new Headers(options.customHeaders);
+  headers.set(CTYPE, options.contentType || 'text/plain');
+  const rqOpts = {
+    method,
+    headers
+  }
+  if (method !== GET && data) {
+    rqOpts.body = data;
+  }
+  if (options.withCredentials) {
+    rqOpts.credentials = 'include';
+  }
+  if (options.browsingTopics && isSecureContext) {
+    // the Request constructor will throw an exception if the browser supports topics
+    // but we're not in a secure context
+    rqOpts.browsingTopics = true;
+  }
+  return dep.makeRequest(url, rqOpts);
+}
 
-      if (typeof callback === 'function') {
-        callbacks.success = callback;
-      }
+/**
+ * Return a version of `fetch` that automatically cancels requests after `timeout` milliseconds.
+ *
+ * If provided, `request` and `done` should be functions accepting a single argument.
+ * `request` is invoked at the beginning of each request, and `done` at the end; both are passed its origin.
+ *
+ * @returns {function(*, {}?): Promise<Response>}
+ */
+export function fetcherFactory(timeout = 3000, {request, done} = {}) {
+  let fetcher = (resource, options) => {
+    let to;
+    if (timeout != null && options?.signal == null && !config.getConfig('disableAjaxTimeout')) {
+      to = dep.timeout(timeout, resource);
+      options = Object.assign({signal: to.signal}, options);
+    }
+    let pm = dep.fetch(resource, options);
+    if (to?.done != null) pm = pm.finally(to.done);
+    return pm;
+  };
 
-      x = new window.XMLHttpRequest();
+  if (request != null || done != null) {
+    fetcher = ((fetch) => function (resource, options) {
+      const origin = new URL(resource?.url == null ? resource : resource.url, document.location).origin;
+      let req = fetch(resource, options);
+      request && request(origin);
+      if (done) req = req.finally(() => done(origin));
+      return req;
+    })(fetcher);
+  }
+  return fetcher;
+}
 
-      x.onreadystatechange = function () {
-        if (x.readyState === XHR_DONE) {
-          if (typeof done === 'function') {
-            done(parser.origin);
-          }
-          let status = x.status;
-          if ((status >= 200 && status < 300) || status === 304) {
-            callbacks.success(x.responseText, x);
-          } else {
-            callbacks.error(x.statusText, x);
-          }
+function toXHR({status, statusText = '', headers, url}, responseText) {
+  let xml = 0;
+  return {
+    readyState: XMLHttpRequest.DONE,
+    status,
+    statusText,
+    responseText,
+    response: responseText,
+    responseType: '',
+    responseURL: url,
+    get responseXML() {
+      if (xml === 0) {
+        try {
+          xml = new DOMParser().parseFromString(responseText, headers?.get(CTYPE)?.split(';')?.[0])
+        } catch (e) {
+          xml = null;
+          logError(e);
         }
-      };
-
-      // Disabled timeout temporarily to avoid xhr failed requests. https://github.com/prebid/Prebid.js/issues/2648
-      if (!config.getConfig('disableAjaxTimeout')) {
-        x.ontimeout = function () {
-          logError('  xhr timeout after ', x.timeout, 'ms');
-        };
       }
+      return xml;
+    },
+    getResponseHeader: (header) => headers?.has(header) ? headers.get(header) : null,
+  }
+}
 
-      if (method === 'GET' && data) {
-        let urlInfo = parseUrl(url, options);
-        Object.assign(urlInfo.search, data);
-        url = buildUrl(urlInfo);
-      }
-
-      x.open(method, url, true);
-      // IE needs timeout to be set after open - see #1410
-      // Disabled timeout temporarily to avoid xhr failed requests. https://github.com/prebid/Prebid.js/issues/2648
-      if (!config.getConfig('disableAjaxTimeout')) {
-        x.timeout = timeout;
-      }
-
-      if (options.withCredentials) {
-        x.withCredentials = true;
-      }
-      _each(options.customHeaders, (value, header) => {
-        x.setRequestHeader(header, value);
-      });
-      if (options.preflight) {
-        x.setRequestHeader('X-Requested-With', 'XMLHttpRequest');
-      }
-      x.setRequestHeader('Content-Type', options.contentType || 'text/plain');
-
-      if (typeof request === 'function') {
-        request(parser.origin);
-      }
+/**
+ * attach legacy `ajax` callbacks to a fetch promise.
+ */
+export function attachCallbacks(fetchPm, callback) {
+  const {success, error} = typeof callback === 'object' && callback != null ? callback : {
+    success: typeof callback === 'function' ? callback : () => null,
+    error: (e, x) => logError('Network error', e, x)
+  };
+  fetchPm.then(response => response.text().then((responseText) => [response, responseText]))
+    .then(([response, responseText]) => {
+      const xhr = toXHR(response, responseText);
+      response.ok || response.status === 304 ? success(responseText, xhr) : error(response.statusText, xhr);
+    }, () => error('', toXHR({status: 0}, '')));
+}
 
-      if (method === 'POST' && data) {
-        x.send(data);
-      } else {
-        x.send();
-      }
-    } catch (error) {
-      logError('xhr construction', error);
-      typeof callback === 'object' && callback !== null && callback.error(error);
-    }
-  }
+export function ajaxBuilder(timeout = 3000, {request, done} = {}) {
+  const fetcher = fetcherFactory(timeout, {request, done});
+  return function (url, callback, data, options = {}) {
+    attachCallbacks(fetcher(toFetchRequest(url, data, options)), callback);
+  };
 }
+
+export const ajax = ajaxBuilder();
+export const fetch = fetcherFactory();

package/src/constants.json

@@ -163,11 +163,17 @@
     "MAIN": 3
   },
   "NATIVE_KEYS_THAT_ARE_NOT_ASSETS": [
-    "privacyLink",
     "clickUrl",
     "sendTargetingKeys",
     "adTemplate",
     "rendererUrl",
     "type"
-  ]
+  ],
+  "FLOOR_VALUES": {
+	"NO_DATA": "noData",
+	"AD_UNIT": "adUnit",
+	"SET_CONFIG": "setConfig",
+	"FETCH": "fetch",
+	"SUCCESS": "success"
+  }
 }

package/src/native.js

@@ -480,6 +480,11 @@ export function toOrtbNativeRequest(legacyNativeAssets) {
       continue;
     }
 
+    if (key === 'privacyLink') {
+      ortb.privacy = 1;
+      continue;
+    }
+
     const asset = legacyNativeAssets[key];
     let required = 0;
     if (asset.required && isBoolean(asset.required)) {
@@ -623,6 +628,9 @@ export function fromOrtbNativeRequest(openRTBRequest) {
         oldNativeObject[prebidAssetName].len = asset.data.len;
       }
     }
+    if (openRTBRequest.privacy) {
+      oldNativeObject.privacyLink = { required: false };
+    }
     // video was not supported by old prebid assets
   }
   return oldNativeObject;
@@ -696,8 +704,11 @@ export function legacyPropertiesToOrtbNative(legacyNative) {
         // in general, native trackers seem to be neglected and/or broken
         response.jstracker = Array.isArray(value) ? value.join('') : value;
         break;
+      case 'privacyLink':
+        response.privacy = value;
+        break;
     }
-  })
+  });
   return response;
 }
 

package/test/mocks/xhr.js

@@ -1,12 +1,236 @@
 import {getUniqueIdentifierStr} from '../../src/utils.js';
+import {GreedyPromise} from '../../src/utils/promise.js';
+import {fakeXhr} from 'nise';
+import {dep} from 'src/ajax.js';
 
-export let server = sinon.createFakeServer();
-export let xhr = global.XMLHttpRequest;
+export const xhr = sinon.useFakeXMLHttpRequest();
+export const server = mockFetchServer();
 
-beforeEach(function() {
-  server.restore();
-  server = sinon.createFakeServer();
-  xhr = global.XMLHttpRequest;
+/**
+ * An (incomplete) replica of nise's fakeServer, but backing fetch used in ajax.js (rather than XHR).
+ */
+function mockFetchServer() {
+  const sandbox = sinon.createSandbox();
+  const bodies = new WeakMap();
+  const requests = [];
+  const {DONE, UNSENT} = XMLHttpRequest;
+
+  function makeRequest(resource, options) {
+    const requestBody = options?.body || bodies.get(resource);
+    const request = new Request(resource, options);
+    bodies.set(request, requestBody);
+    return request;
+  }
+
+  function mockXHR(resource, options) {
+    let resolve, reject;
+    const promise = new GreedyPromise((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+
+    function error(reason = new TypeError('Failed to fetch')) {
+      mockReq.status = 0;
+      reject(reason);
+    }
+
+    const request = makeRequest(resource, options);
+    request.signal.onabort = () => error(new DOMException('The user aborted a request'));
+    let responseHeaders;
+
+    const mockReq = {
+      fetch: {
+        request,
+        requestBody: bodies.get(request),
+        promise,
+      },
+      readyState: UNSENT,
+      url: request.url,
+      method: request.method,
+      requestBody: bodies.get(request),
+      status: 0,
+      statusText: '',
+      requestHeaders: new Proxy(request.headers, {
+        get(target, prop) {
+          return typeof prop === 'string' && target.has(prop) ? target.get(prop) : {}[prop];
+        },
+        has(target, prop) {
+          return typeof prop === 'string' && target.has(prop);
+        },
+        ownKeys(target) {
+          return Array.from(target.keys());
+        },
+        getOwnPropertyDescriptor(target, prop) {
+          if (typeof prop === 'string' && target.has(prop)) {
+            return {
+              enumerable: true,
+              configurable: true,
+              writable: false,
+              value: target.get(prop)
+            }
+          }
+        }
+      }),
+      withCredentials: request.credentials === 'include',
+      setStatus(status) {
+        // nise replaces invalid status with 200
+        status = typeof status === 'number' ? status : 200;
+        mockReq.status = status;
+        mockReq.statusText = fakeXhr.FakeXMLHttpRequest.statusCodes[status] || '';
+      },
+      setResponseHeaders(headers) {
+        responseHeaders = headers;
+      },
+      setResponseBody(body) {
+        if (mockReq.status === 0) {
+          error();
+          return;
+        }
+        const resp = Object.defineProperties(new Response(body, {
+          status: mockReq.status,
+          statusText: mockReq.statusText,
+          headers: responseHeaders || {},
+        }), {
+          url: {
+            get: () => mockReq.fetch.request.url,
+          }
+        });
+        mockReq.readyState = DONE;
+        // tests expect respond() to run everything immediately,
+        // so make body available syncronously
+        resp.text = () => GreedyPromise.resolve(body || '');
+        Object.assign(mockReq.fetch, {
+          response: resp,
+          responseBody: body || ''
+        })
+        resolve(resp);
+      },
+      respond(status = 200, headers, body) {
+        mockReq.setStatus(status);
+        mockReq.setResponseHeaders(headers);
+        mockReq.setResponseBody(body);
+      },
+      error
+    };
+    return mockReq;
+  }
+
+  let enabled = false;
+  let timeoutsEnabled = false;
+
+  function enable() {
+    if (!enabled) {
+      sandbox.stub(dep, 'fetch').callsFake((resource, options) => {
+        const req = mockXHR(resource, options);
+        requests.push(req);
+        return req.fetch.promise;
+      });
+      sandbox.stub(dep, 'makeRequest').callsFake(makeRequest);
+      const timeout = dep.timeout;
+      sandbox.stub(dep, 'timeout').callsFake(function () {
+        if (timeoutsEnabled) {
+          return timeout.apply(null, arguments);
+        } else {
+          return {};
+        }
+      });
+      enabled = true;
+    }
+  }
+
+  enable();
+
+  const responders = [];
+
+  function respondWith() {
+    let response, urlMatcher, methodMatcher;
+    urlMatcher = methodMatcher = () => true;
+    switch (arguments.length) {
+      case 1:
+        ([response] = arguments);
+        break;
+      case 2:
+        ([urlMatcher, response] = arguments);
+        break;
+      case 3:
+        ([methodMatcher, urlMatcher, response] = arguments);
+        methodMatcher = ((toMatch) => (method) => method === toMatch)(methodMatcher);
+        break;
+      default:
+        throw new Error('Invalid respondWith invocation');
+    }
+    if (typeof urlMatcher.exec === 'function') {
+      urlMatcher = ((rx) => (url) => rx.exec(url)?.slice(1))(urlMatcher);
+    } else if (typeof urlMatcher === 'string') {
+      urlMatcher = ((toMatch) => (url) => url === toMatch)(urlMatcher);
+    }
+    responders.push((req) => {
+      if (req.readyState !== DONE && methodMatcher(req.method)) {
+        const arg = urlMatcher(req.url);
+        if (arg) {
+          if (typeof response === 'function') {
+            response(req, ...(Array.isArray(arg) ? arg : []));
+          } else if (typeof response === 'string') {
+            req.respond(200, null, response);
+          } else {
+            req.respond.apply(req, response);
+          }
+        }
+      }
+    });
+  }
+
+  function resetState() {
+    requests.length = 0;
+    responders.length = 0;
+    timeoutsEnabled = false;
+  }
+
+  return {
+    requests,
+    enable,
+    restore() {
+      resetState();
+      sandbox.restore();
+      enabled = false;
+    },
+    reset() {
+      sandbox.resetHistory();
+      resetState();
+    },
+    respondWith,
+    respond() {
+      if (arguments.length > 0) {
+        respondWith.apply(null, arguments);
+      }
+      requests.forEach(req => {
+        for (let i = responders.length - 1; i >= 0; i--) {
+          responders[i](req);
+          if (req.readyState === DONE) break;
+        }
+        if (req.readyState !== DONE) {
+          req.respond(404, {}, '');
+        }
+      });
+    },
+    /**
+     * the timeout mechanism is quite different between XHR and fetch
+     * by default, mocked fetch does not time out - to reflect fakeServer XHRs
+     * note that many tests will fire requests without caring or waiting for their response -
+     * if they are timed out later, during unrelated tests, the log messages might interfere with their
+     * assertions
+     */
+    get autoTimeout() {
+      return timeoutsEnabled;
+    },
+    set autoTimeout(val) {
+      timeoutsEnabled = !!val;
+    }
+  };
+}
+
+beforeEach(function () {
+  server.reset();
 });
 
 const bid = getUniqueIdentifierStr().substring(4);
@@ -20,12 +244,35 @@ afterEach(function () {
       return (s) => s.split('\n').map(s => `${preamble} ${s}`).join('\n');
     })();
 
+    function format(obj, body = null) {
+      if (obj == null) return obj;
+      const fmt = {};
+      let node = obj;
+      while (node != null) {
+        Object.keys(node).forEach((k) => {
+          const val = obj[k];
+          if (typeof val !== 'function' && !fmt.hasOwnProperty(k)) {
+            fmt[k] = val;
+          }
+        });
+        node = Object.getPrototypeOf(node);
+      }
+      if (obj.headers != null) {
+        fmt.headers = Object.fromEntries(obj.headers.entries())
+      }
+      fmt.body = body;
+      return fmt;
+    }
+
 
-    console.log(prepend(`XHR mock state after failure (for test '${this.currentTest.fullTitle()}'): ${server.requests.length} requests`))
+    console.log(prepend(`XHR mock state after failure (for test '${this.currentTest.fullTitle()}'): ${server.requests.length} requests`));
     server.requests.forEach((req, i) => {
       console.log(prepend(`Request #${i}:`));
-      console.log(prepend(JSON.stringify(req, null, 2)));
-    })
+      console.log(prepend(JSON.stringify({
+        request: format(req.fetch.request, req.fetch.requestBody),
+        response: format(req.fetch.response, req.fetch.responseBody)
+      }, null, 2)));
+    });
   }
 });
 /* eslint-enable */