Value Composer - Frontic Docs

The Value Composer transforms data by chaining together operations. Below is the full catalogue of available operations, grouped by category.

How operations are configured

A composer slot is a JSON object with a source discriminator. There are three sources you’ll work with:

Source	Shape	Use for
`static`	`{ "source": "static", "value": <literal>, "outputType": "<type>" }`	A fixed value baked into the configuration.
`data-field`	`{ "source": "data-field", "field": "path.to.field" }`	A reference to a field on the incoming feed record. Use `$item` / `$parent` inside iterations.
`composed`	`{ "source": "composed", "composition": { "type": "<op>", "<param>": <slot>, ... } }`	An operation. Each parameter is itself a slot, so operations nest arbitrarily.

Putting it together — a concat of vendor.name + - + name, the JSON the admin UI emits:

{
  "source": "composed",
  "composition": {
    "type": "concat",
    "value1": { "source": "data-field", "field": "vendor.name" },
    "value2": { "source": "data-field", "field": "name" },
    "separator": { "source": "static", "value": " - " }
  }
}

The same recursion shows up everywhere: an if whose then is a concat of two static values, a map whose mapFunction is a get on $item, and so on. The catalogue below documents the parameter names and types each operation expects.

Type compatibility

Every slot has a known output type, and operations declare what they accept:

Concrete types (number, string, boolean, array, object) — the input slot must produce that exact type, or the configuration is invalid.
Type markers (T, K, V) — polymorphic placeholders. The first input that fills a marker fixes the type for every other slot using the same marker. For example, equals(value: T, compare: T) accepts any type as long as value and compare agree — fill value with a string and compare is constrained to strings too.

The admin UI surfaces type mismatches in the slot’s validation state — slots that can’t yet produce the required type stay highlighted as invalid and the configuration won’t save. There’s no implicit coercion at runtime: a string flowing into a number slot raises an explicit type error rather than getting cast silently. When you actually want a cast, use toString / toNumber / toBoolean so the conversion is part of the chain. See Error handling for what happens when something does slip through.

Operations

Array Operations

`count`

Returns the number of elements in an array.

Show Inputs

array

The array to count elements in.

number

`filter`

Returns an array of all elements that satisfy a condition. Access each element of the array with the $item variable.

Show Inputs

array

The array to filter.

boolean

The function to determine if the element should be included in the result.

array<T>

`findFirst`

Finds and returns the first element of an array that satisfies a condition. Access each element of the array with the $item variable.

Show Inputs

array

The array to find the first element of.

boolean

The function to determine if the element should be returned.

`first`

Returns the first element of an array.

Show Inputs

array

The array to get the first element from.

`flatMap`

Applies a function to each element of an array, flattens and returns the resulting array. Access each element of the array with the $item variable.

Show Inputs

array

The array to map over.

array

The function to apply to each element.

array

`join`

Joins an array of strings into a single string.

Show Inputs

array

The array of strings to join.

string

An optional separator to insert between the strings.

string

`map`

Applies a function to each element of an array and returns the resulting array. Access each element of the array with the $item variable.

Show Inputs

array

The array to map over.

The function to apply to each element.

array

`merge`

Merges an array of scalar values together.

Show Inputs

array

The base array of values.

array

An array of additional values to add to the base array.

array

`slice`

Extracts a portion of an array.

Show Inputs

array

The array to slice.

number

The starting position (zero-based index).

number

The number of elements to extract.

array

`split`

Splits a string into an array of strings given a separator.

Show Inputs

string

The string to split.

string

The separator to use for splitting.

array

`unique`

Removes duplicate values from a scalar array.

Show Inputs

array

The array with duplicate values.

array

Comparison Operations

`equals`

Compares two values.

Show Inputs

The first value to compare.

The second value to compare.

boolean

`greaterThan`

Compares two values and returns true if the first is greater than the second.

Show Inputs

number

The first value to compare.

number

The second value to compare against.

boolean

`isEmpty`

Returns whether a value is empty.

Show Inputs

The value to check for emptiness.

boolean

`isNull`

Returns whether a value is NULL.

Show Inputs

The value to check for NULL.

boolean

`isScalar`

Returns whether a value is a scalar (i.e. not an object or array).

Show Inputs

The possibly scalar value.

boolean

Logic Operations

`and`

Returns true if all values are true.

Show Inputs

boolean

The first value to compare.

boolean

The second value to compare.

boolean

`if`

Splits the execution flow based on a condition.

Show Inputs

boolean

The condition to evaluate.

The value to return if the condition is true.

The value to return if the condition is false.

Show Details

Overview

The if handler is a logic component that splits the execution flow based on a boolean condition. It evaluates a condition and returns the result of either the then or else branch, depending on whether the condition is true or false.

Schema

Property	Type	Required	Description
type	string	Yes	Must be `'if'`
condition	value	Yes	The condition to evaluate (must resolve to bool)
then	value	Yes	Value to return if condition is `true`
else	value	Yes	Value to return if condition is `false`

