Data & Variables

Variable types

A variable is a typed container that carries data between nodes. One node fills it, the next reads it — and its type tells the platform what kind of value it's allowed to hold.

You declare variables in the Variables panel: give each one a name and pick a type. Getting the type right matters, because a query won't drop a record into a text box, and a calculation won't run on an object.

The primitive types

• text — any string: a name, a status, an id, a chunk of formatted output.
• number — an integer or decimal. Supports a defaultValue so it starts at, say, 0 instead of empty.
• boolean — true / false. Also takes a defaultValue (handy for a flag that should begin false).
• date — a calendar date (or date-time), the input to formulas like ADDDAYS.
• currency — a money value; like number it accepts a defaultValue.

The structured types

• object — holds an actual platform record. Because the platform must know which kind of record, an object variable needs an object API (e.g. account__m — your API names may differ). Flip isList on and it holds a list of those records instead of one.
• wrapper — a custom data shape you define yourself, for data that doesn't map to any object. It's important enough to get its own unit later in this module.

Reading records with Query

The query node is how a function reads data: it loads records from an object and drops them into a variable for the rest of the flow to use.

A query is three decisions: which fields to bring back, which records to filter to, and how many you want.

Name the fields — explicitly

There is no wildcard. List every field you intend to read or change: _id, name, status. This keeps queries fast and makes the flow's data dependencies obvious. For a lookup field, reach into the related record with the dotted form — e.g. customer__m._id to pull the linked record's id (your API names may differ).

Filter with conditions

Each condition has all three parts: a field, an operator, and a value. A condition missing any part is incomplete and must be removed before the function will compile.

How many — the take mode

The take mode decides whether you get a list or a single record — and it must match how you typed the variable:

• all — every matching record, as a list (store in a variable with isList: true).
• index — also a list, but capped: with index: '5' it returns up to 5 records — it acts as a LIMIT.
• first / last — a single record (isList: false). Use these when you expect exactly one.

Need a page of results? Combine skip and limit: set enableSkip: true, a skipCount (how many to skip), then take: index with index as the page size.

Assignment: literal, variable, formula

The assignment node sets a value — and it does so in one of three modes. Picking the right mode is the difference between storing the word "name" and storing someone's actual name.

// 1. LITERAL — the text "Active", exactly as written
value: 'Active'

// 2. VARIABLE — the VALUE of that field/variable
value: 'record.name'

// 3. FORMULA — a calculation (note formula: true)
value:   'count + 1'
formula: true

• Literal — stores the text as-is. value: 'Active' stores the five letters Active.
• Variable — resolves a name to its data. value: 'record.name' stores whatever that record's name happens to be.
• Formula — evaluates an expression. value: 'count + 1' with formula: true stores the result of the calculation.

Wrappers: custom data shapes

Sometimes your data doesn't map to a platform object — a report row, the JSON from an external API, a computed summary you'll hand back to a page. That's exactly what a wrapper is for: a custom data shape you define yourself.

Where an object variable mirrors a real table, a wrapper is a structure you invent — a little bundle of fields that exists only while the function runs.

Declaring a wrapper variable

A wrapper variable points at a wrapperName — the shape's definition (its fields). As with objects, set isList: true when you want a list of that shape rather than a single one.

Object or wrapper? A quick test

• It's a real record you'll read from or save to a table → use an object (give it the object API).
• It's transient or computed data with no table behind it → use a wrapper (give it a wrapper name).

Put it together

Let's tie the pieces into one short flow: read some Accounts and compute a value from them. Four moves — declare, query, declare, assign.

1. Declare a list variable for the records

   In the Variables panel add accounts as an object variable with object API account__m (your API names may differ) and isList: true — it'll hold the list we're about to load.

2. Add a Query node

   Set its object to Account. List the fields explicitly — _id, name (add a condition or two if you only want some Accounts). Set the take mode to all and store the result in accounts.

3. Declare a number variable

   Add accountCount as a number with defaultValue: 0, so it starts clean.

4. Set it with an assignment

   Add an assignment node targeting accountCount. In formula mode (formula: true), compute a value from the list — LEN(accounts) for the count, for instance. One node, one computed answer.

Earn the Data Handler stamp

Answer all five to lock in Module 03.