n8n-nodes-data-mapper 0.1.0 → 0.2.0

package/README.md

@@ -6,13 +6,17 @@
 
 An [n8n](https://n8n.io) community node that **maps data from one structure to another**. Rename and nest fields, map whole arrays with `[*]`, convert types, format dates, translate codes with lookup tables, and convert between **JSON and XML**, all in one node.
 
+Load a **target profile** (a profile component exported as XML/JSON/Flat File, JSON Schema, sample JSON/XML, XSD or a CSV header) — paste it or upload it — to pick target fields from a dropdown, or let **auto-map** match source fields to the target for you.
+
 Use it to turn an API response into your internal format, shape database rows into a request payload, read a supplier's XML into clean JSON, or pull just the useful parts out of a large payload.
 
+- [Screenshots](#screenshots)
 - [Installation](#installation)
 - [Quick start](#quick-start)
 - [Paths](#paths)
 - [Parameters](#parameters)
 - [Transforms](#transforms)
+- [Target profiles and auto-map](#target-profiles-and-auto-map)
 - [Reusable JSON definitions](#reusable-json-definitions)
 - [Working with XML](#working-with-xml)
 - [Examples](#examples)
@@ -20,6 +24,16 @@ Use it to turn an API response into your internal format, shape database rows in
 - [Development](#development)
 - [License](#license)
 
+## Screenshots
+
+**Mapping fields to a JSON output** — rename and nest fields, convert types, and reshape arrays:
+
+![Data Mapper producing JSON output](docs/images/json-mapping.webp)
+
+**Building XML with transforms and added fields** — attributes, nested elements, repeated items, a country lookup, rounding and a generated timestamp:
+
+![Data Mapper producing XML output](docs/images/xml-output.webp)
+
 ## Installation
 
 ### From the n8n UI (recommended)
@@ -108,8 +122,10 @@ Mappings run in order, and a later mapping to the same target overwrites an earl
 | **Input** | *Item JSON* maps each incoming item. *Text Field* first parses JSON or XML text stored in a field. *File* first parses a JSON or XML binary file. |
 | **Input Field** / **Input Binary Field** | Which field holds the text or file. |
 | **Input Format** | *Detect Automatically* (XML when the text starts with `<`), *JSON* or *XML*. |
-| **Define Mappings** | *Using Fields Below* or *Using JSON*. See [Reusable JSON definitions](#reusable-json-definitions). |
-| **Mappings** | The list of mappings. Each has a **Source** (*Input Field* path or *Fixed Value*, which can be an expression), a **Target Path**, an optional **Transform**, and **If Source Is Missing**: *Leave Out* (default), *Set to Null*, *Use Default* or *Stop With Error*. |
+| **Define Mappings** | *Using Fields Below*, *Auto-Map From Profile*, or *Using JSON*. See [Target profiles and auto-map](#target-profiles-and-auto-map) and [Reusable JSON definitions](#reusable-json-definitions). |
+| **Target Profile** / **Target Profile Format** | Optional. The structure to map into. See [Target profiles and auto-map](#target-profiles-and-auto-map). |
+| **Mappings** | The list of mappings. Each has a **Source** (*Input Field* path or *Fixed Value*, which can be an expression), a **Target** (*Custom Path* you type, or *From Target Profile* picked from a dropdown), an optional **Transform**, and **If Source Is Missing**: *Leave Out* (default), *Set to Null*, *Use Default* or *Stop With Error*. |
+| **Auto-Map Remaining Target Fields** | *Fields mode.* Fills any profile fields you did not map by hand by matching them to source fields by name. |
 | **Unmapped Fields** | *Drop* outputs only mapped fields. *Keep* starts from a copy of the input and applies the mappings on top. |
 | **Output Format** | *JSON* (the item), *JSON File*, *XML* (text in a field) or *XML File*. |
 | **Put Output in Field** | *XML only.* Default `xml`. |
@@ -137,6 +153,53 @@ Turn on **Settings → On Error → Continue** to output failed items as `{ "err
 
 For anything else, use a **Fixed Value** with an expression, e.g. `{{ $json.first + ' ' + $json.last }}`.
 
+## Target profiles and auto-map
+
+A **target profile** describes the structure you want to map into. Paste it into the **Target Profile** field (or reference an uploaded file with an expression — see below). The node reads it and gives you two things: a **dropdown of target fields** in manual mode, and **auto-map**, which matches your source fields to the profile for you.
+
+### Supported formats
+
+**Target Profile Format** is *Detect Automatically* by default. Supported:
+
+| Format | Notes |
+| --- | --- |
+| Profile Component (XML/JSON/Flat File) | Integration profile components exported as XML, with `type="profile.xml"`, `"profile.json"` or `"profile.flatfile"`. Attributes become `.$.name`, repeating elements become `[*]`, and the JSON profile's `Root`/`Object` wrappers are skipped. |
+| JSON Schema | `properties`, `required`, `items`, `type` and `format` (date/date-time → datetime). |
+| Sample JSON | A representative JSON document; array object fields are merged into one shape. |
+| Sample XML | A representative XML document; attributes become `.$.name`. |
+| XSD | `xs:element` / `xs:complexType` / `xs:attribute`, with `maxOccurs` for repeating elements. |
+| CSV Header | The first line, split on comma, semicolon, tab or pipe. |
+
+### Paste or upload
+
+**Target Profile** has two sources:
+
+- **Paste It** — paste the profile text into the box. This is the only source that fills the target-field dropdown.
+- **Upload a File** — read the profile from an uploaded file. Put a node that produces a binary file before Data Mapper (for example **Read/Write Files From Disk**, a **Form Trigger** with a file-upload field, or an **HTTP Request**), then name that binary field. Auto-map reads the uploaded file directly; to pick fields from the dropdown, paste the profile instead.
+
+### Picking targets (manual mode)
+
+With **Define Mappings** = *Using Fields Below*, paste a profile, then set a mapping's **Target** to *From Target Profile* and choose the field from the dropdown. The dropdown shows each field's path, whether it is a list, and its type. Switch **Target** to *Custom Path* to type a path the profile does not contain.
+
+### Auto-map
+
+With **Define Mappings** = *Auto-Map From Profile*, the node matches each target field to the best source field by name and builds the mapping automatically. The target's type becomes the transform (a `number` field gets *To Number*, a `datetime` field gets *Format Date*, and so on).
+
+**Auto-Map Options:**
+
+| Option | Default | Description |
+| --- | --- | --- |
+| Minimum Confidence | 0.6 | How close names must be, from 0 (anything) to 1 (identical). Names are compared ignoring case and punctuation. |
+| Match | Fuzzy | *Fuzzy* allows similar names; *Exact Names Only* requires the same name. |
+| Case Sensitive | off | Whether names must match in the same case. |
+| Reuse a Source for Several Targets | off | Whether one source may fill more than one target. |
+| Unmatched Target Fields | Leave Out | *Leave Out*, or *Set to Null* to include them as null. |
+| Add Auto-Map Report | off | Adds an `_autoMap` field listing matched and unmatched fields (JSON output). |
+
+Auto-map respects arrays: `items[*].Qty` → `lines[*].qty` works, and a non-repeating source is never mapped onto a repeating target. To tweak a few fields by hand, use *Using Fields Below* with **Auto-Map Remaining Target Fields** on — your manual mappings win, and the rest are filled in automatically.
+
+For an XML target profile, the root element name comes from the profile, so XML output needs no **Root Element**.
+
 ## Reusable JSON definitions
 
 Set **Define Mappings** to **Using JSON** to describe the mapping as data. You can paste it in, or load it with an expression so one mapping is shared by many workflows. For example, `{{ $('Get mapping').item.json.mapping }}` can read it from a database row, a file or a static data node.
@@ -216,6 +279,53 @@ Special characters are escaped automatically. Invalid XML input fails with the l
 
 ## Examples
 
+The [`examples/`](examples) folder has importable workflows (**Workflows → Import from File**). The easiest way to build a flow, though, is to add **Data Mapper** from the node panel directly.
+
+| File | Shows |
+| --- | --- |
+| [`examples/data-mapper-examples.json`](examples/data-mapper-examples.json) | JSON, XML and CSV output side by side |
+| [`examples/auto-map-with-profile.json`](examples/auto-map-with-profile.json) | Auto-map and the profile-field dropdown |
+| [`examples/fixed-workflow.json`](examples/fixed-workflow.json) | Field mapping to JSON (the first screenshot above) |
+| [`examples/xml-output-workflow.json`](examples/xml-output-workflow.json) | Building XML with transforms and added fields (the second screenshot above) |
+
+> **Importing a workflow and the node shows as `?`** — the node type in a workflow file depends on how the package was installed. Installed through **Settings → Community Nodes**, the type is `n8n-nodes-data-mapper.dataMapper` (what the files in `examples/` use). Installed by copying into n8n's **custom** folder, n8n registers it as `CUSTOM.dataMapper` instead. If an imported workflow shows `?`, either add the node from the panel, or edit the file and swap the type prefix to match your install. [`examples/fixed-workflow.json`](examples/fixed-workflow.json) and [`examples/xml-output-workflow.json`](examples/xml-output-workflow.json) use the `CUSTOM.` prefix.
+
+### Build an XML invoice with transforms
+
+This is the second screenshot above ([`examples/xml-output-workflow.json`](examples/xml-output-workflow.json)). From an order like `{ "OrderID": "A1", "CustomerName": " Ann de Vries ", "Country": "NL", "Currency": "eur", "Amount": "129.456", "OrderDate": "2026-10-17", "Items": [...] }`, these mappings (Output Format **XML**):
+
+| Source | Target | Transform |
+| --- | --- | --- |
+| `OrderID` | `invoice.$.id` | |
+| *Fixed* `n8n` | `invoice.$.source` | |
+| `CustomerName` | `invoice.customer.name` | Trim |
+| `Country` | `invoice.customer.country` | Lookup `NL=Netherlands` |
+| `Amount` | `invoice.amount._` | Round (2) |
+| `Currency` | `invoice.amount.$.currency` | Uppercase |
+| `OrderDate` | `invoice.issuedDate` | Format Date `dd/MM/yyyy` |
+| *Fixed* `{{ $now.toISO() }}` | `invoice.generatedAt` | |
+| `Items[*].SKU` | `invoice.lines.line[*].$.sku` | |
+| `Items[*].Qty` | `invoice.lines.line[*].qty` | To Integer |
+
+produce:
+
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<invoice id="A1" source="n8n">
+  <customer>
+    <name>Ann de Vries</name>
+    <country>Netherlands</country>
+  </customer>
+  <amount currency="EUR">129.46</amount>
+  <issuedDate>17/10/2026</issuedDate>
+  <generatedAt>2026-10-17T09:00:00.000Z</generatedAt>
+  <lines>
+    <line sku="P-1"><qty>2</qty></line>
+    <line sku="P-2"><qty>1</qty></line>
+  </lines>
+</invoice>
+```
+
 ### Distill a large API response
 
 Keep three fields from a big payload: **Unmapped Fields** *Drop*, with mappings `data.user.id` → `id`, `data.user.profile.email` → `email` (Lowercase) and `data.user.roles[*].name` → `roles`.
@@ -244,7 +354,7 @@ npm run lint
 npm test
 ```
 
-See [CONTRIBUTING.md](CONTRIBUTING.md) for the project layout and release process, and [CHANGELOG.md](CHANGELOG.md) for version history.
+See the [wiki](docs/Home.md) for full documentation, [CONTRIBUTING.md](CONTRIBUTING.md) for the project layout and release process, and [CHANGELOG.md](CHANGELOG.md) for version history.
 
 ## License
 

package/dist/nodes/DataMapper/DataMapper.node.d.ts

@@ -1,5 +1,10 @@
-import type { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from 'n8n-workflow';
+import type { IExecuteFunctions, ILoadOptionsFunctions, INodeExecutionData, INodePropertyOptions, INodeType, INodeTypeDescription } from 'n8n-workflow';
 export declare class DataMapper implements INodeType {
     description: INodeTypeDescription;
+    methods: {
+        loadOptions: {
+            getTargetFields(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+        };
+    };
     execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
 }

package/dist/nodes/DataMapper/DataMapper.node.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DataMapper = void 0;
 const n8n_workflow_1 = require("n8n-workflow");
 const mapping_1 = require("./mapping");
+const profile_1 = require("./profile");
 const xml_1 = require("./xml");
 const show = (values) => ({ show: values });
 const mappingFields = [
@@ -33,14 +34,37 @@ const mappingFields = [
         description: 'Fixed text, or an expression such as {{ $now.toISO() }}',
         displayOptions: show({ sourceType: ['value'] }),
     },
+    {
+        displayName: 'Target',
+        name: 'targetMode',
+        type: 'options',
+        options: [
+            { name: 'Custom Path', value: 'custom', description: 'Type the target path yourself' },
+            {
+                name: 'From Target Profile',
+                value: 'profile',
+                description: 'Pick a field from the uploaded target profile',
+            },
+        ],
+        default: 'custom',
+    },
+    {
+        displayName: 'Target Field Name or ID',
+        name: 'targetField',
+        type: 'options',
+        typeOptions: { loadOptionsMethod: 'getTargetFields' },
+        default: '',
+        description: 'Field from the target profile. Fill the Target Profile field above first. Choose from the list, or specify an ID using an expression. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+        displayOptions: show({ targetMode: ['profile'] }),
+    },
     {
         displayName: 'Target Path',
         name: 'target',
         type: 'string',
         default: '',
-        required: true,
         placeholder: 'shipping.cities[*]',
         description: 'Where to write the value in the output. Each [*] matches a [*] in the source path, in order.',
+        displayOptions: show({ targetMode: ['custom'] }),
     },
     {
         displayName: 'Transform',
@@ -162,7 +186,7 @@ class DataMapper {
             icon: { light: 'file:mapper.svg', dark: 'file:mapper.dark.svg' },
             group: ['transform'],
             version: 1,
-            subtitle: '={{ $parameter["definitionMode"] === "json" ? "JSON definition" : "Field mappings" }}',
+            subtitle: '={{ $parameter["definitionMode"] === "auto" ? "Auto-map from profile" : $parameter["definitionMode"] === "json" ? "JSON definition" : "Field mappings" }}',
             description: 'Map and transform data from one structure to another, between JSON and XML',
             defaults: {
                 name: 'Data Mapper',
@@ -223,6 +247,11 @@ class DataMapper {
                     noDataExpression: true,
                     options: [
                         { name: 'Using Fields Below', value: 'fields' },
+                        {
+                            name: 'Auto-Map From Profile',
+                            value: 'auto',
+                            description: 'Match source fields to a target profile automatically by name',
+                        },
                         {
                             name: 'Using JSON',
                             value: 'json',
@@ -231,6 +260,69 @@ class DataMapper {
                     ],
                     default: 'fields',
                 },
+                {
+                    displayName: 'Define the target structure with a profile, then map into it — pick target fields from a dropdown, or let Auto-Map match them for you',
+                    name: 'profileNotice',
+                    type: 'notice',
+                    default: '',
+                    displayOptions: show({ definitionMode: ['fields', 'auto'] }),
+                },
+                {
+                    displayName: 'Target Profile',
+                    name: 'targetProfileSource',
+                    type: 'options',
+                    options: [
+                        {
+                            name: 'Paste It',
+                            value: 'paste',
+                            description: 'Paste the profile text. Lets you pick target fields from a dropdown.',
+                        },
+                        {
+                            name: 'Upload a File',
+                            value: 'binary',
+                            description: 'Read the profile from an uploaded file (a binary field from a Read/Write Files, Form or HTTP node)',
+                        },
+                    ],
+                    default: 'paste',
+                    displayOptions: show({ definitionMode: ['fields', 'auto'] }),
+                },
+                {
+                    displayName: 'Profile',
+                    name: 'targetProfile',
+                    type: 'string',
+                    typeOptions: { rows: 6 },
+                    default: '',
+                    placeholder: 'Paste a profile component (XML/JSON/Flat File), JSON Schema, sample JSON or XML, XSD, or a CSV header row',
+                    description: 'The structure to map into. The target fields come from this.',
+                    displayOptions: show({ definitionMode: ['fields', 'auto'], targetProfileSource: ['paste'] }),
+                },
+                {
+                    displayName: 'Profile File Field',
+                    name: 'profileBinaryField',
+                    type: 'string',
+                    default: 'data',
+                    required: true,
+                    hint: 'The name of the binary field that holds the uploaded profile file',
+                    description: 'Add a Read/Write Files From Disk, Form Trigger (file upload) or HTTP Request node before this one to bring the profile in, then name its binary field here. Auto-Map uses it; the field dropdown is only available when you paste the profile.',
+                    displayOptions: show({ definitionMode: ['fields', 'auto'], targetProfileSource: ['binary'] }),
+                },
+                {
+                    displayName: 'Profile Format',
+                    name: 'targetProfileFormat',
+                    type: 'options',
+                    options: [
+                        { name: 'Detect Automatically', value: 'auto' },
+                        { name: 'Profile Component (XML/JSON/Flat File)', value: 'component' },
+                        { name: 'JSON Schema', value: 'jsonSchema' },
+                        { name: 'Sample JSON', value: 'sampleJson' },
+                        { name: 'Sample XML', value: 'sampleXml' },
+                        { name: 'XSD', value: 'xsd' },
+                        { name: 'CSV Header', value: 'csv' },
+                    ],
+                    default: 'auto',
+                    description: 'The kind of profile you provided. Detect Automatically works for most profiles.',
+                    displayOptions: show({ definitionMode: ['fields', 'auto'] }),
+                },
                 {
                     displayName: 'Mappings',
                     name: 'mappings',
@@ -242,6 +334,14 @@ class DataMapper {
                     displayOptions: show({ definitionMode: ['fields'] }),
                     options: [{ displayName: 'Mapping', name: 'mapping', values: mappingFields }],
                 },
+                {
+                    displayName: 'Auto-Map Remaining Target Fields',
+                    name: 'autoMapRemaining',
+                    type: 'boolean',
+                    default: false,
+                    description: 'Whether to also fill any target-profile fields you have not mapped above, by matching them to source fields by name',
+                    displayOptions: show({ definitionMode: ['fields'] }),
+                },
                 {
                     displayName: 'Mapping Definition',
                     name: 'mappingJson',
@@ -250,6 +350,65 @@ class DataMapper {
                     description: 'An array of mappings, or { "mappings": [...] }. Each mapping has "target" and either "source" or "value", plus optional "transform", "ifMissing", "default", "separator", "decimals", "dateInputFormat", "dateOutputFormat", "lookup", "lookupFallback" and "lookupDefault".',
                     displayOptions: show({ definitionMode: ['json'] }),
                 },
+                {
+                    displayName: 'Auto-Map Options',
+                    name: 'autoOptions',
+                    type: 'collection',
+                    placeholder: 'Add option',
+                    default: {},
+                    displayOptions: show({ definitionMode: ['auto'] }),
+                    options: [
+                        {
+                            displayName: 'Add Auto-Map Report',
+                            name: 'report',
+                            type: 'boolean',
+                            default: false,
+                            description: 'Whether to add an _autoMap field listing which fields matched and which did not (JSON output only)',
+                        },
+                        {
+                            displayName: 'Case Sensitive',
+                            name: 'caseSensitive',
+                            type: 'boolean',
+                            default: false,
+                            description: 'Whether field names must match in the same letter case',
+                        },
+                        {
+                            displayName: 'Match',
+                            name: 'strategy',
+                            type: 'options',
+                            options: [
+                                { name: 'Fuzzy (Similar Names)', value: 'fuzzy' },
+                                { name: 'Exact Names Only', value: 'exact' },
+                            ],
+                            default: 'fuzzy',
+                        },
+                        {
+                            displayName: 'Minimum Confidence',
+                            name: 'threshold',
+                            type: 'number',
+                            typeOptions: { minValue: 0, maxValue: 1, numberPrecision: 2 },
+                            default: 0.6,
+                            description: 'How close names must be to match, from 0 (match anything) to 1 (identical names)',
+                        },
+                        {
+                            displayName: 'Reuse a Source for Several Targets',
+                            name: 'reuseSources',
+                            type: 'boolean',
+                            default: false,
+                            description: 'Whether one source field may be mapped to more than one target field',
+                        },
+                        {
+                            displayName: 'Unmatched Target Fields',
+                            name: 'unmatched',
+                            type: 'options',
+                            options: [
+                                { name: 'Leave Out', value: 'skip' },
+                                { name: 'Set to Null', value: 'null' },
+                            ],
+                            default: 'skip',
+                        },
+                    ],
+                },
                 {
                     displayName: 'Unmapped Fields',
                     name: 'unmapped',
@@ -321,19 +480,54 @@ class DataMapper {
                 },
             ],
         };
+        this.methods = {
+            loadOptions: {
+                async getTargetFields() {
+                    var _a, _b, _c;
+                    const source = (_a = safeParam(this, 'targetProfileSource')) !== null && _a !== void 0 ? _a : 'paste';
+                    if (source !== 'paste') {
+                        return [
+                            { name: 'Using An Uploaded File — Use Auto-Map, Or Paste To Pick Fields', value: '' },
+                        ];
+                    }
+                    const text = ((_b = safeParam(this, 'targetProfile')) !== null && _b !== void 0 ? _b : '').trim();
+                    if (text === '')
+                        return [{ name: 'Paste A Profile First', value: '' }];
+                    if (text.startsWith('=') || text.includes('{{')) {
+                        return [{ name: 'Profile Is Set By An Expression — Use Auto-Map To Match Fields', value: '' }];
+                    }
+                    const format = ((_c = safeParam(this, 'targetProfileFormat')) !== null && _c !== void 0 ? _c : 'auto');
+                    try {
+                        const profile = (0, profile_1.parseProfile)(text, format);
+                        if (profile.fields.length === 0)
+                            return [{ name: 'No Fields Found In The Profile', value: '' }];
+                        return profile.fields.map((field) => ({
+                            name: `${field.path}${field.repeating ? ' (list)' : ''} [${field.type}]`,
+                            value: field.path,
+                        }));
+                    }
+                    catch (error) {
+                        return [{ name: `Profile Error: ${error.message}`, value: '' }];
+                    }
+                },
+            },
+        };
     }
     async execute() {
         const items = this.getInputData();
         const returnData = [];
+        const profileCache = new Map();
         for (let i = 0; i < items.length; i++) {
             try {
                 const input = await readInput(this, items[i], i);
-                const rules = readRules(this, i);
+                const { rules, report } = await buildRules(this, i, input, profileCache);
                 const unmapped = this.getNodeParameter('unmapped', i);
                 const start = unmapped === 'keep' && input && typeof input === 'object' && !Array.isArray(input)
                     ? structuredClone(input)
                     : {};
                 const mapped = (0, mapping_1.applyMappings)(input, rules, start);
+                if (report)
+                    mapped._autoMap = report;
                 returnData.push(await writeOutput(this, mapped, i));
             }
             catch (error) {
@@ -345,7 +539,9 @@ class DataMapper {
                     ? error
                     : new n8n_workflow_1.NodeOperationError(this.getNode(), error.message, {
                         itemIndex: i,
-                        description: error instanceof mapping_1.MappingError || error instanceof xml_1.XmlParseError
+                        description: error instanceof mapping_1.MappingError ||
+                            error instanceof xml_1.XmlParseError ||
+                            error instanceof profile_1.ProfileError
                             ? undefined
                             : 'Unexpected error while mapping this item',
                     });
@@ -398,28 +594,104 @@ async function readInput(ctx, item, itemIndex) {
         });
     }
 }
-function readRules(ctx, itemIndex) {
+function safeParam(ctx, name) {
+    try {
+        return ctx.getCurrentNodeParameter(name);
+    }
+    catch {
+        return undefined;
+    }
+}
+async function getProfile(ctx, itemIndex, cache) {
+    var _a;
+    const profileSource = ctx.getNodeParameter('targetProfileSource', itemIndex, 'paste');
+    let text;
+    if (profileSource === 'binary') {
+        const field = ctx.getNodeParameter('profileBinaryField', itemIndex);
+        ctx.helpers.assertBinaryData(itemIndex, field);
+        text = (await ctx.helpers.getBinaryDataBuffer(itemIndex, field)).toString('utf8').trim();
+    }
+    else {
+        text = ((_a = ctx.getNodeParameter('targetProfile', itemIndex, '')) !== null && _a !== void 0 ? _a : '').trim();
+    }
+    if (text === '')
+        return undefined;
+    const format = ctx.getNodeParameter('targetProfileFormat', itemIndex, 'auto');
+    const key = `${format}\u0000${text}`;
+    if (!cache.has(key))
+        cache.set(key, (0, profile_1.parseProfile)(text, format));
+    return cache.get(key);
+}
+function readAutoOptions(ctx, itemIndex) {
+    var _a, _b, _c;
+    const o = ctx.getNodeParameter('autoOptions', itemIndex, {});
+    return {
+        threshold: (_a = o.threshold) !== null && _a !== void 0 ? _a : 0.6,
+        strategy: (_b = o.strategy) !== null && _b !== void 0 ? _b : 'fuzzy',
+        caseSensitive: o.caseSensitive === true,
+        reuseSources: o.reuseSources === true,
+        unmatched: (_c = o.unmatched) !== null && _c !== void 0 ? _c : 'skip',
+    };
+}
+function uiMappingToRule(m, ctx, itemIndex) {
+    var _a, _b, _c;
+    let target = m.target;
+    if (m.targetMode === 'profile') {
+        target = (_a = m.targetField) !== null && _a !== void 0 ? _a : '';
+        if (target === '') {
+            throw new n8n_workflow_1.NodeOperationError(ctx.getNode(), 'A mapping is set to "From Target Profile" but no target field is selected', { itemIndex });
+        }
+    }
+    return {
+        ...(m.sourceType === 'value' ? { value: (_b = m.value) !== null && _b !== void 0 ? _b : '' } : { source: (_c = m.source) !== null && _c !== void 0 ? _c : '' }),
+        target,
+        transform: m.transform,
+        separator: m.separator,
+        decimals: m.decimals,
+        dateInputFormat: m.dateInputFormat,
+        dateOutputFormat: m.dateOutputFormat,
+        lookup: m.lookupTable,
+        lookupFallback: m.lookupFallback,
+        lookupDefault: m.lookupDefault,
+        ifMissing: m.ifMissing,
+        default: m.defaultValue,
+    };
+}
+async function buildRules(ctx, itemIndex, input, cache) {
     const mode = ctx.getNodeParameter('definitionMode', itemIndex);
     if (mode === 'json')
-        return (0, mapping_1.parseDefinition)(ctx.getNodeParameter('mappingJson', itemIndex));
-    const entries = ctx.getNodeParameter('mappings.mapping', itemIndex, []);
-    return entries.map((m) => {
-        var _a, _b;
-        return ({
-            ...(m.sourceType === 'value' ? { value: (_a = m.value) !== null && _a !== void 0 ? _a : '' } : { source: (_b = m.source) !== null && _b !== void 0 ? _b : '' }),
-            target: m.target,
-            transform: m.transform,
-            separator: m.separator,
-            decimals: m.decimals,
-            dateInputFormat: m.dateInputFormat,
-            dateOutputFormat: m.dateOutputFormat,
-            lookup: m.lookupTable,
-            lookupFallback: m.lookupFallback,
-            lookupDefault: m.lookupDefault,
-            ifMissing: m.ifMissing,
-            default: m.defaultValue,
+        return { rules: (0, mapping_1.parseDefinition)(ctx.getNodeParameter('mappingJson', itemIndex)) };
+    const profile = await getProfile(ctx, itemIndex, cache);
+    if (mode === 'auto') {
+        if (!profile) {
+            throw new n8n_workflow_1.NodeOperationError(ctx.getNode(), 'Auto-Map needs a target profile. Paste one in, or upload a profile file.', { itemIndex });
+        }
+        const options = readAutoOptions(ctx, itemIndex);
+        const result = (0, profile_1.autoMap)((0, profile_1.flattenSource)(input), profile, options);
+        const built = { rules: result.rules, profile };
+        if (ctx.getNodeParameter('autoOptions.report', itemIndex, false) === true) {
+            built.report = {
+                matched: result.matched,
+                unmatched: result.unmatched,
+            };
+        }
+        return built;
+    }
+    const entries = ctx.getNodeParameter('mappings.mapping', itemIndex, []).filter(Boolean);
+    const rules = entries.map((m) => uiMappingToRule(m, ctx, itemIndex));
+    if (profile && ctx.getNodeParameter('autoMapRemaining', itemIndex, false) === true) {
+        const covered = new Set(rules.map((r) => r.target));
+        const remaining = { ...profile, fields: profile.fields.filter((f) => !covered.has(f.path)) };
+        const result = (0, profile_1.autoMap)((0, profile_1.flattenSource)(input), remaining, {
+            threshold: 0.6,
+            strategy: 'fuzzy',
+            caseSensitive: false,
+            reuseSources: false,
+            unmatched: 'skip',
         });
-    });
+        rules.push(...result.rules);
+    }
+    return { rules, profile };
 }
 async function writeOutput(ctx, mapped, itemIndex) {
     const format = ctx.getNodeParameter('outputFormat', itemIndex);