Transformer Reference

Reference guide for supported transformation functions and parameters for attribute transformers

This page includes a comprehensive list of all supported transformer functions and parameters. Some commonly used transformation functions include:

• Replacing a character with a different one

• Removing domains from email addresses

• Transforming to upper, lower, title, sentence, camel, or snake case

• Using a substring from the original value

See Attribute Transformers for more information about using attribute transformers to update or create attributes in downstream systems based on changes in your source of identity.

Understanding the Attribute Transformer Interface

When configuring attribute transformers in Lifecycle Management policies, you work with three key fields:

Destination Attribute

A Destination Attribute is a target-system attribute that Lifecycle Management creates or updates (e.g., email, username, first_name).

Lifecycle Management uses the Destination Attribute when you build a transformer or Sync/Deprovision action. You select a Destination Attribute (from the target entity type), then supply a Formatter (a fixed value, a {source_attribute}, or a transformation pipeline). Destination Attributes can be configured for continuous sync, used by action-level or common transformers, and referenced with $target inside the same action.

Formatter

A Formatter defines the exact value or expression used to populate a target attribute (Destination Attribute) when provisioning or syncing identities.

Formatters can be a fixed literal, a reference to a source-of-identity attribute (e.g., {first_name}), or an expression that applies transformation functions and pipelines (e.g., {email | REMOVE_DOMAIN | LOWER}).

They're configured on transformers used by Sync/Deprovision actions and control continuous sync behavior, fallbacks, and uniqueness.

The base transformation expression that defines how to construct the attribute value. This field can contain:

• Source attribute references: {first_name}, {email}

• Static text and source attributes combined: {first_name}.{last_name}@company.com

• Static values only: "Veza" or true

• Conditional logic: IF statements with comparison operators

Pipeline Functions

A Pipeline Function is a chained sequence of attribute formatters that run in order using the pipe (|) operator.

Pipeline Functions take the output of one formatter as the input to the next, letting you build multi-step transformations (for triggers, transformers, and formatter fields). They are used in workflow trigger conditions and transformer attributes to normalize, format, or compute values (for example: {department | TRIM | UPPER} or {hire_date | DATE_FORMAT, "2006-01-02"}).

Optional transformation functions applied after the Formatter. Multiple functions are chained using the pipe (|) character, with each function's output becoming the next function's input. Examples:

• | LOWER

• | ASCII | REMOVE_WHITESPACE

• | TRIM_CHARS, "." | UPPER

At runtime, Veza combines the {Formatter}{Pipeline Functions} fields to create the complete transformation.

Reading the Examples

Each transformer below includes three types of examples:

1. Basic Usage: Shows the transformer used alone with a simple source attribute

2. In a Pipeline: Demonstrates chaining multiple transformers together

3. Example: Provides practical context from Lifecycle Management scenarios

Copy-paste these examples directly into your attribute transformer configuration, adjusting attribute names to match your source of identity.

APPEND

APPEND

This transformer enables string concatenation by appending text to the end of attribute values during identity provisioning workflows.

Parameter Format

Characters (STRING, required)

Basic Usage

• Destination Attribute: email

• Formatter: {username}

• Pipeline Functions: | APPEND, "@company.com"

• Result: If username = john.smith, output is [email protected]

In a Pipeline

• Destination Attribute: display_name

• Formatter: {first_name}

• Pipeline Functions: | APPEND, " " | APPEND, "{last_name}"

• Result: If first_name = John and last_name = Smith, output is John Smith

Example

• Destination Attribute: user_principal_name

• Formatter: {first_name}.{last_name}

• Pipeline Functions: | LOWER | APPEND, "@contoso.com"

• Use case: Generate standardized email addresses for Azure AD user provisioning

ASCII

ASCII

Removes non-printable characters and replaces non-ASCII characters with their closest ASCII equivalents. Particularly useful for Active Directory sAMAccountName and other legacy systems with strict character requirements.

Note: The ASCII transformer performs operations on the base level, not the extended set.

Parameter Format

None (no parameters required)

Basic Usage

• Destination Attribute: username

• Formatter: {first_name}

• Pipeline Functions: | ASCII

• Result: If first_name = Łukasz, output is Lukasz

In a Pipeline

• Destination Attribute: login_name

• Formatter: {first_name}.{last_name}

• Pipeline Functions: | ASCII | LOWER | REMOVE_WHITESPACE

• Result: If first_name = José María, last_name = García, output is josemaria.garcia

Example

• Destination Attribute: sAMAccountName

• Formatter: {first_name}

• Pipeline Functions: | ASCII | SUB_STRING, 0, 1 | LOWER

• Use case: Generate Active Directory account names that comply with character restrictions while handling international names (converts "Łukasz" to "l")

ASSUME_TIME_ZONE

ASSUME_TIME_ZONE

Interprets the incoming time string as if it were in the specified time zone, then converts it to a UTC time. (example: if the input is "1/2/2025 11pm" and the defined time zone is America/Los_Angeles the function will treat "1/2/2025 11pm" as local time in Los Angeles and output the corresponding UTC time "1/3/2025 7am")

Parameter Format

String - Time Zone String (Optional) - Format

Usage Example

Input:

{activation_date | ASSUME_TIME_ZONE, "America/Los_Angeles"}

{activation_date | ASSUME_TIME_ZONE, "America/Los_Angeles", "RFC3339"}

{activation_date | ASSUME_TIME_ZONE, "-07:00"}

{activation_date | ASSUME_TIME_ZONE, "-07:00", "RFC3339"}

COUNTRY_CODE_ISO3166

COUNTRY_CODE_ISO3166

Transforms country code to ISO 3166 format.

ISO 3166 defines codes for the representation of country names, dependent territories, and their subdivisions

