Flow

Flows & the editor

Home lists every flow you have access to, each tagged DEPLOYED or STOPPED. Open one to reach the editor: a canvas in the middle, the node palette on the left, and a properties panel on the right that appears when a node is selected.

Across the top: Search (find nodes within the current flow), Export/Import (JSON), Undo/Redo, Save, Publish to Git, and Deploy/Stop.

The Toolbox

The left palette — the Toolbox — organizes node types into collapsible categories (Input, Function, Sequence, Output, Network, Storage, Parsers, Config, Subflow, Data Ops, ...) with a search box that filters by label or type across every category at once. Collapsed state persists across reloads.

Drag a node from the Toolbox onto the canvas, then draw a connection from one node's output dot to another's input dot to wire them together.

Node config & shared connections

Click any node to open its properties in the right-hand panel. A Database Query node, for example, can point at a raw connection string — or, just like Detanami and Smith, pull a shared connection from Core instead, so the same credential defined once in Core's vault works here with no re-entry.

Database Query never interpolates values into SQL text directly — bind parameters through msg.params with ? placeholders, translated to $1, $2, ... automatically for PostgreSQL.

• Stale shared connections are called out. If a node holds a shared connection that was deleted in Core, or is no longer shared with you, the dropdown now shows it explicitly as Connection #N (unavailable – deleted or not shared with you) instead of a blank – none – — and it can be replaced. A failed Deploy names the failing connection and the likely causes rather than a generic “not authorized” error.
• jdbc: URLs are accepted. A connection string copied from a Java or Eclipse tool, such as jdbc:postgresql://user:pw@host/db, works as-is for MySQL and PostgreSQL — Flow strips the leading jdbc:.

Merging branches with Join

Join has two modes. The default, auto, reassembles the output of a Split using msg.parts. The new count mode is for fanning parallel branches back into one — for example two database queries wired into the same Join — where there is no msg.parts to key on.

• Count: the Join waits for N messages from anywhere, then emits one message whose payload is either an array of the collected payloads or, in the object format, an object keyed by each message's msg.topic.
• Timeout (optional): sends a short batch, with a warning, instead of waiting forever.

Kafka nodes

Flow can consume from and publish to Apache Kafka, using the same config-node pattern as MQTT and WebSocket: a Kafka Broker config node holds the connection (brokers, client ID, TLS, and SASL mechanism, username and password), and any number of Kafka In and Kafka Out nodes reference it. The SASL password is credential-flagged, so it is encrypted at rest like Flow's other secrets.

• Kafka In runs its own consumer with its own group ID and topic subscription. Each message is emitted with its topic, partition, offset, key, headers and a string payload.
• Kafka Out publishes through the broker's single shared producer. Object payloads are JSON-stringified, msg.key becomes the record key when set, and the topic comes from the node or, if left blank, msg.topic.

Debug & Log panel

Every message that reaches a Debug node streams into a docked Debug & Log panel under the canvas. The panel holds a fixed height and scrolls inside itself, so a long log no longer squeezes the canvas away, and it always jumps to the newest entry when output arrives or when you re-expand it, so the result of the run you just triggered is never out of sight. Clear empties it. The trade-off: a flow that emits output every second keeps pulling the log to the bottom, so older entries are hard to read while it streams — Stop the flow, or Clear, to read in peace.

Node-config AI Assistant

The same right-hand column that shows a node's properties can also show an AI Assistant scoped to that exact node — it sees the node's field schema and current values, so a suggestion can be applied straight to one field with a per-field Apply button (wired into the same undo/redo path as a manual edit). Credential-flagged fields never get an Apply button.

AI DBA nodes

Two Data Ops nodes turn Flow into the suite's telemetry collector: Telemetry Poller polls a Shared Data Connection on a schedule for health metrics (like connection utilization), and Index Evaluator checks for unused indexes. Both push what they find to DBMojo Core, which stores it and prunes it on a retention schedule — Core never queries the target database itself.

That pushed data is exactly what feeds DataMosaic's DBOps Dashboard — deploy a Telemetry Poller here, then go build a dashboard over there to see it charted.

Coverage: Telemetry Poller supports PostgreSQL/TimescaleDB, MySQL/MariaDB, MSSQL/Azure SQL, Oracle, IBM DB2, and Amazon Redshift; Index Evaluator supports PostgreSQL/TimescaleDB, MySQL/MariaDB, MSSQL/Azure SQL, and IBM DB2; the Database Query node reaches SQLite, MySQL/MariaDB/Doris, PostgreSQL/TimescaleDB, DuckDB, DB2, Firebird, Snowflake, BigQuery, Athena, Spanner, Trino/Presto/Iceberg, Cassandra, Neo4j, InfluxDB, Solr, OpenSearch, Couchbase (N1QL), and Elasticsearch (SQL) (Oracle's execution-plan model doesn't expose the same "unused index" signal the others do).

Publishing to Git

The editor's Publish to Git button commits the current flow to a connected GitHub, GitLab, or Bitbucket repository — DBMojo Core's Version Control integration, available from any tool through a common Git-provider interface rather than being hardcoded to one host. When a flow is deployed against a connection that needs approval, the request filed in Core now carries the flow's full node definition, so an approver can read what the flow does before deciding — see Deployments.

Walkthrough: polling a database into a dashboard

1. Create a new flow and drag an Inject node onto the canvas, set to fire on an interval.
2. Drag a Telemetry Poller node next to it, wire Inject into it, and set its connection to a Shared Data Connection from Core.
3. Click Deploy — the poller now runs on schedule and pushes to Core.
4. Open AI Assistant on the Telemetry Poller node if you want help tuning its polling interval or metric selection.
5. Switch to DataMosaic and click + New DBOps Dashboard against the same connection to see the pushed data charted.

Roles & security

• analyst — open and inspect flows; cannot edit, save, or deploy.
• developer — full authoring: create, edit, save, deploy/stop, trigger nodes manually.
• admin — everything developer can do, plus user management and the audit log.

The Function node runs your JavaScript inside a Node vm context with no access to require/module/process — the same contained-trust model Node-RED's own Function node uses. The Exec node runs an OS process with the server's own privileges via spawn and an argv array (never a shell string), and — like Function — is restricted to the editor/admin roles. Credential-flagged fields (a Database Query connection string, an Email SMTP password, an MQTT Broker password) are encrypted at rest.