n8n-nodes-data-mapper 0.1.0 → 0.4.0

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

@@ -3,6 +3,8 @@ 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 visual_1 = require("./visual");
 const xml_1 = require("./xml");
 const show = (values) => ({ show: values });
 const mappingFields = [
@@ -12,10 +14,24 @@ const mappingFields = [
         type: 'options',
         options: [
             { name: 'Input Field', value: 'field', description: 'Read a value from the input by path' },
+            {
+                name: 'From Source Profile',
+                value: 'profile',
+                description: 'Pick a field from the source profile',
+            },
             { name: 'Fixed Value', value: 'value', description: 'Write a fixed value or the result of an expression' },
         ],
         default: 'field',
     },
+    {
+        displayName: 'Source Field Name or ID',
+        name: 'sourceField',
+        type: 'options',
+        typeOptions: { loadOptionsMethod: 'getSourceFields' },
+        default: '',
+        description: 'Field from the source profile. Fill the Source Profile field above first. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+        displayOptions: show({ sourceType: ['profile'] }),
+    },
     {
         displayName: 'Source Path',
         name: 'source',
@@ -33,14 +49,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 <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',
@@ -137,14 +176,14 @@ const mappingFields = [
             { name: 'Stop With Error', value: 'error' },
         ],
         default: 'skip',
-        displayOptions: show({ sourceType: ['field'] }),
+        displayOptions: show({ sourceType: ['field', 'profile'] }),
     },
     {
         displayName: 'Default Value',
         name: 'defaultValue',
         type: 'string',
         default: '',
-        displayOptions: show({ sourceType: ['field'], ifMissing: ['default'] }),
+        displayOptions: show({ sourceType: ['field', 'profile'], ifMissing: ['default'] }),
     },
 ];
 const exampleDefinition = JSON.stringify([
@@ -154,6 +193,329 @@ const exampleDefinition = JSON.stringify([
     { source: 'items[*].qty', target: 'lines[*].quantity', transform: 'integer' },
     { value: 'EUR', target: 'lines[*].currency' },
 ], null, 2);
+const v1Properties = [
+    {
+        displayName: 'Input',
+        name: 'inputSource',
+        type: 'options',
+        noDataExpression: true,
+        options: [
+            { name: 'Item JSON', value: 'json', description: 'Map the fields of each incoming item' },
+            {
+                name: 'Text Field',
+                value: 'field',
+                description: 'Parse JSON or XML text stored in a field first',
+            },
+            { name: 'File', value: 'binary', description: 'Parse a JSON or XML file first' },
+        ],
+        default: 'json',
+    },
+    {
+        displayName: 'Input Field',
+        name: 'inputField',
+        type: 'string',
+        default: 'data',
+        required: true,
+        displayOptions: show({ inputSource: ['field'] }),
+    },
+    {
+        displayName: 'Input Binary Field',
+        name: 'inputBinaryField',
+        type: 'string',
+        default: 'data',
+        required: true,
+        displayOptions: show({ inputSource: ['binary'] }),
+    },
+    {
+        displayName: 'Input Format',
+        name: 'inputFormat',
+        type: 'options',
+        options: [
+            { name: 'Detect Automatically', value: 'auto' },
+            { name: 'JSON', value: 'json' },
+            { name: 'XML', value: 'xml' },
+        ],
+        default: 'auto',
+        description: 'XML is read with attributes under "$" and text under "_", so a path looks like order.$.ID or order.total._',
+        displayOptions: show({ inputSource: ['field', 'binary'] }),
+    },
+    {
+        displayName: 'Define Mappings',
+        name: 'definitionMode',
+        type: 'options',
+        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',
+                description: 'Paste or reference a mapping definition, so one mapping can be reused across workflows',
+            },
+        ],
+        default: 'fields',
+    },
+    {
+        displayName: 'Source Profile',
+        name: 'sourceProfile',
+        type: 'string',
+        typeOptions: { rows: 4 },
+        default: '',
+        placeholder: 'Optional: paste the structure of the incoming data (profile component, JSON Schema, sample JSON or XML, XSD, CSV header)',
+        description: 'Optional. Describes the incoming data, so you can pick source fields from a dropdown (Source: From Source Profile) instead of typing paths.',
+        displayOptions: show({ definitionMode: ['fields'] }),
+    },
+    {
+        displayName: 'Source Profile Format',
+        name: 'sourceProfileFormat',
+        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',
+        displayOptions: show({ definitionMode: ['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',
+        placeholder: 'Add Mapping',
+        type: 'fixedCollection',
+        typeOptions: { multipleValues: true, sortable: true },
+        default: {},
+        description: 'Applied in order; a later mapping to the same target overwrites an earlier one',
+        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',
+        type: 'json',
+        default: exampleDefinition,
+        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',
+        type: 'options',
+        options: [
+            { name: 'Drop', value: 'drop', description: 'Output only the mapped fields' },
+            {
+                name: 'Keep',
+                value: 'keep',
+                description: 'Start from a copy of the input and apply the mappings on top',
+            },
+        ],
+        default: 'drop',
+    },
+    {
+        displayName: 'Output Format',
+        name: 'outputFormat',
+        type: 'options',
+        noDataExpression: true,
+        options: [
+            { name: 'JSON', value: 'json', description: 'Output the mapped data as the item' },
+            { name: 'JSON File', value: 'jsonFile', description: 'Output the mapped data as a JSON file' },
+            { name: 'XML', value: 'xml', description: 'Output the mapped data as XML text in a field' },
+            { name: 'XML File', value: 'xmlFile', description: 'Output the mapped data as an XML file' },
+        ],
+        default: 'json',
+    },
+    {
+        displayName: 'Put Output in Field',
+        name: 'outputField',
+        type: 'string',
+        default: 'xml',
+        required: true,
+        displayOptions: show({ outputFormat: ['xml'] }),
+    },
+    {
+        displayName: 'Put Output File in Field',
+        name: 'outputBinaryField',
+        type: 'string',
+        default: 'data',
+        required: true,
+        displayOptions: show({ outputFormat: ['xmlFile', 'jsonFile'] }),
+    },
+    {
+        displayName: 'File Name',
+        name: 'fileName',
+        type: 'string',
+        default: '',
+        placeholder: 'output.xml',
+        description: 'Leave empty to name the file output with the matching extension',
+        displayOptions: show({ outputFormat: ['xmlFile', 'jsonFile'] }),
+    },
+    {
+        displayName: 'Root Element',
+        name: 'rootElement',
+        type: 'string',
+        default: '',
+        placeholder: 'order',
+        description: 'Name of the XML root element. Leave empty to use the single top-level field, or "root" when there are several.',
+        displayOptions: show({ outputFormat: ['xml', 'xmlFile'] }),
+    },
+    {
+        displayName: 'Include XML Declaration',
+        name: 'xmlDeclaration',
+        type: 'boolean',
+        default: true,
+        description: 'Whether to start the XML with &lt;?xml version="1.0" encoding="UTF-8"?&gt;',
+        displayOptions: show({ outputFormat: ['xml', 'xmlFile'] }),
+    },
+];
+function forVersions(properties, versions) {
+    return properties.map((property) => {
+        var _a;
+        return ({
+            ...property,
+            displayOptions: {
+                ...property.displayOptions,
+                show: { ...(_a = property.displayOptions) === null || _a === void 0 ? void 0 : _a.show, '@version': versions },
+            },
+        });
+    });
+}
 class DataMapper {
     constructor() {
         this.description = {
@@ -161,179 +523,93 @@ class DataMapper {
             name: 'dataMapper',
             icon: { light: 'file:mapper.svg', dark: 'file:mapper.dark.svg' },
             group: ['transform'],
-            version: 1,
-            subtitle: '={{ $parameter["definitionMode"] === "json" ? "JSON definition" : "Field mappings" }}',
-            description: 'Map and transform data from one structure to another, between JSON and XML',
+            version: [1, 2],
+            defaultVersion: 2,
+            subtitle: '={{ $parameter["targetFormat"] ? "Map to " + $parameter["targetFormat"].toUpperCase() : $parameter["definitionMode"] === "auto" ? "Auto-map from profile" : $parameter["definitionMode"] === "json" ? "JSON definition" : "Field mappings" }}',
+            description: 'Drag and drop incoming data onto a target profile and output XML, JSON or CSV',
             defaults: {
                 name: 'Data Mapper',
             },
             inputs: [n8n_workflow_1.NodeConnectionTypes.Main],
             outputs: [n8n_workflow_1.NodeConnectionTypes.Main],
             usableAsTool: true,
-            properties: [
-                {
-                    displayName: 'Input',
-                    name: 'inputSource',
-                    type: 'options',
-                    noDataExpression: true,
-                    options: [
-                        { name: 'Item JSON', value: 'json', description: 'Map the fields of each incoming item' },
-                        {
-                            name: 'Text Field',
-                            value: 'field',
-                            description: 'Parse JSON or XML text stored in a field first',
-                        },
-                        { name: 'File', value: 'binary', description: 'Parse a JSON or XML file first' },
-                    ],
-                    default: 'json',
-                },
-                {
-                    displayName: 'Input Field',
-                    name: 'inputField',
-                    type: 'string',
-                    default: 'data',
-                    required: true,
-                    displayOptions: show({ inputSource: ['field'] }),
-                },
-                {
-                    displayName: 'Input Binary Field',
-                    name: 'inputBinaryField',
-                    type: 'string',
-                    default: 'data',
-                    required: true,
-                    displayOptions: show({ inputSource: ['binary'] }),
-                },
-                {
-                    displayName: 'Input Format',
-                    name: 'inputFormat',
-                    type: 'options',
-                    options: [
-                        { name: 'Detect Automatically', value: 'auto' },
-                        { name: 'JSON', value: 'json' },
-                        { name: 'XML', value: 'xml' },
-                    ],
-                    default: 'auto',
-                    description: 'XML is read with attributes under "$" and text under "_", so a path looks like order.$.ID or order.total._',
-                    displayOptions: show({ inputSource: ['field', 'binary'] }),
-                },
-                {
-                    displayName: 'Define Mappings',
-                    name: 'definitionMode',
-                    type: 'options',
-                    noDataExpression: true,
-                    options: [
-                        { name: 'Using Fields Below', value: 'fields' },
-                        {
-                            name: 'Using JSON',
-                            value: 'json',
-                            description: 'Paste or reference a mapping definition, so one mapping can be reused across workflows',
-                        },
-                    ],
-                    default: 'fields',
-                },
-                {
-                    displayName: 'Mappings',
-                    name: 'mappings',
-                    placeholder: 'Add Mapping',
-                    type: 'fixedCollection',
-                    typeOptions: { multipleValues: true, sortable: true },
-                    default: {},
-                    description: 'Applied in order; a later mapping to the same target overwrites an earlier one',
-                    displayOptions: show({ definitionMode: ['fields'] }),
-                    options: [{ displayName: 'Mapping', name: 'mapping', values: mappingFields }],
-                },
-                {
-                    displayName: 'Mapping Definition',
-                    name: 'mappingJson',
-                    type: 'json',
-                    default: exampleDefinition,
-                    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: 'Unmapped Fields',
-                    name: 'unmapped',
-                    type: 'options',
-                    options: [
-                        { name: 'Drop', value: 'drop', description: 'Output only the mapped fields' },
-                        {
-                            name: 'Keep',
-                            value: 'keep',
-                            description: 'Start from a copy of the input and apply the mappings on top',
-                        },
-                    ],
-                    default: 'drop',
-                },
-                {
-                    displayName: 'Output Format',
-                    name: 'outputFormat',
-                    type: 'options',
-                    noDataExpression: true,
-                    options: [
-                        { name: 'JSON', value: 'json', description: 'Output the mapped data as the item' },
-                        { name: 'JSON File', value: 'jsonFile', description: 'Output the mapped data as a JSON file' },
-                        { name: 'XML', value: 'xml', description: 'Output the mapped data as XML text in a field' },
-                        { name: 'XML File', value: 'xmlFile', description: 'Output the mapped data as an XML file' },
-                    ],
-                    default: 'json',
-                },
-                {
-                    displayName: 'Put Output in Field',
-                    name: 'outputField',
-                    type: 'string',
-                    default: 'xml',
-                    required: true,
-                    displayOptions: show({ outputFormat: ['xml'] }),
-                },
-                {
-                    displayName: 'Put Output File in Field',
-                    name: 'outputBinaryField',
-                    type: 'string',
-                    default: 'data',
-                    required: true,
-                    displayOptions: show({ outputFormat: ['xmlFile', 'jsonFile'] }),
-                },
-                {
-                    displayName: 'File Name',
-                    name: 'fileName',
-                    type: 'string',
-                    default: '',
-                    placeholder: 'output.xml',
-                    description: 'Leave empty to name the file output with the matching extension',
-                    displayOptions: show({ outputFormat: ['xmlFile', 'jsonFile'] }),
-                },
-                {
-                    displayName: 'Root Element',
-                    name: 'rootElement',
-                    type: 'string',
-                    default: '',
-                    placeholder: 'order',
-                    description: 'Name of the XML root element. Leave empty to use the single top-level field, or "root" when there are several.',
-                    displayOptions: show({ outputFormat: ['xml', 'xmlFile'] }),
+            properties: [...forVersions(v1Properties, [1]), ...forVersions(visual_1.visualProperties, [2])],
+        };
+        this.methods = {
+            resourceMapping: {
+                getProfileFields: visual_1.getProfileFields,
+            },
+            loadOptions: {
+                async getSourceFields() {
+                    var _a, _b;
+                    const text = ((_a = safeParam(this, 'sourceProfile')) !== null && _a !== void 0 ? _a : '').trim();
+                    if (text === '')
+                        return [{ name: 'Paste A Source Profile First', value: '' }];
+                    if (text.startsWith('=') || text.includes('{{')) {
+                        return [{ name: 'Source Profile Is Set By An Expression — Type The Source Path Instead', value: '' }];
+                    }
+                    const format = ((_b = safeParam(this, 'sourceProfileFormat')) !== null && _b !== void 0 ? _b : 'auto');
+                    try {
+                        const fields = (0, profile_1.sourceFields)((0, profile_1.parseProfile)(text, format));
+                        if (fields.length === 0)
+                            return [{ name: 'No Fields Found In The Source Profile', value: '' }];
+                        return fields.map((field) => ({
+                            name: `${field.path}${field.repeating ? ' (list)' : ''} [${field.type}]`,
+                            value: field.path,
+                        }));
+                    }
+                    catch (error) {
+                        return [{ name: `Profile Error: ${error.message}`, value: '' }];
+                    }
                 },
-                {
-                    displayName: 'Include XML Declaration',
-                    name: 'xmlDeclaration',
-                    type: 'boolean',
-                    default: true,
-                    description: 'Whether to start the XML with &lt;?xml version="1.0" encoding="UTF-8"?&gt;',
-                    displayOptions: show({ outputFormat: ['xml', 'xmlFile'] }),
+                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() {
+        if (this.getNode().typeVersion >= 2)
+            return await visual_1.executeVisual.call(this);
         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 +621,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 +676,115 @@ 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 });
+        }
+    }
+    let sourcePart;
+    if (m.sourceType === 'value')
+        sourcePart = { value: (_b = m.value) !== null && _b !== void 0 ? _b : '' };
+    else if (m.sourceType === 'profile') {
+        if (!m.sourceField) {
+            throw new n8n_workflow_1.NodeOperationError(ctx.getNode(), 'A mapping is set to "From Source Profile" but no source field is selected', { itemIndex });
+        }
+        sourcePart = { source: m.sourceField, broadcast: true };
+    }
+    else
+        sourcePart = { source: (_c = m.source) !== null && _c !== void 0 ? _c : '' };
+    return {
+        ...sourcePart,
+        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);