Parameter Format

Format (STRING, optional): [alpha2, alpha3, numeric], defaults to alpha2

Usage Example

Input:

{"US" | COUNTRY_CODE_ISO3166, "alpha3"}

Output:

USA

DATE_ADJUST

DATE_ADJUST

Adjusts date values based on hour, day, month, and year inputs. Provides full control over all time components for complex date manipulation.

Parameter Format

Parameter	Type	Required	Description
Hours	INTEGER	Yes	Number of hours to add (use negative values to subtract)
Days	INTEGER	No	Number of days to add
Months	INTEGER	No	Number of months to add
Years	INTEGER	No	Number of years to add
Format	STRING	No	Output format (defaults to auto-detection)

Usage Example

Input:

{activation_date | DATE_ADJUST, +1, 2, 3, -1}

Adjusts the date by adding 1 hour, 2 days, 3 months, and subtracting 1 year.

{activation_date | DATE_ADJUST, +1, 2, 3, -1, "RFC3339"}

{activation_date | DATE_ADJUST, +1, 2, 3, -1, "2006-01-02T15:04:05Z07:00"}

Example

If the input date is 2021-01-01 00:00:00 and you apply DATE_ADJUST, +1, 2, 3, -1, the output is 2020-04-03 01:00:00 (added 1 hour, 2 days, 3 months, subtracted 1 year).

DATE_ADJUST_DAY

DATE_ADJUST_DAY

A convenience transformer that adjusts date values by a specified number of days only. Use this for simple day-based calculations; use DATE_ADJUST for more complex adjustments involving hours, months, or years.

Parameter Format

Parameter	Type	Required	Description
Days	INTEGER	Yes	Number of days to add (use negative values to subtract)
Format	STRING	No	Output format (defaults to auto-detection)

Usage Example

Input:

{activation_date | DATE_ADJUST_DAY, +1}

Adds 1 day to the activation date.

{activation_date | DATE_ADJUST_DAY, +1, "RFC3339"}

{activation_date | DATE_ADJUST_DAY, +1, "2006-01-02T15:04:05Z07:00"}

Example

If the input date is 2021-01-01 00:00:00 and you apply DATE_ADJUST_DAY, +1, the output is 2021-01-02 00:00:00.

DATE_FORMAT

DATE_FORMAT

Transforms dates to a different format using Go time layout syntax. Essential for LDAP integration and standardizing dates across systems.

Parameter Format

Output Layout (STRING, required): Go time layout for output format Input Layout (STRING, optional): Go time layout for input format

Go Time Layout Syntax: Unlike most date formatting systems that use patterns like YYYY-MM-DD, Go uses a reference date: Mon Jan 2 15:04:05 MST 2006. Each component of this specific date represents a format element. This can be unintuitive at first, but provides unambiguous formatting.

Understanding Go Date Format

The reference date Mon Jan 2 15:04:05 MST 2006 breaks down as:

Component	Reference Value	Meaning
Year	2006	4-digit year
Year	06	2-digit year
Month	01	2-digit month (01-12)
Month	1	1 or 2-digit month (1-12)
Month	Jan	3-letter abbreviation
Month	January	Full month name
Day	02	2-digit day (01-31)
Day	2	1 or 2-digit day (1-31)
Day	_2	Space-padded day
Hour	15	24-hour format (00-23)
Hour	03 or 3	12-hour format (01-12 or 1-12)
Minute	04	Minutes (00-59)
Second	05	Seconds (00-59)
AM/PM	PM	Uppercase AM/PM
AM/PM	pm	Lowercase am/pm
Timezone	MST	Timezone abbreviation
Timezone	-0700	Numeric offset
Timezone	Z0700	Z for UTC, offset otherwise

Common Format Patterns

Output Format	Go Layout String	Example Output
ISO 8601 / RFC3339	2006-01-02T15:04:05Z07:00	2023-03-15T14:30:25-07:00
US date	01/02/2006	03/15/2023
European date	02/01/2006	15/03/2023
LDAP/AD format	20060102150405Z	20230315143025Z
Human readable	Jan 2, 2006	Mar 15, 2023
Full datetime	January 2, 2006 3:04 PM	March 15, 2023 2:30 PM
Date only	2006-01-02	2023-03-15
Time only	15:04:05	14:30:25

Named Format Aliases

Instead of Go layout strings, you can use these named aliases (case-insensitive):

Alias	Equivalent Layout	Example Output
dateonly	2006-01-02	2023-03-15
timeonly	15:04:05	14:30:25
datetime	2006-01-02 15:04:05	2023-03-15 14:30:25
kitchen	3:04PM	2:30PM
rfc822	02 Jan 06 15:04 MST	15 Mar 23 14:30 PDT
rfc822z	02 Jan 06 15:04 -0700	15 Mar 23 14:30 -0700
rfc850	Monday, 02-Jan-06 15:04:05 MST	Wednesday, 15-Mar-23 14:30:25 PDT
rfc1123	Mon, 02 Jan 2006 15:04:05 MST	Wed, 15 Mar 2023 14:30:25 PDT
rfc1123z	Mon, 02 Jan 2006 15:04:05 -0700	Wed, 15 Mar 2023 14:30:25 -0700
rfc3339	2006-01-02T15:04:05Z07:00	2023-03-15T14:30:25-07:00
rfc3339nano	2006-01-02T15:04:05.999999999Z07:00	2023-03-15T14:30:25.123456789-07:00
ansic	Mon Jan _2 15:04:05 2006	Wed Mar 15 14:30:25 2023
unixdate	Mon Jan _2 15:04:05 MST 2006	Wed Mar 15 14:30:25 PDT 2023
rubydate	Mon Jan 02 15:04:05 -0700 2006	Wed Mar 15 14:30:25 -0700 2023
stamp	Jan _2 15:04:05	Mar 15 14:30:25
stampmilli	Jan _2 15:04:05.000	Mar 15 14:30:25.123
stampmicro	Jan _2 15:04:05.000000	Mar 15 14:30:25.123456
stampnano	Jan _2 15:04:05.000000000	Mar 15 14:30:25.123456789
layout	01/02 03:04:05PM '06 -0700	03/15 02:30:25PM '23 -0700
win32	Active Directory FILETIME	133234218250000000

