@adobe/alloy 2.20.0-beta.2 → 2.20.0-beta.6

package/libEs6/components/Identity/index.js

@@ -0,0 +1,125 @@
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+import { areThirdPartyCookiesSupportedByDefault, injectDoesIdentityCookieExist, createLoggingCookieJar, cookieJar } from "../../utils/index.js";
+import injectProcessIdSyncs from "./injectProcessIdSyncs.js";
+import configValidators from "./configValidators.js";
+import createComponent from "./createComponent.js";
+import createLegacyIdentity from "./createLegacyIdentity.js";
+import awaitVisitorOptIn from "./visitorService/awaitVisitorOptIn.js";
+import injectGetEcidFromVisitor from "./visitorService/injectGetEcidFromVisitor.js";
+import injectHandleResponseForIdSyncs from "./injectHandleResponseForIdSyncs.js";
+import injectEnsureSingleIdentity from "./injectEnsureSingleIdentity.js";
+import addEcidQueryToPayload from "./addEcidQueryToPayload.js";
+import injectSetDomainForInitialIdentityPayload from "./injectSetDomainForInitialIdentityPayload.js";
+import injectAddLegacyEcidToPayload from "./injectAddLegacyEcidToPayload.js";
+import injectAddQueryStringIdentityToPayload from "./injectAddQueryStringIdentityToPayload.js";
+import addEcidToPayload from "./addEcidToPayload.js";
+import injectAwaitIdentityCookie from "./injectAwaitIdentityCookie.js";
+import getEcidFromResponse from "./getEcidFromResponse.js";
+import createGetIdentity from "./getIdentity/createGetIdentity.js";
+import createIdentityRequest from "./getIdentity/createIdentityRequest.js";
+import createIdentityRequestPayload from "./getIdentity/createIdentityRequestPayload.js";
+import injectAppendIdentityToUrl from "./appendIdentityToUrl/injectAppendIdentityToUrl.js";
+const createIdentity = ({
+  config,
+  logger,
+  consent,
+  fireReferrerHideableImage,
+  sendEdgeNetworkRequest,
+  apexDomain
+}) => {
+  const {
+    orgId,
+    thirdPartyCookiesEnabled,
+    edgeConfigOverrides: globalConfigOverrides
+  } = config;
+  const getEcidFromVisitor = injectGetEcidFromVisitor({
+    logger,
+    orgId,
+    awaitVisitorOptIn
+  });
+  const loggingCookieJar = createLoggingCookieJar({
+    logger,
+    cookieJar
+  });
+  const legacyIdentity = createLegacyIdentity({
+    config,
+    getEcidFromVisitor,
+    apexDomain,
+    cookieJar: loggingCookieJar,
+    isPageSsl: window.location.protocol === "https:"
+  });
+  const doesIdentityCookieExist = injectDoesIdentityCookieExist({
+    orgId
+  });
+  const getIdentity = createGetIdentity({
+    sendEdgeNetworkRequest,
+    createIdentityRequestPayload,
+    createIdentityRequest,
+    globalConfigOverrides
+  });
+  const setDomainForInitialIdentityPayload = injectSetDomainForInitialIdentityPayload({
+    thirdPartyCookiesEnabled,
+    areThirdPartyCookiesSupportedByDefault
+  });
+  const addLegacyEcidToPayload = injectAddLegacyEcidToPayload({
+    getLegacyEcid: legacyIdentity.getEcid,
+    addEcidToPayload
+  });
+  const addQueryStringIdentityToPayload = injectAddQueryStringIdentityToPayload({
+    locationSearch: window.document.location.search,
+    dateProvider: () => new Date(),
+    orgId,
+    logger
+  });
+  const awaitIdentityCookie = injectAwaitIdentityCookie({
+    doesIdentityCookieExist,
+    orgId,
+    logger
+  });
+  const ensureSingleIdentity = injectEnsureSingleIdentity({
+    doesIdentityCookieExist,
+    setDomainForInitialIdentityPayload,
+    addLegacyEcidToPayload,
+    awaitIdentityCookie,
+    logger
+  });
+  const processIdSyncs = injectProcessIdSyncs({
+    fireReferrerHideableImage,
+    logger
+  });
+  const handleResponseForIdSyncs = injectHandleResponseForIdSyncs({
+    processIdSyncs
+  });
+  const appendIdentityToUrl = injectAppendIdentityToUrl({
+    dateProvider: () => new Date(),
+    orgId,
+    globalConfigOverrides
+  });
+  return createComponent({
+    addEcidQueryToPayload,
+    addQueryStringIdentityToPayload,
+    ensureSingleIdentity,
+    setLegacyEcid: legacyIdentity.setEcid,
+    handleResponseForIdSyncs,
+    getEcidFromResponse,
+    getIdentity,
+    consent,
+    appendIdentityToUrl,
+    logger,
+    config
+  });
+};
+createIdentity.namespace = "Identity";
+createIdentity.configValidators = configValidators;
+export default createIdentity;

