#306

Committed 01 Jul 2025 06:03PM UTC coverage: 90.335% (-0.07%) from 90.409%

Build # #306

Build Type

push

travis-ci

Committed by

prebidjs-release

Commit Message

Prebid 9.53.1 release

Run Details

43587 of 54762 branches covered (79.59%)

64461 of 71358 relevant lines covered (90.33%)

148.96 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

81.13

/modules/permutiveIdentityManagerIdSystem.js

import {MODULE_TYPE_UID} from '../src/activities/modules.js'
import {submodule} from '../src/hook.js'
import {getStorageManager} from '../src/storageManager.js'
import {prefixLog, safeJSONParse} from '../src/utils.js'
/**
 * @typedef {import('../modules/userId/index.js').Submodule} Submodule
 * @typedef {import('../modules/userId/index.js').SubmoduleConfig} SubmoduleConfig
 * @typedef {import('../modules/userId/index.js').ConsentData} ConsentData
 * @typedef {import('../modules/userId/index.js').IdResponse} IdResponse
 */

const MODULE_NAME = 'permutiveIdentityManagerId'
const PERMUTIVE_ID_DATA_STORAGE_KEY = 'permutive-prebid-id'

const ID5_DOMAIN = 'id5-sync.com'
const LIVERAMP_DOMAIN = 'liveramp.com'
const UID_DOMAIN = 'uidapi.com'

const PRIMARY_IDS = ['id5id', 'idl_env', 'uid2']

export const storage = getStorageManager({moduleType: MODULE_TYPE_UID, moduleName: MODULE_NAME})

const logger = prefixLog('[PermutiveID]')

const readFromSdkLocalStorage = () => {
  const data = safeJSONParse(storage.getDataFromLocalStorage(PERMUTIVE_ID_DATA_STORAGE_KEY))
  const id = {}
  if (data && typeof data === 'object' && 'providers' in data && typeof data.providers === 'object') {
    const now = Date.now()
    for (const [idName, value] of Object.entries(data.providers)) {
      if (PRIMARY_IDS.includes(idName) && value.userId) {
        if (!value.expiryTime || value.expiryTime > now) {
          id[idName] = value.userId
        }
      }
    }
  }
  return id
}

/**
 * Catch and log errors
 * @param {function} fn - Function to safely evaluate
 */
function makeSafe (fn) {
  try {
    return fn()
  } catch (e) {
    logger.logError(e)
  }
}

const waitAndRetrieveFromSdk = (timeoutMs) =>
  new Promise(
    resolve => {
      const fallback = setTimeout(() => {
        logger.logInfo('timeout expired waiting for SDK - attempting read from local storage again')
        resolve(readFromSdkLocalStorage())
      }, timeoutMs)
      return window?.permutive?.ready(() => makeSafe(() => {
        logger.logInfo('Permutive SDK is ready')
        const onReady = makeSafe(() => window.permutive.addons.identity_manager.prebid.onReady)
        if (typeof onReady === 'function') {
          onReady((ids) => {
            logger.logInfo('Permutive SDK has provided ids')
            resolve(ids)
            clearTimeout(fallback)
          })
        } else {
          logger.logError('Permutive SDK initialised but identity manager prebid api not present')
        }
      }))
    }
  )

/** @type {Submodule} */
export const permutiveIdentityManagerIdSubmodule = {
  /**
   * used to link submodule with config
   * @type {string}
   */
  name: MODULE_NAME,

  /**
   * decode the stored id value for passing to bid requests
   * @function decode
   * @param {(Object|string)} value
   * @param {SubmoduleConfig|undefined} config
   * @returns {(Object|undefined)}
   */
  decode(value, config) {
    return value
  },

  /**
   * performs action to obtain id and return a value in the callback's response argument
   * @function getId
   * @param {SubmoduleConfig} submoduleConfig
   * @param {ConsentData} consentData
   * @param {(Object|undefined)} cacheIdObj
   * @returns {IdResponse|undefined}
   */
  getId(submoduleConfig, consentData, cacheIdObj) {
    const id = readFromSdkLocalStorage()
    if (Object.entries(id).length > 0) {
      logger.logInfo('found id in sdk storage')
      return { id }
    } else if ('params' in submoduleConfig && submoduleConfig.params.ajaxTimeout) {
      logger.logInfo('failed to find id in sdk storage - waiting for sdk')
      // Is ajaxTimeout an appropriate timeout to use here?
      return { callback: (done) => waitAndRetrieveFromSdk(submoduleConfig.params.ajaxTimeout).then(done) }
    } else {
      logger.logInfo('failed to find id in sdk storage and no wait time specified')
    }
  },

  primaryIds: PRIMARY_IDS,

  eids: {
    'id5id': {
      getValue: function (data) {
        return data.uid
      },
      source: ID5_DOMAIN,
      atype: 1,
      getUidExt: function (data) {
        if (data.ext) {
          return data.ext
        }
      }
    },
    'idl_env': {
      source: LIVERAMP_DOMAIN,
      atype: 3,
    },
    'uid2': {
      source: UID_DOMAIN,
      atype: 3,
      getValue: function(data) {
        return data.id
      },
      getUidExt: function(data) {
        if (data.ext) {
          return data.ext
        }
      }
    }
  }
}

submodule('userId', permutiveIdentityManagerIdSubmodule)