The win32 format outputs the Windows FILETIME format used by Active Directory for attributes like accountExpires. This represents 100-nanosecond intervals since January 1, 1601 UTC.

Basic Usage

• Destination Attribute: hire_date

• Formatter: {start_date}

• Pipeline Functions: | DATE_FORMAT, "01/02/2006"

• Result: If start_date = 2023-03-15, output is 03/15/2023

In a Pipeline

• Destination Attribute: formatted_date

• Formatter: {hire_date}

• Pipeline Functions: | DATE_FORMAT, "Jan 2, 2006" | REPLACE_ALL, " ", "_"

• Result: If hire_date = 2023-03-15, output is Mar_15,_2023

Using Named Aliases

• Destination Attribute: formatted_date

• Formatter: {hire_date}

• Pipeline Functions: | DATE_FORMAT, "rfc3339"

• Result: Outputs ISO 8601 format like 2023-03-15T00:00:00Z

LDAP Z Time Format

• Destination Attribute: accountExpires

• Formatter: {termination_date}

• Pipeline Functions: | DATE_FORMAT, "20060102150405Z"

• Use case: Convert dates to LDAP Z time format (outputs UTC format like 20230315143025Z)

Active Directory FILETIME Format

• Destination Attribute: accountExpires

• Formatter: {termination_date}

• Pipeline Functions: | DATE_FORMAT, "win32"

• Use case: Convert dates to Windows FILETIME format for AD account expiration (outputs values like 133234218250000000)

Parsing Non-Standard Input Dates

When your source data uses a non-standard date format, provide both the output format AND input format:

{date_field | DATE_FORMAT, "2006-01-02", "01-02-2006"}

• First parameter: desired output format

• Second parameter: format of the input data

For example, to convert 03-15-2023 (MM-DD-YYYY) to 2023-03-15 (ISO format):

{start_date | DATE_FORMAT, "2006-01-02", "01-02-2006"}

FIRST_N

FIRST_N

Picks the first N characters of a string. Useful for creating shortened identifiers or initials.

Parameter Format

Length (NUMBER, required): Number of characters to return

Basic Usage

• Destination Attribute: initial

• Formatter: {first_name}

• Pipeline Functions: | FIRST_N, 1

• Result: If first_name = John, output is J

In a Pipeline

• Destination Attribute: username

• Formatter: {first_name}.{last_name}

• Pipeline Functions: | FIRST_N, 1 | LOWER

• Result: If first_name = John, output is j

Example

• Destination Attribute: username

• Formatter: {first_name}

• Pipeline Functions: | FIRST_N, 1 | LOWER

• Use case: Create abbreviated usernames in the format "j.smith" by combining first initial with last name

FROM_ENTITY_ATTRIBUTE

FROM_ENTITY_ATTRIBUTE

Looks up an entity in the Veza graph by matching an attribute value, then returns a different attribute from that entity. This is useful for cross-referencing related entities, such as finding a manager's email from an employee ID.

Parameter Format

Parameter	Type	Required	Description
EntityType	STRING	Yes	The type of graph entity to search (e.g., Employee, OktaUser, ActiveDirectoryUser)
SourceAttribute	STRING	Yes	The attribute on the entity to match against the input value
TargetAttribute	STRING	Yes	The attribute to return from the matched entity. Use id or type for built-in entity properties.
DefaultValue	STRING	No	Value to return if no matching entity is found

How It Works

1. The input value (before the |) is used as the search term

2. The transformer finds an entity of type EntityType where SourceAttribute equals the input value

3. It returns the TargetAttribute value from that entity

4. If no entity is found and DefaultValue is provided, the default is returned; otherwise an error occurs

Special Behaviors

Scenario	Behavior
Empty input value	Returns empty string "" (no error)
Input wrapped in brackets [value]	Brackets are automatically stripped before lookup
TargetAttribute is id	Returns the entity's unique graph ID
TargetAttribute is type	Returns the entity's type name
No entity found, no default	Returns error with details about the failed lookup
Target attribute missing on entity	Returns error (unless default provided)

When used in sync workflows, this transformer checks previously computed values from the current job before querying the graph cache. This optimization prevents redundant lookups during batch operations.

Usage Examples

Example 1: Get manager's name from employee ID

{12345 | FROM_ENTITY_ATTRIBUTE, "Employee", "employee_id", "manager_name"}

• Input: 12345 (an employee ID)

• Finds: An Employee entity where employee_id = 12345

• Returns: The manager_name attribute from that employee (e.g., Jane Smith)

Example 2: Get department from email with a default value

{[email protected] | FROM_ENTITY_ATTRIBUTE, "OktaUser", "email", "department", "Unknown"}

• Input: [email protected]

• Finds: An OktaUser entity where email = [email protected]

• Returns: The department attribute, or Unknown if no user is found

Example 3: Chain with other transformers

{$workday.employee_id | FROM_ENTITY_ATTRIBUTE, "Employee", "id", "cost_center" | UPPERCASE}

• Takes the employee ID from Workday

• Looks up the employee's cost center

• Converts the result to uppercase

Example 4: Get entity's graph ID