package/libEs6/components/Identity/injectAddLegacyEcidToPayload.js

@@ -0,0 +1,30 @@
+/*
+Copyright 2020 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+import ecidNamespace from "../../constants/ecidNamespace.js";
+export default (({
+  getLegacyEcid,
+  addEcidToPayload
+}) => {
+  return payload => {
+    if (payload.hasIdentity(ecidNamespace)) {
+      // don't get the legacy identity if we already have the query string identity or if
+      // the user specified it in the identity map
+      return Promise.resolve();
+    }
+    return getLegacyEcid().then(ecidToMigrate => {
+      if (ecidToMigrate) {
+        addEcidToPayload(payload, ecidToMigrate);
+      }
+    });
+  };
+});

package/libEs6/components/Identity/injectAddQueryStringIdentityToPayload.js

@@ -0,0 +1,59 @@
+/*
+Copyright 2023 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+// Example: adobe_mc=TS%3D1641432103%7CMCMID%3D77094828402023918047117570965393734545%7CMCORGID%3DFAF554945B90342F0A495E2C%40AdobeOrg
+// Decoded: adobe_mc=TS=1641432103|MCMID=77094828402023918047117570965393734545|MCORGID=FAF554945B90342F0A495E2C@AdobeOrg
+
+import { queryString } from "../../utils/index.js";
+import queryStringIdentityParam from "../../constants/queryStringIdentityParam.js";
+import ecidNamespace from "../../constants/ecidNamespace.js";
+const LINK_TTL_SECONDS = 300; // 5 minute link time to live
+
+export default (({
+  locationSearch,
+  dateProvider,
+  orgId,
+  logger
+}) => payload => {
+  if (payload.hasIdentity(ecidNamespace)) {
+    // don't overwrite a user provided ecid identity
+    return;
+  }
+  const parsedQueryString = queryString.parse(locationSearch);
+  let queryStringValue = parsedQueryString[queryStringIdentityParam];
+  if (queryStringValue === undefined) {
+    return;
+  }
+  if (Array.isArray(queryStringValue)) {
+    logger.warn("Found multiple adobe_mc query string paramters, only using the last one.");
+    queryStringValue = queryStringValue[queryStringValue.length - 1];
+  }
+  const properties = queryStringValue.split("|").reduce((memo, keyValue) => {
+    const [key, value] = keyValue.split("=");
+    memo[key] = value;
+    return memo;
+  }, {});
+  // We are using MCMID and MCORGID to be compatible with Visitor.
+  const ts = parseInt(properties.TS, 10);
+  const mcmid = properties.MCMID;
+  const mcorgid = decodeURIComponent(properties.MCORGID);
+  if (
+  // When TS is not specified or not a number, the following inequality returns false.
+  // All inequalities with NaN variables are false.
+  dateProvider().getTime() / 1000 <= ts + LINK_TTL_SECONDS && mcorgid === orgId && mcmid) {
+    logger.info(`Found valid ECID identity ${mcmid} from the adobe_mc query string parameter.`);
+    payload.addIdentity(ecidNamespace, {
+      id: mcmid
+    });
+  } else {
+    logger.info("Detected invalid or expired adobe_mc query string parameter.");
+  }
+});

package/libEs6/components/Identity/injectAwaitIdentityCookie.js

@@ -0,0 +1,52 @@
+/*
+Copyright 2020 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+export default (({
+  doesIdentityCookieExist,
+  orgId,
+  logger
+}) => {
+  /**
+   * Returns a promise that will be resolved once an identity cookie exists.
+   * If an identity cookie doesn't already exist, it should always exist after
+   * the first response.
+   */
+  return ({
+    onResponse,
+    onRequestFailure
+  }) => {
+    return new Promise((resolve, reject) => {
+      onResponse(() => {
+        if (doesIdentityCookieExist()) {
+          resolve();
+        } else {
+          // This logic assumes that the code setting the cookie is working as expected and that
+          // the cookie was missing from the response.
+          logger.warn(`Identity cookie not found. This could be caused by any of the following issues:\n` + `\t* The org ID ${orgId} configured in Alloy doesn't match the org ID specified in the edge configuration.\n` + `\t* Experience edge was not able to set the identity cookie due to domain or cookie restrictions.\n` + `\t* The request was canceled by the browser and not fully processed.`);
+
+          // Rejecting the promise will tell queued events to still go out
+          // one at a time.
+          reject(new Error("Identity cookie not found."));
+        }
+      });
+      onRequestFailure(() => {
+        if (doesIdentityCookieExist()) {
+          resolve();
+        } else {
+          // The error from the request failure will be logged separately. Rejecting this here
+          // will tell ensureSingleIdentity to send the next request without identity
+          reject(new Error("Identity cookie not found."));
+        }
+      });
+    });
+  };
+});

