@adobe/alloy 2.28.0 → 2.28.1-beta.0

package/libEs6/core/edgeNetwork/injectGetLocationHint.js

@@ -0,0 +1,32 @@
+/*
+Copyright 2022 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 { getNamespacedCookieName } from "../../utils/index.js";
+import { CLUSTER } from "../../constants/cookieNameKey.js";
+import { MBOX_EDGE_CLUSTER } from "../../constants/legacyCookies.js";
+export default ({
+  orgId,
+  cookieJar
+}) => {
+  const clusterCookieName = getNamespacedCookieName(orgId, CLUSTER);
+  const fromClusterCookie = () => cookieJar.get(clusterCookieName);
+  const fromTarget = () => {
+    const mboxEdgeCluster = cookieJar.get(MBOX_EDGE_CLUSTER);
+    if (mboxEdgeCluster) {
+      return `t${mboxEdgeCluster}`;
+    }
+    return undefined;
+  };
+  return () => {
+    return fromClusterCookie() || fromTarget();
+  };
+};

package/libEs6/core/edgeNetwork/injectProcessWarningsAndErrors.js

@@ -0,0 +1,42 @@
+/*
+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 { NO_CONTENT } from "../../constants/httpStatusCode.js";
+const MESSAGE_PREFIX = "The server responded with a";
+export default ({
+  logger
+}) => {
+  return networkResponse => {
+    const {
+      statusCode,
+      body,
+      parsedBody
+    } = networkResponse;
+    if (statusCode < 200 || statusCode >= 300 || !parsedBody && statusCode !== NO_CONTENT || parsedBody && !Array.isArray(parsedBody.handle)) {
+      const bodyToLog = parsedBody ? JSON.stringify(parsedBody, null, 2) : body;
+      const messageSuffix = bodyToLog ? `response body:\n${bodyToLog}` : `no response body.`;
+      throw new Error(`${MESSAGE_PREFIX} status code ${statusCode} and ${messageSuffix}`);
+    }
+    if (parsedBody) {
+      const {
+        warnings = [],
+        errors = []
+      } = parsedBody;
+      warnings.forEach(warning => {
+        logger.warn(`${MESSAGE_PREFIX} warning:`, warning);
+      });
+      errors.forEach(error => {
+        logger.error(`${MESSAGE_PREFIX} non-fatal error:`, error);
+      });
+    }
+  };
+};

package/libEs6/core/edgeNetwork/injectSendEdgeNetworkRequest.js

@@ -0,0 +1,123 @@
+/*
+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 { ID_THIRD_PARTY as ID_THIRD_PARTY_DOMAIN } from "../../constants/domain.js";
+import apiVersion from "../../constants/apiVersion.js";
+import { createCallbackAggregator, noop } from "../../utils/index.js";
+import { isNetworkError } from "../../utils/networkErrors.js";
+import mergeLifecycleResponses from "./mergeLifecycleResponses.js";
+import handleRequestFailure from "./handleRequestFailure.js";
+const isDemdexBlockedError = (error, request) => {
+  return request.getUseIdThirdPartyDomain() && isNetworkError(error);
+};
+export default ({
+  config,
+  lifecycle,
+  cookieTransfer,
+  sendNetworkRequest,
+  createResponse,
+  processWarningsAndErrors,
+  getLocationHint,
+  getAssuranceValidationTokenParams
+}) => {
+  const {
+    edgeDomain,
+    edgeBasePath,
+    datastreamId
+  } = config;
+  let hasDemdexFailed = false;
+  const buildEndpointUrl = (endpointDomain, request) => {
+    const locationHint = getLocationHint();
+    const edgeBasePathWithLocationHint = locationHint ? `${edgeBasePath}/${locationHint}${request.getEdgeSubPath()}` : `${edgeBasePath}${request.getEdgeSubPath()}`;
+    const configId = request.getDatastreamIdOverride() || datastreamId;
+    if (configId !== datastreamId) {
+      request.getPayload().mergeMeta({
+        sdkConfig: {
+          datastream: {
+            original: datastreamId
+          }
+        }
+      });
+    }
+    return `https://${endpointDomain}/${edgeBasePathWithLocationHint}/${apiVersion}/${request.getAction()}?configId=${configId}&requestId=${request.getId()}${getAssuranceValidationTokenParams()}`;
+  };
+
+  /**
+   * Sends a network request that is aware of payload interfaces,
+   * lifecycle methods, configured edge domains, response structures, etc.
+   */
+  return ({
+    request,
+    runOnResponseCallbacks = noop,
+    runOnRequestFailureCallbacks = noop
+  }) => {
+    const onResponseCallbackAggregator = createCallbackAggregator();
+    onResponseCallbackAggregator.add(lifecycle.onResponse);
+    onResponseCallbackAggregator.add(runOnResponseCallbacks);
+    const onRequestFailureCallbackAggregator = createCallbackAggregator();
+    onRequestFailureCallbackAggregator.add(lifecycle.onRequestFailure);
+    onRequestFailureCallbackAggregator.add(runOnRequestFailureCallbacks);
+    return lifecycle.onBeforeRequest({
+      request,
+      onResponse: onResponseCallbackAggregator.add,
+      onRequestFailure: onRequestFailureCallbackAggregator.add
+    }).then(() => {
+      const endpointDomain = hasDemdexFailed || !request.getUseIdThirdPartyDomain() ? edgeDomain : ID_THIRD_PARTY_DOMAIN;
+      const url = buildEndpointUrl(endpointDomain, request);
+      const payload = request.getPayload();
+      cookieTransfer.cookiesToPayload(payload, endpointDomain);
+      return sendNetworkRequest({
+        requestId: request.getId(),
+        url,
+        payload,
+        useSendBeacon: request.getUseSendBeacon()
+      });
+    }).then(networkResponse => {
+      processWarningsAndErrors(networkResponse);
+      return networkResponse;
+    }).catch(error => {
+      if (isDemdexBlockedError(error, request)) {
+        hasDemdexFailed = true;
+        request.setUseIdThirdPartyDomain(false);
+        const url = buildEndpointUrl(edgeDomain, request);
+        const payload = request.getPayload();
+        cookieTransfer.cookiesToPayload(payload, edgeDomain);
+        return sendNetworkRequest({
+          requestId: request.getId(),
+          url,
+          payload,
+          useSendBeacon: request.getUseSendBeacon()
+        });
+      }
+      return handleRequestFailure(onRequestFailureCallbackAggregator)(error);
+    }).then(({
+      parsedBody,
+      getHeader
+    }) => {
+      // Note that networkResponse.parsedBody may be undefined if it was a
+      // 204 No Content response. That's fine.
+      const response = createResponse({
+        content: parsedBody,
+        getHeader
+      });
+      cookieTransfer.responseToCookies(response);
+
+      // Notice we're calling the onResponse lifecycle method even if there are errors
+      // inside the response body. This is because the full request didn't actually fail--
+      // only portions of it that are considered non-fatal (a specific, non-critical
+      // Konductor plugin, for example).
+      return onResponseCallbackAggregator.call({
+        response
+      }).then(mergeLifecycleResponses);
+    });
+  };
+};

