Introduction to Nodes

> Nodes are the building blocks of every route in Brickr. Connect them together to define your API logic visually.

In Brickr, you build backend logic by placing nodes on a canvas and wiring them together. Each node performs a single operation -- reading data, transforming values, querying a database, making an HTTP request, or controlling the flow of execution.

Anatomy of a node

Every node on the canvas has a consistent structure:

Title bar

The top of the node displays its name and category. The color of the title bar indicates which category the node belongs to.

Input pins

Input pins appear on the left side of the node. They receive data from other nodes or from values you type directly into the input fields. Each input pin has a label and a type.

Output pins

Output pins appear on the right side of the node. They provide the result of the node's operation to downstream nodes. A node can have one or more outputs.

Sequence pins

sequence pins control execution order. They appear as arrow-shaped connectors at the top of the node:

  • Sequence In (top-left) -- connects from a previous node's sequence out.
  • Sequence Out (top-right) -- connects to the next node to execute.

Not all nodes have sequence pins. Nodes that only transform data (like math-add or string-equal) are pure nodes -- they compute their result on demand when a downstream node needs the value. Nodes that cause side effects (like create-table-row, http-request, or return-json) require sequence connections to determine when they run.

Pin types

Every pin has a type that determines what kind of data it can carry. Wires can only connect pins of compatible types. The wire color reflects the data type.

| Type | Description | Wire color | |------|-------------|------------| | string | Text values | Teal | | number | Numeric values | Coral / red | | float / numeric | Numeric aliases used by some nodes | Lime | | boolean | True or false | Amber | | object | Structured data with named properties | Indigo | | array | Ordered lists of values | Neutral gray when generic | | enum | Predefined set of values | Purple | | any | Accepts any type -- flexible but untyped | Gray | | sequence | Execution order connection (not data) | White dashed |

The any type is compatible with all other types. Use it when you need flexibility, but prefer typed pins when possible to catch wiring mistakes early.

Typed arrays and objects

Arrays and objects can carry additional type information:

  • Typed arrays use the format X:array where X is the element type. For example, string:array is an array of strings, and number:array is an array of numbers.
  • Typed objects use the format object:StructName where StructName refers to a structure you have defined. This lets the editor know what properties the object contains.

How data flows through nodes

A flow in Brickr follows two parallel systems:

Sequence flow

Sequence connections determine the order in which nodes execute. Execution begins at the Start Node and follows the sequence wires from left to right. When a sequence wire reaches a node, that node runs its operation before passing control to the next node in the chain.

Data flow

Data connections carry values between nodes. When a node needs the value of an input pin, it traces the wire back to the source node and evaluates it. Pure nodes (those without sequence pins) are evaluated lazily -- they only compute when their output is requested.

Think of sequence flow as "when things happen" and data flow as "what values are used." A database insert node needs a sequence connection to know when to run, and data connections to know what values to insert.

The quick menu

The quick menu is the fastest way to add nodes to your canvas.

Opening the quick menu

There are two ways to open it:

  • Drag from a pin -- drag a wire from any pin and release it on empty canvas space. The menu opens filtered to show only nodes with a compatible pin.
  • Right-click the canvas -- opens the full menu with all available nodes.

Searching

Type in the search bar at the top of the quick menu to filter nodes by name or category. Results update as you type.

Categories

Nodes in the quick menu are organized by category. The exact node list changes as Brickr grows, so this documentation focuses on the groups rather than a fixed node count.

Common groups include response, request/input, auth, math, string, type conversions, control flow, object/json, array, variables, database, forms, email, integrations, public APIs, AI, storage, data transform, utility/time, and web nodes.

When you drag from a pin, the quick menu automatically filters to compatible nodes. This is the most efficient way to build your flow -- start from the Start Node's sequence out and keep dragging from the last node's output pins.

What's next

| Topic | Description | |-------|-------------| | Math nodes | Arithmetic, comparison, and type conversions | | String nodes | Text comparison, combining, and measurement | | Array nodes | Work with ordered lists of values | | Object nodes | Structured data, typed fields, and JSON operations | | Logic nodes | Control flow, conditionals, and validation | | HTTP nodes | Request reading, responses, and external API calls | | Database nodes | KV storage and table operations | | Storage nodes | File uploads | | Form nodes | Form submissions and triggers | | AI nodes | AI-powered text generation | | Utility nodes | Logging, dates, encoding, variables, and more |