prebid.js 7.22.0 → 7.23.0

package/modules/prebidServerBidAdapter/ortbConverter.js

@@ -0,0 +1,274 @@
+import {ortbConverter} from '../../libraries/ortbConverter/converter.js';
+import {
+  deepAccess,
+  deepSetValue,
+  getBidRequest,
+  getDefinedParams,
+  isArray,
+  logError,
+  logWarn,
+  mergeDeep,
+  timestamp
+} from '../../src/utils.js';
+import {config} from '../../src/config.js';
+import CONSTANTS from '../../src/constants.json';
+import {createBid} from '../../src/bidfactory.js';
+import {pbsExtensions} from '../../libraries/pbsExtensions/pbsExtensions.js';
+import {setImpBidParams} from '../../libraries/pbsExtensions/processors/params.js';
+import {SUPPORTED_MEDIA_TYPES} from '../../libraries/pbsExtensions/processors/mediaType.js';
+import {IMP, REQUEST, RESPONSE} from '../../src/pbjsORTB.js';
+import {beConvertCurrency} from '../../src/utils/currency.js';
+
+const DEFAULT_S2S_TTL = 60;
+const DEFAULT_S2S_CURRENCY = 'USD';
+const DEFAULT_S2S_NETREVENUE = true;
+const BIDDER_SPECIFIC_REQUEST_PROPS = new Set(['bidderCode', 'bidderRequestId', 'uniquePbsTid', 'bids', 'timeout']);
+
+const PBS_CONVERTER = ortbConverter({
+  processors: pbsExtensions,
+  context: {
+    netRevenue: DEFAULT_S2S_NETREVENUE,
+  },
+  imp(buildImp, proxyBidRequest, context) {
+    Object.assign(context, proxyBidRequest.pbsData);
+    const imp = buildImp(proxyBidRequest, context);
+    if (Object.values(SUPPORTED_MEDIA_TYPES).some(mtype => imp[mtype])) {
+      imp.secure = context.s2sBidRequest.s2sConfig.secure;
+      return imp;
+    }
+  },
+  request(buildRequest, imps, proxyBidderRequest, context) {
+    if (!imps.length) {
+      logError('Request to Prebid Server rejected due to invalid media type(s) in adUnit.');
+    } else {
+      let {s2sBidRequest, requestedBidders, eidPermissions} = context;
+      const request = buildRequest(imps, proxyBidderRequest, context);
+
+      request.tmax = s2sBidRequest.s2sConfig.timeout;
+      deepSetValue(request, 'source.tid', proxyBidderRequest.auctionId);
+
+      [request.app, request.site].forEach(section => {
+        if (section && !section.publisher?.id) {
+          deepSetValue(section, 'publisher.id', s2sBidRequest.s2sConfig.accountId);
+        }
+      })
+
+      if (isArray(eidPermissions) && eidPermissions.length > 0) {
+        if (requestedBidders && isArray(requestedBidders)) {
+          eidPermissions = eidPermissions.map(p => ({
+            ...p,
+            bidders: p.bidders.filter(bidder => requestedBidders.includes(bidder))
+          }))
+        }
+        deepSetValue(request, 'ext.prebid.data.eidpermissions', eidPermissions);
+      }
+
+      return request;
+    }
+  },
+  bidResponse(buildBidResponse, bid, context) {
+    // before sending the response throgh "stock" ortb conversion, here we need to:
+    // - filter out ones that come from an "unknown" bidder (if allowUnknownBidderCode is not set)
+    // - overwrite context.bidRequest with the actual bid request for this seat / imp combination
+
+    let bidRequest = context.actualBidRequests.get(context.seatbid.seat);
+    if (bidRequest == null) {
+      // for stored impressions, a request was made with bidder code `null`. Pick it up here so that NO_BID, BID_WON, etc events
+      // can work as expected (otherwise, the original request will always result in NO_BID).
+      bidRequest = context.actualBidRequests.get(null);
+    }
+
+    if (bidRequest) {
+      Object.assign(context, {
+        bidRequest,
+        bidderRequest: context.actualBidderRequests.find(req => req.bidderCode === bidRequest.bidder)
+      })
+    }
+
+    const bidResponse = buildBidResponse(bid, context);
+    bidResponse.requestBidder = bidRequest?.bidder;
+
+    if (bidResponse.native?.ortb) {
+      // TODO: do we need to set bidResponse.adm here?
+      // Any consumers can now get the same object from bidResponse.native.ortb;
+      // I could not find any, which raises the question - who is looking for this?
+      bidResponse.adm = bidResponse.native.ortb;
+    }
+
+    // because core has special treatment for PBS adapter responses, we need some additional processing
+    bidResponse.requestTimestamp = context.requestTimestamp;
+    const status = bid.price !== 0 ? CONSTANTS.STATUS.GOOD : CONSTANTS.STATUS.NO_BID;
+    return {
+      bid: Object.assign(createBid(status, {
+        src: CONSTANTS.S2S.SRC,
+        bidId: bidRequest ? (bidRequest.bidId || bidRequest.bid_Id) : null,
+        transactionId: context.adUnit.transactionId,
+        auctionId: context.bidderRequest.auctionId,
+      }), bidResponse),
+      adUnit: context.adUnit.code
+    };
+  },
+  overrides: {
+    [IMP]: {
+      id(orig, imp, proxyBidRequest, context) {
+        imp.id = context.impId;
+      },
+      params(orig, imp, proxyBidRequest, context) {
+        // override params processing to do it for each bidRequest in this imp;
+        // also, take overrides from s2sConfig.adapterOptions
+        const adapterOptions = context.s2sBidRequest.s2sConfig.adapterOptions;
+        for (const req of context.actualBidRequests.values()) {
+          setImpBidParams(imp, req, context, context);
+          if (adapterOptions && adapterOptions[req.bidder]) {
+            Object.assign(imp.ext.prebid.bidder[req.bidder], adapterOptions[req.bidder]);
+          }
+        }
+      },
+      bidfloor(orig, imp, proxyBidRequest, context) {
+        // for bid floors, we pass each bidRequest associated with this imp through normal bidfloor processing,
+        // and aggregate all of them into a single, minimum floor to put in the request
+        let min;
+        for (const req of context.actualBidRequests.values()) {
+          const floor = {};
+          orig(floor, req, context);
+          // if any bid does not have a valid floor, do not attempt to send any to PBS
+          if (floor.bidfloorcur == null || floor.bidfloor == null) {
+            min = null;
+            break;
+          } else if (min == null) {
+            min = floor;
+          } else {
+            const value = beConvertCurrency(floor.bidfloor, floor.bidfloorcur, min.bidfloorcur);
+            if (value != null && value < min.bidfloor) {
+              min = floor;
+            }
+          }
+        }
+        if (min != null) {
+          Object.assign(imp, min);
+        }
+      }
+    },
+    [REQUEST]: {
+      fpd(orig, ortbRequest, proxyBidderRequest, context) {
+        // FPD is handled different for PBS - the base request will only contain global FPD;
+        // bidder-specific values are set in ext.prebid.bidderconfig
+
+        mergeDeep(ortbRequest, context.s2sBidRequest.ortb2Fragments?.global);
+
+        // also merge in s2sConfig.extPrebid
+        if (context.s2sBidRequest.s2sConfig.extPrebid && typeof context.s2sBidRequest.s2sConfig.extPrebid === 'object') {
+          deepSetValue(ortbRequest, 'ext.prebid', mergeDeep(ortbRequest.ext?.prebid || {}, context.s2sBidRequest.s2sConfig.extPrebid));
+        }
+
+        const fpdConfigs = Object.entries(context.s2sBidRequest.ortb2Fragments?.bidder || {}).map(([bidder, ortb2]) => ({
+          bidders: [bidder],
+          config: {ortb2}
+        }));
+        if (fpdConfigs.length) {
+          deepSetValue(ortbRequest, 'ext.prebid.bidderconfig', fpdConfigs);
+        }
+      },
+      extPrebidAliases(orig, ortbRequest, proxyBidderRequest, context) {
+        // override alias processing to do it for each bidder in the request
+        context.actualBidderRequests.forEach(req => orig(ortbRequest, req, context));
+      },
+      sourceExtSchain(orig, ortbRequest, proxyBidderRequest, context) {
+        // pass schains in ext.prebid.schains, with the most commonly used one in source.ext.schain
+        let mainChain;
+
+        let chains = (deepAccess(ortbRequest, 'ext.prebid.schains') || []);
+        const chainBidders = new Set(chains.flatMap((item) => item.bidders));
+
+        chains = Object.values(
+          chains
+            .concat(context.actualBidderRequests
+              .filter((req) => !chainBidders.has(req.bidderCode)) // schain defined in s2sConfig.extPrebid takes precedence
+              .map((req) => ({
+                bidders: [req.bidderCode],
+                schain: deepAccess(req, 'bids.0.schain')
+              })))
+            .filter(({bidders, schain}) => bidders?.length > 0 && schain)
+            .reduce((chains, {bidders, schain}) => {
+              const key = JSON.stringify(schain);
+              if (!chains.hasOwnProperty(key)) {
+                chains[key] = {bidders: new Set(), schain};
+              }
+              bidders.forEach((bidder) => chains[key].bidders.add(bidder));
+              if (mainChain == null || chains[key].bidders.size > mainChain.bidders.size) {
+                mainChain = chains[key]
+              }
+              return chains;
+            }, {})
+        ).map(({bidders, schain}) => ({bidders: Array.from(bidders), schain}));
+
+        if (mainChain != null) {
+          deepSetValue(ortbRequest, 'source.ext.schain', mainChain.schain);
+        }
+
+        if (chains.length) {
+          deepSetValue(ortbRequest, 'ext.prebid.schains', chains);
+        }
+      }
+    },
+    [RESPONSE]: {
+      serverSideStats(orig, response, ortbResponse, context) {
+        // override to process each request
+        context.actualBidderRequests.forEach(req => orig(response, ortbResponse, {...context, bidderRequest: req, bidRequests: req.bids}));
+      }
+    }
+  },
+});
+
+export function buildPBSRequest(s2sBidRequest, bidderRequests, adUnits, requestedBidders, eidPermissions) {
+  const requestTimestamp = timestamp();
+  const impIds = new Set();
+  const proxyBidRequests = [];
+
+  adUnits.forEach(adUnit => {
+    const actualBidRequests = new Map();
+
+    adUnit.bids.forEach((bid) => {
+      if (bid.mediaTypes != null) {
+        // TODO: support labels / conditional bids
+        // for now, just warn about them
+        logWarn(`Prebid Server adapter does not (yet) support bidder-specific mediaTypes for the same adUnit. Size mapping configuration will be ignored for adUnit: ${adUnit.code}, bidder: ${bid.bidder}`);
+      }
+      actualBidRequests.set(bid.bidder, getBidRequest(bid.bid_id, bidderRequests));
+    });
+
+    let impId = adUnit.code;
+    let i = 1;
+    while (impIds.has(impId)) {
+      i++;
+      impId = `${adUnit.code}-${i}`;
+    }
+    impIds.add(impId)
+    proxyBidRequests.push({
+      ...adUnit,
+      ...getDefinedParams(actualBidRequests.values().next().value || {}, ['userId', 'userIdAsEids', 'schain']),
+      pbsData: {impId, actualBidRequests, adUnit}
+    });
+  });
+
+  const proxyBidderRequest = Object.fromEntries(Object.entries(bidderRequests[0]).filter(([k]) => !BIDDER_SPECIFIC_REQUEST_PROPS.has(k)))
+
+  return PBS_CONVERTER.toORTB({
+    bidderRequest: proxyBidderRequest,
+    bidRequests: proxyBidRequests,
+    context: {
+      currency: config.getConfig('currency.adServerCurrency') || DEFAULT_S2S_CURRENCY,
+      ttl: s2sBidRequest.s2sConfig.defaultTtl || DEFAULT_S2S_TTL,
+      requestTimestamp,
+      s2sBidRequest,
+      requestedBidders,
+      actualBidderRequests: bidderRequests,
+      eidPermissions,
+      nativeRequest: s2sBidRequest.s2sConfig.ortbNative,
+    }
+  });
+}
+
+export function interpretPBSResponse(response, request) {
+  return PBS_CONVERTER.fromORTB({response, request});
+}

