Part 15: Workflow Patterns and Recipes - Data Transformation

As we conclude this 15-part series on Vyshyvanka, we want to leave you with practical tools. One of the most common challenges in workflow automation is not moving data, but transforming it. Today, we look at the patterns we use to map, clean, and reshape data as it flows through your pipelines.

The Transformation Challenge

In a real-world workflow, you rarely get the data exactly in the format you need. Service A might return a deeply nested JSON object, while Service B expects a flat structure with different field names. Vyshyvanka handles this through its expression engine and Code Node — giving you both declarative and programmatic transformation options.

Pattern 1: Path Projection with Expressions

When you have a large JSON response and only need specific values, use expressions in your node configuration to extract exactly what you need:

{{ nodes.api.data.items[0].user.id }}

This plucks a deeply nested ID from an API response and passes it as a clean input to your next node. You can use this directly in any node's configuration field.

For more complex extraction, combine with built-in functions:

{{ toUpper(nodes.api.data.items[0].user.name) }}

{{ concat(nodes.user.data.firstName, " ", nodes.user.data.lastName) }}

{{ coalesce(nodes.api.data.nickname, nodes.api.data.name, "Anonymous") }}

Pattern 2: Structural Remapping with Code Nodes

When you need to transform the entire shape of the data, the Code Node is your best tool. It supports two runtimes:

JavaScript (via Jint engine):

General-purpose JavaScript for complex transformations. You have access to:

• 
  input — the full input data from upstream nodes


• 
  executionId — current execution ID


• 
  workflowId — current workflow ID


• 
  log(message) — logging that appears in execution output


• 
  getItems() — returns input as an array (wraps single values)


• 
  toJson(value) — serializes a value to a JSON string
  

// Remap an API response to a different structure

log("Transforming user data: " + input.email);

return {

    email: input.email.toLowerCase(),

    fullName: input.firstName + " " + input.lastName,

    isVerified: input.status === "active",

    createdYear: new Date(input.createdAt).getFullYear()

};

JSONata:

A declarative query and transformation language, ideal for complex path selection and restructuring:

{

    "users": items.{

        "id": userId,

        "name": firstName & " " & lastName,

        "active": status = "active"

    },

    "total": $count(items)

}

JSONata shines when you need to reshape deeply nested structures without imperative loop code.

Pattern 3: Batch Processing with runForEachItem

Both JavaScript and JSONata support two execution modes:

• 
  runOnce: Executes your code against the full input object. Use this for single-item transformations or when you need access to the entire dataset.


• 
  runForEachItem: If your input is an array, the engine executes your logic for every item, collecting the results into a new array.
  

// Mode: runForEachItem

// 'input' here is a single item from the array

return {

    id: input.id,

    label: input.name.toUpperCase(),

    processed: true

};

This is the equivalent of a .map() operation, but managed by the engine with proper error handling and logging for each item.

Pattern 4: Conditional Routing with Logic Nodes

Not all transformation is about reshaping data — sometimes you need to route data differently based on its content. The Switch node evaluates a value and routes to different output ports:

• Configure the switch value: {{ nodes.api.data.status }}
  


• Define cases: "active" → port A, "suspended" → port B, default → port C

Each downstream branch can then apply its own transformation logic appropriate to that case.

The If node handles binary decisions:

• Condition: {{ nodes.check.data.amount }} > threshold


• True branch: process normally


• False branch: send alert

Pattern 5: Aggregation with Loop + Merge

For workflows that need to process a collection and then aggregate the results:

1. 
   Loop Node: Iterates over an array, executing a subgraph for each item.


2. 
   Subgraph nodes: Transform/enrich each item (API calls, lookups, etc.).


3. 
   Loop completion: The loop node collects all outputs from its "done" port.


4. 
   Merge Node: Combines data from multiple branches into a single object.

The loop node exposes per-iteration context:

{{ nodes.loop.data.index }}        // Current iteration index

{{ nodes.loop.data.item }}         // Current item

{{ nodes.loop.data.isFirst }}      // Boolean

{{ nodes.loop.data.isLast }}       // Boolean

{{ nodes.loop.data.totalCount }}   // Total items

Pattern 6: Data Enrichment Pipeline

A common pattern is fetching additional data for each item in a collection:

1. 
   HttpRequest → Get list of orders from API


2. 
   Loop → For each order:
   
   
   
   
   • 
     HttpRequest → Fetch customer details by {{ nodes.loop.data.item.customerId }}
     
   
   
   • 
     Code Node → Merge order + customer into enriched object
   
   
   
   


3. 
   DatabaseQuery → Store enriched results

Each step references the previous step's output through expressions, creating a data pipeline that transforms raw API responses into enriched, business-ready objects.

Best Practices

• 
  Keep transformations close to their consumer: Transform data in the node configuration or a Code Node immediately before the node that needs it.


• 
  Use expressions for simple extractions: {{ nodes.api.data.user.name }} is clearer than a Code Node for simple path access.


• 
  Use Code Nodes for complex logic: Multi-field remapping, conditional logic, and calculations belong in Code Nodes where they are testable and readable.


• 
  Prefer JSONata for pure data reshaping: When you are only restructuring JSON without side effects, JSONata expressions are more concise than JavaScript.


• 
  Use runForEachItem for array transformations: It handles iteration, error collection, and result aggregation automatically.

Wrapping Up the Series

We hope this series has shown you that Vyshyvanka is built for the real world — secure, extensible, and performant. We started with basic triggers and ended with complex data transformation patterns. The platform gives you the building blocks; how you combine them is up to your creativity.

The community is the final piece of the puzzle. Now it is your turn. Go build something, share your custom nodes, and let us know what you think.

Check out the project source code here: https://github.com/homolibere/Vyshyvanka