prebid.js 7.52.0 → 7.53.0

package/modules/conceptxBidAdapter.md

@@ -0,0 +1,36 @@
+# Overview
+
+```
+Module Name: ConceptX Bidder Adapter
+Module Type: Bidder Adapter
+Maintainer: info@concept.dk
+```
+
+# Description
+
+ConceptX Bidder Adapter for Prebid.js. 
+Only Banner format is supported.
+
+# Test Parameters
+```
+    var adUnits = [
+            {
+                code: "test-div",
+                mediaTypes: {
+                    banner: {
+                        sizes: [[980, 180]]
+                    }
+                },
+                bids: [
+                    {
+                        bidder: "conceptx",
+                        params: {
+                            site: "example",
+                            adunit: "some-id-3",
+                        }
+                    },
+                ]
+            },
+           
+        ];
+```

package/modules/criteoBidAdapter.js

@@ -28,7 +28,7 @@ const LOG_PREFIX = 'Criteo: ';
   Unminified source code can be found in the privately shared repo: https://github.com/Prebid-org/prebid-js-external-js-criteo/blob/master/dist/prod.js
 */
 const FAST_BID_VERSION_PLACEHOLDER = '%FAST_BID_VERSION%';
-export const FAST_BID_VERSION_CURRENT = 135;
+export const FAST_BID_VERSION_CURRENT = 136;
 const FAST_BID_VERSION_LATEST = 'latest';
 const FAST_BID_VERSION_NONE = 'none';
 const PUBLISHER_TAG_URL_TEMPLATE = 'https://static.criteo.net/js/ld/publishertag.prebid' + FAST_BID_VERSION_PLACEHOLDER + '.js';