package/modules/priceFloors.js

@@ -10,6 +10,7 @@ import {
   logError,
   logInfo,
   logWarn,
+  mergeDeep,
   parseGPTSingleSizeArray,
   parseUrl,
   pick
@@ -24,7 +25,9 @@ import {find} from '../src/polyfill.js';
 import {getRefererInfo} from '../src/refererDetection.js';
 import {bidderSettings} from '../src/bidderSettings.js';
 import {auctionManager} from '../src/auctionManager.js';
+import {IMP, PBS, registerOrtbProcessor, REQUEST} from '../src/pbjsORTB.js';
 import {timedAuctionHook, timedBidResponseHook} from '../src/utils/perfMetrics.js';
+import {beConvertCurrency} from '../src/utils/currency.js';
 
 /**
  * @summary This Module is intended to provide users with the ability to dynamically set and enforce price floors on a per auction basis.
@@ -79,7 +82,7 @@ const getHostname = (() => {
   let domain;
   return function() {
     if (domain == null) {
-      domain = parseUrl(getRefererInfo().topmostLocation, {noDecodeWholeUrl: true}).hostname;
+      domain = parseUrl(getRefererInfo().topmostLocation, {noDecodeWholeURL: true}).hostname;
     }
     return domain;
   }
@@ -745,3 +748,72 @@ export const addBidResponseHook = timedBidResponseHook('priceFloors', function a
 });
 
 config.getConfig('floors', config => handleSetFloorsConfig(config.floors));
+
+/**
+ * Sets bidfloor and bidfloorcur for ORTB imp objects
+ */
+export function setOrtbImpBidFloor(imp, bidRequest, context) {
+  if (typeof bidRequest.getFloor === 'function') {
+    let currency, floor;
+    try {
+      ({currency, floor} = bidRequest.getFloor({
+        currency: context.currency || config.getConfig('currency.adServerCurrency') || 'USD',
+        mediaType: context.mediaType || '*',
+        size: '*'
+      }));
+    } catch (e) {
+      logWarn('Cannot compute floor for bid', bidRequest);
+      return;
+    }
+    floor = parseFloat(floor);
+    if (currency != null && floor != null && !isNaN(floor)) {
+      Object.assign(imp, {
+        bidfloor: floor,
+        bidfloorcur: currency
+      });
+    }
+  }
+}
+
+export function setImpExtPrebidFloors(imp, bidRequest, context) {
+  // logic below relates to https://github.com/prebid/Prebid.js/issues/8749 and does the following:
+  // 1. check client-side floors (ref bidfloor/bidfloorcur & ortb2Imp floorMin/floorMinCur (if present))
+  // 2. set pbs req wide floorMinCur to the first floor currency found when iterating over imp's
+  //    (if currency conversion logic present, convert all imp floor values to this currency)
+  // 3. compare/store ref to lowest floorMin value as each imp is iterated over
+  // 4. set req wide floorMin and floorMinCur values for pbs after iterations are done
+
+  if (imp.bidfloor != null) {
+    let {floorMinCur, floorMin} = context.reqContext.floorMin || {};
+
+    if (floorMinCur == null) { floorMinCur = imp.bidfloorcur }
+    const ortb2ImpFloorCur = imp.ext?.prebid?.floors?.floorMinCur || imp.ext?.prebid?.floorMinCur || floorMinCur;
+    const ortb2ImpFloorMin = imp.ext?.prebid?.floors?.floorMin || imp.ext?.prebid?.floorMin;
+    const convertedFloorMinValue = beConvertCurrency(imp.bidfloor, imp.bidfloorcur, floorMinCur);
+    const convertedOrtb2ImpFloorMinValue = ortb2ImpFloorMin && ortb2ImpFloorCur ? beConvertCurrency(ortb2ImpFloorMin, ortb2ImpFloorCur, floorMinCur) : false;
+
+    const lowestImpFloorMin = convertedOrtb2ImpFloorMinValue && convertedOrtb2ImpFloorMinValue < convertedFloorMinValue
+      ? convertedOrtb2ImpFloorMinValue
+      : convertedFloorMinValue;
+
+    deepSetValue(imp, 'ext.prebid.floors.floorMin', lowestImpFloorMin);
+    if (floorMin == null || floorMin > lowestImpFloorMin) { floorMin = lowestImpFloorMin }
+    context.reqContext.floorMin = {floorMin, floorMinCur};
+  }
+}
+
+/**
+ * PBS specific extension: set ext.prebid.floors.enabled = false if floors are processed client-side
+ */
+export function setOrtbExtPrebidFloors(ortbRequest, bidderRequest, context) {
+  if (addedFloorsHook) {
+    deepSetValue(ortbRequest, 'ext.prebid.floors.enabled', ortbRequest.ext?.prebid?.floors?.enabled || false);
+  }
+  if (context?.floorMin) {
+    mergeDeep(ortbRequest, {ext: {prebid: {floors: context.floorMin}}})
+  }
+}
+
+registerOrtbProcessor({type: IMP, name: 'bidfloor', fn: setOrtbImpBidFloor});
+registerOrtbProcessor({type: IMP, name: 'extPrebidFloors', fn: setImpExtPrebidFloors, dialects: [PBS], priority: -1});
+registerOrtbProcessor({type: REQUEST, name: 'extPrebidFloors', fn: setOrtbExtPrebidFloors, dialects: [PBS]});

package/modules/rtdModule/index.js

@@ -108,6 +108,13 @@
  * @param {UserConsentData} userConsent
  */
 
+/**
+ * @function?
+ * @summary on data deletion request
+ * @name RtdSubmodule#onDataDeletionRequest
+ * @param {SubmoduleConfig} config
+ */
+
 /**
  * @interface ModuleConfig
  */
@@ -156,7 +163,7 @@ import {getHook, module} from '../../src/hook.js';
 import {logError, logInfo, logWarn} from '../../src/utils.js';
 import * as events from '../../src/events.js';
 import CONSTANTS from '../../src/constants.json';
-import {gdprDataHandler, uspDataHandler} from '../../src/adapterManager.js';
+import adapterManager, {gdprDataHandler, uspDataHandler} from '../../src/adapterManager.js';
 import {find} from '../../src/polyfill.js';
 import {timedAuctionHook} from '../../src/utils/perfMetrics.js';
 
@@ -230,6 +237,7 @@ export function init(config) {
     _dataProviders = realTimeData.dataProviders;
     setEventsListeners();
     getHook('startAuction').before(setBidRequestsData, 20); // RTD should run before FPD
+    adapterManager.callDataDeletionRequest.before(onDataDeletionRequest);
     initSubModules();
   });
 }
