@adobe/alloy 2.30.1-beta.9 → 2.31.0

package/libEs6/components/Advertising/createComponent.js

@@ -18,7 +18,8 @@ export default ({
   eventManager,
   cookieManager,
   adConversionHandler,
-  getBrowser
+  getBrowser,
+  consent
 }) => {
   const componentConfig = config.advertising;
   const sendAdConversionHandler = createSendAdConversion({
@@ -27,12 +28,15 @@ export default ({
     adConversionHandler,
     logger,
     componentConfig,
-    getBrowser
+    getBrowser,
+    consent
   });
   return {
     lifecycle: {
       onComponentsRegistered() {
-        return sendAdConversionHandler();
+        // Fire-and-forget: don't return the promise so we don't block
+        // the configure command from resolving while waiting for consent.
+        sendAdConversionHandler();
       },
       onBeforeEvent: ({
         event,

package/libEs6/components/Advertising/handlers/onBeforeSendEventHandler.js

@@ -1,7 +1,13 @@
 /*
 Copyright 2023 Adobe. All rights reserved.
-Licensed under the Apache License, Version 2.0.
-http://www.apache.org/licenses/LICENSE-2.0
+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 collectSurferId from "../identities/collectSurferId.js";

package/libEs6/components/Advertising/handlers/sendAdConversion.js

@@ -25,16 +25,21 @@ export default ({
   adConversionHandler,
   logger,
   componentConfig,
-  getBrowser
+  getBrowser,
+  consent
 }) => {
   const activeAdvertiserIds = componentConfig?.advertiserSettings ? normalizeAdvertiser(componentConfig.advertiserSettings) : "";
   return async () => {
-    const {
-      skwcid,
-      efid
-    } = getUrlParams();
-    const isClickThru = !!(skwcid || efid);
     try {
+      // Wait for consent before any ad conversion processing.
+      // This ensures no advertising cookies are set without user consent.
+      // If consent is declined, awaitConsent() rejects and we exit gracefully.
+      await consent.awaitConsent();
+      const {
+        skwcid,
+        efid
+      } = getUrlParams();
+      const isClickThru = !!(skwcid || efid);
       if (isClickThru) {
         // wait for click through to complete
         return handleClickThrough({

package/libEs6/components/Advertising/handlers/viewThroughHandler.js

@@ -1,7 +1,13 @@
 /*
 Copyright 2025 Adobe. All rights reserved.
-Licensed under the Apache License, Version 2.0.
-http://www.apache.org/licenses/LICENSE-2.0
+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 collectAllIdentities from "../identities/collectAllIdentities.js";

package/libEs6/components/Advertising/identities/collectSurferId.js

@@ -1,6 +1,13 @@
 /*
 Copyright 2025 Adobe. All rights reserved.
-This file is licensed under the Apache License, Version 2.0.
+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 { DISPLAY_CLICK_COOKIE_KEY, SURFER_ID, SURFER_PIXEL_HOST, SURFER_USER_ID, SURFER_TIMEOUT_MS, SURFER_TRUSTED_ORIGIN, SURFER_PARAM_KEY, DISPLAY_CLICK_COOKIE_KEY_EXPIRES } from "../constants/index.js";

package/libEs6/components/Advertising/index.js

@@ -41,7 +41,8 @@ const createAdvertising = ({
     eventManager,
     cookieManager,
     adConversionHandler,
-    getBrowser
+    getBrowser,
+    consent
   });
 };
 createAdvertising.namespace = "Advertising";

package/libEs6/components/BrandConcierge/configValidators.js

@@ -0,0 +1,22 @@
+/*
+Copyright 2026 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 { STREAM_START_TIMEOUT_MS } from "./constants.js";
+import { number, objectOf, boolean } from "../../utils/validation/index.js";
+export default objectOf({
+  conversation: objectOf({
+    stickyConversationSession: boolean().default(false),
+    streamTimeout: number().integer().minimum(STREAM_START_TIMEOUT_MS).default(STREAM_START_TIMEOUT_MS)
+  }).default({
+    stickyConversationSession: false,
+    streamTimeout: STREAM_START_TIMEOUT_MS
+  })
+});

package/libEs6/components/BrandConcierge/constants.js

@@ -0,0 +1,13 @@
+/*
+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.
+*/
+export const BC_SESSION_COOKIE_NAME = "bc_session_id";
+export const STREAM_START_TIMEOUT_MS = 10000;

package/libEs6/components/BrandConcierge/createBuildEndpointUrl.js

@@ -0,0 +1,30 @@
+/*
+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.
+*/
+
+export default ({
+  queryString
+}) => {
+  return ({
+    edgeDomain,
+    request,
+    datastreamId
+  }) => {
+    const params = request.getRequestParams();
+    const configId = request.getDatastreamIdOverride() || datastreamId;
+    params.requestId = request.getId();
+    params.configId = configId;
+    const stringifiedRequestParams = queryString.stringify({
+      ...params
+    });
+    return `https://${edgeDomain}${request.getEdgeSubPath()}/${request.getAction()}?${stringifiedRequestParams}`;
+  };
+};

package/libEs6/components/BrandConcierge/createConversationServiceRequest.js

@@ -0,0 +1,31 @@
+/*
+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 { createRequest } from "../../utils/request/index.js";
+export default ({
+  payload,
+  action = "conversations",
+  sessionId
+}) => {
+  return createRequest({
+    payload: payload,
+    edgeSubPath: "/brand-concierge",
+    requestParams: {
+      sessionId
+    },
+    getAction() {
+      return action;
+    },
+    getUseSendBeacon() {
+      return false;
+    }
+  });
+};

package/libEs6/components/BrandConcierge/createSendConversationEvent.js

@@ -0,0 +1,144 @@
+/*
+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.
+*/
+import { createDataCollectionRequestPayload } from "../../utils/request/index.js";
+import createConversationServiceRequest from "./createConversationServiceRequest.js";
+import { getConciergeSessionCookie, getPageSurface } from "./utils.js";
+import uuid from "../../utils/uuid.js";
+import createStreamParser from "./createStreamParser.js";
+import createTimeoutWrapper from "./createTimeoutWrapper.js";
+export default ({
+  eventManager,
+  loggingCookieJar,
+  config,
+  logger,
+  sendConversationServiceRequest,
+  buildEndpointUrl,
+  cookieTransfer,
+  createResponse,
+  decodeKndctrCookie,
+  lifecycle,
+  consent
+}) => {
+  const {
+    edgeDomain,
+    edgeBasePath,
+    datastreamId,
+    onBeforeEventSend,
+    conversation
+  } = config;
+  return options => {
+    let streamingEnabled = false;
+    const {
+      message,
+      onStreamResponse,
+      xdm,
+      data
+    } = options;
+    const sessionId = getConciergeSessionCookie({
+      loggingCookieJar,
+      config
+    }) || uuid();
+    const payload = createDataCollectionRequestPayload();
+    const request = createConversationServiceRequest({
+      payload,
+      sessionId: sessionId
+    });
+    const event = eventManager.createEvent();
+    if (message || data) {
+      const pageSurface = getPageSurface();
+      event.mergeQuery({
+        conversation: {
+          surfaces: [pageSurface],
+          message,
+          data
+        }
+      });
+    }
+    const {
+      state
+    } = consent.current();
+    event.mergeMeta({
+      consent: {
+        state: state
+      }
+    });
+    const ecid = decodeKndctrCookie();
+    event.mergeXdm({
+      identityMap: {
+        ECID: [{
+          id: ecid
+        }]
+      }
+    });
+    event.mergeXdm({
+      ...xdm
+    });
+    if (message || data) {
+      streamingEnabled = true;
+    }
+    const url = buildEndpointUrl({
+      edgeDomain,
+      edgeBasePath,
+      datastreamId,
+      request
+    });
+    return lifecycle.onBeforeEvent({
+      event
+    }).then(() => {
+      try {
+        // NOTE: this calls onBeforeEventSend callback (if configured)
+        event.finalize(onBeforeEventSend);
+      } catch (error) {
+        onStreamResponse({
+          error
+        });
+        throw error;
+      }
+      payload.addEvent(event);
+      cookieTransfer.cookiesToPayload(payload, edgeDomain);
+      return sendConversationServiceRequest({
+        requestId: uuid(),
+        url,
+        request,
+        onStreamResponse,
+        streamingEnabled
+      }).then(response => {
+        if (response.status === 204) {
+          return;
+        }
+        const onStreamResponseCallback = event => {
+          if (event.error) {
+            logger.error("Stream error occurred", event.error);
+            onStreamResponse({
+              error: event.error
+            });
+            return;
+          }
+          const substr = event.data.replace("data: ", "");
+          const responseJson = JSON.parse(substr);
+          const response = createResponse({
+            content: responseJson
+          });
+          cookieTransfer.responseToCookies(response);
+          logger.info("onStreamResponse callback called with", response.getPayloadsByType("brand-concierge:conversation"));
+          onStreamResponse(response.getPayloadsByType("brand-concierge:conversation"));
+        };
+        const timeoutWrapper = createTimeoutWrapper({
+          onStreamResponseCallback,
+          streamTimeout: conversation.streamTimeout
+        });
+        const streamParser = createStreamParser();
+        streamParser(response.body, timeoutWrapper);
+      });
+    });
+  };
+};

package/libEs6/components/BrandConcierge/createSendConversationServiceRequest.js

@@ -0,0 +1,81 @@
+/*
+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.
+*/
+import { stackError } from "../../utils/index.js";
+export default ({
+  logger,
+  fetch
+}) => {
+  return async ({
+    requestId,
+    url,
+    request,
+    streamingEnabled = true
+  }) => {
+    const payload = request.getPayload();
+    const stringifiedPayload = JSON.stringify(payload);
+    const parsedPayload = JSON.parse(stringifiedPayload);
+    const headers = {
+      "Content-Type": "text/plain"
+    };
+    if (streamingEnabled) {
+      headers.Accept = "text/event-stream";
+    } else {
+      headers.Accept = "text/plain";
+    }
+    logger.logOnBeforeNetworkRequest({
+      url,
+      requestId,
+      payload: parsedPayload
+    });
+    const fetchWithRetries = async (attemptNumber = 1) => {
+      const maxAttempts = 4;
+      const retryDelays = [2000, 3000, 5000];
+      try {
+        const response = await fetch(url, {
+          method: "POST",
+          headers: headers,
+          body: stringifiedPayload
+        });
+        if (!response.ok) {
+          throw new Error(`Request failed with status ${response.status}`);
+        }
+        return response;
+      } catch (error) {
+        if (attemptNumber < maxAttempts) {
+          const delay = retryDelays[attemptNumber - 1];
+          logger.logOnNetworkError({
+            requestId,
+            url,
+            payload: parsedPayload,
+            error: new Error(`Attempt ${attemptNumber} failed, retrying in ${delay}ms: ${error.message}`)
+          });
+          await new Promise(resolve => setTimeout(resolve, delay));
+          return fetchWithRetries(attemptNumber + 1);
+        }
+        logger.logOnNetworkError({
+          requestId,
+          url,
+          payload: parsedPayload,
+          error
+        });
+        throw stackError({
+          error,
+          message: "Network request failed after all retries."
+        });
+      }
+    };
+    const executeRequest = async () => {
+      return fetchWithRetries();
+    };
+    return executeRequest();
+  };
+};

package/libEs6/components/BrandConcierge/createStreamParser.js

@@ -0,0 +1,127 @@
+/*
+Copyright 2024 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 () => {
+  // SSE streams are always UTF-8 encoded per specification
+  const ENCODING = "utf-8";
+  // SSE spec allows three line ending styles: CRLF (\r\n), LF (\n), or CR (\r)
+  const LINE_ENDING_REGEX = /\r\n|\r|\n/;
+  // Events are separated by blank lines (double line endings)
+  const EVENT_SEPARATOR_REGEX = /\r\n\r\n|\n\n|\r\r/;
+  // Ping comment format: `: ping` (colon followed immediately by "ping")
+  const PING_COMMENT = ": ping";
+
+  /**
+   * Check if an event block is a ping comment.
+   * Ping comments are SSE comments in the format `:ping`
+   *
+   * @param {string} eventData - Raw event data
+   * @returns {boolean} - True if this is a ping comment
+   */
+  const isPingComment = eventData => {
+    const trimmed = eventData.trim();
+    return trimmed.startsWith(PING_COMMENT);
+  };
+
+  /**
+   * Parse a single SSE event from raw event data.
+   * Follows the Server-Sent Events specification (https://html.spec.whatwg.org/multipage/server-sent-events.html)
+   *
+   * @param {string} eventData - Raw event data (multi-line string containing SSE fields)
+   * @returns {Object|null} - Parsed SSE event with structure { type, data, id } or null if invalid
+   */
+  const parseEventFromBuffer = eventData => {
+    const lines = eventData.split(LINE_ENDING_REGEX);
+    const parsedEvent = {};
+    for (const line of lines) {
+      const trimmedLine = line.trim();
+      if (!trimmedLine) {
+        continue;
+      }
+      const colonIndex = trimmedLine.indexOf(":");
+      if (colonIndex === -1) {
+        continue;
+      }
+      const field = trimmedLine.substring(0, colonIndex).trim();
+      const value = trimmedLine.substring(colonIndex + 1).trim();
+      if (field === "data") {
+        parsedEvent.data = (parsedEvent.data || "") + value;
+      } else if (field === "event") {
+        parsedEvent.type = value;
+      } else if (field === "id") {
+        parsedEvent.id = value;
+      }
+    }
+    return parsedEvent.data ? parsedEvent : null;
+  };
+
+  /**
+   * Parse SSE stream using callbacks.
+   * Uses modern async iteration (for await...of) for clean, performant stream processing.
+   *
+   * @param {ReadableStream} stream - The readable stream from fetch response
+   * @param {Object} callbacks - Callback functions for stream events
+   * @param {Function} callbacks.onEvent - Callback function called for each parsed event
+   * @param {Function} callbacks.onPing - Callback function called for ping comments
+   * @param {Function} callbacks.onComplete - Callback function called when stream ends
+   */
+  return async (stream, {
+    onEvent,
+    onPing,
+    onComplete
+  }) => {
+    const decoder = new TextDecoder(ENCODING);
+    let buffer = "";
+    try {
+      for await (const chunk of stream) {
+        buffer += decoder.decode(chunk, {
+          stream: true
+        });
+        const events = buffer.split(EVENT_SEPARATOR_REGEX);
+        buffer = events.pop() || "";
+        for (const event of events) {
+          const trimmedEvent = event.trim();
+          if (!trimmedEvent) {
+            continue;
+          }
+          if (isPingComment(trimmedEvent)) {
+            onPing();
+            continue;
+          }
+          const parsedEvent = parseEventFromBuffer(trimmedEvent);
+          if (parsedEvent !== null) {
+            onEvent(parsedEvent);
+          }
+        }
+      }
+      const trimmedBuffer = buffer.trim();
+      if (!trimmedBuffer) {
+        onComplete();
+        return;
+      }
+      if (isPingComment(trimmedBuffer)) {
+        onPing();
+        onComplete();
+        return;
+      }
+      const event = parseEventFromBuffer(trimmedBuffer);
+      if (event !== null) {
+        onEvent(event);
+      }
+      onComplete();
+    } catch (error) {
+      onEvent({
+        error
+      });
+      onComplete();
+    }
+  };
+};

package/libEs6/components/BrandConcierge/createTimeoutWrapper.js

@@ -0,0 +1,76 @@
+/*
+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.
+*/
+
+/**
+ * Creates a wrapper around a callback that implements a rolling timeout.
+ * The timeout resets on every data event or ping. If no activity occurs
+ * within the timeout period, an error is passed to the callback.
+ * After timeout fires, all subsequent calls are ignored.
+ *
+ * @param {Object} options - Configuration options
+ * @param {Function} options.onStreamResponseCallback - The callback function to wrap
+ * @param {number} options.streamTimeout - Timeout duration in milliseconds
+ * @returns {Object} Object with onEvent, onPing, and onComplete handler functions
+ */
+export default ({
+  onStreamResponseCallback,
+  streamTimeout
+}) => {
+  let timedOut = false;
+  let timeoutId;
+  const resetTimeout = () => {
+    clearTimeout(timeoutId);
+    timeoutId = setTimeout(() => {
+      timedOut = true;
+      onStreamResponseCallback({
+        error: {
+          message: "Stream timeout: No data received within 10 seconds"
+        }
+      });
+    }, streamTimeout);
+  };
+
+  // Start initial timeout
+  resetTimeout();
+  return {
+    /**
+     * Handle data events from the stream parser.
+     * Resets the timeout and forwards the event to the callback.
+     *
+     * @param {Object} event - The parsed SSE event
+     */
+    onEvent: event => {
+      if (timedOut) {
+        return;
+      }
+      resetTimeout();
+      onStreamResponseCallback(event);
+    },
+    /**
+     * Handle ping events from the stream parser.
+     * Resets the timeout but does not forward anything to the callback.
+     */
+    onPing: () => {
+      if (timedOut) {
+        return;
+      }
+      resetTimeout();
+    },
+    /**
+     * Handle stream completion.
+     * Clears the timeout since the stream has ended successfully.
+     */
+    onComplete: () => {
+      clearTimeout(timeoutId);
+    }
+  };
+};