Example

- type: if
  condition:
    source: static
    value: true
  then:
    source: static
    value: "Condition is true"
  else:
    source: static
    value: "Condition is false"

Behavior Table

`condition` Value	Result Returned	Notes
`true`	Result of `then` value	Evaluates and returns `then` branch
`false`	Result of `else` value	Evaluates and returns `else` branch
not boolean	Exception thrown	Must resolve to boolean, else error

Edge Cases

Non-boolean condition: If the resolved condition is not a boolean (true or false), a CompositionParameterTypeException is thrown.
Missing required fields: If any of condition, then, or else are missing, schema validation will fail.
Side effects in branches: Only the selected branch (then or else) is resolved and executed. The other branch is not evaluated, so any side effects or errors in the non-selected branch are ignored.
Nested handlers: Both then and else can themselves be handlers, including nested if handlers, allowing for complex conditional logic.

Usage Notes

Use the if handler to implement conditional logic in your composition flows.
Ensure that the condition resolves to a boolean value; otherwise, execution will fail with a type exception.
Both then and else branches must be provided, even if one is a placeholder or a no-op.

Example with Nested If

- type: if
  condition:
    source: static
    value: false
  then:
    type: if
    condition:
      source: static
      value: true
    then:
      source: static
      value: "Nested true"
    else:
      source: static
      value: "Nested false"
  else:
    source: static
    value: "Outer false"

`not`

Returns the negation of the value.

Show Inputs

boolean

The value to negate.

boolean

Show Details

Not Handler

Returns the negation of the provided boolean value.

Schema

{
  "type": "object",
  "properties": {
    "type": { "const": "not" },
    "value": { "$ref": "#/definitions/value" }
  },
  "required": ["type", "value"]
}

Example

{
  "type": "not",
  "value": { "source": "static", "value": true }
}

Description

Evaluates to true if value is false, and to false if value is true.

`or`

Returns true if at least one value is true.

Show Inputs

boolean

The first value to compare.

boolean

The second value to compare.

boolean

Show Details

Or Handler

Returns true if at least one of the provided boolean values is true.

Schema

{
  "type": "object",
  "properties": {
    "type": { "const": "or" },
    "value1": { "$ref": "#/definitions/value" },
    "value2": { "$ref": "#/definitions/value" }
  },
  "required": ["type", "value1", "value2"]
}

Example

{
  "type": "or",
  "value1": { "source": "static", "value": true },
  "value2": { "source": "static", "value": false }
}

Description

Evaluates to true if either value1 or value2 is true. Otherwise, returns false.

`xor`

Returns true if exactly one value is true.

Show Inputs

boolean

The first value to compare.

boolean

The second value to compare.

boolean

Show Details

Xor Handler

Returns true if exactly one of the provided boolean values is true.

Schema

{
  "type": "object",
  "properties": {
    "type": { "const": "xor" },
    "value1": { "$ref": "#/definitions/value" },
    "value2": { "$ref": "#/definitions/value" }
  },
  "required": ["type", "value1", "value2"]
}

Example

{
  "type": "xor",
  "value1": { "source": "static", "value": true },
  "value2": { "source": "static", "value": false }
}

Description

Evaluates to true if either value1 or value2 is true, but not both. Returns false if both are true or both are false.

Math Operations

`divide`

Divides two numbers (i.e. $numerator / $denominator).

Show Inputs

number

The numerator for the division.

number

The denominator for the division.

number

`exponent`

Calculates the exponentiation of a number by another number (base^exponent).

Show Inputs

number

The base number.

number

The exponent number.

number

`multiply`

Multiplies two numbers.

Show Inputs

number

The first number to multiply.

number

The second number to multiply.

number

`round`

Rounds a number with given significant decimal places.

Show Inputs

number

The number to round.

number

The number of significant decimal places to round to.

number

Object Operations

`get`

Accesses a value of an object field with the given key.

Show Inputs

string

The key of the field to access.

object

The object containing the field.

`object`

Handles an object composition by resolving its properties.

Show Inputs

object

The properties of the object to resolve.

object

Text Operations

`concat`

Concatenates two strings.

Show Inputs

string

The first string to concatenate.

string

The second string to concatenate.

string

An optional separator to insert between the concatenated strings.

string

`contains`

Checks if a string contains another string with optional case sensitivity.

Show Inputs

string

The string to search in.

string

The string to search for.

boolean

Whether to perform case-insensitive search (defaults to false).

boolean

`length`

Returns the number of characters in a string.

Show Inputs

string

The string to measure length of.

number

`md5`

Hashes a string with the MD5 algorithm.

Show Inputs

string

The string to hash with MD5.

string

`padLeft`

Pads a string to the left.

Show Inputs

string

The original string.

number

The length to pad to. If the length is negative, no padding takes place.

string

The character to pad with.

string

`padRight`

Pads a string to the right.

Show Inputs

string

The original string.

number

The length to pad to. If the length is negative, no padding takes place.

string

The character to pad with.

string

`replace`