@@ -386,5 +394,18 @@ export function deepMerge(arr) {
   }, {});
 }
 
+export function onDataDeletionRequest(next, ...args) {
+  subModules.forEach((sm) => {
+    if (typeof sm.onDataDeletionRequest === 'function') {
+      try {
+        sm.onDataDeletionRequest(sm.config);
+      } catch (e) {
+        logError(`Error executing ${sm.name}.onDataDeletionRequest`, e)
+      }
+    }
+  });
+  next.apply(this, args);
+}
+
 module('realTimeData', attachRealTimeDataProvider);
 init(config);

package/modules/schain.js

@@ -1,6 +1,18 @@
 import { config } from '../src/config.js';
 import adapterManager from '../src/adapterManager.js';
-import { isNumber, isStr, isArray, isPlainObject, hasOwn, logError, isInteger, _each, logWarn } from '../src/utils.js';
+import {
+  isNumber,
+  isStr,
+  isArray,
+  isPlainObject,
+  hasOwn,
+  logError,
+  isInteger,
+  _each,
+  logWarn,
+  deepAccess, deepSetValue
+} from '../src/utils.js';
+import {registerOrtbProcessor, REQUEST} from '../src/pbjsORTB.js';
 
 // https://github.com/InteractiveAdvertisingBureau/openrtb/blob/master/supplychainobject.md
 
