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:

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.

In the warehouse database, create a procedure that returns all status rows with an id above LastExportedId and advances the mark in the same transaction; the pick-up port (Step 7) calls it. This is the high-water mark that makes the poll safe to miss or repeat: a missed or repeated tick neither drops nor double-sends. The result SELECT ends in FOR XML PATH('Row'), ROOT('Result'), so the SQL Caller’s response is the XML envelope the splitter (Step 4) parses.

The warehouse writes ShipmentStatus; ExportWatermark remembers how far this feed has read.

CREATE TABLE dbo.ShipmentStatus (
    ShipmentId  BIGINT      NOT NULL PRIMARY KEY,
    OrderNumber VARCHAR(40) NOT NULL,
    Status      VARCHAR(20) NOT NULL,
    StatusAt    DATETIME2   NOT NULL
);

CREATE TABLE dbo.ExportWatermark (
    FeedName       VARCHAR(60) NOT NULL PRIMARY KEY,
    LastExportedId BIGINT      NOT NULL CONSTRAINT DF_Wm DEFAULT 0
);
INSERT INTO dbo.ExportWatermark (FeedName, LastExportedId)
VALUES ('ShipmentStatus', 0);

CREATE OR ALTER PROCEDURE dbo.GetNewShipmentStatuses
AS
BEGIN
    SET NOCOUNT ON;
    DECLARE @from BIGINT, @to BIGINT;

    BEGIN TRANSACTION;
        SELECT @from = LastExportedId
        FROM dbo.ExportWatermark WITH (UPDLOCK, HOLDLOCK)
        WHERE FeedName = 'ShipmentStatus';

        SELECT @to = MAX(ShipmentId) FROM dbo.ShipmentStatus;

        SELECT ShipmentId, OrderNumber, Status, StatusAt
        FROM dbo.ShipmentStatus
        WHERE ShipmentId > @from
        ORDER BY ShipmentId
        FOR XML PATH('Row'), ROOT('Result');

        UPDATE dbo.ExportWatermark
        SET LastExportedId = ISNULL(@to, @from)
        WHERE FeedName = 'ShipmentStatus';
    COMMIT;
END;

Under the application’s Pipeline components, create SqlCallerResultSplitter, a reusable disassembler: it parses the <Result><Row> envelope and returns one message per row, classified by the Message Type you set in the component’s configuration. An empty result set returns no messages, nothing to do this tick. The same component is reused by the FHIR tutorial. SqlCallerResult is the SQL Caller’s built-in result envelope (you do not create it as a message type; the adapter classifies its two-way response under that name).

Because the pick-up procedure’s result SELECT ends in FOR XML PATH('Row'), ROOT('Result'), the SqlCallerResult body is XML, one <Row> per status row, each column an element:

<Result>
  <Row><ShipmentId>88412</ShipmentId><OrderNumber>SO-10472</OrderNumber><Status>Shipped</Status><StatusAt>2026-06-04T16:12:00</StatusAt></Row>
  <Row><ShipmentId>88413</ShipmentId><OrderNumber>SO-10488</OrderNumber><Status>Packed</Status><StatusAt>2026-06-04T16:14:30</StatusAt></Row>
</Result>

using System.Xml.Linq;
using System.ComponentModel.DataAnnotations;
using CC.Art2link.Pipelines.Domain.Models.PipelineComponents;

public sealed class SqlSplitterConfig
{
    // Message Type assigned to each row message before the map runs.
    [Required] public string RowMessageType { get; set; } = string.Empty;
}

public sealed class SqlCallerResultSplitter
    : PipelineComponentBase<SqlSplitterConfig>
{
    public override string Name => "SqlCallerResultSplitter";

    protected override Task<PipelineComponentOutput> ExecuteAsync(
        PipelineComponentInput input,
        SqlSplitterConfig config,
        CancellationToken cancellationToken)
    {
        try
        {
            var doc  = XDocument.Parse(input.Body);
            var rows = doc.Root?.Elements("Row") ?? Enumerable.Empty<XElement>();

            var messages = rows
                .Select(r => new PipelineMessage
                {
                    Body        = r.ToString(),
                    MessageType = config.RowMessageType
                })
                .ToList();

            return Task.FromResult(new PipelineComponentOutput
            {
                Success  = true,
                Messages = messages   // empty list => nothing published
            });
        }
        catch (Exception ex)
        {
            return Task.FromResult(new PipelineComponentOutput
            {
                Success      = false,
                ErrorMessage = $"SqlCallerResultSplitter: {ex.Message}",
                Exception    = ex
            });
        }
    }
}

Under the application’s Maps, create the map that shapes each split <Row> into the canonical JSON the storefront’s API expects:

One canonical ShipmentStatus as the map publishes it:

{
  "orderNumber": "SO-10472",
  "status": "Shipped",
  "statusAt": "2026-06-04T16:12:00"
}

Maps are authored in XSLT 3.0 and run on Saxon HE 12.9:

<xsl:stylesheet version="3.0"
    xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:output method="text"/>
  <xsl:template match="/Row">
    <xsl:value-of select="serialize(
      map {
        'orderNumber': string(OrderNumber),
        'status': string(Status),
        'statusAt': string(StatusAt)
      },
      map { 'method': 'json', 'indent': true() })"/>
  </xsl:template>
</xsl:stylesheet>

Create a receive port ShipmentStatusClock on the Scheduler; its tick is what wakes the pick-up port (Step 7). Leave the Payload empty, the tick is just a wake-up.

Create a send port ShipmentPickup on the SQL Caller, two-way mode, calling the procedure from Step 3. Subscription: {{Config.PortName}} == "ShipmentStatusClock". (The dropdowns can also create types and maps inline; building the dependencies first keeps each dialog a selection.)

Set Authentication to WarehouseDbSql, from Step 2.

The result set re-enters the bus through the port’s Response stages. Select the SqlCallerResultSplitter, from Step 4, and set its RowMessageType to ShipmentRow, from Step 1; then set Map Assignment to Typed and add one row, selecting the map from Step 5:

Create a send port StatusToStorefront on the API Caller, one-way mode, subscribing on {{Message.MessageType}} == "ShipmentStatus".

Set Authentication to StorefrontApi, from Step 2.

On both send ports, ShipmentPickup and StatusToStorefront, set Exception Message Type to ShipmentSyncFailed, from Step 1.

Create an O365 Mail send port OpsAlert subscribing on {{Message.MessageType}} == "ShipmentSyncFailed":

Everything you configure is live the moment you save it, there is nothing to deploy. Start the send ports first, StatusToStorefront, OpsAlert and ShipmentPickup, then the receive port ShipmentStatusClock.

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.

Insert a test status row, and watch the next tick in tracking: tick → pick-up → N statuses → N pushes. If five minutes is too long a wait, temporarily set ShipmentStatusClock to Repeat Every 1 / Minutes, then restore it once the test passes. Insert two rows and confirm two independent pushes.

Point the API port at a dead URL and confirm the alert email and the suspended runs waiting for replay.