Value Composer

The Value Composer is the per-field configuration inside a Data Sync. For every field in the target Data Storage, it defines how that field’s value gets produced from the incoming feed record. A Data Sync does two things: it maps the integration’s channels and translations onto your project’s scopes and locales, and it holds the Value Composer configuration that defines what every field of the target record becomes. This page covers the second part.

Value Composer runs at sync time — it produces the values that land in a storage record. To include a value from another storage without syncing it in, see Mapped fields — they resolve as the response is built, so the value appears alongside the stored fields.

Buddy can read, create, debug, and manage Value Composer configurations for you. Describe the source shape and the target shape, and Buddy will build a working configuration — often faster than setting it up by hand. You can always refine the result in the UI afterward.

Four slot modes

Each field in the storage mapping is a slot. Every slot operates in one of four modes:

Mode	What it does	When to use it
Schema Field	Maps a field directly from the feed record	Straight field renames, 1:1 mappings
Computed Value	Builds the value through a chain of operations	Reshaping, conditional logic, combining, transforming
Static Value	Sets a fixed value that never changes	Flags, defaults, brand-wide constants
Keep Empty	Leaves the field untouched during sync	Fields you don’t want to populate yet

Schema Field and Static are straightforward — pick a source field or enter a constant. Computed Value is where the Value Composer becomes interesting: a declarative language of chainable operations that take feed fields, static inputs, and the output of other operations as arguments.

Compose Value dropdown showing four slot modes: Schema Field, Computed Value, Static Value, Keep Empty

Operations

Computed Value mode gives you access to a wide range of operations across categories like logic, comparison, text, math, array, object, and transform. Operations are type-aware — the UI only shows operations compatible with the slot’s expected output type, so you don’t have to memorize what’s available. See the Value Composer reference for the full catalogue with arguments and return types.

Working with slots

Every slot in the composer can be switched between the four modes. When you select Computed Value, a dialog opens where you build the operation chain visually.

Compose Value dialog showing an IF operation with condition, then, and else slots configured

Copy, paste, and wrap

Slots support clipboard operations that speed up repetitive work:

Copy a slot’s configuration to reuse it on another field
Paste a copied configuration into a different slot — the UI checks type compatibility before allowing it
Wrap an existing slot inside a new operation. For example, wrap a Schema Field in an if to make it conditional, or wrap a concat result in tolower to normalize it. The UI shows which operations are compatible wrappers for the current slot type.

Iteration context

When working inside an array mapping (e.g. transforming an array of images into an array of MediaFile composites), the Value Composer provides special variables:

$item — the current element in the array being iterated
$parent — access the parent iteration context when nesting arrays inside arrays

For example, if each image has a list of size variants, use $item.url for the current variant and $parent.alt for the parent image’s alt text.

Auto-complete from feed schema

When selecting a Schema Field, the UI auto-completes from the feed schema. If a field doesn’t appear in auto-complete, either the schema hasn’t been inferred yet (no records have arrived) or the field needs to be added manually in the feed’s Schema tab. You can also create new feed schema fields directly from the composer UI.

Debug configurations

The Value Composer has a built-in debugger that runs your configuration against a JSON payload. Load an initial payload from a feed record with Search Record, paste your own, or edit the current one at any time — the payload persists between runs and is fully yours to manipulate. It’s not connected to the live record, so changes you make stay until you load a different one. The payload is shared across both debugger levels.

Field-level debugger

Open the debugger from the Compose Value dialog to test a single field’s configuration in isolation:

Node-wise output — see what each operation in the chain produces before it feeds into the next
Live updates — results refresh as you modify the configuration

Record-level debugger

Test all field configurations at once across the entire storage mapping:

Runs every slot’s configuration against the selected record
Shows the complete output for each storage field
Highlights fields with errors so you can spot broken configurations without checking each one individually

Use the field-level debugger while building individual compositions, and the record-level debugger as a final check before activating the sync.

Worked examples

The examples below use a sample product record. Each covers a pattern that shows up in most Data Syncs.

Disclaimer — Apple, iPhone, and iPhone Pro are trademarks of Apple Inc. Used for illustrative purposes only.

Show Sample record payload

