prebid.js 7.43.0 → 7.45.0

package/modules/gdprEnforcement.js

@@ -11,7 +11,13 @@ import {getHook} from '../src/hook.js';
 import {validateStorageEnforcement} from '../src/storageManager.js';
 import * as events from '../src/events.js';
 import CONSTANTS from '../src/constants.json';
-import {VENDORLESS_GVLID} from '../src/consentHandler.js';
+import {GDPR_GVLIDS, VENDORLESS_GVLID} from '../src/consentHandler.js';
+import {
+  MODULE_TYPE_ANALYTICS,
+  MODULE_TYPE_BIDDER,
+  MODULE_TYPE_CORE, MODULE_TYPE_RTD,
+  MODULE_TYPE_UID
+} from '../src/activities/modules.js';
 
 export const STRICT_STORAGE_ENFORCEMENT = 'strictStorageEnforcement';
 
@@ -49,77 +55,56 @@ const analyticsBlocked = [];
 let hooksAdded = false;
 let strictStorageEnforcement = false;
 
-// Helps in stubbing these functions in unit tests.
-export const internal = {
-  getGvlidForBidAdapter,
-  getGvlidForUserIdModule,
-  getGvlidForAnalyticsAdapter
-};
+const GVLID_LOOKUP_PRIORITY = [
+  MODULE_TYPE_BIDDER,
+  MODULE_TYPE_UID,
+  MODULE_TYPE_ANALYTICS,
+  MODULE_TYPE_RTD
+];
 
 /**
- * Returns GVL ID for a Bid adapter / an USERID submodule / an Analytics adapter.
- * If modules of different types have the same moduleCode: For example, 'appnexus' is the code for both Bid adapter and Analytics adapter,
- * then, we assume that their GVL IDs are same. This function first checks if GVL ID is defined for a Bid adapter, if not found, tries to find User ID
- * submodule's GVL ID, if not found, tries to find Analytics adapter's GVL ID. In this process, as soon as it finds a GVL ID, it returns it
- * without going to the next check.
- * @param {{string|Object}} - module
- * @return {number} - GVL ID
+ * Retrieve a module's GVL ID.
  */