package/libEs6/components/Identity/injectEnsureSingleIdentity.js

@@ -0,0 +1,98 @@
+/*
+Copyright 2020 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+// TO-DOCUMENT: We queue subsequent requests until we have an identity cookie.
+export default (({
+  doesIdentityCookieExist,
+  setDomainForInitialIdentityPayload,
+  addLegacyEcidToPayload,
+  awaitIdentityCookie,
+  logger
+}) => {
+  let obtainedIdentityPromise;
+  const allowRequestToGoWithoutIdentity = request => {
+    setDomainForInitialIdentityPayload(request);
+    return addLegacyEcidToPayload(request.getPayload());
+  };
+
+  /**
+   * Ensures that if no identity cookie exists, we only let one request at a
+   * time without an identity until its response returns. In the meantime,
+   * we queue all other requests, otherwise the requests could result in
+   * multiple ECIDs being minted for the user. Once we get an identity
+   * cookie, we can let the queued requests be sent all at once, since they
+   * will have the newly minted ECID.
+   *
+   * Konductor should make every effort to return an identity, but in
+   * certain scenarios it may not. For example, in cases where the
+   * request does not match what Konductor is expecting (ie 400s).
+   * In cases where Konductor does not set an identity, there should be
+   * no events recorded so we don't need to worry about multiple ECIDs
+   * being minted for each user.
+   *
+   * The reason we allow for multiple sequential requests to be sent without
+   * an identity is to prevent a single malformed request causing all other
+   * requests to never send.
+   */
+  return ({
+    request,
+    onResponse,
+    onRequestFailure
+  }) => {
+    if (doesIdentityCookieExist()) {
+      request.setIsIdentityEstablished();
+      return Promise.resolve();
+    }
+    if (obtainedIdentityPromise) {
+      // We don't have an identity cookie, but at least one request has
+      // been sent to get it. Konductor may set the identity cookie in the
+      // response. We will hold up this request until the previous request
+      // returns and awaitIdentityCookie confirms the identity was set.
+      logger.info("Delaying request while retrieving ECID from server.");
+      const previousObtainedIdentityPromise = obtainedIdentityPromise;
+
+      // This promise resolves when we have an identity cookie. Additional
+      // requests are chained together so that only one is sent at a time
+      // until we have the identity cookie.
+      obtainedIdentityPromise = previousObtainedIdentityPromise.catch(() => {
+        return awaitIdentityCookie({
+          onResponse,
+          onRequestFailure
+        });
+      });
+
+      // When this returned promise resolves, the request will go out.
+      return previousObtainedIdentityPromise.then(() => {
+        logger.info("Resuming previously delayed request.");
+        request.setIsIdentityEstablished();
+      })
+      // If Konductor did not set the identity cookie on the previous
+      // request, then awaitIdentityCookie will reject its promise.
+      // Catch the rejection here and allow this request to go out.
+      .catch(() => {
+        return allowRequestToGoWithoutIdentity(request);
+      });
+    }
+
+    // For Alloy+Konductor communication to be as robust as possible and
+    // to ensure we don't mint new ECIDs for requests that would otherwise
+    // be sent in parallel, we'll let this request go out to fetch the
+    // cookie
+    obtainedIdentityPromise = awaitIdentityCookie({
+      onResponse,
+      onRequestFailure
+    });
+    // This prevents an un-caught promise in the console when the identity isn't set.
+    obtainedIdentityPromise.catch(() => undefined);
+    return allowRequestToGoWithoutIdentity(request);
+  };
+});

package/libEs6/components/Identity/injectHandleResponseForIdSyncs.js

