prebid.js 9.53.1 → 9.53.2

package/modules/fanAdapter.js

@@ -1,176 +1,370 @@
-import * as utils from '../src/utils.js';
-import { ajax } from '../src/ajax.js';
-import { BANNER, NATIVE } from '../src/mediaTypes.js';
+import { ortbConverter } from '../libraries/ortbConverter/converter.js';
 import { registerBidder } from '../src/adapters/bidderFactory.js';
-
-/**
- * @typedef {import('../src/adapters/bidderFactory.js').BidderRequest} BidderRequest
- * @typedef {import('../src/adapters/bidderFactory.js').BidRequest} BidRequest
- * @typedef {import('../src/adapters/bidderFactory.js').Bid} Bid
- * @typedef {import('../src/adapters/bidderFactory.js').ServerResponse} ServerResponse
- */
+import { BANNER, VIDEO } from '../src/mediaTypes.js';
+import { deepAccess, deepSetValue, logInfo, logWarn, logError, triggerPixel } from '../src/utils.js';
+import { getStorageManager } from '../src/storageManager.js';
+import { Renderer } from '../src/Renderer.js';
+import { getGptSlotInfoForAdUnitCode } from '../libraries/gptUtils/gptUtils.js';
 
 const BIDDER_CODE = 'freedomadnetwork';
-const BASE_URL = 'https://srv.freedomadnetwork.com';
+const BIDDER_VERSION = '0.2.0';
+const NETWORK_ENDPOINTS = {
+  'fan': 'https://srv.freedomadnetwork.com/ortb',
+  'armanet': 'https://srv.armanet.us/ortb',
+  'test': 'http://localhost:8001/ortb',
+};
 