{john.smith | FROM_ENTITY_ATTRIBUTE, "OktaUser", "login", "id"}

• Looks up an OktaUser by login

• Returns the entity's unique graph ID (useful for subsequent lookups)

FROM_MANY_ENTITIES_ATTRIBUTE

FROM_MANY_ENTITIES_ATTRIBUTE

Looks up multiple entities in the Veza graph by matching an attribute value, then returns a specified attribute from all matching entities as a combined string. Use this when an input value may match multiple entities and you need all their values.

Parameter Format

Parameter	Type	Required	Description
EntityType	STRING	Yes	The type of graph entity to search (e.g., Employee, OktaUser)
SourceAttribute	STRING	Yes	The attribute on entities to match against the input value
TargetAttribute	STRING	Yes	The attribute to return from all matched entities. Use id or type for built-in entity properties.
Separator	STRING	No	Character(s) to join multiple results (defaults to ,)

How It Works

1. The input value (before the |) is used as the search term

2. The transformer finds ALL entities of type EntityType where SourceAttribute equals the input value

3. It collects the TargetAttribute value from each matched entity

4. Results are joined using the separator (comma by default)

5. If no entities are found, returns an empty string

Special Behaviors

Scenario	Behavior
Empty input value	Returns empty string "" (no error)
Input wrapped in brackets [value]	Brackets are automatically stripped before lookup
No entities found	Returns empty string "" (no error)
Target attribute missing on some entities	Those entities are skipped (no error logged)
TargetAttribute is id	Returns the entity's unique graph ID
TargetAttribute is type	Returns the entity's type name
Result ordering	Results appear in graph discovery order (not guaranteed to be consistent)

Unlike FROM_ENTITY_ATTRIBUTE, this transformer does not error when entities are missing the target attribute—it silently skips them. Verify your results include all expected values.

Usage Examples

Example 1: Get all group names for a user

{[email protected] | FROM_MANY_ENTITIES_ATTRIBUTE, "OktaGroup", "member_email", "name"}

• Input: [email protected]

• Finds: All OktaGroup entities where member_email = [email protected]

• Returns: Engineering,Sales,All-Employees (comma-separated group names)

Example 2: Custom separator for multi-value attributes

{12345 | FROM_MANY_ENTITIES_ATTRIBUTE, "Application", "owner_id", "app_name", ";"}

• Input: 12345 (an owner ID)

• Finds: All Application entities owned by this user

• Returns: Slack;Salesforce;Jira (semicolon-separated)

Example 3: Get all entity IDs

{Engineering | FROM_MANY_ENTITIES_ATTRIBUTE, "Employee", "department", "id"}

• Finds all employees in the Engineering department

• Returns their graph IDs as a comma-separated list

Example 4: Get entity types

{[email protected] | FROM_MANY_ENTITIES_ATTRIBUTE, "Identity", "email", "type"}

• Looks up all identity nodes with the given email

• Returns their type names (e.g., OktaUser,ActiveDirectoryUser,WorkdayWorker)

LANGUAGE_RFC5646

LANGUAGE_RFC5646

Transforms language to RFC 5646 format.

RFC 5646 defines "Tags for Identifying Languages." It does not contain a fixed, exhaustive list of language codes within the RFC itself. Instead, it specifies the structure and rules for constructing language tags, which are then built using codes from various external standards and registries.

Parameter Format

None (no parameters required)

Usage Example

Input:

{"Spanish" | LANGUAGE_RFC5646}

Output:

es

LAST_N

LAST_N

Picks the last N characters of a string, where N is the number of characters to return.

Parameter Format

Length (NUMBER, required)

Usage Example

Input:

{"helloworld" | LAST_N, 5}

Output:

world

LEFT_PAD

LEFT_PAD

Adds padding characters to the left side of a string until it reaches the specified length. Useful for creating fixed-width identifiers.

Parameter Format

Length (NUMBER, required): Target string length Pad (CHARACTER, optional): Character to use for padding (default is space)

Basic Usage

• Destination Attribute: employee_id

• Formatter: {id}

• Pipeline Functions: | LEFT_PAD, 5, "0"

• Result: If id = 123, output is 00123

In a Pipeline

• Destination Attribute: formatted_code

• Formatter: {cost_center}

• Pipeline Functions: | TRIM_CHARS, "0" | LEFT_PAD, 6, "0"

• Result: If cost_center = 001234, output is 001234 (first removes then re-applies padding)

Example

• Destination Attribute: employee_id

• Formatter: {employee_id}

• Pipeline Functions: | REMOVE_CHARS, "#" | TRIM_CHARS, "0" | LEFT_PAD, 6, "0"

• Use case: Standardize employee IDs to 6-digit format (converts "##001234##" to "001234")

LOOKUP

LOOKUP

Transforms a value using a lookup table defined in your Lifecycle Management policy. Essential for mapping codes to descriptive values or standardizing data across systems.

Parameter Format

Parameter	Type	Required	Description
TableName	STRING	Yes	Name or ID of the lookup table
ColumnName	STRING	Yes	Column to search for the input value
ReturnColumnName	STRING	Yes	Column whose value to return
DefaultValue	STRING	No	Value to return if lookup fails

How It Works

1. The transformer first tries to match TableName against configured lookup table names

2. If no name match is found, TableName is treated as a table ID

3. The input value is searched in ColumnName

4. If found, the corresponding ReturnColumnName value is returned

5. If not found and DefaultValue is provided, the default is returned

6. If not found and no default, an error is returned

Table name matching is case-sensitive. Ensure the table name in your transformer exactly matches the lookup table name defined in your policy, including capitalization.

Special Behaviors