{
  "name": "iPhone Pro",
  "description": "The Apple iPhone Pro is a high-end smartphone with a 6.7-inch display, 128GB of storage, and a 12MP camera.",
  "price": 999.99,
  "currency": "USD",
  "inStock": true,
  "stock": 15,
  "colors": ["Graphite", "Silver", "Gold", "Sierra Blue"],
  "storage_options": [128, 256, 512, 1024],
  "specs": {
    "screen_size": "6.7 inches",
    "resolution": "2778 x 1284",
    "processor": "A15 Bionic",
    "ram": "6GB",
    "battery": "4352 mAh"
  },
  "vendor": {
    "name": "Apple",
    "website": "https://www.apple.com",
    "support_phone": "1-800-MY-APPLE",
    "headquarters": "Cupertino, CA"
  },
  "images": [
    {
      "path": "/images/iphone-pro-front.jpg",
      "mimeType": "image/jpeg",
      "alt": "iPhone Pro front view",
      "key": "550e8400-e29b-41d4-a716-446655440000"
    },
    {
      "path": "/images/iphone-pro-back.jpg",
      "mimeType": "image/jpeg",
      "alt": "iPhone Pro back view",
      "key": "550e8400-e29b-41d4-a716-446655440001"
    }
  ],
  "properties": [
    { "id": "color", "value": "#2F4F4F", "label": "Graphite" },
    { "id": "material", "value": "Stainless Steel", "label": "Stainless Steel" },
    { "id": "weight", "value": "238g", "label": "238 grams" }
  ]
}

Example 1: Concatenate values

Combine vendor.name and name into a single label field — producing “Apple - iPhone Pro”.

Switch the slot to Computed Value

Click the mode toggle on the label slot and select Computed Value.

Add the concat operation

In the Compose Value dialog, search for concat and select it. You’ll see three input slots: the two values to join and a separator.

Map the input slots

Set the first slot to Schema Field → vendor.name, the separator to Static Value → -, and the second slot to Schema Field → name.

Test with the debugger

Open the debugger to see the node-wise output. With the sample record, the result is Apple - iPhone Pro.

Example 2: Conditional logic

Set an availability field to “In Stock” or “Low Stock” based on the stock value.

Add an if operation

Switch the slot to Computed Value and add the if operation. It takes three slots: condition, then, else.

Build the condition

Set the condition slot to Computed Value and add greaterthan. Map its value slot to Schema Field → stock and its compare slot to Static Value → 10.

Set the return values

Set the then slot to Static Value → In Stock and the else slot to Static Value → Low Stock.

Test it

Open the debugger. With stock: 15, the result is “In Stock”. Edit the payload to stock: 5 and the result flips to “Low Stock”.

Example 3: Array transformation

Transform an array of source images into an array of MediaFile composites with description, type, and url fields.

Set the reference array

The images storage field expects an array. Set the reference array to Schema Field → images — this is what the composer iterates over.

Map fields using $item

Inside the iteration, each sub-field maps from the current element:

description → Schema Field → $item.alt
type → Schema Field → $item.mimeType
url → Computed Value → concat with Static Value https://cdn.demo-shop.com/images/, separator Schema Field → $item.key, and second value Static Value → /gallery.jpg

Test the output

The debugger shows each source image transformed into a MediaFile with a full CDN URL built from the image key.

Example 4: Extract from a nested array

A common pattern in commerce data: product properties sit in an array, but you need a specific property as a flat field. Here, extract the color hex value from the properties array to fill a colorHex storage field.

Add findfirst to locate the property

Switch the slot to Computed Value and add findfirst. Set its array slot to Schema Field → properties. The filter function needs to match items where id equals color.

Build the filter condition

Inside the filter function, add an equals operation. Set the value slot to Schema Field → $item.id and the compare slot to Static Value → color.

Extract the value

Wrap the findfirst result in a get operation to pick the value field from the matched property. The output is #2F4F4F — the hex color, ready to render as a swatch.

Tips

Start with Schema Field, upgrade when needed. Most fields start as direct mappings. Switch to Computed Value when you discover the simpler mode can’t express what you need.
Use the debugger early and often. The field-level debugger shows node-wise output, so you can pinpoint exactly which operation in the chain produces the wrong result.
Use wrap to extend existing configurations. Need to lowercase a mapped field? Don’t rebuild — wrap the existing Schema Field slot in a tolower operation.
Edit the payload when real data hasn’t arrived yet. Craft a test input that exercises the edge cases you care about without waiting for production data.
Cast types when they don’t match. Source data often has numbers as strings (e.g. "123" instead of 123). Use toNumber, toBoolean, or toString to make sure the value matches the storage field type — a price field expects a number, not a string that looks like one.
Watch the feed schema. Fields you reference need to exist in the schema. If auto-complete isn’t finding a field, check the feed’s Schema tab or add it manually.
Let Buddy build the first draft. Describe the source shape and the target shape, and Buddy will propose a working configuration you can refine in the UI.

Data Storages

Storage schemas, field types, and how Data Syncs connect feeds to storages.

Ingest Data

Connectors and Data Feeds — where the source records come from.

Value Composer reference

Complete catalogue of every operation with arguments and return types.

Storage Field Types

The field types your storage supports and that composer outputs must match.

Essentials

Commerce Concepts

Data Integration

API Builder

Release Control

Build in Studio

Build in Your IDE

Context Base

Project Settings

Administration

Four slot modes

Operations