Workflow Properties v2

The same Property structure is used for Workflow Parameters, Workflow Returns, Step Parameters, Step Returns, and nested object or array fields.

A Property declares shape, design-time guidance, runtime assignment, logging behavior, or a combination appropriate to its location and Node Method contract.

Fields

Field	Purpose
`Type`	Simplified type used for validation, mapping, editing, and compilation.
`Description`	Optional explanation of the Property's meaning or contract.
`Sample`	Representative design-time value for previews, inference, and generated interface examples. It is not a runtime assignment or a complete schema.
`Value`	Literal value assigned at runtime.
`Expression`	Runtime mapping from a Workflow Parameter, available Step Return, or mapping function.
`Logging`	Workflow Log handling. `Redact: true` replaces the captured value with the redaction marker.
`Properties`	Named child Property definitions for an object or an array item.

Configure Logging in Code view to apply Property redaction.

Types

Use the type supplied by the discovered Node Method contract. The authored simplified types are:

Type	Represents
`string`	Text, characters, and URL-like scalar values.
`number`	Numeric primitive values.
`boolean`	`true` or `false`.
`datetime`	Date/time and date/time-offset values.
`timespan`	A duration.
`guid`	A globally unique identifier.
`enum`	One option from the Method's published enum contract.
`object`	A structured object, dictionary, or JSON value.
`array`	A synchronous or asynchronous collection.
`stream`	An opaque byte Stream.
`connectionKey`	The exact ID of a compatible Connection selected through Console or an authorized tool.

Type describes the target contract. It does not convert incompatible data automatically. Flowgear validates it against the resolved Node Method and mapping shape.

See Data Types for the relationship between authored the Runtime types, document formats, and concrete Node types.

Literal values

Use Value for scalar literals and supported scalar collections:

Parameters:
  minimumAmount:
    Type: number
    Value: 100

  labels:
    Type: array
    Value:
      - priority
      - reviewed

Do not put an object or collection-of-objects payload in a complex Value. Declare its Properties, map it from runtime data, or pass a document to a parser Step. This keeps the authored shape aligned with the Method contract.

Expressions

Use Expression for runtime values:

CustomerId:
  Type: string
  Expression: "{.customerId}"

A runtime-assigned Property must not specify both Value and Expression. The validator reports that combination as an error.

The snippet represents a Step Parameter named CustomerId. Workflow Parameters are inputs, so they cannot define Expressions. Step Parameters and Workflow Returns can map from values available in their scope. A Step Return normally declares the output contract supplied by its Node Method rather than remapping that output.

Short scalar form

A scalar or sequence can be written without the full Property mapping:

Parameters:
  Text: Hello
  Source: "{readRecord.Record.name}"
  Tags:
    - customer
    - active

Flowgear treats a string containing a balanced {...} token as an Expression in short form. Use explicit Value when braces are literal text:

Parameters:
  Template:
    Type: string
    Value: "Use {braces} as text"

Prefer the full form when type, shape, sample, description, or logging behavior matters.

Objects

Use Properties to declare object fields:

Type: object
Properties:
  id:
    Type: string
  displayName:
    Type: string

An object mapping can put an Expression on the parent when the target accepts the upstream object directly. To reshape it, map the required fields under Properties.

Arrays

For a collection-of-objects mapping, put the source collection Expression on the array Property and define one target item beneath Properties:

Type: array
Expression: "{listCustomers.Customers}"
Properties:
  id:
    Type: string
    Expression: "{listCustomers.Customers.id}"
  name:
    Type: string
    Expression: "{listCustomers.Customers.name}"

The parent Expression establishes the per-item collection scope. Mapping a child field from a collection directly into a scalar outside that scope is invalid.

An expressionless array with mapped child fields constructs one item. Use that form only when a singleton collection is the intended target shape.

Streams

A stream is opaque and cannot declare child Properties. Pass it as one value to a Step that accepts a Stream. Parse it first when you need named fields.

The same direct Stream source cannot be exposed through more than one top-level Workflow Return. Return it once and let the caller consume that output.

Samples and logging

Use Sample to make design-time shape and preview behavior more useful. A sample does not provide runtime data and does not replace explicit Properties when a stable nested contract is required.

Logging.Redact: true affects Workflow Log capture for that Property. It does not alter the runtime value and does not sanitize Debug results, exception text, or diagnostics produced elsewhere. Apply redaction before publishing and review all other ways sensitive information could leave the Workflow. See Workflow Log Redaction for nested and deferred values.