Scenario	Behavior
Table name not found	Falls back to treating the parameter as a table ID
Value not found in table, default provided	Returns the default value
Value not found in table, no default	Returns error with lookup details
Other lookup errors	Returns error with full context

Basic Usage

• Destination Attribute: city

• Formatter: {location_code}

• Pipeline Functions: | LOOKUP, "locationTable", "location_code", "city"

• Result: If location_code = IL001 and locationTable contains that code, output is Chicago

With Default Value

• Destination Attribute: region

• Formatter: {office_code}

• Pipeline Functions: | LOOKUP, "regionTable", "code", "region_name", "Unknown Region"

• Result: Returns mapped region name, or Unknown Region if code not in table

In a Pipeline

• Destination Attribute: office_email_domain

• Formatter: {office_code}

• Pipeline Functions: | LOOKUP, "officeTable", "code", "domain" | LOWER

• Result: Looks up domain from table, then converts to lowercase

Example

• Destination Attribute: office_location

• Formatter: {location}

• Pipeline Functions: | LOOKUP, "locationTable", "location_code", "city"

• Use case: Convert abbreviated location codes (like "IL001", "CA002") to full city names for user profiles, maintaining consistency across different source systems

LOWER

LOWER

Transforms all uppercase characters in a string to lowercase. One of the most commonly used transformers for normalizing usernames and email addresses.

Parameter Format

None (no parameters required)

Basic Usage

• Destination Attribute: username

• Formatter: {first_name}

• Pipeline Functions: | LOWER

• Result: If first_name = JOHN, output is john

In a Pipeline

• Destination Attribute: email

• Formatter: {first_name}.{last_name}@company.com

• Pipeline Functions: | LOWER

• Result: If first_name = John, last_name = Smith, output is [email protected]

Example

• Destination Attribute: login

• Formatter: {first_name}

• Pipeline Functions: | SUB_STRING, 0, 1 | LOWER

• Use case: Create standardized Okta login names in format "j.smith" by extracting first initial and converting to lowercase

LOWER_SNAKE_CASE

LOWER_SNAKE_CASE

Transforms string to lowercase with underscores.

Parameter Format

None (no parameters required)

Usage Example

Input:

{"Hello World" | LOWER_SNAKE_CASE}

Output:

hello_world

LOWER_CAMEL_CASE

LOWER_CAMEL_CASE

Transforms a string to lower camel case (also known as dromedaryCase). The first word is lowercase, and subsequent words are capitalized with no separators.

Parameter Format

None (no parameters required)

Basic Usage

• Destination Attribute: identifier

• Formatter: {field_name}

• Pipeline Functions: | LOWER_CAMEL_CASE

• Result: If field_name = hello world, output is helloWorld

In a Pipeline

• Destination Attribute: api_field

• Formatter: {attribute_name}

• Pipeline Functions: | TRIM | LOWER_CAMEL_CASE

• Result: If attribute_name = User Display Name , output is userDisplayName

Example

• Destination Attribute: json_property

• Formatter: {column_name}

• Pipeline Functions: | LOWER_CAMEL_CASE

• Use case: Convert database column names or display names to JSON property names following JavaScript/TypeScript conventions

NEXT_NUMBER

NEXT_NUMBER

Generates a set of alternative values by appending sequential numbers. Essential for handling unique constraint conflicts during user provisioning. Returns an empty string first, then "2", "3", "4", etc.

Parameter Format

Start Integer (NUMBER, required): First number in sequence Length (NUMBER, required): How many alternatives to generate

Basic Usage

• Destination Attribute: username

• Formatter: {first_name}.{last_name}

• Pipeline Functions: | LOWER | NEXT_NUMBER, 2, 3

• Result: Generates john.smith, john.smith2, john.smith3, john.smith4 as fallback options

In a Pipeline

• Destination Attribute: email

• Formatter: {first_name}{last_name}

• Pipeline Functions: | LOWER | NEXT_NUMBER, 2, 5 | APPEND, "@company.com"

• Result: Creates email alternatives: [email protected], [email protected], etc.

Example

• Destination Attribute: user_principal_name

• Formatter: (see conditional example below)

• Pipeline Functions: N/A (used within IF statement)

• Use case: Intelligent username generation with length-based fallbacks:

IF sys_attr__would_be_value_len le 20
  {first_name | LOWER}.{last_name | LOWER | NEXT_NUMBER, 2, 3}
ELSE IF sys_attr__would_be_value_len le 30
  {first_name | LOWER}.{last_name | LOWER | FIRST_N, 1 | NEXT_NUMBER, 2, 3}
ELSE
  {first_name | LOWER | FIRST_N, 1}.{last_name | LOWER | FIRST_N, 1 | NEXT_NUMBER, 2, 3}

This handles both name length constraints and uniqueness conflicts automatically.

NEXT_NUMBER Max Length

NEXT_NUMBER Max Length

This transformer supports an optional maximum length parameter to simplify complex username generation workflows. It automatically evaluates combined strings (such as {first_name}_{last_name}) and truncates to specified character limits before appending numerical suffixes.

Generates a set of integers as strings.

Parameter Format

Integer (NUMBER, required), Length (NUMBER, required)

Usage Example

Input:

{"foobar" | NEXT_NUMBER, 1, 12, 4}

Output:

foob foo1 foo2 foo3 foo4 foo5 foo6 foo7 foo8 foo9 fo10 fo11 fo12

NOW

NOW

Returns the current time in UTC. An optional argument indicates the outgoing time format; by default, the RFC3339 format.

Parameter Format

String (Optional) - Format

Usage Example

Input:

{NOW}

{| NOW, "RFC3339"}

{NOW, "RFC3339"}

{NOW, "2006-01-02T15:04:05Z07:00"}

PHONE_NUMBER_E164

PHONE_NUMBER_E164