package/libEs6/core/edgeNetwork/mergeLifecycleResponses.js

@@ -0,0 +1,21 @@
+/*
+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.
+*/
+
+import { assignConcatArrayValues } from "../../utils/index.js";
+export default returnValues => {
+  // Merges all returned objects from all `onResponse` callbacks into
+  // a single object that can later be returned to the customer.
+  const lifecycleOnResponseReturnValues = returnValues.shift() || [];
+  const consumerOnResponseReturnValues = returnValues.shift() || [];
+  const lifecycleOnBeforeRequestReturnValues = returnValues;
+  return assignConcatArrayValues({}, ...lifecycleOnResponseReturnValues, ...consumerOnResponseReturnValues, ...lifecycleOnBeforeRequestReturnValues);
+};

package/libEs6/core/getMonitors.js

@@ -0,0 +1,31 @@
+/*
+Copyright 2025 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.
+*/
+
+/* eslint-disable dot-notation */
+
+/** @import { AlloyMonitor } from './types.js' */
+
+/**
+ * This factory function creates a getter that combines both provided monitors
+ * and any monitors found in the global window.__alloyMonitors array.
+ *
+ * @param {Array<AlloyMonitor>} [monitors] - Optional array of monitor objects to append to the current one
+ * @returns {Function} A function that when called, returns all available monitors
+ */
+export default monitors => {
+  /** @type {Array<AlloyMonitor>} */
+  let alloyMonitors = window["__alloyMonitors"] || [];
+  if (monitors) {
+    alloyMonitors = alloyMonitors.concat(monitors);
+  }
+  return alloyMonitors;
+};

package/libEs6/core/index.js

