@adobe/alloy 2.28.0 → 2.28.1-beta.0

package/libEs5/core/index.js

@@ -0,0 +1,243 @@
+"use strict";
+
+exports.default = exports.createExecuteCommand = void 0;
+var _createInstanceFunction = require("./createInstanceFunction.js");
+var _index = require("../utils/index.js");
+var _createLogController = require("./createLogController.js");
+var _createLifecycle = require("./createLifecycle.js");
+var _createComponentRegistry = require("./createComponentRegistry.js");
+var _injectSendNetworkRequest = require("./network/injectSendNetworkRequest.js");
+var _injectExtractEdgeInfo = require("./edgeNetwork/injectExtractEdgeInfo.js");
+var _createConsent = require("./consent/createConsent.js");
+var _createConsentStateMachine = require("./consent/createConsentStateMachine.js");
+var _createEvent = require("./createEvent.js");
+var _injectCreateResponse = require("./injectCreateResponse.js");
+var _injectExecuteCommand = require("./injectExecuteCommand.js");
+var _validateCommandOptions = require("./validateCommandOptions.js");
+var _buildAndValidateConfig = require("./buildAndValidateConfig.js");
+var _initializeComponents = require("./initializeComponents.js");
+var _createConfig = require("./config/createConfig.js");
+var _createCoreConfigs = require("./config/createCoreConfigs.js");
+var _injectHandleError = require("./injectHandleError.js");
+var _injectSendFetchRequest = require("./network/requestMethods/injectSendFetchRequest.js");
+var _injectSendBeaconRequest = require("./network/requestMethods/injectSendBeaconRequest.js");
+var _createLogger = require("./createLogger.js");
+var _createEventManager = require("./createEventManager.js");
+var _createCookieTransfer = require("./createCookieTransfer.js");
+var _injectShouldTransferCookie = require("./injectShouldTransferCookie.js");
+var _index2 = require("../utils/request/index.js");
+var _injectSendEdgeNetworkRequest = require("./edgeNetwork/injectSendEdgeNetworkRequest.js");
+var _injectProcessWarningsAndErrors = require("./edgeNetwork/injectProcessWarningsAndErrors.js");
+var _injectGetLocationHint = require("./edgeNetwork/injectGetLocationHint.js");
+var _isRequestRetryable = require("./network/isRequestRetryable.js");
+var _getRequestRetryDelay = require("./network/getRequestRetryDelay.js");
+var _injectApplyResponse = require("./edgeNetwork/injectApplyResponse.js");
+var _getMonitors = require("./getMonitors.js");
+var requiredComponents = require("./requiredComponentCreators.js");
+/*
+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.
+*/
+
+const createNamespacedStorage = (0, _index.injectStorage)(window);
+const {
+  console,
+  fetch,
+  navigator
+} = window;
+const coreConfigValidators = (0, _createCoreConfigs.default)();
+const apexDomain = (0, _index.getApexDomain)(window, _index.cookieJar);
+const sendFetchRequest = (0, _injectSendFetchRequest.default)({
+  fetch
+});
+const fireReferrerHideableImage = (0, _index.injectFireReferrerHideableImage)();
+const getAssuranceValidationTokenParams = (0, _index2.createGetAssuranceValidationTokenParams)({
+  window,
+  createNamespacedStorage
+});
+const getBrowser = (0, _index.injectGetBrowser)({
+  userAgent: window.navigator.userAgent
+});
+const createExecuteCommand = ({
+  instanceName,
+  logController: {
+    setDebugEnabled,
+    logger,
+    createComponentLogger
+  },
+  components
+}) => {
+  const componentRegistry = (0, _createComponentRegistry.default)();
+  const lifecycle = (0, _createLifecycle.default)(componentRegistry);
+  const componentCreators = components.concat(Object.values(requiredComponents));
+  const setDebugCommand = options => {
+    setDebugEnabled(options.enabled, {
+      fromConfig: false
+    });
+  };
+  const loggingCookieJar = (0, _index.createLoggingCookieJar)({
+    logger,
+    cookieJar: _index.cookieJar
+  });
+  const configureCommand = options => {
+    const config = (0, _buildAndValidateConfig.default)({
+      options,
+      componentCreators,
+      coreConfigValidators,
+      createConfig: _createConfig.default,
+      logger,
+      setDebugEnabled
+    });
+    const {
+      orgId,
+      targetMigrationEnabled
+    } = config;
+    const shouldTransferCookie = (0, _injectShouldTransferCookie.default)({
+      orgId,
+      targetMigrationEnabled
+    });
+    const cookieTransfer = (0, _createCookieTransfer.default)({
+      cookieJar: loggingCookieJar,
+      shouldTransferCookie,
+      apexDomain,
+      dateProvider: () => new Date()
+    });
+    const sendBeaconRequest = (0, _index.isFunction)(navigator.sendBeacon) ? (0, _injectSendBeaconRequest.default)({
+      // Without the bind(), the browser will complain about an
+      // illegal invocation.
+      sendBeacon: navigator.sendBeacon.bind(navigator),
+      sendFetchRequest,
+      logger
+    }) : sendFetchRequest;
+    const sendNetworkRequest = (0, _injectSendNetworkRequest.default)({
+      logger,
+      sendFetchRequest,
+      sendBeaconRequest,
+      isRequestRetryable: _isRequestRetryable.default,
+      getRequestRetryDelay: _getRequestRetryDelay.default
+    });
+    const processWarningsAndErrors = (0, _injectProcessWarningsAndErrors.default)({
+      logger
+    });
+    const extractEdgeInfo = (0, _injectExtractEdgeInfo.default)({
+      logger
+    });
+    const createResponse = (0, _injectCreateResponse.default)({
+      extractEdgeInfo
+    });
+    const getLocationHint = (0, _injectGetLocationHint.default)({
+      orgId,
+      cookieJar: _index.cookieJar
+    });
+    const sendEdgeNetworkRequest = (0, _injectSendEdgeNetworkRequest.default)({
+      config,
+      lifecycle,
+      cookieTransfer,
+      sendNetworkRequest,
+      createResponse,
+      processWarningsAndErrors,
+      getLocationHint,
+      getAssuranceValidationTokenParams
+    });
+    const applyResponse = (0, _injectApplyResponse.default)({
+      lifecycle,
+      cookieTransfer,
+      createResponse,
+      processWarningsAndErrors
+    });
+    const generalConsentState = (0, _createConsentStateMachine.default)({
+      logger
+    });
+    const consent = (0, _createConsent.default)({
+      generalConsentState,
+      logger
+    });
+    const eventManager = (0, _createEventManager.default)({
+      config,
+      logger,
+      lifecycle,
+      consent,
+      createEvent: _createEvent.default,
+      createDataCollectionRequestPayload: _index2.createDataCollectionRequestPayload,
+      createDataCollectionRequest: _index2.createDataCollectionRequest,
+      sendEdgeNetworkRequest,
+      applyResponse
+    });
+    return (0, _initializeComponents.default)({
+      componentCreators,
+      lifecycle,
+      componentRegistry,
+      getImmediatelyAvailableTools(componentName) {
+        const componentLogger = createComponentLogger(componentName);
+        return {
+          config,
+          componentRegistry,
+          consent,
+          eventManager,
+          fireReferrerHideableImage,
+          logger: componentLogger,
+          lifecycle,
+          sendEdgeNetworkRequest,
+          handleError: (0, _injectHandleError.default)({
+            errorPrefix: "[" + instanceName + "] [" + componentName + "]",
+            logger: componentLogger
+          }),
+          createNamespacedStorage,
+          apexDomain,
+          getBrowser
+        };
+      }
+    });
+  };
+  const handleError = (0, _injectHandleError.default)({
+    errorPrefix: "[" + instanceName + "]",
+    logger
+  });
+  const executeCommand = (0, _injectExecuteCommand.default)({
+    logger,
+    configureCommand,
+    setDebugCommand,
+    handleError,
+    validateCommandOptions: _validateCommandOptions.default
+  });
+  return executeCommand;
+};
+exports.createExecuteCommand = createExecuteCommand;
+var _default = ({
+  components
+}) => {
+  // eslint-disable-next-line no-underscore-dangle
+  const instanceNames = window.__alloyNS;
+  if (instanceNames) {
+    instanceNames.forEach(instanceName => {
+      const logController = (0, _createLogController.default)({
+        console,
+        locationSearch: window.location.search,
+        createLogger: _createLogger.default,
+        instanceName,
+        createNamespacedStorage,
+        getMonitors: _getMonitors.default
+      });
+      const executeCommand = createExecuteCommand({
+        instanceName,
+        logController,
+        components
+      });
+      const instance = (0, _createInstanceFunction.default)(executeCommand);
+      const queue = window[instanceName].q;
+      queue.push = instance;
+      logController.logger.logOnInstanceCreated({
+        instance
+      });
+      queue.forEach(instance);
+    });
+  }
+};
+exports.default = _default;