Transforms a phone number into the E.164 format.

E. 164 numbers are formatted [+] [country code] [subscriber number including area code] and can have a maximum of fifteen digits. Parameter Format

Region (STRING, optional): ISO 3166-1 alpha-2 format

Usage Example

Input:

{"[phone]" | PHONE_NUMBER_E164}

Output:

[phone]

PREPEND

PREPEND

Adds text to the beginning of attribute values. Useful for adding prefixes like organization codes or type indicators.

Parameter Format

Characters (STRING, required): Text to add at the beginning

Basic Usage

• Destination Attribute: location_code

• Formatter: {city_code}

• Pipeline Functions: | PREPEND, "CORP_"

• Result: If city_code = NYC, output is CORP_NYC

In a Pipeline

• Destination Attribute: contractor_username

• Formatter: {username}

• Pipeline Functions: | PREPEND, "c-" | LOWER

• Result: If username = JSmith, output is c-jsmith

Example

• Destination Attribute: account_name

• Formatter: {username}

• Pipeline Functions: | PREPEND, "c-"

• Use case: Identify contractor accounts by prefixing their usernames (converts "jsmith" to "c-jsmith" to distinguish from employee accounts)

RANDOM_ALPHANUMERIC_GENERATOR

RANDOM_ALPHANUMERIC_GENERATOR

Generates a random alphanumeric string.

Parameter Format

Length (NUMBER, required)

Usage Example

Input:

{| RANDOM_ALPHANUMERIC_GENERATOR, 8}

Output:

a1B2c3D4

Note: This transformer generates an alphanumeric string with eight characters.

RANDOM_INTEGER

RANDOM_INTEGER

Generates a random integer value between specified minimum and maximum values (inclusive). Useful for creating unique test IDs or temporary identifiers. Does not require an input value.

Parameter Format

Min (NUMBER, required): The minimum value (inclusive) Max (NUMBER, required): The maximum value (inclusive)

Basic Usage

• Destination Attribute: test_id

• Formatter: TEST

• Pipeline Functions: | RANDOM_INTEGER, 1000, 9999

• Result: Output is TEST followed by random number like TEST4827

In a Pipeline

• Destination Attribute: temp_username

• Formatter: user

• Pipeline Functions: | RANDOM_INTEGER, 1, 100 | APPEND, "@temp.local"

• Result: Output like [email protected]

Example

• Destination Attribute: temporary_id

• Formatter: TEST

• Pipeline Functions: | RANDOM_INTEGER, 1000, 9999

• Use case: Generate unique test identifiers for sandbox environments (produces values like "TEST4827", "TEST8391")

RANDOM_NUMBER_GENERATOR

RANDOM_NUMBER_GENERATOR

Generates a random number string.

Parameter Format

Length (NUMBER, required)

Usage Example

Input:

{| RANDOM_NUMBER_GENERATOR, 4}

Output:

4829

Note: This transformer generates a random numeric string with four characters.

RANDOM_STRING_GENERATOR

RANDOM_STRING_GENERATOR

Generates a random string.

Parameter Format

Length (NUMBER, required)

Usage Example

Input:

{| RANDOM_STRING_GENERATOR, 6}

Output:

uFkLxw

Note: This transformer generates a random alpha string with six characters.

REMOVE_CHARS

REMOVE_CHARS

Removes all instances of specified characters from a string. Useful for cleaning up data and removing unwanted punctuation or special characters.

Parameter Format

Characters (STRING, required): String containing all characters to be removed

Basic Usage

• Destination Attribute: username

• Formatter: {email}

• Pipeline Functions: | REMOVE_CHARS, "@."

• Result: If email = [email protected], output is johndoeexamplecom

In a Pipeline

• Destination Attribute: phone

• Formatter: {phone_number}

• Pipeline Functions: | REMOVE_CHARS, "()- "

• Result: If phone_number = [phone], output is 1234567890

Example

• Destination Attribute: user_id

• Formatter: {email}

• Pipeline Functions: | REMOVE_CHARS, "-"

• Use case: Create clean user IDs from email addresses by removing hyphens (converts "[email protected]" to "[email protected]")

REMOVE_DIACRITICS

REMOVE_DIACRITICS

Removes diacritics (accents, etc.) from input string.

Parameter Format

None (no parameters required)

Usage Example

Input:

{"José" | REMOVE_DIACRITICS}

Output:

Jose

REMOVE_DOMAIN

REMOVE_DOMAIN

Removes the domain portion from an email address, leaving only the username. One of the most frequently used transformers for generating usernames from email addresses.

Parameter Format

None (no parameters required)

Basic Usage

• Destination Attribute: username

• Formatter: {email}

• Pipeline Functions: | REMOVE_DOMAIN

• Result: If email = [email protected], output is john.smith

In a Pipeline

• Destination Attribute: login_name

• Formatter: {email}

• Pipeline Functions: | REMOVE_DOMAIN | REPLACE_ALL, ".", "_"

• Result: If email = [email protected], output is john_smith

Example

• Destination Attribute: username

• Formatter: {email}

• Pipeline Functions: | REMOVE_DOMAIN

• Use case: Extract usernames for target systems that don't use email-style logins (converts "[email protected]" to "jsmith")

REMOVE_WHITESPACE

REMOVE_WHITESPACE

Removes all whitespace characters (spaces, tabs, newlines) from a string. Useful for creating compact identifiers and ensuring data consistency.

Parameter Format

None (no parameters required)

Basic Usage

• Destination Attribute: username

• Formatter: {display_name}

• Pipeline Functions: | REMOVE_WHITESPACE

• Result: If display_name = John A. Doe, output is JohnA.Doe

In a Pipeline

• Destination Attribute: tag

