n8n-nodes-data-mapper 0.2.0 → 0.4.0

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

@@ -4,6 +4,7 @@ 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 = [
@@ -13,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',
@@ -54,7 +69,7 @@ const mappingFields = [
         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>.',
+        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'] }),
     },
     {
@@ -161,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([
@@ -178,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 = {
@@ -185,303 +523,45 @@ class DataMapper {
             name: 'dataMapper',
             icon: { light: 'file:mapper.svg', dark: 'file:mapper.dark.svg' },
             group: ['transform'],
-            version: 1,
-            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',
+            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: '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: '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'] }),
-                },
-            ],
+            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: '' }];
+                    }
+                },
                 async getTargetFields() {
                     var _a, _b, _c;
                     const source = (_a = safeParam(this, 'targetProfileSource')) !== null && _a !== void 0 ? _a : 'paste';
@@ -514,6 +594,8 @@ class DataMapper {
         };
     }
     async execute() {
+        if (this.getNode().typeVersion >= 2)
+            return await visual_1.executeVisual.call(this);
         const items = this.getInputData();
         const returnData = [];
         const profileCache = new Map();
@@ -642,8 +724,19 @@ function uiMappingToRule(m, ctx, itemIndex) {
             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 {
-        ...(m.sourceType === 'value' ? { value: (_b = m.value) !== null && _b !== void 0 ? _b : '' } : { source: (_c = m.source) !== null && _c !== void 0 ? _c : '' }),
+        ...sourcePart,
         target,
         transform: m.transform,
         separator: m.separator,