package/libEs5/core/initializeComponents.js

@@ -0,0 +1,43 @@
+"use strict";
+
+exports.default = void 0;
+var _index = require("../utils/index.js");
+/*
+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.
+*/
+var _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 (0, _index.stackError)({
+        error,
+        message: "[" + namespace + "] An error occurred during component creation."
+      });
+    }
+    componentRegistry.register(namespace, component);
+  });
+  return lifecycle.onComponentsRegistered({
+    lifecycle
+  }).then(() => componentRegistry);
+};
+exports.default = _default;

package/libEs5/core/injectCreateResponse.js

@@ -0,0 +1,71 @@
+"use strict";
+
+exports.default = void 0;
+var _httpHeaderNames = require("../constants/httpHeaderNames.js");
+/*
+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.
+*/
+/**
+ * Creates a representation of a gateway response with the addition of
+ * helper methods.
+ * @returns Response
+ */
+var _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(_httpHeaderNames.ADOBE_EDGE));
+    },
+    toJSON() {
+      return content;
+    }
+  };
+};
+exports.default = _default;

package/libEs5/core/injectExecuteCommand.js

@@ -0,0 +1,116 @@
+"use strict";
+
+exports.default = void 0;
+var _index = require("../utils/index.js");
+var _coreCommands = require("../constants/coreCommands.js");
+var _index2 = require("../utils/validation/index.js");
+/*
+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.
+*/
+var _default = ({
+  logger,
+  configureCommand,
+  setDebugCommand,
+  handleError,
+  validateCommandOptions
+}) => {
+  let configurePromise;
+  const getExecutor = (commandName, options) => {
+    let executor;
+    if (commandName === _coreCommands.CONFIGURE) {
+      if (configurePromise) {
+        throw new Error("The library has already been configured and may only be configured once.");
+      }
+      executor = () => {
+        configurePromise = configureCommand(options);
+        return configurePromise.then(() => {
+          // Don't expose internals to the user.
+        });
+      };
+    } else {
+      if (!configurePromise) {
+        throw new Error("The library must be configured first. Please do so by executing the configure command.");
+      }
+      if (commandName === _coreCommands.SET_DEBUG) {
+        executor = () => {
+          const optionsValidator = (0, _index2.objectOf)({
+            enabled: (0, _index2.boolean)().required()
+          }).noUnknownFields();
+          const validatedOptions = validateCommandOptions({
+            command: {
+              commandName: _coreCommands.SET_DEBUG,
+              optionsValidator
+            },
+            options
+          });
+          setDebugCommand(validatedOptions);
+        };
+      } else {
+        executor = () => {
+          return configurePromise.then(componentRegistry => {
+            const command = componentRegistry.getCommand(commandName);
+            if (!command || !(0, _index.isFunction)(command.run)) {
+              const commandNames = [_coreCommands.CONFIGURE, _coreCommands.SET_DEBUG].concat(componentRegistry.getCommandNames()).join(", ");
+              throw new Error("The " + commandName + " command does not exist. List of available commands: " + commandNames + ".");
+            }
+            const validatedOptions = validateCommandOptions({
+              command,
+              options
+            });
+            return command.run(validatedOptions);
+          }, () => {
+            logger.warn("An error during configuration is preventing the " + commandName + " command from executing.");
+            // If configuration failed, we prevent the configuration
+            // error from bubbling here because we don't want the
+            // configuration error to be reported in the console every
+            // time any command is executed. Only having it bubble
+            // once when the configure command runs is sufficient.
+            // Instead, for this command, we'll just return a promise
+            // that never gets resolved.
+            return new Promise(() => {});
+          });
+        };
+      }
+    }
+    return executor;
+  };
+  return (commandName, options = {}) => {
+    return new Promise(resolve => {
+      // We have to wrap the getExecutor() call in the promise so the promise
+      // will be rejected if getExecutor() throws errors.
+      const executor = getExecutor(commandName, options);
+      logger.logOnBeforeCommand({
+        commandName,
+        options
+      });
+      resolve(executor());
+    }).catch(error => {
+      return handleError(error, commandName + " command");
+    }).catch(error => {
+      logger.logOnCommandRejected({
+        commandName,
+        options,
+        error
+      });
+      throw error;
+    }).then(rawResult => {
+      // We should always be returning an object from every command.
+      const result = (0, _index.isObject)(rawResult) ? rawResult : {};
+      logger.logOnCommandResolved({
+        commandName,
+        options,
+        result
+      });
+      return result;
+    });
+  };
+};
+exports.default = _default;