-/**
- * Build OpenRTB request from bidRequest and bidderRequest
- *
- * @param {BidRequest} bid
- * @param {BidderRequest} bidderRequest
- * @returns {Request}
- */
-function buildBidRequest(bid, bidderRequest) {
-  const payload = {
-    id: bid.bidId,
-    tmax: bidderRequest.timeout,
-    placements: [bid.params.placementId],
-    at: 1,
-    user: {}
-  }
+const DEFAULT_ENDPOINT = NETWORK_ENDPOINTS['fan'];
+const DEFAULT_CURRENCY = 'USD';
+const DEFAULT_TTL = 300;
 
-  const gdprConsent = utils.deepAccess(bidderRequest, 'gdprConsent');
-  if (!!gdprConsent && gdprConsent.gdprApplies) {
-    payload.user.gdpr = 1;
-    payload.user.consent = gdprConsent.consentString;
-  }
+export const storage = getStorageManager({bidderCode: BIDDER_CODE});
 
-  const uspConsent = utils.deepAccess(bidderRequest, 'uspConsent');
-  if (uspConsent) {
-    payload.user.usp = uspConsent;
-  }
+const converter = ortbConverter({
+  context: {
+    netRevenue: true,
+    ttl: DEFAULT_TTL,
+    currency: DEFAULT_CURRENCY
+  },
+
+  imp(buildImp, bidRequest, context) {
+    const imp = buildImp(bidRequest, context);
+
+    // Add custom fields to impression
+    if (bidRequest.params.placementId) {
+      imp.tagid = bidRequest.params.placementId;
+    }
+
+    // Add floor price
+    if (bidRequest.params.bidFloor) {
+      imp.bidfloor = parseFloat(bidRequest.params.bidFloor);
+      imp.bidfloorcur = bidRequest.params.bidFloorCur || DEFAULT_CURRENCY;
+    }
+
+    // Add custom extensions
+    deepSetValue(imp, 'ext.prebid.storedrequest.id', bidRequest.params.placementId);
+    deepSetValue(imp, 'ext.bidder', {
+      network: bidRequest.params.network || 'fan',
+      placementId: bidRequest.params.placementId
+    });
+
+    return imp;
+  },
+
+  request(buildRequest, imps, bidderRequest, context) {
+    const request = buildRequest(imps, bidderRequest, context);
+
+    // First price auction
+    request.at = 1;
+    request.cur = [DEFAULT_CURRENCY];
+
+    // Add source information
+    deepSetValue(request, 'source.tid', bidderRequest.auctionId);
+
+    // Add custom extensions
+    deepSetValue(request, 'ext.prebid.channel', BIDDER_CODE);
+    deepSetValue(request, 'ext.prebid.version', BIDDER_VERSION);
+
+    // Add user extensions
+    const firstBid = imps[0];
+    const pbUser = firstBid.userId || {};
+    request.user = request.user || {};
+    request.user.ext = request.user.ext || {};
 
-  return {
-    method: 'POST',
-    url: BASE_URL + '/pb/req',
-    data: JSON.stringify(payload),
-    options: {
-      contentType: 'application/json',
-      withCredentials: false,
-      customHeaders: {
-        'Accept-Language': 'en;q=10',
-      },
-    },
-    originalBidRequest: bid
+    if (pbUser.tdid) {
+      request.user.ext.tdid = pbUser.tdid;
+    }
+
+    if (window.geck) {
+      request.user.ext.adi = window.geck;
+    }
+
+    if (pbUser.pubcid) {
+      request.user.ext.pubcid = pbUser.pubcid;
+    }
+
+    if (pbUser.id5id?.uid) {
+      request.user.ext.id5id = pbUser.id5id.uid;
+    }
+
+    if (pbUser.lipb?.lipbid) {
+      request.user.ext.lipbid = pbUser.lipb.lipbid;
+    }
+
+    return request;
+  },
+
+  bidResponse(buildBidResponse, bid, context) {
+    const { bidRequest } = context;
+    const bidResponse = buildBidResponse(bid, context);
+
+    // Add custom bid response fields
+    bidResponse.meta = bidResponse.meta || {};
+    bidResponse.meta.networkName = BIDDER_CODE;
+    bidResponse.meta.advertiserDomains = bid.adomain || [];
+
+    if (bid.ext && bid.ext.libertas) {
+      bidResponse.meta.libertas = bid.ext.libertas;
+    }
+
+    // Add tracking URLs
+    if (bid.nurl) {
+      bidResponse.nurl = bid.nurl;
+    }
+
+    // Handle different ad formats
+    if (bidResponse.mediaType === BANNER) {
+      bidResponse.ad = bid.adm;
+      bidResponse.width = bid.w;
+      bidResponse.height = bid.h;
+    } else if (bidResponse.mediaType === VIDEO) {
+      bidResponse.vastXml = bid.adm;
+      bidResponse.width = bid.w;
+      bidResponse.height = bid.h;
+    }
+
+    // Add renderer if needed for outstream video
+    if (bidResponse.mediaType === VIDEO && bid.ext.libertas.ovp) {
+      bidResponse.width = bid.w;
+      bidResponse.height = bid.h;
+      bidResponse.renderer = createRenderer(bidRequest, bid.ext.libertas.vp);
+    }
+
+    return bidResponse;
   }
-}
+});
 
 export const spec = {
   code: BIDDER_CODE,
-  isBidRequestValid: function(bid) {
-    if (!bid) {
-      utils.logWarn(BIDDER_CODE, 'Invalid bid', bid);
+  supportedMediaTypes: [BANNER, VIDEO],
+
+  isBidRequestValid(bid) {
+    // Validate minimum required parameters
+    if (!bid.params) {
+      logError(`${BIDDER_CODE}: bid.params is required`);
 
       return false;
     }
 
-    if (!bid.params) {
-      utils.logWarn(BIDDER_CODE, 'bid.params is required');
+    // Validate placement ID
+    if (!bid.params.placementId) {
+      logError(`${BIDDER_CODE}: placementId is required`);
 
       return false;
     }
 
-    if (!bid.params.placementId) {
-      utils.logWarn(BIDDER_CODE, 'bid.params.placementId is required');
+    // Validate network parameter
+    if (bid.params.network && !NETWORK_ENDPOINTS[bid.params.network]) {
+      logError(`${BIDDER_CODE}: Invalid network: ${bid.params.network}`);
 
       return false;
     }
 
-    var banner = utils.deepAccess(bid, 'mediaTypes.banner');
-    if (banner === undefined) {
+    // Validate media types
+    if (!bid.mediaTypes || (!bid.mediaTypes.banner && !bid.mediaTypes.video)) {
+      logError(`${BIDDER_CODE}: Only banner and video mediaTypes are supported`);
+
       return false;
     }
 
+    // Validate video parameters if video mediaType is present
+    if (bid.mediaTypes.video) {
+      const video = bid.mediaTypes.video;
+      if (!video.mimes || !Array.isArray(video.mimes) || video.mimes.length === 0) {
+        logError(`${BIDDER_CODE}: video.mimes is required for video ads`);
+
+        return false;
+      }
+
+      if (!video.playerSize || !Array.isArray(video.playerSize)) {
+        logError(`${BIDDER_CODE}: video.playerSize is required for video ads`);
+
+        return false;
+      }
+    }
+
     return true;
   },
 
-  buildRequests: function(validBidRequests, bidderRequest) {
-    return validBidRequests.map(bid => buildBidRequest(bid, bidderRequest));
+  /**
+   * Make server requests from the list of BidRequests
+   */
+  buildRequests(validBidRequests, bidderRequest) {
+    const requestsByNetwork = validBidRequests.reduce((acc, bid) => {
+      const network = bid.params.network || 'fan';
+      if (!acc[network]) {
+        acc[network] = [];
+      }
+      acc[network].push(bid);
+
+      return acc;
+    }, {});
+
+    return Object.entries(requestsByNetwork).map(([network, bids]) => {
+      const data = converter.toORTB({
+        bidRequests: bids,
+        bidderRequest,
+        context: { network }
+      });
+
+      return {
+        method: 'POST',
+        url: NETWORK_ENDPOINTS[network] || DEFAULT_ENDPOINT,
+        data,
+        options: {
+          contentType: 'application/json',
+          withCredentials: false
+        },
+        bids
+      };
+    });
   },
 
   /**
-   * 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.
+   * Unpack the response from the server into a list of bids
    */
-  interpretResponse: function (serverResponse, bidRequest) {
-    const serverBody = serverResponse.body;
-    let bidResponses = [];
-
-    if (!serverBody) {
-      return bidResponses;
-    }
-
-    serverBody.forEach((response) => {
-      const bidResponse = {
-        requestId: response.id,
-        bidid: response.bidid,
-        impid: response.impid,
-        userId: response.userId,
-        cpm: response.cpm,
-        currency: response.currency,
-        width: response.width,
-        height: response.height,
-        ad: response.payload,
-        ttl: response.ttl,
-        creativeId: response.crid,
-        netRevenue: response.netRevenue,
-        trackers: response.trackers,
-        meta: {
-          mediaType: response.mediaType,
-          advertiserDomains: response.domains,
-        }
-      };
+  interpretResponse(serverResponse, bidRequest) {
+    if (!serverResponse.body) {
+      return [];
+    }
 
-      bidResponses.push(bidResponse);
+    const response = converter.fromORTB({
+      response: serverResponse.body,
+      request: bidRequest.data,
     });
 
-    return bidResponses;
+    return response.bids || [];
   },
 
   /**
-   * Register bidder specific code, which will execute if a bid from this bidder won the auction
-   *
-   * @param {Bid} bid The bid that won the auction
+   * Handle bidder errors
    */
-  onBidWon: function (bid) {
-    if (!bid) {
-      return;
-    }
+  onBidderError: function(error) {
+    logError(`${BIDDER_CODE} bidder error`, error);
+  },
 
-    const payload = {
-      id: bid.bidid,
-      impid: bid.impid,
-      t: bid.cpm,
-      u: bid.userId,
+  /**
+   * Register user sync pixels
+   */
+  getUserSyncs(syncOptions, serverResponses, gdprConsent, uspConsent, gppConsent) {
+    if (!syncOptions.iframeEnabled && !syncOptions.pixelEnabled) {
+      return [];
     }
 
-    ajax(BASE_URL + '/pb/imp', null, JSON.stringify(payload), {
-      method: 'POST',
-      customHeaders: {
-        'Accept-Language': 'en;q=10',
-      },
+    const syncs = [];
+    const seenUrls = new Set();
+
+    serverResponses.forEach(response => {
+      const userSync = deepAccess(response.body, 'ext.sync');
+      if (!userSync) {
+        return;
+      }
+
+      if (syncOptions.iframeEnabled && userSync.iframe) {
+        userSync.iframe.forEach(sync => {
+          const url = buildSyncUrl(sync.url, gdprConsent, uspConsent, gppConsent);
+          if (!seenUrls.has(url)) {
+            seenUrls.add(url);
+            syncs.push({
+              type: 'iframe',
+              url
+            });
+          }
+        });
+      }
+
+      if (syncOptions.pixelEnabled && userSync.image) {
+        userSync.image.forEach(sync => {
+          const url = buildSyncUrl(sync.url, gdprConsent, uspConsent, gppConsent);
+          if (!seenUrls.has(url)) {
+            seenUrls.add(url);
+            syncs.push({
+              type: 'image',
+              url
+            });
+          }
+        });
+      }
     });
 
-    if (bid.trackers && bid.trackers.length > 0) {
-      for (var i = 0; i < bid.trackers.length; i++) {
-        if (bid.trackers[i].type == 0) {
-          utils.triggerPixel(bid.trackers[i].url);
+    return syncs;
+  },
+
+  /**
+   * Handle bid won event
+   */
+  onBidWon(bid) {
+    logInfo(`${BIDDER_CODE}: Bid won`, bid);
+
+    if (bid.nurl) {
+      triggerPixel(bid.nurl);
+    }
+
+    if (bid.meta.libertas.pxl && bid.meta.libertas.pxl.length > 0) {
+      for (var i = 0; i < bid.meta.libertas.pxl.length; i++) {
+        if (bid.meta.libertas.pxl[i].type == 0) {
+          triggerPixel(bid.meta.libertas.pxl[i].url);
         }
       }
     }
   },
-  onSetTargeting: function(bid) {},
-  onBidderError: function(error) {
-    utils.logError(`${BIDDER_CODE} bidder error`, error);
-  },
-  getUserSyncs: function(syncOptions, serverResponses, gdprConsent, uspConsent) {
-    const syncs = [];
-    return syncs;
-  },
-  onTimeout: function(timeoutData) {},
-  supportedMediaTypes: [BANNER, NATIVE]
+};
+
+/**
+ * Build sync URL with privacy parameters
+ */
+function buildSyncUrl(baseUrl, gdprConsent, uspConsent, gppConsent) {
+  try {
+    const url = new URL(baseUrl);
+
+    if (gdprConsent) {
+      url.searchParams.set('gdpr', gdprConsent.gdprApplies ? '1' : '0');
+      if (gdprConsent.consentString) {
+        url.searchParams.set('gdpr_consent', gdprConsent.consentString);
+      }
+    }
+
+    if (uspConsent) {
+      url.searchParams.set('us_privacy', uspConsent);
+    }
+
+    if (gppConsent?.gppString) {
+      url.searchParams.set('gpp', gppConsent.gppString);
+      if (gppConsent.applicableSections?.length) {
+        url.searchParams.set('gpp_sid', gppConsent.applicableSections.join(','));
+      }
+    }
+
+    return url.toString();
+  } catch (e) {
+    logWarn(`${BIDDER_CODE}: Invalid sync URL: ${baseUrl}`);
+
+    return baseUrl;
+  }
+}
+
+/**
+ * Create renderer for outstream video
+ */
+function createRenderer(bid, videoPlayerUrl) {
+  const renderer = Renderer.install({
+    url: videoPlayerUrl,
+    loaded: false,
+    adUnitCode: bid.adUnitCode,
+  });
+
+  try {
+    renderer.setRender(function (bidResponse) {
+      const divId = document.getElementById(bid.adUnitCode) ? bid.adUnitCode : getGptSlotInfoForAdUnitCode(bid.adUnitCode).divId;
+      const adUnit = document.getElementById(divId);
+
+      window.createOutstreamPlayer(adUnit, bidResponse.vastXml, bid.width, bid.height);
+    });
+  } catch (error) {
+    logWarn('Renderer error: setRender() failed', error);
+  }
+
+  return renderer;
 }
 
 registerBidder(spec);

package/modules/userId/index.js

@@ -571,25 +571,21 @@ export function enrichEids(ortb2Fragments) {
 export function addIdData({adUnits, ortb2Fragments}) {
   ortb2Fragments = ortb2Fragments ?? {global: {}, bidder: {}}
   enrichEids(ortb2Fragments);
-  if ([adUnits].some(i => !Array.isArray(i) || !i.length)) {
-    return;
+
+  // Set bid.userId for backward compatibility with tests
+  if (adUnits && Array.isArray(adUnits) && adUnits.length) {
+    const globalIds = getIds(initializedSubmodules.global);
+    adUnits.forEach(adUnit => {
+      if (adUnit.bids && Array.isArray(adUnit.bids)) {
+        adUnit.bids.forEach(bid => {
+          const bidderIds = Object.assign({}, globalIds, getIds(initializedSubmodules.bidder[bid.bidder] ?? {}));
+          if (Object.keys(bidderIds).length > 0) {
+            bid.userId = bidderIds;
+          }
+        });
+      }
+    });
   }
-  const globalIds = getIds(initializedSubmodules.global);
-  const globalEids = ortb2Fragments.global.user?.ext?.eids || [];
-  adUnits.forEach(adUnit => {
-    if (adUnit.bids && isArray(adUnit.bids)) {
-      adUnit.bids.forEach(bid => {
-        const bidderIds = Object.assign({}, globalIds, getIds(initializedSubmodules.bidder[bid.bidder] ?? {}));
-        const bidderEids = globalEids.concat(ortb2Fragments.bidder?.[bid.bidder]?.user?.ext?.eids || []);
-        if (Object.keys(bidderIds).length > 0) {
-          bid.userId = bidderIds;
-        }
-        if (bidderEids.length > 0) {
-          bid.userIdAsEids = bidderEids;
-        }
-      });
-    }
-  });
 }
 
 const INIT_CANCELED = {};
@@ -724,15 +720,22 @@ export const startAuctionHook = timedAuctionHook('userId', function requestBidsH
 });
 
 /**
- * Append user id data from config to bids to be accessed in adapters when there are no submodules.
- * @param {function} fn required; The next function in the chain, used by hook.js
- * @param {Object} reqBidsConfigObj required; This is the same param that's used in pbjs.requestBids.
+ * Alias bid requests' `userIdAsEids` to `ortb2.user.ext.eids`
+ * Do this lazily (instead of attaching a copy) so that it also shows EIDs added after the userId module runs (e.g. from RTD modules)
  */
-export const addUserIdsHook = timedAuctionHook('userId', function requestBidsHook(fn, reqBidsConfigObj) {
-  addIdData(reqBidsConfigObj);
-  // calling fn allows prebid to continue processing
-  fn.call(this, reqBidsConfigObj);
-});
+function aliasEidsHook(next, bidderRequests) {
+  bidderRequests.forEach(bidderRequest => {
+    bidderRequest.bids.forEach(bid =>
+      Object.defineProperty(bid, 'userIdAsEids', {
+        configurable: true,
+        get() {
+          return bidderRequest.ortb2.user?.ext?.eids;
+        }
+      })
+    )
+  })
+  next(bidderRequests);
+}
 
 /**
  * Is startAuctionHook added
@@ -1158,7 +1161,6 @@ function updateSubmodules() {
 
   if (submodules.length) {
     if (!addedStartAuctionHook()) {
-      startAuction.getHooks({hook: addUserIdsHook}).remove();
       startAuction.before(startAuctionHook, 100) // use higher priority than dataController / rtd
       adapterManager.callDataDeletionRequest.before(requestDataDeletion);
       coreGetPPID.after((next) => next(getPPID()));
@@ -1259,6 +1261,7 @@ export function init(config, {mkDelay = delay} = {}) {
       }
     }
   });
+  adapterManager.makeBidRequests.after(aliasEidsHook);
 
   // exposing getUserIds function in global-name-space so that userIds stored in Prebid can be used by external codes.
   (getGlobal()).getUserIds = getUserIds;
@@ -1268,10 +1271,6 @@ export function init(config, {mkDelay = delay} = {}) {
   (getGlobal()).refreshUserIds = normalizePromise(refreshUserIds);
   (getGlobal()).getUserIdsAsync = normalizePromise(getUserIdsAsync);
   (getGlobal()).getUserIdsAsEidBySource = getUserIdsAsEidBySource;
-  if (!addedStartAuctionHook()) {
-    // Add ortb2.user.ext.eids even if 0 submodules are added
-    startAuction.before(addUserIdsHook, 100); // use higher priority than dataController / rtd
-  }
 }
 
 export function resetUserIds() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prebid.js",
-  "version": "9.53.1",
+  "version": "9.53.2",
   "description": "Header Bidding Management Library",
   "main": "src/prebid.public.js",
   "exports": {
@@ -123,8 +123,7 @@
     "webpack": "^5.70.0",
     "webpack-bundle-analyzer": "^4.5.0",
     "webpack-manifest-plugin": "^5.0.0",
-    "webpack-stream": "^7.0.0",
-    "yargs": "^1.3.1"
+    "webpack-stream": "^7.0.0"
   },
   "dependencies": {
     "@babel/core": "^7.27.4",
@@ -139,7 +138,8 @@
     "fun-hooks": "^1.1.0",
     "gulp-wrap": "^0.15.0",
     "klona": "^2.0.6",
-    "live-connect-js": "^7.2.0"
+    "live-connect-js": "^7.2.0",
+    "yargs": "^1.3.1"
   },
   "optionalDependencies": {
     "fsevents": "^2.3.2"

package/test/spec/modules/euidIdSystem_spec.js

@@ -38,9 +38,15 @@ const cstgApiUrl = 'https://prod.euid.eu/v2/token/client-generate';
 const headers = { 'Content-Type': 'application/json' };
 const makeSuccessResponseBody = (token) => btoa(JSON.stringify({ status: 'success', body: { ...apiHelpers.makeTokenResponse(initialToken), advertising_token: token } }));
 const makeOptoutResponseBody = (token) => btoa(JSON.stringify({ status: 'optout', body: { ...apiHelpers.makeTokenResponse(initialToken), advertising_token: token } }));
-const expectToken = (bid, token) => expect(bid?.userId ?? {}).to.deep.include(makeEuidIdentityContainer(token));
-const expectOptout = (bid, token) => expect(bid?.userId ?? {}).to.deep.include(makeEuidOptoutContainer(token));
-const expectNoIdentity = (bid) => expect(bid).to.not.haveOwnProperty('userId');
+function findEuid(bid) {
+  return (bid?.userIdAsEids ?? []).find(e => e.source === 'euid.eu');
+}
+const expectToken = (bid, token) => {
+  const eid = findEuid(bid);
+  expect(eid && eid.uids[0].id).to.equal(token);
+};
+const expectOptout = (bid) => expect(findEuid(bid)).to.be.undefined;
+const expectNoIdentity = (bid) => expect(findEuid(bid)).to.be.undefined;
 
 describe('EUID module', function() {
   let suiteSandbox, restoreSubtleToUndefined = false;