1	import {MODULE_TYPE_UID} from '../src/activities/modules.js'	1✔
2	import {submodule} from '../src/hook.js'
3	import {getStorageManager} from '../src/storageManager.js'
4	import {prefixLog, safeJSONParse} from '../src/utils.js'
5	/**
6	* @typedef {import('../modules/userId/index.js').Submodule} Submodule
7	* @typedef {import('../modules/userId/index.js').SubmoduleConfig} SubmoduleConfig
8	* @typedef {import('../modules/userId/index.js').ConsentData} ConsentData
9	* @typedef {import('../modules/userId/index.js').IdResponse} IdResponse
10	*/
11
12	const MODULE_NAME = 'permutiveIdentityManagerId'	1✔
13	const PERMUTIVE_ID_DATA_STORAGE_KEY = 'permutive-prebid-id'	1✔
14
15	const ID5_DOMAIN = 'id5-sync.com'	1✔
16	const LIVERAMP_DOMAIN = 'liveramp.com'	1✔
17	const UID_DOMAIN = 'uidapi.com'	1✔
18
19	const PRIMARY_IDS = ['id5id', 'idl_env', 'uid2']	1✔
20
21	export const storage = getStorageManager({moduleType: MODULE_TYPE_UID, moduleName: MODULE_NAME})	1✔
22
23	const logger = prefixLog('[PermutiveID]')	1✔
24
25	const readFromSdkLocalStorage = () => {	1✔
26	const data = safeJSONParse(storage.getDataFromLocalStorage(PERMUTIVE_ID_DATA_STORAGE_KEY))	3✔
27	const id = {}	3✔
28	if (data && typeof data === 'object' && 'providers' in data && typeof data.providers === 'object') {	3✔
29	const now = Date.now()	1✔
30	for (const [idName, value] of Object.entries(data.providers)) {	1✔
31	if (PRIMARY_IDS.includes(idName) && value.userId) {	2✔
32	if (!value.expiryTime \|\| value.expiryTime > now) {	1!
33	id[idName] = value.userId	1✔
34	}
35	}
36	}
37	}
38	return id	3✔
39	}
40
41	/**
42	* Catch and log errors
43	* @param {function} fn - Function to safely evaluate
44	*/
45	function makeSafe (fn) {
46	try {	2✔
47	return fn()	2✔
48	} catch (e) {
49	logger.logError(e)	×
50	}
51	}
52
53	const waitAndRetrieveFromSdk = (timeoutMs) =>	1✔
54	new Promise(	1✔
55	resolve => {
56	const fallback = setTimeout(() => {	1✔
57	logger.logInfo('timeout expired waiting for SDK - attempting read from local storage again')	×
58	resolve(readFromSdkLocalStorage())	×
59	}, timeoutMs)
60	return window?.permutive?.ready(() => makeSafe(() => {	1✔
61	logger.logInfo('Permutive SDK is ready')	1✔
62	const onReady = makeSafe(() => window.permutive.addons.identity_manager.prebid.onReady)	1✔
63	if (typeof onReady === 'function') {	1!
64	onReady((ids) => {	1✔
65	logger.logInfo('Permutive SDK has provided ids')	1✔
66	resolve(ids)	1✔
67	clearTimeout(fallback)	1✔
68	})
69	} else {
70	logger.logError('Permutive SDK initialised but identity manager prebid api not present')	×
71	}
72	}))
73	}
74	)
75
76	/** @type {Submodule} */
77	export const permutiveIdentityManagerIdSubmodule = {	1✔
78	/**
79	* used to link submodule with config
80	* @type {string}
81	*/
82	name: MODULE_NAME,
83
84	/**
85	* decode the stored id value for passing to bid requests
86	* @function decode
87	* @param {(Object\|string)} value
88	* @param {SubmoduleConfig\|undefined} config
89	* @returns {(Object\|undefined)}
90	*/
91	decode(value, config) {
92	return value	1✔
93	},
94
95	/**
96	* performs action to obtain id and return a value in the callback's response argument
97	* @function getId
98	* @param {SubmoduleConfig} submoduleConfig
99	* @param {ConsentData} consentData
100	* @param {(Object\|undefined)} cacheIdObj
101	* @returns {IdResponse\|undefined}
102	*/
103	getId(submoduleConfig, consentData, cacheIdObj) {
104	const id = readFromSdkLocalStorage()	3✔
105	if (Object.entries(id).length > 0) {	3✔
106	logger.logInfo('found id in sdk storage')	1✔
107	return { id }	1✔
108	} else if ('params' in submoduleConfig && submoduleConfig.params.ajaxTimeout) {	2✔
109	logger.logInfo('failed to find id in sdk storage - waiting for sdk')	1✔
110	// Is ajaxTimeout an appropriate timeout to use here?
111	return { callback: (done) => waitAndRetrieveFromSdk(submoduleConfig.params.ajaxTimeout).then(done) }	1✔
112	} else {
113	logger.logInfo('failed to find id in sdk storage and no wait time specified')	1✔
114	}
115	},
116
117	primaryIds: PRIMARY_IDS,
118
119	eids: {
120	'id5id': {
121	getValue: function (data) {
122	return data.uid	×
123	},
124	source: ID5_DOMAIN,
125	atype: 1,
126	getUidExt: function (data) {
127	if (data.ext) {	×
128	return data.ext	×
129	}
130	}
131	},
132	'idl_env': {
133	source: LIVERAMP_DOMAIN,
134	atype: 3,
135	},
136	'uid2': {
137	source: UID_DOMAIN,
138	atype: 3,
139	getValue: function(data) {
140	return data.id	×
141	},
142	getUidExt: function(data) {
143	if (data.ext) {	×
144	return data.ext	×
145	}
146	}
147	}
148	}
149	}
150
151	submodule('userId', permutiveIdentityManagerIdSubmodule)	1✔

prebid / Prebid.js / #306

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous