Connections and streams

These actions come in families of two or three: connect, send, close. The connection stays open between the boxes, which lets you interleave other calls in the middle.

The common pattern

A connect action has two outputs:

Output	Emission
connected	A signal, once, when the connection is established
message	One emission per message received

It carries a connection name (connectionName). The send and close actions then designate that connection by its box identifier (connectionNodeId).

Handling every message

A box wired onto message only triggers once by default. For it to handle all the messages, enable “Play on each event received” in its context menu. See Ports and links.

The classic pattern:

Connexion MQTT ──connected──► Requête HTTP (déclencher l'action métier)
       └────────message─────► Assert (le message attendu est arrivé)
                              puis ──► Fermeture connexion MQTT

WebSocket

Action	Inputs	Outputs
WebSocket connect	—	connected, message (any frame received)
WebSocket send	payload	—
WebSocket connection close	—	—
WebSocket server close	—	—

See WebSocket.

Socket.IO

Action	Inputs	Outputs
Socket.IO connect	—	connected, one event:<name> port per declared event, and others
Socket.IO send	channel, payload	—
Socket.IO connection close	—	—
Socket.IO server close	—	—

This is the only connect action whose outputs are configurable: declare the list of events you care about and each one gets its own port. Any undeclared event arrives on others.

See Socket.IO.

MQTT

Action	Inputs	Outputs
MQTT connect	—	connected, message
MQTT publish	payload	—
MQTT connection close	—	—

Connecting subscribes to the request’s topic; sending publishes with the QoS and retention option configured. See MQTT.

SSE

Action	Inputs	Outputs
SSE connect	—	connected, message
SSE connection close	—	—

Receive-only: there is no send action. See SSE.

STOMP

Action	Inputs	Outputs
STOMP connect	—	connected, message
STOMP send	payload	—
STOMP connection close	—	—

Connecting emits the CONNECT then one SUBSCRIBE per configured subscription; sending produces a SEND frame; closing a DISCONNECT. See STOMP.

AMQP

Action	Inputs	Outputs
AMQP connect	—	connected, message
AMQP publish	payload	—
AMQP connection close	—	—

Connecting consumes the request’s queue (subscribe mode); publishing uses its exchange and routing key. See AMQP.

Redis

Action	Inputs	Outputs
Redis subscribe	—	connected, message
Redis connection close	—	—

For a single command, that is Redis command, which is a request / response action — see Requests and composition.

Kafka

Action	Inputs	Outputs
Kafka consume	—	connected, message
Kafka connection close	—	—

Consuming subscribes through the request’s consumer group. To produce, that is Kafka produce, a single-shot action. See Kafka.

Streaming gRPC

Action	Inputs	Outputs
gRPC connect	—	connected, message
gRPC send	payload	—
gRPC connection close	—	—

For the server-stream, client-stream and bidirectional-stream modes: sending only makes sense for the last two, and closing performs the client-side half-close. A unary call is made with HTTP Request. See gRPC.

GraphQL subscriptions

Action	Inputs	Outputs
GraphQL subscribe	—	connected, message
GraphQL unsubscribe	—	—

See GraphQL.