@@ -181,3 +193,14 @@ export function init() {
 }
 
 init()
+
+export function setOrtbSourceExtSchain(ortbRequest, bidderRequest, context) {
+  if (!deepAccess(ortbRequest, 'source.ext.schain')) {
+    const schain = deepAccess(context, 'bidRequests.0.schain');
+    if (schain) {
+      deepSetValue(ortbRequest, 'source.ext.schain', schain);
+    }
+  }
+}
+
+registerOrtbProcessor({type: REQUEST, name: 'sourceExtSchain', fn: setOrtbSourceExtSchain});

package/modules/spotxBidAdapter.js

@@ -149,7 +149,7 @@ export const spec = {
         }
       }
 
-      const mimes = getBidIdParameter('mimes', bid.params) || ['application/javascript', 'video/mp4', 'video/webm'];
+      const mimes = getBidIdParameter('mimes', bid.params) || deepAccess(bid, 'mediaTypes.video.mimes') || ['application/javascript', 'video/mp4', 'video/webm'];
 
       const spotxReq = {
         id: bid.bidId,
@@ -176,28 +176,29 @@ export const spec = {
         spotxReq.bidfloor = getBidIdParameter('price_floor', bid.params);
       }
 
-      if (getBidIdParameter('start_delay', bid.params) != '') {
-        spotxReq.video.startdelay = 0 + Boolean(getBidIdParameter('start_delay', bid.params));
+      const startdelay = getBidIdParameter('start_delay', bid.params) || deepAccess(bid, 'mediaTypes.video.startdelay');
+      if (startdelay) {
+        spotxReq.video.startdelay = 0 + Boolean(startdelay);
       }
 
-      if (getBidIdParameter('min_duration', bid.params) != '') {
-        spotxReq.video.minduration = getBidIdParameter('min_duration', bid.params);
+      const minduration = getBidIdParameter('min_duration', bid.params) || deepAccess(bid, 'mediaTypes.video.minduration');
+      if (minduration) {
+        spotxReq.video.minduration = minduration;
       }
 
-      if (getBidIdParameter('max_duration', bid.params) != '') {
-        spotxReq.video.maxduration = getBidIdParameter('max_duration', bid.params);
+      const maxduration = getBidIdParameter('max_duration', bid.params) || deepAccess(bid, 'mediaTypes.video.maxduration');
+      if (maxduration) {
+        spotxReq.video.maxduration = maxduration;
       }
 
-      if (getBidIdParameter('placement_type', bid.params) != '') {
-        spotxReq.video.ext.placement = getBidIdParameter('placement_type', bid.params);
+      const placement = getBidIdParameter('placement_type', bid.params) || deepAccess(bid, 'mediaTypes.video.placement');
+      if (placement) {
+        spotxReq.video.ext.placement = placement;
       }
 
-      if (getBidIdParameter('position', bid.params) != '') {
-        spotxReq.video.ext.pos = getBidIdParameter('position', bid.params);
-      } else {
-        if (deepAccess(bid, 'mediaTypes.video.pos')) {
-          spotxReq.video.ext.pos = deepAccess(bid, 'mediaTypes.video.pos');
-        }
+      const position = getBidIdParameter('position', bid.params) || deepAccess(bid, 'mediaTypes.video.pos');
+      if (position) {
+        spotxReq.video.ext.pos = position;
       }
 
       if (bid.crumbs && bid.crumbs.pubcid) {

package/modules/synacormediaBidAdapter.js

@@ -71,7 +71,7 @@ export const spec = {
         seatId = bid.params.seatId;
       }
       const tagIdOrPlacementId = bid.params.tagId || bid.params.placementId;
-      let pos = parseInt(bid.params.pos, 10);
+      let pos = parseInt(bid.params.pos || deepAccess(bid.mediaTypes, 'video.pos'), 10);
       if (isNaN(pos)) {
         logWarn(`Synacormedia: there is an invalid POS: ${bid.params.pos}`);
         pos = 0;

package/modules/teadsIdSystem.js

@@ -37,6 +37,11 @@ export const teadsIdSubmodule = {
      * @type {string}
      */
   name: MODULE_NAME,
+  /**
+   * Vendor id of Teads
+   * @type {number}
+   */
+  gvlid: GVL_ID,
   /**
      * decode the stored id value for passing to bid requests
      * @function

package/modules/userId/index.js

@@ -129,7 +129,7 @@ import {find, includes} from '../../src/polyfill.js';
 import {config} from '../../src/config.js';
 import * as events from '../../src/events.js';
 import {getGlobal} from '../../src/prebidGlobal.js';
-import {gdprDataHandler} from '../../src/adapterManager.js';
+import adapterManager, {gdprDataHandler} from '../../src/adapterManager.js';
 import CONSTANTS from '../../src/constants.json';
 import {hook, module, ready as hooksReady} from '../../src/hook.js';
 import {buildEidPermissions, createEidsArray, USER_IDS_CONFIG} from './eids.js';
@@ -149,11 +149,12 @@ import {
   logInfo,
   logWarn,
   timestamp,
-  isEmpty
+  isEmpty, deepSetValue
 } from '../../src/utils.js';
 import {getPPID as coreGetPPID} from '../../src/adserver.js';
 import {defer, GreedyPromise} from '../../src/utils/promise.js';
 import {hasPurpose1Consent} from '../../src/utils/gpdr.js';
+import {registerOrtbProcessor, REQUEST} from '../../src/pbjsORTB.js';
 import {newMetrics, timedAuctionHook, useMetrics} from '../../src/utils/perfMetrics.js';
 
 const MODULE_NAME = 'User ID';
@@ -216,6 +217,14 @@ export function setSubmoduleRegistry(submodules) {
   submoduleRegistry = submodules;
 }
 
+function cookieSetter(submodule) {
+  const domainOverride = (typeof submodule.submodule.domainOverride === 'function') ? submodule.submodule.domainOverride() : null;
+  const name = submodule.config.storage.name;
+  return function setCookie(suffix, value, expiration) {
+    coreStorage.setCookie(name + (suffix || ''), value, expiration, 'Lax', domainOverride);
+  }
+}
+
 /**
  * @param {SubmoduleContainer} submodule
  * @param {(Object|string)} value
@@ -225,15 +234,15 @@ export function setStoredValue(submodule, value) {
    * @type {SubmoduleStorage}
    */
   const storage = submodule.config.storage;
-  const domainOverride = (typeof submodule.submodule.domainOverride === 'function') ? submodule.submodule.domainOverride() : null;
 
   try {
-    const valueStr = isPlainObject(value) ? JSON.stringify(value) : value;
     const expiresStr = (new Date(Date.now() + (storage.expires * (60 * 60 * 24 * 1000)))).toUTCString();
+    const valueStr = isPlainObject(value) ? JSON.stringify(value) : value;
     if (storage.type === COOKIE) {
-      coreStorage.setCookie(storage.name, valueStr, expiresStr, 'Lax', domainOverride);
+      const setCookie = cookieSetter(submodule);
+      setCookie(null, value, expiresStr);
       if (typeof storage.refreshInSeconds === 'number') {
-        coreStorage.setCookie(`${storage.name}_last`, new Date().toUTCString(), expiresStr, 'Lax', domainOverride);
+        setCookie('_last', new Date().toUTCString(), expiresStr);
       }
     } else if (storage.type === LOCAL_STORAGE) {
       coreStorage.setDataInLocalStorage(`${storage.name}_exp`, expiresStr);
@@ -247,6 +256,31 @@ export function setStoredValue(submodule, value) {
   }
 }
 
+export function deleteStoredValue(submodule) {
+  let deleter, suffixes;
+  switch (submodule.config?.storage?.type) {
+    case COOKIE:
+      const setCookie = cookieSetter(submodule);
+      const expiry = (new Date(Date.now() - 1000 * 60 * 60 * 24)).toUTCString();
+      deleter = (suffix) => setCookie(suffix, '', expiry)
+      suffixes = ['', '_last'];
+      break;
+    case LOCAL_STORAGE:
+      deleter = (suffix) => coreStorage.removeDataFromLocalStorage(submodule.config.storage.name + suffix)
+      suffixes = ['', '_last', '_exp'];
+      break;
+  }
+  if (deleter) {
+    suffixes.forEach(suffix => {
+      try {
+        deleter(suffix)
+      } catch (e) {
+        logError(e);
+      }
+    });
+  }
+}
+
 function setPrebidServerEidPermissions(initializedSubmodules) {
   let setEidPermissions = getPrebidInternal().setEidPermissions;
   if (typeof setEidPermissions === 'function' && isArray(initializedSubmodules)) {
@@ -1009,12 +1043,28 @@ function updateSubmodules() {
   if (!addedUserIdHook && submodules.length) {
     // priority value 40 will load after consentManagement with a priority of 50
     getGlobal().requestBids.before(requestBidsHook, 40);
+    adapterManager.callDataDeletionRequest.before(requestDataDeletion);
     coreGetPPID.after((next) => next(getPPID()));
     logInfo(`${MODULE_NAME} - usersync config updated for ${submodules.length} submodules: `, submodules.map(a => a.submodule.name));
     addedUserIdHook = true;
   }
 }
 
+export function requestDataDeletion(next, ...args) {
+  logInfo('UserID: received data deletion request; deleting all stored IDs...')
+  submodules.forEach(submodule => {
+    if (typeof submodule.submodule.onDataDeletionRequest === 'function') {
+      try {
+        submodule.submodule.onDataDeletionRequest(submodule.config, submodule.idObj, ...args);
+      } catch (e) {
+        logError(`Error calling onDataDeletionRequest for ID submodule ${submodule.submodule.name}`, e);
+      }
+    }
+    deleteStoredValue(submodule);
+  })
+  next.apply(this, args);
+}
+
 /**
  * enable submodule in User ID
  * @param {Submodule} submodule
@@ -1082,3 +1132,11 @@ export function init(config, {delay = GreedyPromise.timeout} = {}) {
 init(config);
 
 module('userId', attachIdSystem);
+
+export function setOrtbUserExtEids(ortbRequest, bidderRequest, context) {
+  const eids = deepAccess(context, 'bidRequests.0.userIdAsEids');
+  if (eids) {
+    deepSetValue(ortbRequest, 'user.ext.eids', eids);
+  }
+}
+registerOrtbProcessor({type: REQUEST, name: 'userExtEids', fn: setOrtbUserExtEids});