@@ -177,7 +177,14 @@ export const spec = {
 
     if (publisherTagAvailable()) {
       // eslint-disable-next-line no-undef
-      const adapter = new Criteo.PubTag.Adapters.Prebid(PROFILE_ID_PUBLISHERTAG, ADAPTER_VERSION, bidRequests, bidderRequest, '$prebid.version$');
+      const adapter = new Criteo.PubTag.Adapters.Prebid(
+        PROFILE_ID_PUBLISHERTAG,
+        ADAPTER_VERSION,
+        bidRequests,
+        bidderRequest,
+        '$prebid.version$',
+        { createOutstreamVideoRenderer: createOutstreamVideoRenderer }
+      );
       url = adapter.buildCdbUrl();
       data = adapter.buildCdbRequest();
     } else {

package/modules/eskimiBidAdapter.js

@@ -1,7 +1,7 @@
-import {registerBidder} from '../src/adapters/bidderFactory.js';
-import {BANNER} from '../src/mediaTypes.js';
+import { ortbConverter } from '../libraries/ortbConverter/converter.js';
+import { registerBidder } from '../src/adapters/bidderFactory.js';
+import { BANNER, VIDEO } from '../src/mediaTypes.js';
 import * as utils from '../src/utils.js';
-import {ortbConverter} from '../libraries/ortbConverter/converter.js'
 
 const BIDDER_CODE = 'eskimi';
 // const ENDPOINT = 'https://hb.eskimi.com/bids'
@@ -12,43 +12,35 @@ const DEFAULT_CURRENCY = 'USD';
 const DEFAULT_NET_REVENUE = true;
 const GVLID = 814;
 
+const VIDEO_ORTB_PARAMS = [
+  'mimes',
+  'minduration',
+  'maxduration',
+  'placement',
+  'protocols',
+  'startdelay',
+  'skip',
+  'skipafter',
+  'minbitrate',
+  'maxbitrate',
+  'delivery',
+  'playbackmethod',
+  'api',
+  'linearity',
+  'battr'
+];
+
+const BANNER_ORTB_PARAMS = [
+  'battr'
+]
+
 export const spec = {
   code: BIDDER_CODE,
   gvlid: GVLID,
-  supportedMediaTypes: [BANNER],
-
-  isBidRequestValid: function (bid) {
-    return !!bid.params.placementId;
-  },
-
-  buildRequests(bidRequests, bidderRequest) {
-    const data = converter.toORTB({bidRequests, bidderRequest})
-
-    let bid = bidRequests.find((b) => b.params.placementId)
-    if (!data.site) data.site = {}
-    data.site.ext = {placementId: bid.params.placementId}
-
-    if (bidderRequest.gdprConsent) {
-      if (!data.user) data.user = {};
-      if (!data.user.ext) data.user.ext = {};
-      if (!data.regs) data.regs = {};
-      if (!data.regs.ext) data.regs.ext = {};
-      data.user.ext.consent = bidderRequest.gdprConsent.consentString;
-      data.regs.ext.gdpr = bidderRequest.gdprConsent.gdprApplies ? 1 : 0;
-    }
-
-    return [{
-      method: 'POST',
-      url: ENDPOINT,
-      data,
-      options: {contentType: 'application/json;charset=UTF-8', withCredentials: false}
-    }]
-  },
-
-  interpretResponse(response, request) {
-    return converter.fromORTB({response: response.body, request: request.data}).bids;
-  },
-
+  supportedMediaTypes: [BANNER, VIDEO],
+  isBidRequestValid,
+  buildRequests,
+  interpretResponse,
   /**
    * 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
@@ -60,13 +52,151 @@ export const spec = {
   }
 }
 
-const converter = ortbConverter({
+registerBidder(spec);
+
+const CONVERTER = ortbConverter({
   context: {
     netRevenue: DEFAULT_NET_REVENUE,
     ttl: DEFAULT_BID_TTL,
-    currency: DEFAULT_CURRENCY,
-    mediaType: BANNER // TODO: support more types, we should set mtype on the winning bid
+    currency: DEFAULT_CURRENCY
+  },
+  imp(buildImp, bidRequest, context) {
+    let imp = buildImp(bidRequest, context);
+    imp.secure = Number(window.location.protocol === 'https:');
+    if (!imp.bidfloor && bidRequest.params.bidFloor) {
+      imp.bidfloor = bidRequest.params.bidFloor;
+      imp.bidfloorcur = utils.getBidIdParameter('bidFloorCur', bidRequest.params).toUpperCase() || 'USD'
+    }
+
+    if (bidRequest.mediaTypes[VIDEO]) {
+      imp = buildVideoImp(bidRequest, imp);
+    } else if (bidRequest.mediaTypes[BANNER]) {
+      imp = buildBannerImp(bidRequest, imp);
+    }
+
+    return imp;
   }
 });
 
-registerBidder(spec);
+function isBidRequestValid(bidRequest) {
+  return (isPlacementIdValid(bidRequest) && (isValidBannerRequest(bidRequest) || isValidVideoRequest(bidRequest)));
+}
+
+function isPlacementIdValid(bidRequest) {
+  return utils.isNumber(bidRequest.params.placementId);
+}
+
+function isValidBannerRequest(bidRequest) {
+  const bannerSizes = utils.deepAccess(bidRequest, `mediaTypes.${BANNER}.sizes`);
+  return utils.isArray(bannerSizes) && bannerSizes.length > 0 && bannerSizes.every(size => utils.isNumber(size[0]) && utils.isNumber(size[1]));
+}
+
+function isValidVideoRequest(bidRequest) {
+  const videoSizes = utils.deepAccess(bidRequest, `mediaTypes.${VIDEO}.playerSize`);
+
+  return utils.isArray(videoSizes) && videoSizes.length > 0 && videoSizes.every(size => utils.isNumber(size[0]) && utils.isNumber(size[1]));
+}
+
+function buildRequests(validBids, bidderRequest) {
+  let videoBids = validBids.filter(bid => isVideoBid(bid));
+  let bannerBids = validBids.filter(bid => isBannerBid(bid));
+  let requests = [];
+
+  bannerBids.forEach(bid => {
+    requests.push(createRequest([bid], bidderRequest, BANNER));
+  });
+
+  videoBids.forEach(bid => {
+    requests.push(createRequest([bid], bidderRequest, VIDEO));
+  });
+
+  return requests;
+}
+
+function interpretResponse(response, request) {
+  return CONVERTER.fromORTB({ request: request.data, response: response.body }).bids;
+}
+
+function buildVideoImp(bidRequest, imp) {
+  const videoAdUnitParams = utils.deepAccess(bidRequest, `mediaTypes.${VIDEO}`, {});
+  const videoBidderParams = utils.deepAccess(bidRequest, `params.${VIDEO}`, {});
+
+  const videoParams = { ...videoAdUnitParams, ...videoBidderParams };
+
+  const videoSizes = (videoAdUnitParams && videoAdUnitParams.playerSize) || [];
+
+  if (videoSizes && videoSizes.length > 0) {
+    utils.deepSetValue(imp, 'video.w', videoSizes[0][0]);
+    utils.deepSetValue(imp, 'video.h', videoSizes[0][1]);
+  }
+
+  VIDEO_ORTB_PARAMS.forEach((param) => {
+    if (videoParams.hasOwnProperty(param)) {
+      utils.deepSetValue(imp, `video.${param}`, videoParams[param]);
+    }
+  });
+
+  if (imp.video && videoParams?.context === 'outstream') {
+    imp.video.placement = imp.video.placement || 4;
+  }
+
+  return { ...imp };
+}
+
+function buildBannerImp(bidRequest, imp) {
+  const bannerAdUnitParams = utils.deepAccess(bidRequest, `mediaTypes.${BANNER}`, {});
+  const bannerBidderParams = utils.deepAccess(bidRequest, `params.${BANNER}`, {});
+
+  const bannerParams = { ...bannerAdUnitParams, ...bannerBidderParams };
+
+  let sizes = bidRequest.mediaTypes.banner.sizes;
+
+  if (sizes) {
+    utils.deepSetValue(imp, 'banner.w', sizes[0][0]);
+    utils.deepSetValue(imp, 'banner.h', sizes[0][1]);
+  }
+
+  BANNER_ORTB_PARAMS.forEach((param) => {
+    if (bannerParams.hasOwnProperty(param)) {
+      utils.deepSetValue(imp, `banner.${param}`, bannerParams[param]);
+    }
+  });
+
+  return { ...imp };
+}
+
+function createRequest(bidRequests, bidderRequest, mediaType) {
+  const data = CONVERTER.toORTB({ bidRequests, bidderRequest, context: { mediaType } })
+
+  const bid = bidRequests.find((b) => b.params.placementId)
+  if (!data.site) data.site = {}
+  data.site.ext = { placementId: bid.params.placementId }
+
+  if (bidderRequest.gdprConsent) {
+    if (!data.user) data.user = {};
+    if (!data.user.ext) data.user.ext = {};
+    if (!data.regs) data.regs = {};
+    if (!data.regs.ext) data.regs.ext = {};
+    data.user.ext.consent = bidderRequest.gdprConsent.consentString;
+    data.regs.ext.gdpr = bidderRequest.gdprConsent.gdprApplies ? 1 : 0;
+  }
+
+  if (bid.params.bcat) data.bcat = bid.params.bcat;
+  if (bid.params.badv) data.badv = bid.params.badv;
+  if (bid.params.bapp) data.bapp = bid.params.bapp;
+
+  return {
+    method: 'POST',
+    url: ENDPOINT,
+    data: data,
+    options: { contentType: 'application/json;charset=UTF-8', withCredentials: false }
+  }
+}
+
+function isVideoBid(bid) {
+  return utils.deepAccess(bid, 'mediaTypes.video');
+}
+
+function isBannerBid(bid) {
+  return utils.deepAccess(bid, 'mediaTypes.banner') || !isVideoBid(bid);
+}

package/modules/eskimiBidAdapter.md

@@ -6,29 +6,48 @@ Maintainer: tech@eskimi.com
 
 # Description
 
-An adapter to get a bid from Eskimi DSP.
+Module that connects to Eskimi demand sources to fetch bids using OpenRTB standard.
+Banner and video formats are supported.
 
 # Test Parameters
 ```javascript
     var adUnits = [{
-       code: 'div-gpt-ad-1460505748561-0',
-       mediaTypes: {
-           banner: {
-               sizes: [[300, 250], [300, 600]]
-           }
-       },
-       
-       bids: [{
-           bidder: 'eskimi',
-           params: {
-               placementId: 612
-           }
-       }]
-
-   }];
+        code: '/19968336/prebid_banner_example_1',
+        mediaTypes: {
+            banner: {
+                sizes: [[ 300, 250 ]],
+                ... // battr
+            }
+        },
+        bids: [{
+            bidder: 'eskimi',
+            params: {
+                placementId: 612,
+                ... // bcat, badv, bapp
+            }
+        }]
+    }, {
+        code: '/19968336/prebid_video_example_1',
+        mediaTypes: {
+            video: {
+                context: 'outstream',
+                mimes: ['video/mp4'],
+                api: [1, 2, 4, 6],
+                ... // Aditional ORTB video params (including battr)
+            }
+        },
+        bids: [{
+            bidder: 'eskimi',
+            params: {
+                placementId: 612,
+                ... // bcat, badv, bapp
+            }
+        }]
+    }];
 ```
 
 Where:
 
 * placementId - Placement ID of the ad unit (required)
+* bcat, badv, bapp, battr - ORTB blocking parameters as specified by OpenRTB 2.5
 

package/modules/euidIdSystem.js

@@ -0,0 +1,121 @@
+/**
+ * This module adds EUID ID support to the User ID module. It shares significant functionality with the UID2 module.
+ * The {@link module:modules/userId} module is required.
+ * @module modules/euidIdSystem
+ * @requires module:modules/userId
+ */
+
+import { logInfo, logWarn, deepAccess } from '../src/utils.js';
+import {submodule} from '../src/hook.js';
+import {getStorageManager} from '../src/storageManager.js';
+import {MODULE_TYPE_UID} from '../src/activities/modules.js';
+
+// RE below lint exception: UID2 and EUID are separate modules, but the protocol is the same and shared code makes sense here.
+// eslint-disable-next-line prebid/validate-imports
+import { Uid2GetId, Uid2CodeVersion } from './uid2IdSystem_shared.js';
+
+const MODULE_NAME = 'euid';
+const MODULE_REVISION = Uid2CodeVersion;
+const PREBID_VERSION = '$prebid.version$';
+const EUID_CLIENT_ID = `PrebidJS-${PREBID_VERSION}-EUIDModule-${MODULE_REVISION}`;
+const GVLID_TTD = 21; // The Trade Desk
+const LOG_PRE_FIX = 'EUID: ';
+const ADVERTISING_COOKIE = '__euid_advertising_token';
+
+// eslint-disable-next-line no-unused-vars
+const EUID_TEST_URL = 'https://integ.euid.eu';
+const EUID_PROD_URL = 'https://prod.euid.eu';
+const EUID_BASE_URL = EUID_PROD_URL;
+
+function createLogger(logger, prefix) {
+  return function (...strings) {
+    logger(prefix + ' ', ...strings);
+  }
+}
+const _logInfo = createLogger(logInfo, LOG_PRE_FIX);
+const _logWarn = createLogger(logWarn, LOG_PRE_FIX);
+
+export const storage = getStorageManager({moduleType: MODULE_TYPE_UID, moduleName: MODULE_NAME});
+
+function hasWriteToDeviceConsent(consentData) {
+  const gdprApplies = consentData?.gdprApplies === true;
+  const localStorageConsent = deepAccess(consentData, `vendorData.purpose.consents.1`)
+  const prebidVendorConsent = deepAccess(consentData, `vendorData.vendor.consents.${GVLID_TTD.toString()}`)
+  if (gdprApplies && (!localStorageConsent || !prebidVendorConsent)) {
+    return false;
+  }
+  return true;
+}
+
+/** @type {Submodule} */
+export const euidIdSubmodule = {
+  /**
+   * used to link submodule with config
+   * @type {string}
+   */
+  name: MODULE_NAME,
+
+  /**
+   * Vendor id of The Trade Desk
+   * @type {Number}
+   */
+  gvlid: GVLID_TTD,
+  /**
+   * decode the stored id value for passing to bid requests
+   * @function
+   * @param {string} value
+   * @returns {{euid:{ id: string } }} or undefined if value doesn't exists
+   */
+  decode(value) {
+    const result = decodeImpl(value);
+    _logInfo('EUID decode returned', result);
+    return result;
+  },
+
+  /**
+   * performs action to obtain id and return a value.
+   * @function
+   * @param {SubmoduleConfig} [configparams]
+   * @param {ConsentData|undefined} consentData
+   * @returns {euidId}
+   */
+  getId(config, consentData) {
+    if (consentData?.gdprApplies !== true) {
+      logWarn('EUID is intended for use within the EU. The module will not run when GDPR does not apply.');
+      return;
+    }
+    if (!hasWriteToDeviceConsent(consentData)) {
+      // The module cannot operate without this permission.
+      _logWarn(`Unable to use EUID module due to insufficient consent. The EUID module requires storage permission.`)
+      return;
+    }
+
+    const mappedConfig = {
+      apiBaseUrl: config?.params?.euidApiBase ?? EUID_BASE_URL,
+      paramToken: config?.params?.euidToken,
+      serverCookieName: config?.params?.euidCookie,
+      storage: config?.params?.storage ?? 'localStorage',
+      clientId: EUID_CLIENT_ID,
+      internalStorage: ADVERTISING_COOKIE
+    };
+
+    const result = Uid2GetId(mappedConfig, storage, _logInfo, _logWarn);
+    _logInfo(`EUID getId returned`, result);
+    return result;
+  },
+};
+
+function decodeImpl(value) {
+  if (typeof value === 'string') {
+    _logInfo('Found server-only token. Refresh is unavailable for this token.');
+    const result = { euid: { id: value } };
+    return result;
+  }
+  if (Date.now() < value.latestToken.identity_expires) {
+    return { euid: { id: value.latestToken.advertising_token } };
+  }
+  return null;
+}
+
+// Register submodule for userId
+submodule('userId', euidIdSubmodule);

package/modules/euidIdSystem.md

@@ -0,0 +1,131 @@
+## EUID User ID Submodule
+
+EUID requires initial tokens to be generated server-side. The EUID module handles storing, providing, and optionally refreshing them. The module can operate in one of two different modes: *Client Refresh* mode or *Server Only* mode.
+
+*Server Only* mode was originally referred to as *legacy mode*, but it is a popular mode for new integrations where publishers prefer to handle token refresh server-side.
+
+## Client Refresh mode
+
+This is the recommended mode for most scenarios. In this mode, the full response body from the EUID Token Generate or Token Refresh endpoint must be provided to the module. As long as the refresh token remains valid, the module will refresh the advertising token as needed.
+
+To configure the module to use this mode, you must **either**:
+1. Set `params.euidCookie` to the name of the cookie which contains the response body as a JSON string, **or**
+2. Set `params.euidToken` to the response body as a JavaScript object.
+
+### Client refresh cookie example
+
+In this example, the cookie is called `euid_pub_cookie`.
+
+Cookie:
+```
+euid_pub_cookie={"advertising_token":"...advertising token...","refresh_token":"...refresh token...","identity_expires":1684741472161,"refresh_from":1684741425653,"refresh_expires":1684784643668,"refresh_response_key":"...response key..."}
+```
+
+Configuration:
+```
+pbjs.setConfig({
+    userSync: {
+        userIds: [{
+            name: 'euid',
+            params: {
+                euidCookie: 'euid_pub_cookie'
+            }
+        }]
+    }
+});
+```
+
+### Client refresh euidToken example
+
+Configuration:
+```
+pbjs.setConfig({
+    userSync: {
+        userIds: [{
+            name: 'euid',
+            params: {
+                euidToken: {
+                    'advertising_token': '...advertising token...',
+                    'refresh_token': '...refresh token...',
+                    // etc. - see the Sample Token below for contents of this object
+                }
+            }
+        }]
+    }
+});
+```
+
+## Server-Only Mode
+
+In this mode, only the advertising token is provided to the module. The module will not be able to refresh the token. The publisher is responsible for implementing some other way to refresh the token.
+
+To configure the module to use this mode, you must **either**:
+1. Set a cookie named `__euid_advertising_token` to the advertising token, **or**
+2. Set `value` to an ID block containing the advertising token.
+
+### Server only cookie example
+
+Cookie:
+```
+__euid_advertising_token=...advertising token...
+```
+
+Configuration:
+```
+pbjs.setConfig({
+    userSync: {
+        userIds: [{
+            name: 'euid'
+        }]
+    }
+});
+```
+
+### Server only value example
+
+Configuration:
+```
+pbjs.setConfig({
+    userSync: {
+        userIds: [{
+            name: 'euid'
+            value: {
+                'euid': {
+                    'id': '...advertising token...'
+                }
+            }
+        }]
+    }
+});
+```
+
+## Storage
+
+The module stores a number of internal values. By default, all values are stored in HTML5 local storage. You can switch to cookie storage by setting `params.storage` to `cookie`. The cookie size can be significant and this is not recommended, but is provided as an option if local storage is not an option.
+
+## Sample token
+
+`{`<br />&nbsp;&nbsp;`"advertising_token": "...",`<br />&nbsp;&nbsp;`"refresh_token": "...",`<br />&nbsp;&nbsp;`"identity_expires": 1633643601000,`<br />&nbsp;&nbsp;`"refresh_from": 1633643001000,`<br />&nbsp;&nbsp;`"refresh_expires": 1636322000000,`<br />&nbsp;&nbsp;`"refresh_response_key": "wR5t6HKMfJ2r4J7fEGX9Gw=="`<br />`}`
+
+### Notes
+
+If you are trying to limit the size of cookies, provide the token in configuration and use the default option of local storage.
+
+If you provide an expired identity and the module has a valid identity which was refreshed from the identity you provide, it will use the refreshed identity. The module stores the original token used for refreshing the token, and it will use the refreshed tokens as long as the original token matches the one supplied.
+
+If a new token is supplied which does not match the original token used to generate any refreshed tokens, all stored tokens will be discarded and the new token used instead (refreshed if necessary).
+
+You can set `params.euidApiBase` to `"https://integ.euid.eu"` during integration testing. Be aware that you must use the same environment (production or integration) here as you use for generating tokens.
+
+## Parameter Descriptions for the `usersync` Configuration Section
+
+The below parameters apply only to the EUID User ID Module integration.
+
+| Param under userSync.userIds[] | Scope | Type | Description | Example |
+| --- | --- | --- | --- | --- |
+| name | Required | String | ID value for the EUID module - `"euid"` | `"euid"` |
+| value | Optional, Server only | Object | An object containing the value for the advertising token. | See the example above. |
+| params.euidToken | Optional, Client refresh | Object | The initial EUID token. This should be `body` element of the decrypted response from a call to the `/token/generate` or `/token/refresh` endpoint. | See the sample token above. |
+| params.euidCookie | Optional, Client refresh | String | The name of a cookie which holds the initial EUID token, set by the server. The cookie should contain JSON in the same format as the euidToken param. **If euidToken is supplied, this param is ignored.** | See the sample token above. |
+| params.euidApiBase | Optional, Client refresh | String | Overrides the default EUID API endpoint. | `"https://prod.euid.eu"` _(default)_|
+| params.storage | Optional, Client refresh | String | Specify whether to use `cookie` or `localStorage` for module-internal storage. It is recommended to not provide this and allow the module to use the default. | `localStorage` _(default)_ |

package/modules/freepassIdSystem.js

@@ -0,0 +1,61 @@
+import { submodule } from '../src/hook.js';
+import {generateUUID, logMessage} from '../src/utils.js';
+
+const MODULE_NAME = 'freepassId';
+
+export const freepassIdSubmodule = {
+  name: MODULE_NAME,
+  decode: function (value, config) {
+    logMessage('Decoding FreePass ID: ', value);
+
+    return { [MODULE_NAME]: value };
+  },
+
+  getId: function (config, consent, cachedIdObject) {
+    logMessage('Getting FreePass ID using config: ' + JSON.stringify(config));
+
+    const freepassData = config.params !== undefined ? (config.params.freepassData || {}) : {}
+    let idObject = {userId: generateUUID()};
+
+    if (freepassData.commonId !== undefined) {
+      idObject.commonId = config.params.freepassData.commonId;
+    }
+
+    if (freepassData.userIp !== undefined) {
+      idObject.userIp = config.params.freepassData.userIp;
+    }
+
+    return {id: idObject};
+  },
+
+  extendId: function (config, consent, cachedIdObject) {
+    let freepassData = config.params.freepassData;
+    let hasFreepassData = freepassData !== undefined;
+    if (!hasFreepassData) {
+      logMessage('No Freepass Data. CachedIdObject will not be extended: ' + JSON.stringify(cachedIdObject));
+      return {
+        id: cachedIdObject
+      };
+    }
+
+    if (freepassData.commonId === cachedIdObject.commonId && freepassData.userIp === cachedIdObject.userIp) {
+      logMessage('FreePass ID is already up-to-date: ' + JSON.stringify(cachedIdObject));
+      return {
+        id: cachedIdObject
+      };
+    }
+
+    logMessage('Extending FreePass ID object: ' + JSON.stringify(cachedIdObject));
+    logMessage('Extending FreePass ID using config: ' + JSON.stringify(config));
+
+    return {
+      id: {
+        commonId: freepassData.commonId,
+        userIp: freepassData.userIp,
+        userId: cachedIdObject.userId,
+      },
+    };
+  }
+};
+
+submodule('userId', freepassIdSubmodule);