Node reference
Reference for every node available in Flovello.
Signal
Nodes for emitting and receiving named signals between pipelines, enabling asynchronous, decoupled communication across your project.
Emits a signal to all subscriber pipelines. Each signal parameter maps to a typed input pin. When executed, one execution-intent row is enqueued for every subscribing pipeline; a NOTIFY wakes all cluster instances so any JVM can claim and run a subscriber.
Trigger node that starts the pipeline each time the matching signal is emitted. Each signal parameter appears as a typed output pin carrying the payload sent by the emitter. The pipeline subscribes automatically when saved and runs once per Send Signal invocation.
Triggers
Entry-point nodes that start pipeline execution in response to a schedule or inbound request.
Triggers the pipeline on a cron schedule. Use as the first node in time-based automations.
Triggers the pipeline at a fixed interval (e.g. every 10 minutes). Use as the first node in time-based automations where a cron expression would be overkill.
Starts the pipeline when an HTTP request hits the pipeline's trigger URL. Exposes the request method, headers, and body stream as outputs so downstream nodes can parse the payload without buffering it into memory.
Flow control
Nodes that direct which execution path runs next, including branching, switching, looping, error termination, and value selection.
Conditional branching on a boolean input. Emits the true execution pin when the condition is true and the false pin otherwise.
Routes execution to a case pin whose configured value matches the value input. Falls through to the default pin when no case matches. Case pins are configured per node instance; the value input is generic and locks to its connected type at design-time.
Terminates the pipeline with an error message. Use to abort execution when a precondition isn't met.
Iterates over each element in an array, firing the loop-body pin with element and index outputs, then the completed pin when the array is exhausted. Element type resolves on connection. A null or empty array iterates zero times and goes straight to completed.
Iterates from firstIndex to lastIndex (inclusive), firing the loop-body pin with the current index, then completed when done.
Repeats the loop pin while the boolean condition is true, re-evaluating the condition before each iteration, then fires completed once it becomes false. Wire a node that the loop body changes (e.g. a local variable) into the condition so the loop can end.
Returns one of N option values based on a zero-based index. Pure function — all option inputs are evaluated. Fails the pipeline if the index is out of range.
Returns one of two values based on a boolean condition. Pure function — both branches are evaluated.
Arithmetic
Pure functions for integer and decimal arithmetic operations.
Pure function returning the sum of two numbers.
Pure function returning a minus b.
Pure function returning the product of two numbers.
Pure function returning a divided by b. Integer division truncates toward zero. Decimal division uses IEEE 754 decimal64 precision (16 significant digits). Dividing by zero fails the pipeline.
Pure function returning the remainder of a divided by b. A modulo of zero fails the pipeline.
Pure function returning the negation of a number (i.e. -value).
Pure function returning the absolute value of a number.
Pure function returning the smaller of two numbers.
Pure function returning the larger of two numbers.
Pure function returning base raised to the exponent. Generic on both operands, resolving to INTEGER or DECIMAL at design-time. Integer powers require a non-negative exponent; decimal powers allow negative and fractional exponents (e.g. roots).
Pure function returning value constrained to the inclusive range [min, max]. If min is greater than max the result is min.
Comparison
Pure functions that compare two values and return a boolean result.
Pure function returning true if two values of any type are equal. Generic on both operands; type is fixed at design-time when connected.
Pure function returning true if two values of any type are not equal. Generic on both operands; type is fixed at design-time when connected.
Pure function returning true if a is greater than b.
Pure function returning true if a is less than b.
Pure function returning true if a is greater than or equal to b.
Pure function returning true if a is less than or equal to b.
Pure function returning true if A is before B.
Boolean logic
Pure functions for logical operations on boolean values.
Null handling
Pure functions for working with absent values — the nulls that optional model fields produce when a payload omits them or sends null.
Pure function returning true if the value is null. Generic on the value, in shape as well as type: a scalar, an array, a map or a whole model value can be connected, and the type is fixed at design-time when it is. Nulls reach a pipeline from optional model fields that parsed as JSON null.
Returns the value when it is not null, and the fallback otherwise. Generic on both pins, in shape as well as type: scalars, arrays, maps and whole model values can be connected as long as both pins agree, and the type is fixed at design-time when the first one is. Pure function — the fallback is always evaluated.
Strings
Pure functions for inspecting and transforming text strings.
Pure function returning text1 followed by text2 as a single string.
Pure function returning the text converted to uppercase using the root locale.
Pure function returning the text converted to lowercase using the root locale.
Pure function returning the text with leading and trailing whitespace removed.
Pure function returning the number of characters in the text.
Pure function returning the substring of text starting at the given index for the given length. Out-of-range indices are clamped to the bounds of the string.
Pure function returning true if text contains search.
Pure function returning true if text starts with prefix.
Pure function returning true if text ends with suffix.
Pure function returning text with every occurrence of search replaced by replacement. The search is matched literally — no regular expressions.
Pure function returning true if text has zero characters. Whitespace-only strings are not considered empty — pass through trim first if needed.
Pure function splitting text on a literal separator and returning the resulting parts as a string array. The separator is matched literally — no regular expressions. An empty separator returns the original text as a single-element array.
Pure function joining a string array into a single string with the given separator between each element. A null or empty array returns an empty string.
Pure function parsing text as an integer. Whitespace is trimmed before parsing; non-numeric input fails the pipeline.
Cryptography
Pure functions for encoding, hashing, and signing text — including keyed HMAC for verifying signed webhooks.
Pure function encoding text using the selected algorithm. Base64 produces the standard Base64 alphabet; URL uses application/x-www-form-urlencoded encoding.
Pure function decoding text using the selected algorithm. Base64 expects the standard Base64 alphabet; URL expects application/x-www-form-urlencoded encoding.
Pure function returning the hex-encoded hash of the input text using the selected algorithm. The output is always lowercase hexadecimal.
Pure function returning the keyed HMAC of the input text using the selected algorithm. Hex output is lowercase. Use this to verify signed webhooks (e.g. Stripe, GitHub, Shopify).
Type conversion
Pure functions that convert values between primitive types and between strings and streams.
Pure function converting an integer to its string representation.
Pure function returning "true" or "false" for the given boolean.
Pure function parsing text as a boolean. Returns true for "true" (case-insensitive, whitespace trimmed); false for everything else.
Pure function returning 1 for true and 0 for false.
Pure function returning true for any non-zero integer and false for zero.
Pure function widening an integer to a decimal.
Pure function converting a decimal to an integer, truncating toward zero.
Pure function converting a decimal to its plain string representation, without scientific notation (e.g. 0.0000001 becomes "0.0000001").
Pure function returning the underlying string value of any enum. Accepts any enum source — built-in or user-defined — and emits the raw value. Useful for piping an enum field into log-message or any other string consumer.
Pure function reading a stream fully and returning its contents as a string. Uses the charset from the stream's content-type hint when set; otherwise falls back to the selected charset.
Pure function wrapping a string as an output stream using the selected charset. Use to pipe a literal string into a node that expects an output stream (e.g. an HTTP request body).
Pure function bridging an input stream into an output stream without buffering. When the downstream consumer (e.g. http-request) writes the body, the bytes are pulled from the input stream and piped straight through. Use this to forward an FTP-downloaded file or an HTTP response body into another HTTP request without materialising it as a string first.
Models
Nodes for building, splitting, parsing, and serialising structured model values. The pins on Make, Break, and Parse to model adapt to the model you pick in the inspector.
Composes a model value from one input pin per field. Pick the model in the inspector; the node then exposes an argument input pin for every field of that model, typed to match, and emits the assembled model. A pure function — no side effects and no execution pins.
Splits a model value into one output pin per field. Pick the model in the inspector; the node then exposes an argument output pin for every field of that model, typed to match. A pure function — no side effects and no execution pins.
Parses an input stream into a typed model. Pick the model in the inspector and choose the wire format. Branches on success/error so the pipeline can handle malformed input. An array variant parses the stream into an array of the chosen model.
Pure function that serialises a model to a string. Supports JSON, YAML, and XML formats. Enable pretty for indented output. Useful for debugging — pipe the result into Log message.
Pure function that serialises a model to an output stream. Supports JSON, YAML, and XML formats. Use to send a model as an HTTP request body without buffering the whole payload into memory.
Date and time
Pure functions for reading the current time, formatting, parsing, and doing date arithmetic.
Pure function returning the current moment in the chosen time zone.
Pure function formatting a date/time as a string. The pattern follows Java's DateTimeFormatter syntax; the default is ISO-8601.
Pure function parsing a string into a date/time. The pattern follows Java's DateTimeFormatter syntax; the default is ISO-8601.
Pure function building a duration from an amount and a unit (e.g. 5 MINUTES).
Pure function returning value + duration. Use a negative duration to subtract.
Pure function returning the duration between two date/times (end minus start).
Arrays and ranges
Functions for building arrays, creating integer ranges, and working with array elements.
Pure function returning an integer array from first to last (inclusive). Useful as input to for-each.
Pure function building an array from a dynamic list of element pins. Add and remove pins on the node; removing them all yields an empty array, which is how you make one. Generic on the element type — the first connected pin fixes it for the rest.
Pure function returning the number of elements in an array. Generic on the element type; type is fixed at design-time when connected. A null array counts as empty and returns 0.
Pure function returning the element at the given index in an array. Generic on the element type; type is fixed at design-time when connected. Out-of-range indices fail the pipeline; a null array counts as empty, so every index is out of range.
Appends an element to an array in place and returns the updated array. Has execution pins (not pure).
Removes and returns the element at the given index from an array in place and returns the updated array. Has execution pins (not pure). Out-of-range indices fail the pipeline.
Removes all elements from an array in place and returns the empty array. Has execution pins (not pure).
Maps
Functions for reading, adding and removing key-value entries in maps, and for grouping an array of items into a map of arrays.
Puts a key-value entry into a map in place and returns the updated map. Works on maps of scalars and maps of arrays alike — the value pin follows the map's value shape. Has execution pins (not pure).
Pure function returning the value stored under a key, or null when the key is absent. The value pin follows the map's value shape, so reading a map of arrays yields an array. Pair with Is null? or Default if null to handle a missing key.
Removes an entry by key from a map in place and returns the updated map. Has execution pins (not pure).
Pure function returning true when the map has an entry under the given key. A null map contains nothing and returns false.
Pure function returning the number of entries in a map. A null map counts as empty and returns 0.
Pure function returning every key in the map as a string array, sorted so the order is stable between runs. Feed it into For each to walk the map. Keys are always strings at run time, whatever key type the map declares.
Appends an element to the array stored under a key in a map of arrays, creating the array when the key is absent. The multimap primitive: wire it into a For each to group items by a shared value in one step. Mutates in place and returns the same map. Has execution pins (not pure).
Pure function grouping an array of model values into a map of arrays, keyed by one field every element carries. Pick the field on the node; a dotted path (customer.id) groups by a field of a nested model. Keys are strings at run time whatever the field's declared type. Fails when the chosen field is null on an element — group with For each and Map array append instead when the key can be absent.
Random
Pure functions that generate random values — integers, UUIDs, and booleans.
I/O and network
Side-effecting nodes for logging, pausing, sending HTTP requests, sending email, and posting to Slack.
Writes a message to the execution log at INFO level. Use for debugging and auditing. Has execution pins (not pure).
Pauses execution for the given number of milliseconds before emitting the execution pin.
Sends an HTTP request and returns the raw response object. Branches on success/error; pass the response into a Break node to inspect status, body, or headers. The body input is an output stream — the upstream node writes directly to the request socket on demand, so uploads aren't buffered into memory. Use string-to-stream to pipe in a literal string, or model-to-stream to serialise a model. Wire the headers input to send custom request headers (build them with make-http-headers and add-http-header).
Pure function: fetches an OAuth2 access token via the client credentials grant and returns a credentials object that can be wired into http-request.
Sends an email from the Flovello no-reply address. Branches on success/error and outputs the provider messageId on success. To prevent abuse, the recipient must be an active member of the pipeline's organization or a verified destination — sending to any other address fails on the error branch.
Sends a message to a Slack channel using the organization's connected Slack workspace. Requires an active Slack integration. Branches on success/error so the pipeline can react to delivery failures.
Creates an empty HTTP headers collection on the execution flow. Has execution pins so each fire yields a fresh instance — chain with add-http-header to attach values, then wire the result into http-request's headers input.
Appends a value to the named header on the execution flow and returns the same headers instance. Has execution pins so the append order is deterministic. Header names are matched case-insensitively; multiple values for the same name preserve insertion order. Fails the pipeline if the headers came from an inbound request or response (read-only) — use make-http-headers to build a fresh collection.
Pure function returning the first value of the named header, or an empty string if the header is not set. Header names are matched case-insensitively.
Pure function returning every value of the named header as a string array, in insertion order. Returns an empty array if the header is not set. Header names are matched case-insensitively.
Pure function: builds an FTP credentials object from a host, port, username, password, and protocol (FTP, FTPS_EXPLICIT, FTPS_IMPLICIT, or SFTP). Wire the credentials output into any FTP operation node. A port of 0 selects the protocol default (21 for FTP/FTPS_EXPLICIT, 990 for FTPS_IMPLICIT, 22 for SFTP).
Downloads a file from an FTP/SFTP server and exposes its contents as a stream. Takes an FTP file object from Find/Get FTP files — the server connection comes from the file itself. Branches on success/error; the error branch is taken when the file does not exist. The downloaded bytes are buffered to a temporary file so the stream remains usable after the FTP session closes.
Finds files and directories on an FTP/SFTP server and returns them as an array of FTP file objects carrying name, path, size, modified time, type, and an exists flag. Filter by entry type, match names against a glob pattern, and optionally recurse into subdirectories (symbolic links are treated as files and never followed). Wire a result into Open/Remove/Move FTP file, or into a Break node to read its fields. Branches on success/error.
Looks up a single file or directory on an FTP/SFTP server by path and returns it as an FTP file object. A missing path is not an error: the returned object has exists = false so the flag can be branched on. The error branch is taken only for connection or protocol failures.
Removes a file from an FTP/SFTP server. Takes an FTP file object from Find/Get FTP files — the server connection comes from the file itself. Branches on success/error; the error branch is taken when the file does not exist.
Moves (renames) a file on an FTP/SFTP server to a new path on the same server. Takes an FTP file object from Find/Get FTP files — the server connection comes from the file itself. Branches on success/error; the error branch is taken when the file does not exist.
AI
In-pipeline AI. The Flovello AI step produces a typed model value from your input using a natural-language instruction.
Function I/O
Special nodes used inside user-defined function graphs to declare inputs and outputs.