• Formatter: {department}

• Pipeline Functions: | REMOVE_WHITESPACE | LOWER

• Result: If department = Human Resources, output is humanresources

Example

• Destination Attribute: cost_center_code

• Formatter: {cost_center}

• Pipeline Functions: | REMOVE_WHITESPACE

• Use case: Ensure cost center codes have no embedded spaces for system integration (converts "CC 12345" to "CC12345")

REPLACE_ALL

REPLACE_ALL

Replaces all instances of one string with another. Essential for character substitution and format standardization.

Parameter Format

Original (STRING, required): String to find New (STRING, required): String to replace with

Basic Usage

• Destination Attribute: username

• Formatter: {display_name}

• Pipeline Functions: | REPLACE_ALL, " ", "_"

• Result: If display_name = John Smith, output is John_Smith

In a Pipeline

• Destination Attribute: identifier

• Formatter: {employee_id}

• Pipeline Functions: | REPLACE_ALL, "-", "" | TRIM

• Result: If employee_id = EMP-12345, output is EMP12345

Example

• Destination Attribute: email

• Formatter: {email}

• Pipeline Functions: | REPLACE_ALL, " ", "."

• Use case: Fix malformed email addresses with spaces (converts "john [email protected]" to "[email protected]")

RIGHT_PAD

RIGHT_PAD

Right pads a string with a character.

Parameter Format

Length (NUMBER, required),

Pad (CHARACTER, optional): Default is space

Usage Example

Input:

{"123" | RIGHT_PAD, 5, "0"}

Output:

12300

SENTENCE_CASE

SENTENCE_CASE

Capitalizes only the first non-whitespace character of a string and lowercases the rest. Preserves any leading whitespace. Useful for standardizing sentence-formatted text fields.

Parameter Format

None (no parameters required)

Basic Usage

• Destination Attribute: description

• Formatter: {notes}

• Pipeline Functions: | SENTENCE_CASE

• Result: If notes = THE QUICK BROWN FOX, output is The quick brown fox

In a Pipeline

• Destination Attribute: formatted_notes

• Formatter: {comment}

• Pipeline Functions: | TRIM | SENTENCE_CASE

• Result: If comment = IMPORTANT MESSAGE HERE , output is Important message here

Example

• Destination Attribute: job_description

• Formatter: {job_title}

• Pipeline Functions: | SENTENCE_CASE

• Use case: Normalize job descriptions from all-caps source data to sentence case for cleaner display

SPLIT

SPLIT

Splits a string and returns the string at the given index.

Parameter Format

Split String (STRING, required), Index (NUMBER, required)

Usage Example

Input:

{"[email protected]" | SPLIT, "@", 0}

Output:

first.last

Note: This transformer returns the results where the index starts at zero (0).

SUB_STRING

SUB_STRING

Extracts a substring from the original value starting at a specific position. Commonly used for creating initials or extracting portions of identifiers.

Parameter Format

Offset (NUMBER, required): Starting position (0-based index) Length (NUMBER, required): Number of characters to extract

Basic Usage

• Destination Attribute: initial

• Formatter: {first_name}

• Pipeline Functions: | SUB_STRING, 0, 1

• Result: If first_name = John, output is J

In a Pipeline

• Destination Attribute: short_id

• Formatter: {employee_id}

• Pipeline Functions: | SUB_STRING, 3, 4 | UPPER

• Result: If employee_id = EMP12345, output is 1234

Example

• Destination Attribute: username

• Formatter: {first_name}

• Pipeline Functions: | SUB_STRING, 0, 1 | LOWER

• Use case: Generate usernames like "j.smith" by extracting first initial and combining with last name

TITLE_CASE

TITLE_CASE

Capitalizes the first letter of each word and lowercases the rest. Also handles dot-separated values by capitalizing the first letter of each segment. Useful for formatting names and titles.

Parameter Format

None (no parameters required)

Basic Usage

• Destination Attribute: display_name

• Formatter: {full_name}

• Pipeline Functions: | TITLE_CASE

• Result: If full_name = john doe, output is John Doe

In a Pipeline

• Destination Attribute: formatted_name

• Formatter: {name}

• Pipeline Functions: | TRIM | TITLE_CASE

• Result: If name = JANE SMITH , output is Jane Smith

Example

• Destination Attribute: display_name

• Formatter: {username}

• Pipeline Functions: | TITLE_CASE

• Use case: Format dot-separated usernames for display (converts "john.doe" to "John.Doe")

TRIM

TRIM

Removes leading and trailing whitespace from a string. Essential for cleaning up data from external systems.

Parameter Format

None (no parameters required)

Basic Usage

• Destination Attribute: username

• Formatter: {display_name}

• Pipeline Functions: | TRIM

• Result: If display_name = " John Doe ", output is John Doe

In a Pipeline

• Destination Attribute: email

• Formatter: {email_address}

• Pipeline Functions: | TRIM | LOWER

• Result: If email_address = " [email protected] ", output is [email protected]

Example

• Destination Attribute: display_name

• Formatter: {display_name}

• Pipeline Functions: | TRIM

• Use case: Clean up imported user data that may have padding whitespace from CSV files or database fields

TRIM_CHARS

TRIM_CHARS

Removes all specified characters from both the beginning and end of a string. Useful for removing padding characters or cleaning up formatted data.

Parameter Format

Characters (STRING, required): String containing all characters to remove from both ends

Basic Usage

• Destination Attribute: employee_id

• Formatter: {id_number}

• Pipeline Functions: | TRIM_CHARS, "0."

• Result: If id_number = 000.123.000, output is 123

In a Pipeline

• Destination Attribute: clean_code

• Formatter: {code}

• Pipeline Functions: | TRIM_CHARS, "-_" | UPPER

