Under the application’s Message types, create the three types this flow routes on. A message type is a name plus a format, no schema required:

Promotions live on the message type, so add them while you are here. The lookup port’s parameters (Step 6) and the Listener’s response matching (Step 5) bind these values, and adapter parameters are plain strings: they bind {{…}} tokens but never evaluate a body path.

The answer carries the token back; this is what the response matching will route on:

The lookup request the storefront POSTs, a StockQuery:

{
  "requestId": "9f4c1e8a",
  "sku": "TP-4501"
}

The answer that comes back, a StockAnswer:

{
  "requestId": "9f4c1e8a",
  "sku": "TP-4501",
  "quantity": 106
}

Three external parties, three credentials. Under the application’s Authentications, the dialog asks for a Name, the Adapter it pairs with, and a Definition, the credential shape that adapter offers, with the Application preset; the Definition decides the config section that follows.

Create the table and procedure in your inventory database; the lookup port (Step 6) calls the procedure. It returns the request id alongside the quantity; that echoed RequestId is what the Response Subscription matches on. The SELECT ends in FOR JSON PATH, WITHOUT_ARRAY_WRAPPER so the single row comes back as one JSON object, the shape the response map (Step 4) consumes.

CREATE TABLE dbo.Inventory (
    Sku       VARCHAR(40) NOT NULL PRIMARY KEY,
    Available INT         NOT NULL
);

CREATE OR ALTER PROCEDURE dbo.GetAvailability
    @RequestId VARCHAR(40),
    @Sku       VARCHAR(40)
AS
BEGIN
    SET NOCOUNT ON;
    SELECT
        @RequestId AS RequestId,
        @Sku       AS Sku,
        ISNULL((SELECT Available FROM dbo.Inventory WHERE Sku = @Sku), 0) AS Quantity
    FOR JSON PATH, WITHOUT_ARRAY_WRAPPER;
END;

Under the application’s Maps, create the map the lookup port (Step 6) selects on its response side:

Because the procedure’s SELECT ends in FOR JSON PATH, WITHOUT_ARRAY_WRAPPER, the single row comes back as one JSON object:

{ "RequestId": "9f4c1e8a", "Sku": "TP-4501", "Quantity": 106 }

Maps are authored in XSLT 3.0 and run on Saxon HE 12.9. JSON in, JSON out: parse-json(.) reads the result, the ?key operator pulls each field, and the answer carries the request id so the Listener can match it to the waiting caller:

<xsl:stylesheet version="3.0"
    xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:output method="text"/>
  <xsl:template match="/">
    <xsl:variable name="r" select="parse-json(.)"/>
    <xsl:value-of select="serialize(
      map {
        'requestId': string($r?RequestId),
        'sku': string($r?Sku),
        'quantity': number($r?Quantity)
      },
      map { 'method': 'json', 'indent': true() })"/>
  </xsl:template>
</xsl:stylesheet>

Create a receive port StockLookup on the API Listener, two-way mode, paired with StorefrontToken, from Step 2. (The dropdowns can also create types and maps inline; building the dependencies first keeps each dialog a selection.)

The shared API ingress routes on these plus the Authentication; the Purpose value keeps this Listener distinct from any other in the same Application, see order intake for the full rule. Note it can share the App namespace with order intake precisely because its Purpose differs.

On the Publish step under the port’s Solicit stages, set Message Type Fallback to StockQuery, from Step 1, so the posted body classifies at the start of the inbound flow.

Assign the correlation variable, Variable.RequestId ← {{Message.Body}}.JPath("$.requestId").

Set the Response Subscription Expression on the response side’s Subscription tab: {{Promoted.StockAnswer.RequestId}} == {{Variable.RequestId}}.

Create a send port StockAvailability on the SQL Caller, two-way, subscribing on {{Message.MessageType}} == "StockQuery".

The procedure from Step 3 takes the request id and the SKU, binding the promotions defined on StockQuery in Step 1, one key/value row each:

On the response side, select ResultToStockAnswer, from Step 4.

On StockAvailability, set Exception Message Type, on the port’s General step, to StockQueryFailed, from Step 1, and keep retries minimal, the caller is waiting.

Create the OpsAlert O365 Mail port subscribing on {{Message.MessageType}} == "StockQueryFailed":

Everything you configure is live the moment you save it, there is nothing to deploy. Start the send ports first, then the receive ports.

Set Tracking to Enabled + Body on every port the flow touches, so you can walk each run step by step, with its message body, in tracking.

Call the endpoint with a known SKU, and confirm the quantity comes back on the same connection.

Fire several concurrent requests with distinct request ids and verify each caller receives its own answer.

Stop the database: the caller should get the timeout status (typically 504) once the wait window lapses, and operations should get the StockQueryFailed alert.