Data Mapping Engine
The Data Mapping Engine lets you define, validate, and deploy field-level transformations between source and target data schemas, turning raw integration data into the exact shape your downstream systems expect.
What it does
When you connect two systems in an integration, the source data rarely arrives in the format the target system needs. Field names differ, date formats vary, values need to be translated or combined, and some fields require calculation from others. The Data Mapping Engine gives you a structured way to express all of those transformations, compile them into an executable form, and deploy them so they run automatically every time data flows through your integration.
How mappings are built
You describe each field transformation as a rule that connects one or more source fields to a target field. Rules can express a range of transformation logic:
| Transformation type | What it does |
|---|---|
| Direct copy | Passes a source field value to the target unchanged |
| Constant | Writes a fixed value to a target field regardless of the source |
| Concatenation | Combines multiple source fields and literal text into one target value |
| String transforms | Converts case, adds a prefix or suffix, removes characters, replaces substrings |
| Date formatting | Converts a date from one format to another |
| Conditional logic | Writes different values to a target field depending on whether a condition is met |
| Coalesce | Uses the first non-empty value from a list of source fields |
| Value map lookup | Translates a source value through a crosswalk table to a target value |
| Multi-valued map lookup | Feeds a source key into a crosswalk table and returns a specific output column |
Rules can also carry a top-level condition guard, which causes the entire rule to apply only when a specified field meets a given condition.
Source and target schemas
Every mapping is anchored to a source schema and a target schema. The engine uses the registered field structure of each schema when building the transformation.
A mapping can read from more than one source schema simultaneously. When multiple sources are involved, each field rule identifies which source it reads from, and the engine correlates records across sources using join conditions you define. Joins can match records by key field equality or by positional alignment.
Similarly, a mapping can write to more than one target schema, routing each rule to the appropriate output stream.
Validation before deployment
Before committing a mapping to your integration, you can run a preflight check that reports exactly which rules the engine would be unable to apply. The preflight runs the same compilation logic as a full deployment but stops short of writing anything. It returns a list of rules that would be dropped, each with a plain-language reason, so you can correct problems before they silently affect your data.
The preflight distinguishes between two categories of issue: rules that have no supported transformation form and will always be dropped, and rules that reference a lookup entity that could not be verified at check time but may resolve when the full deployment runs.
Lookup tables
Two types of crosswalk tables can be referenced from mapping rules:
- Value maps translate a single source value to a single target value using a named lookup entity you create and manage separately.
- Multi-valued maps feed a source key into a table that has multiple output columns, and each rule selects which column to return. The column is identified by its display name as it appears in the portal.
Before a mapping that references a lookup table is deployed, the engine verifies that the referenced entity exists. A rule whose lookup entity cannot be found is excluded from the deployment rather than deployed with a dangling reference.
Deploying and running a mapping
When you deploy a mapping, the engine compiles your rules into an executable transformation and registers it as a named entity in your Adeptia environment, associated with a project. If a mapping with the same name already exists, it is silently overwritten.
After deployment you can execute a mapping against real data to verify the output before putting the integration into production. You supply source data inline and the engine returns the transformed result. This lets you confirm correctness immediately after deployment without waiting for a live process flow to run.
Managing mappings
Once deployed, a mapping can be updated in place by supplying a revised configuration. Mappings can also be permanently removed when they are no longer needed. Removing a mapping that is still referenced by active process flows may cause those flows to fail, so the engine surfaces a conflict when that condition is detected.
Fitting into your integration workflow
The typical workflow is:
- Author mapping rules connecting source fields to target fields, applying transformations as needed.
- Run a preflight check to identify any rules that would be dropped.
- Deploy the mapping to your Adeptia environment.
- Execute the mapping against sample data to verify the output.