Transform Agent

Reshape JSON-like data without writing code.

What it does

Provides 16 pure data-transformation operations organised into four groups: field access and mapping, array manipulation, null and value safety, and serialisation. All operations run in-memory with no external calls, making them fast and safe to chain inside any workflow.

Capabilities

Field Access & Mapping

The most commonly used group. These operations read or write individual fields and remap entire object shapes — essential for translating between different API schemas.

Operation	Description
Get Value By Path	Read a single value from a nested object using dot/bracket notation.
Set Value By Path	Write a value into a specific path in an object, creating intermediate keys as needed.
Map Fields	Bulk-remap a source object to a target shape via a field-mapping table. The most-used Transform operation overall.
Extract Property	Pull one property from every item in an array and return a flat list (e.g. all SKUs from `line_items`).

Array Manipulation

Essential whenever you work with order line items, product lists, or fulfilment batches.

Operation	Description
Filter Array	Keep or exclude items whose property value matches a specified list.
Filter Non-Values	Strip nulls, empty strings, blanks, and zeros from an array in one step.
Ensure Array	Normalise input so the next step always receives an array: arrays pass through, null becomes `[]`, any other value is wrapped in `[value]`.
Sort Array	Sort items by a property path, ascending or descending.
Append	Add one item to the end of an array.
Flat Map	Extract nested arrays from each item by property path and flatten into a single array (e.g. variants inside products).
Array Length	Return the count of items in an array, characters in a string, or keys in an object. Useful for conditional branching.
Group By	Bucket array items by a property key, returning either a map or an array of groups.

Null & Value Safety

Defensive operations for handling missing or inconsistent data from external APIs.

Operation	Description
Coalesce	Return the first non-null value from a list of candidates.
Select First	Like Coalesce, but also skips `false`, `0`, and `""` — returns the first truthy value.

Serialisation

Operation	Description
From JSON String	Parse a raw JSON string into a structured value. Common after HTTP Agent responses or CSV cell values.
To JSON String	Serialise a value to a JSON string before storing or forwarding to a system that expects a string.

Most commonly used

For most integrations, these six operations cover the majority of transformation needs:

Map Fields — remapping between source and target schemas
Get Value By Path — extracting a single field from a response
Filter Array — keeping only relevant line items or records
Coalesce — providing fallback values for optional fields
From JSON String — parsing HTTP responses or embedded JSON
Group By — splitting records by location, status, or category

Typical patterns

Pattern A — Shopify order to 3PL payload

Translate a raw Shopify order into the shape expected by a third-party logistics API.

Shopify Agent (order trigger)
  → Transform: Ensure Array      (line_items — guards against single-item edge cases)
  → Transform: Filter Array      (keep only line items where fulfillment_service = "manual")
  → Transform: Map Fields        (Shopify schema → 3PL schema)
  → HTTP Agent                   (POST shipment to 3PL endpoint)

Pattern B — HTTP API response normalisation

Parse and clean up a raw JSON response before passing data downstream.

HTTP Agent                         (raw response body arrives as a string)
  → Transform: From JSON String
  → Transform: Get Value By Path   ("data.orders")
  → Transform: Filter Non-Values   (remove any null or blank entries)
  → Transform: Map Fields          (normalise to internal schema)

Pattern C — Multi-location fulfilment grouping

Split a list of orders by warehouse or fulfilment location and process each group separately.

Transform: Ensure Array            (orders — normalise input)
  → Transform: Group By            (fulfillment_location_id)
  → [Split]
  → HTTP Agent                     (POST each group to the relevant warehouse)

Pattern D — Null-safe field access

Provide a safe fallback when a field may exist in one of several locations within an object, or may be absent entirely.

Transform: Coalesce
  Values: [
    order.shipping_address.company,
    order.billing_address.company,
    "Unknown"
  ]

Setup notes

Paths use JSONPath-like dot notation with bracket support for arrays: order.line_items[0].sku
All operations are pure — no external calls, no side effects, safe to retry.
Use Ensure Array before any array operation when the input source may deliver a single object or null instead of an array.
Map Fields accepts a mapping table of source_path → target_path pairs; both sides support nested paths.
Coalesce vs Select First: by default, Coalesce only skips null; use Treat Empty Strings and Treat Zero As Null flags to extend that behaviour. Select First always skips null, "", 0, and false with no configuration needed.