Replaces a value in a string.

Show Inputs

string

The original string.

string

The substring to search for.

string

The substring to replace with.

boolean

Should the search be case sensitive?

string

`slugify`

Converts a string to a slug with no spaces or special characters.

Show Inputs

string

The string to convert to a slug.

string

The separator to use in the slug. It will be used to replace spaces and special characters.

string

`substring`

Extracts a substring from a string.

Show Inputs

string

The string to extract from.

number

The starting position.

number

Length of the substring.

string

`toLower`

Converts a string to lowercase.

Show Inputs

string

The string to convert to lowercase.

string

`toUpper`

Converts a string to uppercase.

Show Inputs

string

The string to convert to uppercase.

string

`trim`

Trims whitespace from the beginning and end of a string.

Show Inputs

string

The string to trim.

string

Transform Operations

`toBoolean`

Converts a value to a boolean.

Show Inputs

The value to convert to a boolean, e.g. “false”, “0”, and [] will all be converted to false.

boolean

`toNumber`

Converts a value to a number. NULL is converted to 0.

Show Inputs

The value to convert to a number.

number

`toString`

Converts a value to a string. NULL is converted to an empty string.

Show Inputs

The value to convert to a string.

string

Utilities Operations

`randomBoolean`

Returns a random boolean. Set probability (0-100) to control how often true is returned.

Show Inputs

number

Chance of returning true, from 0 (never) to 100 (always).

boolean

`randomNumber`

Returns a random number between min and max. Set precision to 0 for integers, or higher for decimals (e.g. 2 produces values like 3.14).

Show Inputs

number

Minimum value (inclusive).

number

Maximum value (inclusive).

number

Decimal places: 0 for integers, 2 for values like 3.14.

number

Error handling

The composer is strict about types and forgiving about absence:

Missing fields and keys resolve to null. A data-field slot pointing at a path that doesn’t exist on the current record returns null. get against a missing key returns null. The chain continues with null flowing through.
null inputs are absorbed where it makes sense. Per-operation handling, not a global rule:
- concat coalesces null inputs to empty strings.
- filter, map, and other array operations coalesce a null array input to [] and return an empty array.
- get against a null object returns null.
- findFirst against an empty array returns null.
Type mismatches throw. Operations don’t implicitly coerce — passing a number into a string slot, or a non-array into filter’s array parameter, raises a runtime error and fails the sync. Use explicit toString / toNumber / toBoolean when you need a cast, so the conversion is visible in the chain.
Math has guard rails. divide raises a runtime error on a zero denominator instead of producing Infinity or NaN.
Iteration context has a limit. filter and map populate $item (and $parent when nested one level). Three or more nesting levels aren’t supported and raise a runtime error — flatten with flatMap instead.

The field-level debugger shows node-wise output for the configuration: when a chain produces an unexpected null or fails outright, the debugger pinpoints which operation introduced it. Use it before the configuration runs against real sync data. Configuration errors that the type system can catch — an invalid operation type, a slot whose output can’t satisfy the parent’s expected type, a missing required parameter — show as inline validation on the affected slot in the admin UI; the configuration won’t save until they’re resolved. Backend resolution carries equivalent runtime checks as a backstop, raising explicit exceptions if an invalid configuration somehow reaches it.

​How operations are configured

​Type compatibility

​Operations

​Array Operations

​count

​filter

​findFirst

​first

​flatMap

​join

​map

​merge

​slice

​split

​unique

​Comparison Operations

​equals

​greaterThan

​isEmpty

​isNull

​isScalar

​Logic Operations

​and

​if

Overview

Schema

Example

Behavior Table

Edge Cases

Usage Notes

Example with Nested If

​not

Not Handler

Schema

Example

Description

​or

Or Handler

Schema

Example

Description

​xor

Xor Handler

Schema

Example

Description

​Math Operations

​divide

​exponent

​multiply

​round

​Object Operations

​get

​object

​Text Operations

​concat

​contains

​length

​md5

​padLeft

​padRight

​replace

​slugify

​substring

​toLower

​toUpper

​trim

​Transform Operations

​toBoolean

​toNumber

​toString

​Utilities Operations

​randomBoolean

​randomNumber

​Error handling

How operations are configured

Type compatibility

Operations

Array Operations

`count`

`filter`

`findFirst`

`first`

`flatMap`

`join`

`map`

`merge`

`slice`

`split`

`unique`

Comparison Operations

`equals`

`greaterThan`

`isEmpty`

`isNull`

`isScalar`

Logic Operations

`and`

`if`

`not`

`or`

`xor`

Math Operations

`divide`

`exponent`

`multiply`

`round`

Object Operations

`get`

`object`

Text Operations

`concat`

`contains`

`length`

`md5`

`padLeft`

`padRight`

`replace`

`slugify`

`substring`

`toLower`

`toUpper`

`trim`

Transform Operations

`toBoolean`

`toNumber`

`toString`

Utilities Operations

`randomBoolean`

`randomNumber`

Error handling