New PubProvided Id UserId Submodule

integrationExamples/gpt/userId_example.html

@@ -134,6 +134,30 @@
                 // },
                 userSync: {
                     userIds: [{
+                        name: "pubProvidedId",
+                        params: {
+                            eids: [{
+                                source: "domain.com",
+                                uids:[{
+                                    id: "value read from cookie or local storage",
+                                    atype: 1,
+                                    ext: {
+                                        stype: "ppuid" // allowable options are sha256email, DMP, ppuid for now
+                                    }
+                                }]
+                            },{
+                                source: "3rdpartyprovided.com",
+                                uids:[{
+                                    id: "value read from cookie or local storage",
+                                    atype: 3,
+                                    ext: {
+                                        stype: "sha256email"
+                                    }
+                                }]
+                            }],
+                            eidsFunction: getHashedEmail  // any user defined function that exists in the page
+                        }
+                    },{
                         name: "unifiedId",
                         params: {
                             partner: "prebid",

modules/pubProvidedSystem.js

@@ -0,0 +1,53 @@
+/**
+ * This module adds Publisher Provided ids support to the User ID module
+ * The {@link module:modules/userId} module is required.
+ * @module modules/pubProvidedSystem
+ * @requires module:modules/userId
+ */
+
+import {submodule} from '../src/hook.js';
+import * as utils from '../src/utils.js';
+
+const MODULE_NAME = 'pubProvidedId';
+
+/** @type {Submodule} */
+export const pubProvidedIdSubmodule = {
+
+  /**
+   * used to link submodule with config
+   * @type {string}
+   */
+  name: MODULE_NAME,
+
+  /**
+   * decode the stored id value for passing to bid request
+   * @function
+   * @param {string} value
+   * @returns {{pubProvidedId: array}} or undefined if value doesn't exists
+   */
+  decode(value) {
+    const res = value ? {pubProvidedId: value} : undefined;
+    utils.logInfo('PubProvidedId: Decoded value ' + JSON.stringify(res));
+    return res;
+  },
+
+  /**
+   * performs action to obtain id and return a value.
+   * @function
+   * @param {SubmoduleParams} [configParams]
+   * @returns {{id: array}}
+   */
+  getId(configParams) {
+    let res = [];
+    if (utils.isArray(configParams.eids)) {
+      res = res.concat(configParams.eids);
+    }
+    if (typeof configParams.eidsFunction === 'function') {
+      res = res.concat(configParams.eidsFunction());
+    }
+    return {id: res};
+  }
+};
+
+// Register submodule for userId
+submodule('userId', pubProvidedIdSubmodule);

modules/rubiconBidAdapter.js

@@ -559,6 +559,17 @@ export const spec = {
     const configUserId = config.getConfig('user.id');
     if (configUserId) {
       data['ppuid'] = configUserId;
+    } else {
+      // if config.getConfig('user.id') doesn't return anything, then look for the first eid.uids[*].ext.stype === 'ppuid'
+      for (let i = 0; bidRequest.userIdAsEids && i < bidRequest.userIdAsEids.length; i++) {
+        if (bidRequest.userIdAsEids[i].uids) {
+          const pubProvidedId = find(bidRequest.userIdAsEids[i].uids, uid => uid.ext && uid.ext.stype === 'ppuid');
+          if (pubProvidedId && pubProvidedId.id) {
+            data['ppuid'] = pubProvidedId.id;
+            break;
+          }
+        }
+      }
     }
 
     if (bidderRequest.gdprConsent) {

modules/userId/eids.js

@@ -182,9 +182,13 @@ export function createEidsArray(bidRequestUserId) {
   let eids = [];
   for (const subModuleKey in bidRequestUserId) {
     if (bidRequestUserId.hasOwnProperty(subModuleKey)) {
-      const eid = createEidObject(bidRequestUserId[subModuleKey], subModuleKey);
-      if (eid) {
-        eids.push(eid);
+      if (subModuleKey === 'pubProvidedId') {
+        eids = eids.concat(bidRequestUserId['pubProvidedId']);
+      } else {
+        const eid = createEidObject(bidRequestUserId[subModuleKey], subModuleKey);
+        if (eid) {
+          eids.push(eid);
+        }
       }
     }
   }

test/spec/modules/eids_spec.js

@@ -237,8 +237,42 @@ describe('eids array generation for known sub-modules', function() {
       }]
     });
   });
+  it('pubProvidedId', function() {
+    const userId = {
+      pubProvidedId: [{
+        source: 'example.com',
+        uids: [{
+          id: 'value read from cookie or local storage',
+          ext: {
+            stype: 'ppuid'
+          }
+        }]
+      }, {
+        source: 'id-partner.com',
+        uids: [{
+          id: 'value read from cookie or local storage'
+        }]
+      }]
+    };
+    const newEids = createEidsArray(userId);
+    expect(newEids.length).to.equal(2);
+    expect(newEids[0]).to.deep.equal({
+      source: 'example.com',
+      uids: [{
+        id: 'value read from cookie or local storage',
+        ext: {
+          stype: 'ppuid'
+        }
+      }]
+    });
+    expect(newEids[1]).to.deep.equal({
+      source: 'id-partner.com',
+      uids: [{
+        id: 'value read from cookie or local storage'
+      }]
+    });
+  });
 });
-
 describe('Negative case', function() {
   it('eids array generation for UN-known sub-module', function() {
     // UnknownCommonId