@@ -0,0 +1,19 @@
+/*
+Copyright 2020 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+export default (({
+  processIdSyncs
+}) => {
+  return response => {
+    return processIdSyncs(response.getPayloadsByType("identity:exchange"));
+  };
+});

package/libEs6/components/Identity/injectProcessIdSyncs.js

@@ -0,0 +1,34 @@
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+import { noop } from "../../utils/index.js";
+const createResultLogMessage = (idSync, success) => {
+  return `ID sync ${success ? "succeeded" : "failed"}: ${idSync.spec.url}`;
+};
+export default (({
+  fireReferrerHideableImage,
+  logger
+}) => idSyncs => {
+  const urlIdSyncs = idSyncs.filter(idSync => idSync.type === "url");
+  if (!urlIdSyncs.length) {
+    return Promise.resolve();
+  }
+  return Promise.all(urlIdSyncs.map(idSync => {
+    return fireReferrerHideableImage(idSync.spec).then(() => {
+      logger.info(createResultLogMessage(idSync, true));
+    }).catch(() => {
+      // We intentionally do not throw an error if id syncs fail. We
+      // consider it a non-critical failure and therefore do not want it to
+      // reject the promise handed back to the customer.
+      logger.error(createResultLogMessage(idSync, false));
+    });
+  })).then(noop);
+});

package/libEs6/components/Identity/injectSetDomainForInitialIdentityPayload.js

@@ -0,0 +1,32 @@
+/*
+Copyright 2020 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+import getBrowser from "../../utils/getBrowser.js";
+export default (({
+  thirdPartyCookiesEnabled,
+  areThirdPartyCookiesSupportedByDefault
+}) => {
+  return request => {
+    if (thirdPartyCookiesEnabled && areThirdPartyCookiesSupportedByDefault(getBrowser(window))) {
+      // If third-party cookies are enabled by the customer and
+      // supported by the browser, we will send the request to a
+      // a third-party identification domain that allows for more accurate
+      // identification of the user through use of a third-party cookie.
+      // If we have an identity to migrate, we still want to hit the
+      // third-party identification domain because the third-party identification
+      // domain will use our ECID to set the third-party cookie if the third-party
+      // cookie isn't already set, which provides for better cross-domain
+      // identification for future requests.
+      request.setUseIdThirdPartyDomain();
+    }
+  };
+});

package/libEs6/components/Identity/visitorService/awaitVisitorOptIn.js

@@ -0,0 +1,33 @@
+/*
+Copyright 2020 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+import { isObject } from "../../../utils/index.js";
+export default (({
+  logger
+}) => {
+  return new Promise((resolve, reject) => {
+    if (isObject(window.adobe) && isObject(window.adobe.optIn)) {
+      const optInOld = window.adobe.optIn;
+      logger.info("Delaying request while waiting for legacy opt-in to let Visitor retrieve ECID from server.");
+      optInOld.fetchPermissions(() => {
+        if (optInOld.isApproved([optInOld.Categories.ECID])) {
+          logger.info("Received legacy opt-in approval to let Visitor retrieve ECID from server.");
+          resolve();
+        } else {
+          reject(new Error("Legacy opt-in was declined."));
+        }
+      }, true);
+    } else {
+      resolve();
+    }
+  });
+});

package/libEs6/components/Identity/visitorService/getVisitor.js

@@ -0,0 +1,17 @@
+/*
+Copyright 2020 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+import { isFunction } from "../../../utils/index.js";
+export default (window => {
+  const Visitor = window.Visitor;
+  return isFunction(Visitor) && isFunction(Visitor.getInstance) && Visitor;
+});

package/libEs6/components/Identity/visitorService/injectGetEcidFromVisitor.js

@@ -0,0 +1,48 @@
+/*
+Copyright 2020 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+import getVisitor from "./getVisitor.js";
+export default (({
+  logger,
+  orgId,
+  awaitVisitorOptIn
+}) => {
+  return () => {
+    const Visitor = getVisitor(window);
+    if (Visitor) {
+      // Need to explicitly wait for optIn because visitor will call callback
+      // with invalid values prior to optIn being approved
+      return awaitVisitorOptIn({
+        logger
+      }).then(() => {
+        logger.info("Delaying request while using Visitor to retrieve ECID from server.");
+        return new Promise(resolve => {
+          const visitor = Visitor.getInstance(orgId, {});
+          visitor.getMarketingCloudVisitorID(ecid => {
+            logger.info("Resuming previously delayed request that was waiting for ECID from Visitor.");
+            resolve(ecid);
+          }, true);
+        });
+      }).catch(error => {
+        // If consent was denied, get the ECID from experience edge. OptIn and AEP Web SDK
+        // consent should operate independently, but during id migration AEP Web SDK needs
+        // to wait for optIn object consent resolution so that only one ECID is generated.
+        if (error) {
+          logger.info(`${error.message}, retrieving ECID from experience edge`);
+        } else {
+          logger.info("An error occurred while obtaining the ECID from Visitor.");
+        }
+      });
+    }
+    return Promise.resolve();
+  };
+});