@sapui5/sap.ushell 1.138.1 → 1.139.0

package/src/main/js/sap/ushell/appIntegration/PostMessageManager.js

@@ -19,12 +19,19 @@ sap.ui.define([
 ) => {
     "use strict";
 
+    /**
+     * @typedef {PostMessageRequest|PostMessageResponse} ParsedMessage
+     */
+
     /**
      * @typedef {object} PostMessageRequest
      * @property {string} type the type of the message
      * @property {string} request_id the request id
      * @property {string} service the service name
      * @property {object} body the message body
+     *
+     * @since 1.134.0
+     * @private
      */
 
     /**
@@ -34,13 +41,21 @@ sap.ui.define([
      * @property {string} service the service name
      * @property {string} status the status of the response
      * @property {object} body the message body
+     *
+     * @since 1.134.0
+     * @private
      */
 
     /**
      * @typedef {object} RequestHandlerOptions
      * @property {boolean} [provideApplicationContext=false] flag to indicate if the application context should be used.
      * @property {boolean} [allowInactive=false] flag to indicate if the request should be allowed from inactive applications.
-     * @property {function} [isValidRequest] a function to validate the request
+     * @property {function(MessageEvent):Promise<boolean>} [isValidRequest] an async function to validate the request
+     *
+     * @see {@link sap.ushell.appIntegration.PostMessageManager#setRequestHandler}
+     *
+     * @since 1.134.0
+     * @private
      */
 
     const oDefaultRequestHandlerOptions = {
@@ -50,19 +65,42 @@ sap.ui.define([
 
     /**
      * @typedef {object} DistributionPolicy
-     * @property {boolean} [activeOnly=false] flag to indicate if the message should be sent only to active application
+     * @property {boolean} [preventBroadcast=false] flag to indicate if the message should not be sent to all applications
+     * @property {boolean} [onlyCurrentApplication=false] flag to indicate if the message should be sent only to the current application
      * @property {boolean} [ignoreCapabilities=false] flag to indicate if the capabilities should be ignored
-     * @property {function} [isValidRequestTarget] a function to validate the request target
+     * @property {function(sap.ushell.appIntegration.ApplicationContainer):boolean} [isValidRequestTarget] a function to validate the request target
+     *
+     * @see {@link sap.ushell.appIntegration.PostMessageManager#setDistributionPolicy}
+     * @see {@link sap.ushell.appIntegration.PostMessageManager#sendRequestToAllApplications}
+     *
+     * @since 1.134.0
+     * @private
      */
 
     const oDefaultDistributionPolicy = {
-        activeOnly: false,
+        preventBroadcast: false,
+        onlyCurrentApplication: false,
         ignoreCapabilities: false
     };
 
+    /**
+     * @typedef {object} PreprocessingResult
+     * @property {MessageEvent} event the preprocessed message event
+     * @property {ParsedMessage} message the preprocessed message
+     */
+
     const DoNotReply = Symbol("DoNotReply");
     const oLogger = Log.getLogger("sap.ushell.appIntegration.PostMessageManager");
 
+
+    /**
+     * @alias sap.ushell.appIntegration.PostMessageManager
+     * @namespace
+     * @classdesc This class is used to manage postMessage communication between the applications and the framework.
+     *
+     * @since 1.134.0
+     * @private
+     */
     class PostMessageManager {
         #fnPostMessageEventHandler = () => {
             throw new Error("PostMessageManager is not initialized");
@@ -116,60 +154,66 @@ sap.ui.define([
         }
 
         /**
-         * @param {Event} oEvent
-         * @returns {Promise}
+         * Handles the postMessage event.
+         *  - Parses the message from the event.
+         *  - Preprocesses the event and message.
+         *  - Run checks
+         *  - actual message handling (response, request)
+         * @param {MessageEvent} oMessageEvent The incoming message event.
+         * @returns {Promise} A promise that resolves when the message is handled.
+         *
+         * @since 1.134.0
+         * @private
          */
-        async #handlePostMessageEvent (oEvent) {
+        async #handlePostMessageEvent (oMessageEvent) {
             let oMessage;
             try {
-                // we support stringified JSON and plain objects
-                if (typeof oEvent.data === "string") {
-                    oMessage = JSON.parse(oEvent.data);
-                } else if (isPlainObject(oEvent.data)) {
-                    oMessage = oEvent.data;
-                } else {
-                    // e.g. Error, transferable objects, ...
-                    throw new Error("Invalid message format");
-                }
-                // Initialize the body. It can be undefined which is unexpected for the service request handlers.
-                oMessage.body = oMessage.body || {};
+                oMessage = this.#parseMessage(oMessageEvent);
             } catch {
-                oLogger.debug("Received Post Message with invalid JSON. Ignoring the message.", oEvent.data);
+                oLogger.debug("Received Post Message with invalid JSON. Ignoring the message.", oMessageEvent.data);
                 return;
             }
 
-            const oResult = this.#preprocessMessageEvent(oEvent, oMessage);
-            oEvent = oResult.oEvent;
-            oMessage = oResult.oMessage;
+            const oPreprocessingResult = this.#preprocessMessageEvent(oMessageEvent, oMessage);
+            oMessageEvent = oPreprocessingResult.event;
+            oMessage = oPreprocessingResult.message;
 
             if (!oMessage.service) {
                 oLogger.debug("Received Post Message without a service name. Ignoring the message.");
                 return;
             }
 
-            const oSourceWindow = oEvent.source;
-            const sSourceDomain = oEvent.origin;
-            oLogger.debug(`Received postMessage ${oMessage.service} (${oMessage.request_id}) from iframe with domain '${sSourceDomain}'`, JSON.stringify(oMessage, null, 2));
-
             if (!["response", "request"].includes(oMessage.type)) {
                 oLogger.warning(`Received Post Message with an invalid type: '${oMessage.type}'. Ignoring the message.`);
                 return;
             }
 
+            const oSourceWindow = oMessageEvent.source;
+            const sSourceDomain = oMessageEvent.origin;
+            oLogger.debug(`Received postMessage ${oMessage.service} (${oMessage.request_id}) from iframe with domain '${sSourceDomain}'`, JSON.stringify(oMessage, null, 2));
+
+            if (!oMessage.request_id) {
+                oLogger.debug("Received Post Message without a request_id. Message might be not handled correctly.");
+            }
+
             // first check if the message is a response to a request
             if (oMessage.type === "response") {
-                const bWasHandled = this.#handleResponseHandlers(oEvent);
+                const bWasHandled = this.#handleResponseHandlers(oMessageEvent, oMessage);
                 if (bWasHandled) {
                     oLogger.debug(`Response for ${oMessage.service} (${oMessage.request_id}) was handled by a response handler.`);
                 }
                 return;
             }
-            // handle the message as requests
+
+            // Handle the message as Request
+
+            // Initialize the body. It can be undefined which is unexpected for the service request handlers.
+            oMessage.body = oMessage.body || {};
 
             let oResponseMessageBody;
             let bSuccess = true;
             try {
-                const vResult = await this.#handleServiceRequests(oMessage, oSourceWindow, sSourceDomain, oEvent);
+                const vResult = await this.#handleServiceRequests(oMessage, oSourceWindow, sSourceDomain, oMessageEvent);
                 oLogger.debug(`Service request for ${oMessage.service} (${oMessage.request_id}) was handled successfully.`);
 
                 if (vResult === DoNotReply) {
@@ -201,9 +245,12 @@ sap.ui.define([
                 };
             }
 
+            // always reply with the original service request
+            const sServiceRequest = oMessage.originalMessage?.service || oMessage.service;
+
             return this.sendResponse(
                 oMessage.request_id,
-                oMessage.service,
+                sServiceRequest,
                 oResponseMessageBody,
                 bSuccess,
                 oSourceWindow,
@@ -212,49 +259,92 @@ sap.ui.define([
         }
 
         /**
-         * @param {Event} oEvent
-         * @param {PostMessageRequest|PostMessageResponse} oMessage
+         * Parses the message from the postMessage event.
+         * @param {MessageEvent} oMessageEvent The incoming message event.
+         * @returns {PostMessageResponse|PostMessageRequest} The parsed message from the postMessage event.
+         *
+         * @since 1.139.0
+         * @private
+         */
+        #parseMessage (oMessageEvent) {
+            let oMessage;
+            // we support stringified JSON and plain objects
+            if (typeof oMessageEvent.data === "string") {
+                oMessage = JSON.parse(oMessageEvent.data);
+            } else if (isPlainObject(oMessageEvent.data)) {
+                oMessage = oMessageEvent.data;
+            } else {
+                // e.g. Error, transferable objects, ...
+                throw new Error("Invalid message format");
+            }
+
+            return oMessage;
+        }
+
+        /**
+         * Preprocesses the message event and message.
+         * The preprocessing might change the event.
+         * However, a message is only changed once.
+         *
+         * @param {MessageEvent} oMessageEvent The incoming message event.
+         * @param {ParsedMessage} oMessage The parsed message from the postMessage event.
+         * @returns {{ event: MessageEvent, message: ParsedMessage }} The preprocessed message event and message.
+         *
+         * @since 1.134.0
+         * @private
          */
-        #preprocessMessageEvent (oEvent, oMessage) {
+        #preprocessMessageEvent (oMessageEvent, oMessage) {
             // Event properties are read-only, so we need to create a new event object if we want to change them.
-            let oNewEventObject;
+            let oProcessingResult;
             this.#aEventPreprocessor.forEach((fnProcessor) => {
-                if (oNewEventObject) {
+                if (oProcessingResult) {
                     return;
                 }
 
-                oNewEventObject = fnProcessor(oEvent, oMessage);
+                oProcessingResult = fnProcessor(oMessageEvent, oMessage);
             });
 
             return {
-                oEvent: oNewEventObject || oEvent,
-                oMessage
+                event: oProcessingResult?.event || oMessageEvent,
+                message: oProcessingResult?.message || oMessage
             };
         }
 
         /**
-         * @param {Event} oEvent
-         * @returns {boolean}
+         * Handles the response handlers for the postMessage event.
+         * @param {MessageEvent} oMessageEvent The incoming message event.
+         * @param {PostMessageResponse} oMessage The parsed message from the postMessage event.
+         * @returns {boolean} Whether the response was handled by a response handler.
+         *
+         * @since 1.134.0
+         * @private
          */
-        #handleResponseHandlers (oEvent) {
+        #handleResponseHandlers (oMessageEvent, oMessage) {
             let bWasHandled = false;
             this.#aResponseHandlers.forEach((fnResponseHandler) => {
                 if (bWasHandled) {
                     return;
                 }
 
-                bWasHandled = fnResponseHandler(oEvent);
+                bWasHandled = fnResponseHandler(oMessageEvent, oMessage);
             });
 
             return bWasHandled;
         }
 
         /**
-         * @param {PostMessageRequest} oMessage
-         * @param {Window} oSourceWindow
-         * @param {string} sSourceDomain
-         * @param {Event} oMessageEvent
-         * @returns {Promise<any>}
+         * Handles the service requests.
+         * Tries to apply the RequestHandlerOptions before calling the handler.
+         * Calls the handler with the expected context and returns the result.
+         *
+         * @param {PostMessageRequest} oMessage The parsed message from the postMessage event.
+         * @param {Window} oSourceWindow The source window of the postMessage event.
+         * @param {string} sSourceDomain The origin of the postMessage event.
+         * @param {MessageEvent} oMessageEvent The incoming message event.
+         * @returns {Promise<any>} Resolves with the result of the service request handler.
+         *
+         * @since 1.134.0
+         * @private
          */
         async #handleServiceRequests (oMessage, oSourceWindow, sSourceDomain, oMessageEvent) {
             const sServiceRequest = oMessage.service;
@@ -312,24 +402,38 @@ sap.ui.define([
         }
 
         /**
-         * @param {string} sServiceRequest
-         * @returns {function}
+         * Returns the request handler for the given service request.
+         * @param {string} sServiceRequest The service request name.
+         * @returns {function} The request handler function for the given service request.
+         *
+         * @since 1.134.0
+         * @private
          */
         #getServiceRequestHandler (sServiceRequest) {
             return this.#oRequestHandlers[sServiceRequest]?.handler;
         }
 
         /**
-         * @param {string} sServiceRequest
-         * @returns {RequestHandlerOptions}
+         * Returns the options for the given service request handler.
+         * @param {string} sServiceRequest The service request name.
+         * @returns {RequestHandlerOptions} The options for the given service request handler.
+         *
+         * @since 1.134.0
+         * @private
          */
         #getServiceRequestHandlerOptions (sServiceRequest) {
             return this.#oRequestHandlers[sServiceRequest]?.options;
         }
 
         /**
-         * @param {Window} oSourceWindow
-         * @returns {sap.ushell.appIntegration.IframeApplicationContainer}
+         * Retrieves the application container context for the given source window.
+         *  1) tries to match by iframe reference
+         *  2) falls back to the current application container
+         * @param {Window} oSourceWindow The source window of the postMessage event.
+         * @returns {sap.ushell.appIntegration.IframeApplicationContainer} The application container context for the given source window.
+         *
+         * @since 1.134.0
+         * @private
          */
         #getApplicationContainerContext (oSourceWindow) {
             let oApplicationContainer;
@@ -357,16 +461,29 @@ sap.ui.define([
         }
 
         /**
-         * @param {function} fnPreprocessor
+         * Adds a preprocessor function to the PostMessageManager.
+         * Preprocessors are called before the message is handled.
+         * They can modify the message event and the message itself and even  try to "fix" the message.
+         * @param {function():PreprocessingResult|undefined} fnPreprocessor The preprocessor function.
+         *
+         * @since 1.134.0
+         * @private
          */
         addEventPreprocessor (fnPreprocessor) {
             this.#aEventPreprocessor.push(fnPreprocessor);
         }
 
         /**
-         * @param {string} sServiceRequest
-         * @param {function} fnHandler
-         * @param {RequestHandlerOptions} oOptions
+         * Sets a request handler for the given service request.
+         * The options are mixed with the default options.
+         * If a handler for the service request already exists, it will be overwritten.
+         *
+         * @param {string} sServiceRequest The service request name.
+         * @param {function} fnHandler The handler function for the service request.
+         * @param {RequestHandlerOptions} oOptions The options for the service request handler.
+         *
+         * @since 1.134.0
+         * @private
          */
         setRequestHandler (sServiceRequest, fnHandler, oOptions = {}) {
             if (this.#oRequestHandlers[sServiceRequest]) {
@@ -383,12 +500,18 @@ sap.ui.define([
         }
 
         /**
-         * @param {string} sServiceRequest
-         * @param {any} oMessageBody
-         * @param {Window} oContentWindow
-         * @param {string} sTargetOrigin
-         * @param {boolean} bWaitForResponse
-         * @returns {Promise<any>}
+         * Sends a request to the given iframe.
+         * Constructs a message based on the provided parameters and sends it as a postMessage event.
+         *
+         * @param {string} sServiceRequest The service request name.
+         * @param {any} oMessageBody The message body to send with the request.
+         * @param {Window} oContentWindow The content window to send the request to.
+         * @param {string} sTargetOrigin The target origin for the postMessage request.
+         * @param {boolean} bWaitForResponse Whether to wait for a response from the service request.
+         * @returns {Promise<any>} A promise that resolves with the response from the service request if bWaitForResponse is true, otherwise resolves immediately.
+         *
+         * @since 1.134.0
+         * @private
          */
         async sendRequest (sServiceRequest, oMessageBody, oContentWindow, sTargetOrigin, bWaitForResponse) {
             if (this.#bDisabled) {
@@ -411,13 +534,19 @@ sap.ui.define([
         }
 
         /**
-         * @param {string} sRequestId
-         * @param {string} sServiceRequest
-         * @param {any} oMessageBody
-         * @param {boolean} bSuccess
-         * @param {Window} oContentWindow
-         * @param {string} sTargetOrigin
-         * @returns {Promise}
+         * Sends a response to the given iframe.
+         * Constructs a message based on the provided parameters and sends it as a postMessage event.
+         *
+         * @param {string} sRequestId The request ID of the service request to respond to.
+         * @param {string} sServiceRequest The service request name to respond to.
+         * @param {any} oMessageBody The message body to send with the response.
+         * @param {boolean} bSuccess Whether the response is successful or not.
+         * @param {Window} oContentWindow The content window to send the response to.
+         * @param {string} sTargetOrigin The target origin for the postMessage response.
+         * @returns {Promise} A promise that resolves when the response is sent.
+         *
+         * @since 1.134.0
+         * @private
          */
         async sendResponse (sRequestId, sServiceRequest, oMessageBody, bSuccess, oContentWindow, sTargetOrigin) {
             if (this.#bDisabled) {
@@ -439,11 +568,16 @@ sap.ui.define([
         }
 
         /**
-         * @param {PostMessageRequest|PostMessageResponse} oMessage
-         * @param {Window} oContentWindow
-         * @param {string} sTargetOrigin
-         * @param {boolean} bWaitForResponse
-         * @returns {Promise<any>}
+         * Sends a message to the content window.
+         * Adds the bWaitForResponse handling and actually sends the postMessage.
+         * @param {ParsedMessage} oMessage The message to send.
+         * @param {Window} oContentWindow The content window to send the message to.
+         * @param {string} sTargetOrigin The target origin for the postMessage request.
+         * @param {boolean} bWaitForResponse Whether to wait for a response from the service request.
+         * @returns {Promise<any>} A promise that resolves with the response from the service request if bWaitForResponse is true, otherwise resolves immediately.
+         *
+         * @since 1.134.0
+         * @private
          */
         async #sendMessage (oMessage, oContentWindow, sTargetOrigin, bWaitForResponse) {
             if (!oContentWindow) {
@@ -467,13 +601,19 @@ sap.ui.define([
         }
 
         /**
-         * @param {string} sRequestId
-         * @param {Window} oExpectedContentWindow
-         * @returns {Promise<any>}
+         * Waits for a response from the client for the given request ID.
+         * Adds a response handler to the list of response handlers.
+         * The response handler will be executed when the expected response is received.
+         * @param {string} sRequestId The request ID to wait for a response.
+         * @param {Window} oExpectedContentWindow The expected content window to receive the response from.
+         * @returns {Promise<any>} A promise that resolves with the response from the client.
+         *
+         * @since 1.134.0
+         * @private
          */
         #waitForClientResponse (sRequestId, oExpectedContentWindow) {
             const oDeferred = new Deferred();
-            const fnResponseHandler = this.#handleClientResponse.bind(null, oDeferred, sRequestId, oExpectedContentWindow);
+            const fnResponseHandler = this.#handleClientResponse.bind(this, oDeferred, sRequestId, oExpectedContentWindow);
 
             this.#aResponseHandlers.push(fnResponseHandler);
 
@@ -481,23 +621,20 @@ sap.ui.define([
         }
 
         /**
-         * @param {sap.base.util.Deferred} oDeferred
-         * @param {string} sRequestId
-         * @param {Window} oExpectedContentWindow
-         * @param {Event} oEvent
-         * @returns {boolean}
+         * Generic handler for client responses.
+         * It is called on every response and has to match the request ID and content window.
+         * @param {sap.base.util.Deferred} oDeferred The deferred object to resolve or reject based on the response.
+         * @param {string} sRequestId The request ID to match the response against.
+         * @param {Window} oExpectedContentWindow The expected content window to receive the response from.
+         * @param {MessageEvent} oMessageEvent The incoming message event.
+         * @param {PostMessageResponse} oMessage The parsed message from the postMessage event.
+         * @returns {boolean} Whether the response was handled successfully.
+         *
+         * @since 1.134.0
+         * @private
          */
-        #handleClientResponse (oDeferred, sRequestId, oExpectedContentWindow, oEvent) {
-            // only messages from the expected iframe should be handled, except when running in QUnit
-            const bIsRunningInQUnit = typeof window.QUnit === "object";
-            if (!bIsRunningInQUnit && oExpectedContentWindow !== oEvent.source) {
-                return false;
-            }
-
-            let oMessage;
-            try {
-                oMessage = JSON.parse(oEvent.data);
-            } catch {
+        #handleClientResponse (oDeferred, sRequestId, oExpectedContentWindow, oMessageEvent, oMessage) {
+            if (oExpectedContentWindow !== oMessageEvent.source) {
                 return false;
             }
 
@@ -506,7 +643,7 @@ sap.ui.define([
                 return false;
             }
 
-            oLogger.debug(`Received response for ${oMessage.service} (${oMessage.request_id}) from iframe with domain '${oEvent.origin}'`);
+            oLogger.debug(`Received response for ${oMessage.service} (${oMessage.request_id}) from iframe with domain '${oMessageEvent.origin}'`);
 
             if (oMessage.status === "success") {
                 oDeferred.resolve(oMessage.body);
@@ -528,10 +665,66 @@ sap.ui.define([
         }
 
         /**
-         * @param {string} sServiceRequest
-         * @param {any} oMessageBody
-         * @param {boolean} bWaitForResponse
-         * @returns {Promise<any[]>}
+         * Sends a request to the specified application container.
+         * Applies the distribution policy for the service request and checks if the application container is a valid target.
+         *
+         * @param {string} sServiceRequest The service request name to send the request to.
+         * @param {any} oMessageBody The message body to send with the request.
+         * @param {sap.ushell.appIntegration.IframeApplicationContainer} oApplicationContainer The application container to send the request to.
+         * @param {boolean} bWaitForResponse Whether to wait for a response from the service request.
+         * @returns {Promise<any>} A promise that resolves with the response from the service request.
+         *
+         * @since 1.139.0
+         * @private
+         */
+        async sendRequestToApplication (sServiceRequest, oMessageBody, oApplicationContainer, bWaitForResponse) {
+            if (this.#bDisabled) {
+                throw new Error("PostMessageAPI is disabled by configuration.");
+            }
+            if (!this.#bInitialized) {
+                throw new Error("PostMessageManager is not initialized.");
+            }
+
+            const oDistributionPolicy = this.#getDistributionPolicy(sServiceRequest);
+
+            if (oDistributionPolicy.onlyCurrentApplication) {
+                const oCurrentApplicationContainer = this.#fnGetCurrentApplication();
+                if (oApplicationContainer !== oCurrentApplicationContainer) {
+                    throw new Error("Application is not the current application.");
+                }
+            }
+
+            const bMatchesCapabilities = oDistributionPolicy.ignoreCapabilities || oApplicationContainer.supportsCapabilities([sServiceRequest]);
+            if (!bMatchesCapabilities) {
+                throw new Error(`Application does not support the service request: ${sServiceRequest}`);
+            }
+
+            if (typeof oDistributionPolicy?.isValidRequestTarget === "function") {
+                const bIsValidRequestTarget = oDistributionPolicy.isValidRequestTarget(oApplicationContainer);
+                if (!bIsValidRequestTarget) {
+                    throw new Error("Application is not a valid request target.");
+                }
+            }
+
+            return this.sendRequest(
+                sServiceRequest,
+                oMessageBody,
+                oApplicationContainer.getPostMessageTarget(),
+                oApplicationContainer.getPostMessageTargetOrigin(),
+                bWaitForResponse
+            );
+        }
+
+        /**
+         * Sends a request to all applications that match the distribution policy for the given service request.
+         *
+         * @param {string} sServiceRequest The service request name to send the request to.
+         * @param {any} oMessageBody The message body to send with the request.
+         * @param {boolean} bWaitForResponse Whether to wait for a response from the service request.
+         * @returns {Promise<any[]>} A promise that resolves with an array of responses from the service request.
+         *
+         * @since 1.134.0
+         * @private
          */
         async sendRequestToAllApplications (sServiceRequest, oMessageBody, bWaitForResponse) {
             if (this.#bDisabled) {
@@ -542,9 +735,19 @@ sap.ui.define([
             }
 
             const oDistributionPolicy = this.#getDistributionPolicy(sServiceRequest);
+
+            if (oDistributionPolicy.preventBroadcast) {
+                throw new Error(`Cannot send request to all applications for service request: ${sServiceRequest}. The distribution policy prevents broadcasting.`);
+            }
+
             const aRelevantContainers = [];
-            if (oDistributionPolicy.activeOnly) {
-                aRelevantContainers.push(this.#fnGetCurrentApplication());
+            if (oDistributionPolicy.onlyCurrentApplication) {
+                const oCurrentApplicationContainer = this.#fnGetCurrentApplication();
+                if (!oCurrentApplicationContainer) {
+                    return []; // might be undefined
+                }
+
+                aRelevantContainers.push(oCurrentApplicationContainer);
             } else {
                 this.#fnGetAllApplications().forEach((oContainer) => {
                     aRelevantContainers.push(oContainer);
@@ -553,16 +756,13 @@ sap.ui.define([
 
             const aFilteredContainers = aRelevantContainers
                 .filter((oContainer) => {
-                    if (!oContainer) {
-                        return false;
-                    }
-
                     if (!oContainer.isA("sap.ushell.appIntegration.IframeApplicationContainer")) {
                         return false;
                     }
 
-                    if (oDistributionPolicy.ignoreCapabilities || oContainer.supportsCapabilities([sServiceRequest])) {
-                        return true;
+                    const bMatchesCapabilities = oDistributionPolicy.ignoreCapabilities || oContainer.supportsCapabilities([sServiceRequest]);
+                    if (!bMatchesCapabilities) {
+                        return false;
                     }
 
                     if (typeof oDistributionPolicy?.isValidRequestTarget === "function") {
@@ -570,7 +770,7 @@ sap.ui.define([
                         return bIsValidRequestTarget;
                     }
 
-                    return false;
+                    return true;
                 });
 
             const aPromises = aFilteredContainers.map((oContainer) => {
@@ -583,22 +783,44 @@ sap.ui.define([
                 );
             });
 
-            return Promise.all(aPromises);
+            return Promise.allSettled(aPromises).then((aResults) => {
+                const aErrors = aResults
+                    .filter((oResult) => oResult.status === "rejected")
+                    .map((oResult) => oResult.reason);
+
+                if (aErrors.length > 0) {
+                    throw new Error(`Some requests failed: ${aErrors.map((oError) => oError.message).join(", ")}`);
+                }
+
+                // all requests were successful, return the results
+                return aResults.map((oResult) => {
+                    return oResult.value;
+                });
+            });
         }
 
         /**
-         * @param {string} sServiceRequest
-         * @returns {DistributionPolicy}
+         * Returns the distribution policy for the given service request.
+         * @param {string} sServiceRequest The service request name to get the distribution policy for.
+         * @returns {DistributionPolicy} The distribution policy for the given service request.
+         *
+         * @since 1.134.0
+         * @private
          */
         #getDistributionPolicy (sServiceRequest) {
             return this.#oDistributionPolicies[sServiceRequest] || oDefaultDistributionPolicy;
         }
 
         /**
-         * @param {string} sServiceRequest
-         * @param {DistributionPolicy} oPolicy
+         * Sets the distribution policy for the given service request.
+         * If a policy for the service request already exists, it will be overwritten.
+         * @param {string} sServiceRequest The service request name to set the distribution policy for.
+         * @param {DistributionPolicy} oPolicy The distribution policy to set for the service request.
+         *
+         * @since 1.134.0
+         * @private
          */
-        setDistributionPolicy (sServiceRequest, oPolicy = {}) {
+        setDistributionPolicy (sServiceRequest, oPolicy) {
             if (this.#oDistributionPolicies[sServiceRequest]) {
                 oLogger.error(`Distribution policy for service ${sServiceRequest} is already defined. Overwriting the existing policy.`);
             }
@@ -609,10 +831,18 @@ sap.ui.define([
             };
         }
 
+        /**
+         * Replays all stored messages that were not processed yet.
+         * This is useful for plugins that were added after the messages were received.
+         * It will process all messages that were stored while the PostMessageManager was not initialized.
+         *
+         * @since 1.134.0
+         * @private
+         */
         replayStoredMessages () {
             this.#bKeepMessagesForLaterProcessing = false;
-            this.#aUnprocessedMessages.forEach((oEvent) => {
-                this.#handlePostMessageEvent(oEvent);
+            this.#aUnprocessedMessages.forEach((oMessageEvent) => {
+                this.#handlePostMessageEvent(oMessageEvent);
             });
             this.#aUnprocessedMessages = [];
         }