-export function getGvlid(module, ...args) {
-  let gvlid = null;
-  if (module) {
+export function getGvlid(moduleType, moduleName, fallbackFn) {
+  if (moduleName) {
     // Check user defined GVL Mapping in pbjs.setConfig()
     const gvlMapping = config.getConfig('gvlMapping');
 
-    // For USER ID Module, we pass the submodule object itself as the "module" parameter, this check is required to grab the module code
-    const moduleCode = typeof module === 'string' ? module : module.name;
-
     // Return GVL ID from user defined gvlMapping
-    if (gvlMapping && gvlMapping[moduleCode]) {
-      gvlid = gvlMapping[moduleCode];
-      return gvlid;
-    }
-
-    gvlid = internal.getGvlidForBidAdapter(moduleCode) || internal.getGvlidForUserIdModule(module) || internal.getGvlidForAnalyticsAdapter(moduleCode, ...args);
-  }
-  return gvlid;
-}
-
-/**
- * Returns GVL ID for a bid adapter. If the adapter does not have an associated GVL ID, it returns 'null'.
- * @param  {string=} bidderCode - The 'code' property of the Bidder spec.
- * @return {number} GVL ID
- */
-function getGvlidForBidAdapter(bidderCode) {
-  let gvlid = null;
-  bidderCode = bidderCode || config.getCurrentBidder();
-  if (bidderCode) {
-    const bidder = adapterManager.getBidAdapter(bidderCode);
-    if (bidder && bidder.getSpec) {
-      gvlid = bidder.getSpec().gvlid;
+    if (gvlMapping && gvlMapping[moduleName]) {
+      return gvlMapping[moduleName];
+    } else if (moduleType === MODULE_TYPE_CORE) {
+      return VENDORLESS_GVLID;
+    } else {
+      let {gvlid, modules} = GDPR_GVLIDS.get(moduleName);
+      if (gvlid == null && Object.keys(modules).length > 0) {
+        // this behavior is for backwards compatibility; if multiple modules with the same
+        // name declare different GVL IDs, pick the bidder's first, then userId, then analytics
+        for (const type of GVLID_LOOKUP_PRIORITY) {
+          if (modules.hasOwnProperty(type)) {
+            gvlid = modules[type];
+            if (type !== moduleType && !fallbackFn) {
+              logWarn(`Multiple GVL IDs found for module '${moduleName}'; using the ${type} module's ID (${gvlid}) instead of the ${moduleType}'s ID (${modules[moduleType]})`)
+            }
+            break;
+          }
+        }
+      }
+      if (gvlid == null && fallbackFn) {
+        gvlid = fallbackFn();
+      }
+      return gvlid || null;
     }
   }
-  return gvlid;
-}
-
-/**
- * Returns GVL ID for an userId submodule. If an userId submodules does not have an associated GVL ID, it returns 'null'.
- * @param {Object} userIdModule
- * @return {number} GVL ID
- */
-function getGvlidForUserIdModule(userIdModule) {
-  return (typeof userIdModule === 'object' ? userIdModule.gvlid : null);
+  return null;
 }
 
 /**
- * Returns GVL ID for an analytics adapter. If an analytics adapter does not have an associated GVL ID, it returns 'null'.
- * @param {string} code - 'provider' property on the analytics adapter config
- * @param {{}} config - analytics configuration object
- * @return {number} GVL ID
+ * Retrieve GVL IDs that are dynamically set on analytics adapters.
  */
-function getGvlidForAnalyticsAdapter(code, config) {
+export function getGvlidFromAnalyticsAdapter(code, config) {
   const adapter = adapterManager.getAnalyticsAdapter(code);
-  return adapter?.gvlid || ((gvlid) => {
+  return ((gvlid) => {
     if (typeof gvlid !== 'function') return gvlid;
     try {
       return gvlid.call(adapter.adapter, config);
@@ -185,30 +170,33 @@ export function validateRules(rule, consentData, currentModule, gvlId) {
 
 /**
  * This hook checks whether module has permission to access device or not. Device access include cookie and local storage
+ *
  * @param {Function} fn reference to original function (used by hook logic)
- * @param {Number=} gvlid gvlid of the module
+ * @param {string} moduleType type of the module
  * @param {string=} moduleName name of the module
  * @param result
+ * @param validate
  */
-export function deviceAccessHook(fn, gvlid, moduleName, result, {validate = validateRules} = {}) {
+export function deviceAccessHook(fn, moduleType, moduleName, result, {validate = validateRules} = {}) {
   result = Object.assign({}, {
     hasEnforcementHook: true
   });
   if (!hasDeviceAccess()) {
     logWarn('Device access is disabled by Publisher');
     result.valid = false;
-  } else if (gvlid === VENDORLESS_GVLID && !strictStorageEnforcement) {
+  } else if (moduleType === MODULE_TYPE_CORE && !strictStorageEnforcement) {
     // for vendorless (core) storage, do not enforce rules unless strictStorageEnforcement is set
     result.valid = true;
   } else {
     const consentData = gdprDataHandler.getConsentData();
+    let gvlid;
     if (shouldEnforce(consentData, 1, moduleName)) {
       const curBidder = config.getCurrentBidder();
       // Bidders have a copy of storage object with bidder code binded. Aliases will also pass the same bidder code when invoking storage functions and hence if alias tries to access device we will try to grab the gvl id for alias instead of original bidder
       if (curBidder && (curBidder !== moduleName) && adapterManager.aliasRegistry[curBidder] === moduleName) {
-        gvlid = getGvlid(curBidder);
+        gvlid = getGvlid(moduleType, curBidder);
       } else {
-        gvlid = getGvlid(moduleName) || gvlid;
+        gvlid = getGvlid(moduleType, moduleName)
       }
       const curModule = moduleName || curBidder;
       let isAllowed = validate(purpose1Rule, consentData, curModule, gvlid,);
@@ -223,7 +211,7 @@ export function deviceAccessHook(fn, gvlid, moduleName, result, {validate = vali
       result.valid = true;
     }
   }
-  fn.call(this, gvlid, moduleName, result);
+  fn.call(this, moduleType, moduleName, result);
 }
 
 /**
@@ -235,7 +223,7 @@ export function userSyncHook(fn, ...args) {
   const consentData = gdprDataHandler.getConsentData();
   const curBidder = config.getCurrentBidder();
   if (shouldEnforce(consentData, 1, curBidder)) {
-    const gvlid = getGvlid(curBidder);
+    const gvlid = getGvlid(MODULE_TYPE_BIDDER, curBidder);
     let isAllowed = validateRules(purpose1Rule, consentData, curBidder, gvlid);
     if (isAllowed) {
       fn.call(this, ...args);
@@ -257,8 +245,8 @@ export function userSyncHook(fn, ...args) {
 export function userIdHook(fn, submodules, consentData) {
   if (shouldEnforce(consentData, 1, 'User ID')) {
     let userIdModules = submodules.map((submodule) => {
-      const gvlid = getGvlid(submodule.submodule);
       const moduleName = submodule.submodule.name;
+      const gvlid = getGvlid(MODULE_TYPE_UID, moduleName);
       let isAllowed = validateRules(purpose1Rule, consentData, moduleName, gvlid);
       if (isAllowed) {
         return submodule;
@@ -286,7 +274,7 @@ export function makeBidRequestsHook(fn, adUnits, ...args) {
     adUnits.forEach(adUnit => {
       adUnit.bids = adUnit.bids.filter(bid => {
         const currBidder = bid.bidder;
-        const gvlId = getGvlid(currBidder);
+        const gvlId = getGvlid(MODULE_TYPE_BIDDER, currBidder);
         if (includes(biddersBlocked, currBidder)) return false;
         const isAllowed = !!validateRules(purpose2Rule, consentData, currBidder, gvlId);
         if (!isAllowed) {
@@ -316,7 +304,7 @@ export function enableAnalyticsHook(fn, config) {
     }
     config = config.filter(conf => {
       const analyticsAdapterCode = conf.provider;
-      const gvlid = getGvlid(analyticsAdapterCode, conf);
+      const gvlid = getGvlid(MODULE_TYPE_ANALYTICS, analyticsAdapterCode, () => getGvlidFromAnalyticsAdapter(analyticsAdapterCode, conf));
       const isAllowed = !!validateRules(purpose7Rule, consentData, analyticsAdapterCode, gvlid);
       if (!isAllowed) {
         analyticsBlocked.push(analyticsAdapterCode);

package/modules/glimpseBidAdapter.js

@@ -1,5 +1,4 @@
 import { registerBidder } from '../src/adapters/bidderFactory.js';
-import { config } from '../src/config.js';
 import { BANNER } from '../src/mediaTypes.js';
 import { getStorageManager } from '../src/storageManager.js';
 import {
@@ -12,10 +11,7 @@ import {
 
 const GVLID = 1012;
 const BIDDER_CODE = 'glimpse';
-const storageManager = getStorageManager({
-  gvlid: GVLID,
-  bidderCode: BIDDER_CODE,
-});
+const storageManager = getStorageManager({bidderCode: BIDDER_CODE});
 const ENDPOINT = 'https://market.glimpsevault.io/public/v1/prebid';
 const LOCAL_STORAGE_KEY = {
   vault: {
@@ -102,7 +98,7 @@ function getReferer(bidderRequest) {
 function buildQuery(bidderRequest) {
   let url = appendQueryParam(ENDPOINT, 'ver', '$prebid.version$');
 
-  const timeout = config.getConfig('bidderTimeout');
+  const timeout = bidderRequest.timeout;
   url = appendQueryParam(url, 'tmax', timeout);
 
   if (gdprApplies(bidderRequest)) {

package/modules/globalsunBidAdapter.js

@@ -155,7 +155,7 @@ export const spec = {
       coppa: config.getConfig('coppa') === true ? 1 : 0,
       ccpa: bidderRequest.uspConsent || undefined,
       gdpr: bidderRequest.gdprConsent || undefined,
-      tmax: config.getConfig('bidderTimeout')
+      tmax: bidderRequest.timeout
     };
 
     const len = validBidRequests.length;

package/modules/gnetBidAdapter.js

@@ -4,10 +4,9 @@ import { BANNER } from '../src/mediaTypes.js';
 import { getStorageManager } from '../src/storageManager.js';
 import {ajax} from '../src/ajax.js';
 
-const storage = getStorageManager();
-
 const BIDDER_CODE = 'gnet';
 const ENDPOINT = 'https://service.gnetrtb.com/api';
+const storage = getStorageManager({bidderCode: BIDDER_CODE});
 
 export const spec = {
   code: BIDDER_CODE,

package/modules/gravitoIdSystem.js

@@ -6,9 +6,11 @@
  */
 
 import { submodule } from '../src/hook.js';
-import { getStorageManager } from '../src/storageManager.js';
+import {getStorageManager} from '../src/storageManager.js';
+import {MODULE_TYPE_UID} from '../src/activities/modules.js';
 
-export const storage = getStorageManager();
+const MODULE_NAME = 'gravitompId';
+export const storage = getStorageManager({moduleType: MODULE_TYPE_UID, moduleName: MODULE_NAME});
 
 export const cookieKey = 'gravitompId';
 
@@ -17,7 +19,7 @@ export const gravitoIdSystemSubmodule = {
   * used to link submodule with config
   * @type {string}
   */
-  name: 'gravitompId',
+  name: MODULE_NAME,
 
   /**
   * performs action to obtain id

package/modules/greenbidsAnalyticsAdapter.js

@@ -0,0 +1,181 @@
+import {ajax} from '../src/ajax.js';
+import adapter from '../libraries/analyticsAdapter/AnalyticsAdapter.js';
+import CONSTANTS from '../src/constants.json';
+import adapterManager from '../src/adapterManager.js';
+import {deepClone, logError, logInfo} from '../src/utils.js';
+
+const analyticsType = 'endpoint';
+
+export const ANALYTICS_VERSION = '1.0.0';
+
+const ANALYTICS_SERVER = 'https://europe-west2-greenbids-357713.cloudfunctions.net/publisher-analytics-endpoint';
+
+const {
+  EVENTS: {
+    AUCTION_END,
+    BID_TIMEOUT,
+  }
+} = CONSTANTS;
+
+export const BIDDER_STATUS = {
+  BID: 'bid',
+  NO_BID: 'noBid',
+  TIMEOUT: 'timeout'
+};
+
+const analyticsOptions = {};
+
+export const parseBidderCode = function (bid) {
+  let bidderCode = bid.bidderCode || bid.bidder;
+  return bidderCode.toLowerCase();
+};
+
+export const greenbidsAnalyticsAdapter = Object.assign(adapter({ANALYTICS_SERVER, analyticsType}), {
+
+  cachedAuctions: {},
+
+  initConfig(config) {
+    /**
+     * Required option: pbuid
+     * @type {boolean}
+     */
+    analyticsOptions.options = deepClone(config.options);
+    if (typeof config.options.pbuid !== 'string' || config.options.pbuid.length < 1) {
+      logError('"options.pbuid" is required.');
+      return false;
+    }
+    analyticsOptions.sampled = true;
+    if (typeof config.options.sampling === 'number') {
+      analyticsOptions.sampled = Math.random() < parseFloat(config.options.sampling);
+    }
+
+    analyticsOptions.pbuid = config.options.pbuid
+    analyticsOptions.server = ANALYTICS_SERVER;
+    return true;
+  },
+  sendEventMessage(endPoint, data) {
+    logInfo(`AJAX: ${endPoint}: ` + JSON.stringify(data));
+
+    ajax(`${analyticsOptions.server}${endPoint}`, null, JSON.stringify(data), {
+      contentType: 'application/json'
+    });
+  },
+  createCommonMessage(auctionId) {
+    return {
+      version: ANALYTICS_VERSION,
+      auctionId: auctionId,
+      referrer: window.location.href,
+      sampling: analyticsOptions.options.sampling,
+      prebid: '$prebid.version$',
+      pbuid: analyticsOptions.pbuid,
+      adUnits: [],
+    };
+  },
+  serializeBidResponse(bid, status) {
+    return {
+      bidder: bid.bidder,
+      isTimeout: (status === BIDDER_STATUS.TIMEOUT),
+      hasBid: (status === BIDDER_STATUS.BID),
+    };
+  },
+  addBidResponseToMessage(message, bid, status) {
+    const adUnitCode = bid.adUnitCode.toLowerCase();
+    const adUnitIndex = message.adUnits.findIndex((adUnit) => {
+      return adUnit.code === adUnitCode;
+    });
+    if (adUnitIndex === -1) {
+      logError('Trying to add to non registered adunit');
+      return;
+    }
+    const bidderIndex = message.adUnits[adUnitIndex].bidders.findIndex((bidder) => {
+      return bidder.bidder === bid.bidder;
+    });
+    if (bidderIndex === -1) {
+      message.adUnits[adUnitIndex].bidders.push(this.serializeBidResponse(bid, status));
+    } else {
+      if (status === BIDDER_STATUS.BID) {
+        message.adUnits[adUnitIndex].bidders[bidderIndex].hasBid = true;
+      } else if (status === BIDDER_STATUS.TIMEOUT) {
+        message.adUnits[adUnitIndex].bidders[bidderIndex].isTimeout = true;
+      }
+    }
+  },
+  createBidMessage(auctionEndArgs, timeoutBids) {
+    logInfo(auctionEndArgs)
+    const {auctionId, timestamp, auctionEnd, adUnits, bidsReceived, noBids} = auctionEndArgs;
+    const message = this.createCommonMessage(auctionId);
+
+    message.auctionElapsed = (auctionEnd - timestamp);
+
+    adUnits.forEach((adUnit) => {
+      const adUnitCode = adUnit.code.toLowerCase();
+      message.adUnits.push({
+        code: adUnitCode,
+        mediaTypes: {
+          ...(adUnit.mediaTypes.banner !== undefined) && {banner: adUnit.mediaTypes.banner},
+          ...(adUnit.mediaTypes.video !== undefined) && {video: adUnit.mediaTypes.video},
+          ...(adUnit.mediaTypes.native !== undefined) && {native: adUnit.mediaTypes.native}
+        },
+        bidders: [],
+      });
+    });
+
+    // We enrich noBid then bids, then timeouts, because in case of a timeout, one response from a bidder
+    // Can be in the 3 arrays, and we want that case reflected in the call
+    noBids.forEach(bid => this.addBidResponseToMessage(message, bid, BIDDER_STATUS.NO_BID));
+
+    bidsReceived.forEach(bid => this.addBidResponseToMessage(message, bid, BIDDER_STATUS.BID));
+
+    timeoutBids.forEach(bid => this.addBidResponseToMessage(message, bid, BIDDER_STATUS.TIMEOUT));
+
+    return message;
+  },
+  getCachedAuction(auctionId) {
+    this.cachedAuctions[auctionId] = this.cachedAuctions[auctionId] || {
+      timeoutBids: [],
+    };
+    return this.cachedAuctions[auctionId];
+  },
+  handleAuctionEnd(auctionEndArgs) {
+    const cachedAuction = this.getCachedAuction(auctionEndArgs.auctionId);
+    this.sendEventMessage('/',
+      this.createBidMessage(auctionEndArgs, cachedAuction.timeoutBids)
+    );
+  },
+  handleBidTimeout(timeoutBids) {
+    timeoutBids.forEach((bid) => {
+      const cachedAuction = this.getCachedAuction(bid.auctionId);
+      cachedAuction.timeoutBids.push(bid);
+    });
+  },
+  track({eventType, args}) {
+    if (analyticsOptions.sampled) {
+      switch (eventType) {
+        case BID_TIMEOUT:
+          this.handleBidTimeout(args);
+          break;
+        case AUCTION_END:
+          this.handleAuctionEnd(args);
+          break;
+      }
+    }
+  },
+  getAnalyticsOptions() {
+    return analyticsOptions;
+  },
+});
+
+greenbidsAnalyticsAdapter.originEnableAnalytics = greenbidsAnalyticsAdapter.enableAnalytics;
+
+greenbidsAnalyticsAdapter.enableAnalytics = function(config) {
+  this.initConfig(config);
+  logInfo('loading greenbids analytics');
+  greenbidsAnalyticsAdapter.originEnableAnalytics(config);
+};
+
+adapterManager.registerAnalyticsAdapter({
+  adapter: greenbidsAnalyticsAdapter,
+  code: 'greenbids'
+});
+
+export default greenbidsAnalyticsAdapter;

package/modules/greenbidsAnalyticsAdapter.md

@@ -0,0 +1,23 @@
+# Overview
+
+```
+Module Name: Greenbids Analytics Adapter
+Module Type: Analytics Adapter
+Maintainer: jb@greenbids.ai
+```
+
+# Description
+
+Analytics adapter for Greenbids
+
+# Test Parameters
+
+```
+{
+  provider: 'greenbids',
+  options: {
+    pbuid: "PBUID_FROM_GREENBIDS"
+    sampling: 1.0
+  }
+}
+```

package/modules/gridBidAdapter.js

@@ -31,7 +31,7 @@ const TIME_TO_LIVE = 360;
 const USER_ID_KEY = 'tmguid';
 const GVLID = 686;
 const RENDERER_URL = 'https://acdn.adnxs.com/video/outstream/ANOutstreamVideo.js';
-export const storage = getStorageManager({gvlid: GVLID, bidderCode: BIDDER_CODE});
+export const storage = getStorageManager({bidderCode: BIDDER_CODE});
 
 const LOG_ERROR_MESS = {
   noAuid: 'Bid from response has no auid parameter - ',
@@ -93,7 +93,7 @@ export const spec = {
     let {bidderRequestId, auctionId, gdprConsent, uspConsent, timeout, refererInfo, gppConsent} = bidderRequest || {};
 
     const referer = refererInfo ? encodeURIComponent(refererInfo.page) : '';
-    const tmax = timeout || config.getConfig('bidderTimeout');
+    const tmax = timeout;
     const imp = [];
     const bidsMap = {};
     const requests = [];
@@ -145,12 +145,18 @@ export const spec = {
         if (ortb2Imp.instl) {
           impObj.instl = ortb2Imp.instl;
         }
-        if (ortb2Imp.ext && ortb2Imp.ext.data) {
-          impObj.ext.data = ortb2Imp.ext.data;
-          if (impObj.ext.data.adserver && impObj.ext.data.adserver.adslot) {
-            impObj.ext.gpid = impObj.ext.data.adserver.adslot.toString();
-          } else {
-            impObj.ext.gpid = ortb2Imp.ext.data.pbadslot && ortb2Imp.ext.data.pbadslot.toString();
+
+        if (ortb2Imp.ext) {
+          if (ortb2Imp.ext.data) {
+            impObj.ext.data = ortb2Imp.ext.data;
+            if (impObj.ext.data.adserver && impObj.ext.data.adserver.adslot) {
+              impObj.ext.gpid = impObj.ext.data.adserver.adslot.toString();
+            } else if (ortb2Imp.ext.data.pbadslot) {
+              impObj.ext.gpid = ortb2Imp.ext.data.pbadslot.toString();
+            }
+          }
+          if (ortb2Imp.ext.gpid) {
+            impObj.ext.gpid = ortb2Imp.ext.gpid.toString();
           }
         }
       }

package/modules/gridNMBidAdapter.js

@@ -135,7 +135,7 @@ export const spec = {
         reqSource.ext.schain = schain;
       }
 
-      const bidderTimeout = config.getConfig('bidderTimeout') || timeout;
+      const bidderTimeout = timeout;
       const tmax = timeout ? Math.min(bidderTimeout, timeout) : bidderTimeout;
 
       const request = {

package/modules/growthCodeAnalyticsAdapter.js

@@ -6,15 +6,16 @@ import adapter from '../libraries/analyticsAdapter/AnalyticsAdapter.js';
 import adapterManager from '../src/adapterManager.js';
 import * as utils from '../src/utils.js';
 import CONSTANTS from '../src/constants.json';
-import { getStorageManager } from '../src/storageManager.js';
+import {getStorageManager} from '../src/storageManager.js';
 import {getRefererInfo} from '../src/refererDetection.js';
 import {logError, logInfo} from '../src/utils.js';
+import {MODULE_TYPE_ANALYTICS} from '../src/activities/modules.js';
 
 const MODULE_NAME = 'growthCodeAnalytics';
 const DEFAULT_PID = 'INVALID_PID'
 const ENDPOINT_URL = 'https://p2.gcprivacy.com/v1/pb/analytics'
 
-export const storage = getStorageManager();
+export const storage = getStorageManager({moduleType: MODULE_TYPE_ANALYTICS, moduleName: MODULE_NAME});
 
 let sessionId = utils.generateUUID();
 

package/modules/growthCodeIdSystem.js

@@ -8,14 +8,15 @@
 import {logError, logInfo, tryAppendQueryString} from '../src/utils.js';
 import {ajax} from '../src/ajax.js';
 import { submodule } from '../src/hook.js'
-import { getStorageManager } from '../src/storageManager.js';
+import {getStorageManager} from '../src/storageManager.js';
+import {MODULE_TYPE_UID} from '../src/activities/modules.js';
 
-const GCID_EXPIRY = 7;
 const MODULE_NAME = 'growthCodeId';
 const GC_DATA_KEY = '_gc_data';
+const GCID_KEY = 'gcid';
 const ENDPOINT_URL = 'https://p2.gcprivacy.com/v1/pb?'
 
-export const storage = getStorageManager({ gvlid: undefined, moduleName: MODULE_NAME });
+export const storage = getStorageManager({ moduleType: MODULE_TYPE_UID, moduleName: MODULE_NAME });
 
 /**
  * Read GrowthCode data from cookie or local storage
@@ -25,14 +26,16 @@ export const storage = getStorageManager({ gvlid: undefined, moduleName: MODULE_
 export function readData(key) {
   try {
     let payload
-    if (storage.cookiesAreEnabled()) {
-      payload = tryParse(storage.getCookie(key))
+    if (storage.cookiesAreEnabled(null)) {
+      payload = tryParse(storage.getCookie(key, null))
     }
     if (storage.hasLocalStorage()) {
-      payload = tryParse(storage.getDataFromLocalStorage(key))
+      payload = tryParse(storage.getDataFromLocalStorage(key, null))
     }
-    if ((payload.expire_at !== undefined) && (payload.expire_at > (Date.now() / 1000))) {
-      return payload
+    if (payload !== undefined) {
+      if (payload.expire_at > (Date.now() / 1000)) {
+        return payload
+      }
     }
   } catch (error) {
     logError(error);
@@ -50,12 +53,8 @@ function storeData(key, value) {
     logInfo(MODULE_NAME + ': storing data: key=' + key + ' value=' + value);
 
     if (value) {
-      if (storage.hasLocalStorage()) {
-        storage.setDataInLocalStorage(key, value);
-      }
-      const expiresStr = (new Date(Date.now() + (GCID_EXPIRY * (60 * 60 * 24 * 1000)))).toUTCString();
-      if (storage.cookiesAreEnabled()) {
-        storage.setCookie(key, value, expiresStr, 'LAX');
+      if (storage.hasLocalStorage(null)) {
+        storage.setDataInLocalStorage(key, value, null);
       }
     }
   } catch (error) {
@@ -69,11 +68,15 @@ function storeData(key, value) {
  * @param {object|null}
  */
 function tryParse(data) {
+  let payload;
   try {
-    return JSON.parse(data);
+    payload = JSON.parse(data);
+    if (payload == null) {
+      return undefined
+    }
+    return payload
   } catch (err) {
-    logError(err);
-    return null;
+    return undefined;
   }
 }
 
@@ -149,6 +152,7 @@ export const growthCodeIdSubmodule = {
             // If response is a valid json and should save is true
             if (respJson) {
               storeData(GC_DATA_KEY, JSON.stringify(respJson))
+              storeData(GCID_KEY, respJson.gc_id);
               callback(respJson);
             } else {
               callback();