package/libEs5/core/injectHandleError.js

@@ -0,0 +1,36 @@
+"use strict";
+
+exports.default = void 0;
+var _index = require("../utils/index.js");
+var _createConsentStateMachine = require("./consent/createConsentStateMachine.js");
+/*
+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.
+*/
+var _default = ({
+  errorPrefix,
+  logger
+}) => (error, operation) => {
+  const err = (0, _index.toError)(error);
+
+  // In the case of declined consent, we've opted to not reject the promise
+  // returned to the customer, but instead resolve the promise with an
+  // empty result object.
+  if (err.code === _createConsentStateMachine.DECLINED_CONSENT_ERROR_CODE) {
+    logger.warn("The " + operation + " could not fully complete. " + err.message);
+    return {};
+  }
+  (0, _index.updateErrorMessage)({
+    error: err,
+    message: errorPrefix + " " + err.message
+  });
+  throw err;
+};
+exports.default = _default;

package/libEs5/core/injectShouldTransferCookie.js

@@ -0,0 +1,28 @@
+"use strict";
+
+exports.default = void 0;
+var _index = require("../utils/index.js");
+var _legacyCookies = require("../constants/legacyCookies.js");
+/*
+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.
+*/
+var _default = ({
+  orgId,
+  targetMigrationEnabled
+}) => name => {
+  // We have a contract with the server that we will pass
+  // all cookies whose names are namespaced according to the
+  // logic in isNamespacedCookieName as well as any legacy
+  // cookie names (so that the server can handle migrating
+  // identities on websites previously using Visitor.js)
+  return (0, _index.isNamespacedCookieName)(orgId, name) || name === _legacyCookies.AT_QA_MODE || targetMigrationEnabled && name === _legacyCookies.MBOX;
+};
+exports.default = _default;