@@ -0,0 +1,238 @@
+/*
+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 createInstanceFunction from "./createInstanceFunction.js";
+import { getApexDomain, injectStorage, cookieJar, isFunction, createLoggingCookieJar, injectFireReferrerHideableImage, injectGetBrowser } from "../utils/index.js";
+import createLogController from "./createLogController.js";
+import createLifecycle from "./createLifecycle.js";
+import createComponentRegistry from "./createComponentRegistry.js";
+import injectSendNetworkRequest from "./network/injectSendNetworkRequest.js";
+import injectExtractEdgeInfo from "./edgeNetwork/injectExtractEdgeInfo.js";
+import createConsent from "./consent/createConsent.js";
+import createConsentStateMachine from "./consent/createConsentStateMachine.js";
+import createEvent from "./createEvent.js";
+import injectCreateResponse from "./injectCreateResponse.js";
+import injectExecuteCommand from "./injectExecuteCommand.js";
+import validateCommandOptions from "./validateCommandOptions.js";
+import buildAndValidateConfig from "./buildAndValidateConfig.js";
+import initializeComponents from "./initializeComponents.js";
+import createConfig from "./config/createConfig.js";
+import createCoreConfigs from "./config/createCoreConfigs.js";
+import injectHandleError from "./injectHandleError.js";
+import injectSendFetchRequest from "./network/requestMethods/injectSendFetchRequest.js";
+import injectSendBeaconRequest from "./network/requestMethods/injectSendBeaconRequest.js";
+import createLogger from "./createLogger.js";
+import createEventManager from "./createEventManager.js";
+import createCookieTransfer from "./createCookieTransfer.js";
+import injectShouldTransferCookie from "./injectShouldTransferCookie.js";
+import { createDataCollectionRequest, createDataCollectionRequestPayload, createGetAssuranceValidationTokenParams } from "../utils/request/index.js";
+import injectSendEdgeNetworkRequest from "./edgeNetwork/injectSendEdgeNetworkRequest.js";
+import injectProcessWarningsAndErrors from "./edgeNetwork/injectProcessWarningsAndErrors.js";
+import injectGetLocationHint from "./edgeNetwork/injectGetLocationHint.js";
+import isRequestRetryable from "./network/isRequestRetryable.js";
+import getRequestRetryDelay from "./network/getRequestRetryDelay.js";
+import injectApplyResponse from "./edgeNetwork/injectApplyResponse.js";
+import getMonitors from "./getMonitors.js";
+import * as requiredComponents from "./requiredComponentCreators.js";
+const createNamespacedStorage = injectStorage(window);
+const {
+  console,
+  fetch,
+  navigator
+} = window;
+const coreConfigValidators = createCoreConfigs();
+const apexDomain = getApexDomain(window, cookieJar);
+const sendFetchRequest = injectSendFetchRequest({
+  fetch
+});
+const fireReferrerHideableImage = injectFireReferrerHideableImage();
+const getAssuranceValidationTokenParams = createGetAssuranceValidationTokenParams({
+  window,
+  createNamespacedStorage
+});
+const getBrowser = injectGetBrowser({
+  userAgent: window.navigator.userAgent
+});
+export const createExecuteCommand = ({
+  instanceName,
+  logController: {
+    setDebugEnabled,
+    logger,
+    createComponentLogger
+  },
+  components
+}) => {
+  const componentRegistry = createComponentRegistry();
+  const lifecycle = createLifecycle(componentRegistry);
+  const componentCreators = components.concat(Object.values(requiredComponents));
+  const setDebugCommand = options => {
+    setDebugEnabled(options.enabled, {
+      fromConfig: false
+    });
+  };
+  const loggingCookieJar = createLoggingCookieJar({
+    logger,
+    cookieJar
+  });
+  const configureCommand = options => {
+    const config = buildAndValidateConfig({
+      options,
+      componentCreators,
+      coreConfigValidators,
+      createConfig,
+      logger,
+      setDebugEnabled
+    });
+    const {
+      orgId,
+      targetMigrationEnabled
+    } = config;
+    const shouldTransferCookie = injectShouldTransferCookie({
+      orgId,
+      targetMigrationEnabled
+    });
+    const cookieTransfer = createCookieTransfer({
+      cookieJar: loggingCookieJar,
+      shouldTransferCookie,
+      apexDomain,
+      dateProvider: () => new Date()
+    });
+    const sendBeaconRequest = isFunction(navigator.sendBeacon) ? injectSendBeaconRequest({
+      // Without the bind(), the browser will complain about an
+      // illegal invocation.
+      sendBeacon: navigator.sendBeacon.bind(navigator),
+      sendFetchRequest,
+      logger
+    }) : sendFetchRequest;
+    const sendNetworkRequest = injectSendNetworkRequest({
+      logger,
+      sendFetchRequest,
+      sendBeaconRequest,
+      isRequestRetryable,
+      getRequestRetryDelay
+    });
+    const processWarningsAndErrors = injectProcessWarningsAndErrors({
+      logger
+    });
+    const extractEdgeInfo = injectExtractEdgeInfo({
+      logger
+    });
+    const createResponse = injectCreateResponse({
+      extractEdgeInfo
+    });
+    const getLocationHint = injectGetLocationHint({
+      orgId,
+      cookieJar
+    });
+    const sendEdgeNetworkRequest = injectSendEdgeNetworkRequest({
+      config,
+      lifecycle,
+      cookieTransfer,
+      sendNetworkRequest,
+      createResponse,
+      processWarningsAndErrors,
+      getLocationHint,
+      getAssuranceValidationTokenParams
+    });
+    const applyResponse = injectApplyResponse({
+      lifecycle,
+      cookieTransfer,
+      createResponse,
+      processWarningsAndErrors
+    });
+    const generalConsentState = createConsentStateMachine({
+      logger
+    });
+    const consent = createConsent({
+      generalConsentState,
+      logger
+    });
+    const eventManager = createEventManager({
+      config,
+      logger,
+      lifecycle,
+      consent,
+      createEvent,
+      createDataCollectionRequestPayload,
+      createDataCollectionRequest,
+      sendEdgeNetworkRequest,
+      applyResponse
+    });
+    return initializeComponents({
+      componentCreators,
+      lifecycle,
+      componentRegistry,
+      getImmediatelyAvailableTools(componentName) {
+        const componentLogger = createComponentLogger(componentName);
+        return {
+          config,
+          componentRegistry,
+          consent,
+          eventManager,
+          fireReferrerHideableImage,
+          logger: componentLogger,
+          lifecycle,
+          sendEdgeNetworkRequest,
+          handleError: injectHandleError({
+            errorPrefix: `[${instanceName}] [${componentName}]`,
+            logger: componentLogger
+          }),
+          createNamespacedStorage,
+          apexDomain,
+          getBrowser
+        };
+      }
+    });
+  };
+  const handleError = injectHandleError({
+    errorPrefix: `[${instanceName}]`,
+    logger
+  });
+  const executeCommand = injectExecuteCommand({
+    logger,
+    configureCommand,
+    setDebugCommand,
+    handleError,
+    validateCommandOptions
+  });
+  return executeCommand;
+};
+export default ({
+  components
+}) => {
+  // eslint-disable-next-line no-underscore-dangle
+  const instanceNames = window.__alloyNS;
+  if (instanceNames) {
+    instanceNames.forEach(instanceName => {
+      const logController = createLogController({
+        console,
+        locationSearch: window.location.search,
+        createLogger,
+        instanceName,
+        createNamespacedStorage,
+        getMonitors
+      });
+      const executeCommand = createExecuteCommand({
+        instanceName,
+        logController,
+        components
+      });
+      const instance = createInstanceFunction(executeCommand);
+      const queue = window[instanceName].q;
+      queue.push = instance;
+      logController.logger.logOnInstanceCreated({
+        instance
+      });
+      queue.forEach(instance);
+    });
+  }
+};

package/libEs6/core/initializeComponents.js

@@ -0,0 +1,40 @@
+/*
+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 { stackError } from "../utils/index.js";
+export default ({
+  componentCreators,
+  lifecycle,
+  componentRegistry,
+  getImmediatelyAvailableTools
+}) => {
+  componentCreators.forEach(createComponent => {
+    const {
+      namespace
+    } = createComponent;
+    // TO-DOCUMENT: Helpers that we inject into factories.
+    const tools = getImmediatelyAvailableTools(namespace);
+    let component;
+    try {
+      component = createComponent(tools);
+    } catch (error) {
+      throw stackError({
+        error,
+        message: `[${namespace}] An error occurred during component creation.`
+      });
+    }
+    componentRegistry.register(namespace, component);
+  });
+  return lifecycle.onComponentsRegistered({
+    lifecycle
+  }).then(() => componentRegistry);
+};

package/libEs6/core/injectCreateResponse.js

@@ -0,0 +1,68 @@
+/*
+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 { ADOBE_EDGE } from "../constants/httpHeaderNames.js";
+
+/**
+ * Creates a representation of a gateway response with the addition of
+ * helper methods.
+ * @returns Response
+ */
+export default ({
+  extractEdgeInfo
+}) => ({
+  content = {},
+  getHeader
+}) => {
+  const {
+    handle = [],
+    errors = [],
+    warnings = []
+  } = content;
+
+  /**
+   * Response object.
+   * @typedef {Object} Response
+   */
+  return {
+    /**
+     * Returns matching fragments of the response by type.
+     * @param {String} type A string with the current format: <namespace:action>
+     *
+     * @example
+     * getPayloadsByType("identity:persist")
+     */
+    getPayloadsByType(type) {
+      return handle.filter(fragment => fragment.type === type).flatMap(fragment => fragment.payload);
+    },
+    /**
+     * Returns all errors.
+     */
+    getErrors() {
+      return errors;
+    },
+    /**
+     * Returns all warnings.
+     */
+    getWarnings() {
+      return warnings;
+    },
+    /**
+     * Returns an object containing the regionId from the x-adobe-edge header
+     */
+    getEdge() {
+      return extractEdgeInfo(getHeader(ADOBE_EDGE));
+    },
+    toJSON() {
+      return content;
+    }
+  };
+};