• Result: If code = ---ABC123___, output is ABC123

Example

• Destination Attribute: office_code

• Formatter: {office_code}

• Pipeline Functions: | TRIM_CHARS, ".0" | TRIM_CHARS_RIGHT, ".USCA"

• Use case: Clean up office codes with variable padding (converts "000.8675309.USCA" to "8675309")

TRIM_CHARS_LEFT

TRIM_CHARS_LEFT

Removes all specified characters from the beginning of a string only. Useful for removing leading zeros or prefixes.

Parameter Format

Characters (STRING, required): String containing all characters to remove from the beginning

Basic Usage

• Destination Attribute: cost_center

• Formatter: {cost_center_code}

• Pipeline Functions: | TRIM_CHARS_LEFT, "0"

• Result: If cost_center_code = 00012345, output is 12345

In a Pipeline

• Destination Attribute: identifier

• Formatter: {raw_id}

• Pipeline Functions: | TRIM_CHARS_LEFT, "x" | UPPER

• Result: If raw_id = xxxABC123, output is ABC123

Example

• Destination Attribute: cost_center

• Formatter: {cost_center}

• Pipeline Functions: | TRIM_CHARS_LEFT, "0"

• Use case: Remove leading zeros from cost center codes while preserving trailing zeros (converts "00012345" to "12345")

TRIM_CHARS_RIGHT

TRIM_CHARS_RIGHT

Removes all specified characters from the end of a string only. Useful for removing trailing characters or suffixes.

Parameter Format

Characters (STRING, required): String containing all characters to remove from the end

Basic Usage

• Destination Attribute: office_code

• Formatter: {raw_office_code}

• Pipeline Functions: | TRIM_CHARS_RIGHT, "0"

• Result: If raw_office_code = ABC12300, output is ABC123

In a Pipeline

• Destination Attribute: clean_code

• Formatter: {code}

• Pipeline Functions: | TRIM_CHARS_RIGHT, "temp" | UPPER

• Result: If code = ABC123temp, output is ABC123

Example

• Destination Attribute: office_code

• Formatter: {office_code}

• Pipeline Functions: | TRIM_CHARS_RIGHT, "0"

• Use case: Remove trailing zeros from office codes while preserving leading zeros (converts "ABC12300" to "ABC123")

UPPER

UPPER

Transforms all lowercase characters in a string to uppercase. Commonly used for standardizing identifiers and codes.

Parameter Format

None (no parameters required)

Basic Usage

• Destination Attribute: department_code

• Formatter: {department}

• Pipeline Functions: | UPPER

• Result: If department = sales, output is SALES

In a Pipeline

• Destination Attribute: user_id

• Formatter: {username}

• Pipeline Functions: | REMOVE_WHITESPACE | UPPER

• Result: If username = john smith, output is JOHNSMITH

Example

• Destination Attribute: last_name_normalized

• Formatter: {name}

• Pipeline Functions: | UPPER

• Use case: Standardize employee last names for matching across systems (converts "Smith" to "SMITH")

UPPER_CAMEL_CASE

UPPER_CAMEL_CASE

Transforms a string to upper camel case.

Parameter Format

None (no parameters required)

Usage Example

Input:

{"hello world" | UPPER_CAMEL_CASE}

Output:

HelloWorld

UPPER_SNAKE_CASE

UPPER_SNAKE_CASE

Transforms string to uppercase with underscores.

Parameter Format

None (no parameters required)

Usage Example

Input:

{"hello world" | UPPER_SNAKE_CASE}

Output:

HELLO_WORLD

UTC_TO_TIME_ZONE

UTC_TO_TIME_ZONE

Interprets the incoming time string as if it were in UTC and then converts it to the specified time zone. (example: if the input is "1/2/2025 11pm" and the specified time zone is America/Los_Angeles the function will treat "1/2/2025 11pm" as the UTC time zone and output the corresponding America/Los_Angeles time "1/2/2025 3pm") Note: When using the time zone parameter, a named time zone (America/Los_Angeles) accounts for daylight saving time, whereas a time zone offset (-07:00) is always calculated from UTC, ignoring daylight saving time.

Parameter Format

String - Time Zone String (Optional) - Format

Usage Example

Input:

{activation_date | UTC_TO_TIME_ZONE, "America/Los_Angeles"}

{activation_date | UTC_TO_TIME_ZONE, "America/Los_Angeles", "RFC3339"}

{activation_date | UTC_TO_TIME_ZONE, "-07:00"}

{activation_date | UTC_TO_TIME_ZONE, "-07:00", "RFC3339"}

UUID_GENERATOR

UUID_GENERATOR

Generates a UUID.

A UUID (Universally Unique Identifier) is a 128-bit identifier used to uniquely identify information in computer systems.

Parameter Format

None (no parameters required)

Usage Example

Input:

{| UUID_GENERATOR}

Output:

123e4567-e89b-12d3-a456-426614174000

ZERO_PAD

ZERO_PAD

Adds left zero-padding to numerical string values until they reach the specified length. If the input is non-numeric, it passes through unchanged. If the numeric value is already longer than the specified length, it remains unchanged.

Parameter Format

Length (NUMBER, required): Target string length for zero-padding

Basic Usage

• Destination Attribute: employee_id

• Formatter: {id}

• Pipeline Functions: | ZERO_PAD, 6

• Result: If id = 1234, output is 001234

Example

• Destination Attribute: badge_number

• Formatter: {badge_id}

• Pipeline Functions: | ZERO_PAD, 6

• Use case: Standardize badge numbers to 6-digit format for access control systems (converts "1234" to "001234", leaves "12345678" unchanged, and passes non-numeric values like "admin" through unchanged)