package/libEs5/core/network/getRequestRetryDelay.js

@@ -0,0 +1,75 @@
+"use strict";
+
+exports.default = void 0;
+var _httpHeaderNames = require("../../constants/httpHeaderNames.js");
+var _index = require("../../utils/index.js");
+/*
+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.
+*/
+
+// The retry gets incrementally (but not exponentially) longer for each retry.
+const FIRST_DELAY_MILLIS = 1000;
+const INCREMENTAL_DELAY_MILLIS = 1000;
+
+// When the target delay is randomized, make it within the range of this percentage above or below the target delay.
+const MAX_RANDOM_VARIANCE_PERCENTAGE = 0.3;
+const calculateRetryDelay = retriesAttempted => {
+  const targetDelay = FIRST_DELAY_MILLIS + retriesAttempted * INCREMENTAL_DELAY_MILLIS;
+  const maxVariance = targetDelay * MAX_RANDOM_VARIANCE_PERCENTAGE;
+  const minDelay = targetDelay - maxVariance;
+  const maxDelay = targetDelay + maxVariance;
+  const randomizedDelayWithinRange = Math.round(minDelay + Math.random() * (maxDelay - minDelay));
+  return randomizedDelayWithinRange;
+};
+const getDelayFromHeader = response => {
+  // According to the HTTP spec, if the header is defined, its value will be a string that
+  // represents either:
+  //  * An integer indicating the number of seconds to delay.
+  //  * A date after which a retry may occur. The date would be in HTTP-date
+  //    format (https://tools.ietf.org/html/rfc7231#section-7.1.1.1). When debugging, it can
+  //    be helpful to know that this is the same format that a JavaScript date's
+  //    toGMTString() returns.
+  const headerValue = response.getHeader(_httpHeaderNames.RETRY_AFTER);
+  let delayInMillis;
+  if (headerValue) {
+    const headerValueInt = parseInt(headerValue, 10);
+    if ((0, _index.isInteger)(headerValueInt)) {
+      delayInMillis = headerValueInt * 1000;
+    } else {
+      delayInMillis = Math.max(0, new Date(headerValue).getTime() - new Date().getTime());
+    }
+  }
+  return delayInMillis;
+};
+
+// These rules are in accordance with
+// https://git.corp.adobe.com/pages/experience-edge/konductor/#/apis/errors?id=handling-4xx-and-5xx-responses
+// For retry delays that don't come from a Retry-After response header, we try to stick with the following best
+// practices outlined in https://docs.microsoft.com/en-us/azure/architecture/best-practices/transient-faults:
+//  * Incremental retry
+//  * Random interval
+var _default = ({
+  response,
+  retriesAttempted
+}) => {
+  // Technically, only 429 or 503 responses should have a Retry-After header, but we'll respect the
+  // header if we find it on any response.
+  let delayInMillis = getDelayFromHeader(response);
+
+  // Note that the value of delay may be 0 at this point, which would be a valid delay we want to use
+  // and not override, which is why we don't do:
+  // if (!delay) { ... }
+  if (delayInMillis === undefined) {
+    delayInMillis = calculateRetryDelay(retriesAttempted);
+  }
+  return delayInMillis;
+};
+exports.default = _default;