n8n-nodes-data-mapper 0.0.0-stage → 0.2.0

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

@@ -0,0 +1,722 @@
+"use strict";
+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 = [
+    {
+        displayName: 'Source',
+        name: 'sourceType',
+        type: 'options',
+        options: [
+            { name: 'Input Field', value: 'field', description: 'Read a value from the input by path' },
+            { name: 'Fixed Value', value: 'value', description: 'Write a fixed value or the result of an expression' },
+        ],
+        default: 'field',
+    },
+    {
+        displayName: 'Source Path',
+        name: 'source',
+        type: 'string',
+        default: '',
+        placeholder: 'customer.addresses[*].city',
+        description: 'Dot path into the input. Use [0] for one array element, [*] for every element, or leave empty for the whole input.',
+        displayOptions: show({ sourceType: ['field'] }),
+    },
+    {
+        displayName: 'Value',
+        name: 'value',
+        type: 'string',
+        default: '',
+        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: '',
+        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',
+        name: 'transform',
+        type: 'options',
+        options: [
+            { name: 'None', value: 'none' },
+            { name: 'To String', value: 'string' },
+            { name: 'To Number', value: 'number' },
+            { name: 'To Integer', value: 'integer' },
+            { name: 'Round', value: 'round', description: 'Round a number to a number of decimal places' },
+            { name: 'To Boolean', value: 'boolean', description: 'Accepts true/false, yes/no, 1/0, on/off' },
+            { name: 'Trim', value: 'trim' },
+            { name: 'Uppercase', value: 'uppercase' },
+            { name: 'Lowercase', value: 'lowercase' },
+            { name: 'Format Date', value: 'date', description: 'Read a date and write it in another format (UTC)' },
+            { name: 'Split Into List', value: 'split', description: 'Turn "a,b,c" into ["a", "b", "c"]' },
+            { name: 'Join List', value: 'join', description: 'Turn ["a", "b", "c"] into "a,b,c"' },
+            { name: 'Lookup Table', value: 'lookup', description: 'Replace codes using a key=value table' },
+        ],
+        default: 'none',
+    },
+    {
+        displayName: 'Separator',
+        name: 'separator',
+        type: 'string',
+        default: ',',
+        displayOptions: show({ transform: ['split', 'join'] }),
+    },
+    {
+        displayName: 'Decimal Places',
+        name: 'decimals',
+        type: 'number',
+        typeOptions: { minValue: 0, maxValue: 15 },
+        default: 2,
+        displayOptions: show({ transform: ['round'] }),
+    },
+    {
+        displayName: 'Input Date Format',
+        name: 'dateInputFormat',
+        type: 'string',
+        default: '',
+        placeholder: 'yyyyMMdd',
+        description: 'Leave empty for ISO 8601 or Unix milliseconds. Tokens: yyyy, MM, dd, HH, mm, ss, SSS.',
+        displayOptions: show({ transform: ['date'] }),
+    },
+    {
+        displayName: 'Output Date Format',
+        name: 'dateOutputFormat',
+        type: 'string',
+        default: '',
+        placeholder: 'dd/MM/yyyy',
+        description: 'Leave empty for ISO 8601. Tokens: yyyy, MM, dd, HH, mm, ss, SSS.',
+        displayOptions: show({ transform: ['date'] }),
+    },
+    {
+        displayName: 'Lookup Table',
+        name: 'lookupTable',
+        type: 'string',
+        typeOptions: { rows: 4 },
+        default: '',
+        placeholder: 'NL=Netherlands\nDE=Germany',
+        description: 'One key=value per line, or a JSON object',
+        displayOptions: show({ transform: ['lookup'] }),
+    },
+    {
+        displayName: 'If No Match',
+        name: 'lookupFallback',
+        type: 'options',
+        options: [
+            { name: 'Keep Original Value', value: 'keep' },
+            { name: 'Use Default', value: 'default' },
+            { name: 'Set to Null', value: 'null' },
+            { name: 'Stop With Error', value: 'error' },
+        ],
+        default: 'keep',
+        displayOptions: show({ transform: ['lookup'] }),
+    },
+    {
+        displayName: 'Lookup Default',
+        name: 'lookupDefault',
+        type: 'string',
+        default: '',
+        displayOptions: show({ transform: ['lookup'], lookupFallback: ['default'] }),
+    },
+    {
+        displayName: 'If Source Is Missing',
+        name: 'ifMissing',
+        type: 'options',
+        options: [
+            { name: 'Leave Out', value: 'skip' },
+            { name: 'Set to Null', value: 'null' },
+            { name: 'Use Default', value: 'default' },
+            { name: 'Stop With Error', value: 'error' },
+        ],
+        default: 'skip',
+        displayOptions: show({ sourceType: ['field'] }),
+    },
+    {
+        displayName: 'Default Value',
+        name: 'defaultValue',
+        type: 'string',
+        default: '',
+        displayOptions: show({ sourceType: ['field'], ifMissing: ['default'] }),
+    },
+];
+const exampleDefinition = JSON.stringify([
+    { source: 'id', target: 'orderId' },
+    { source: 'customer.name', target: 'buyer.name', transform: 'trim' },
+    { source: 'items[*].sku', target: 'lines[*].productCode' },
+    { source: 'items[*].qty', target: 'lines[*].quantity', transform: 'integer' },
+    { value: 'EUR', target: 'lines[*].currency' },
+], null, 2);
+class DataMapper {
+    constructor() {
+        this.description = {
+            displayName: 'Data Mapper',
+            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',
+            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'] }),
+                },
+            ],
+        };
+        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, 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) {
+                if (this.continueOnFail()) {
+                    returnData.push({ json: { error: error.message }, pairedItem: { item: i } });
+                    continue;
+                }
+                throw error instanceof n8n_workflow_1.NodeOperationError
+                    ? error
+                    : new n8n_workflow_1.NodeOperationError(this.getNode(), error.message, {
+                        itemIndex: i,
+                        description: error instanceof mapping_1.MappingError ||
+                            error instanceof xml_1.XmlParseError ||
+                            error instanceof profile_1.ProfileError
+                            ? undefined
+                            : 'Unexpected error while mapping this item',
+                    });
+            }
+        }
+        return [returnData];
+    }
+}
+exports.DataMapper = DataMapper;
+async function readInput(ctx, item, itemIndex) {
+    const source = ctx.getNodeParameter('inputSource', itemIndex);
+    if (source === 'json')
+        return item.json;
+    let text;
+    if (source === 'field') {
+        const field = ctx.getNodeParameter('inputField', itemIndex);
+        const value = item.json[field];
+        if (value === undefined) {
+            throw new n8n_workflow_1.NodeOperationError(ctx.getNode(), `Input field "${field}" does not exist`, { itemIndex });
+        }
+        if (typeof value === 'object')
+            return value;
+        text = String(value);
+    }
+    else {
+        const field = ctx.getNodeParameter('inputBinaryField', itemIndex);
+        ctx.helpers.assertBinaryData(itemIndex, field);
+        text = (await ctx.helpers.getBinaryDataBuffer(itemIndex, field)).toString('utf8');
+    }
+    const format = ctx.getNodeParameter('inputFormat', itemIndex, 'auto');
+    const trimmed = text.replace(/^\uFEFF/, '').trim();
+    const isXml = format === 'xml' || (format === 'auto' && trimmed.startsWith('<'));
+    if (isXml) {
+        return (0, xml_1.xmlToJson)((0, xml_1.parseXml)(trimmed), {
+            attributes: 'group',
+            attributeKey: '$',
+            textKey: '_',
+            includeRoot: true,
+            alwaysArray: false,
+            trim: true,
+        });
+    }
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch (error) {
+        throw new n8n_workflow_1.NodeOperationError(ctx.getNode(), 'The input is not valid JSON', {
+            itemIndex,
+            description: error.message,
+        });
+    }
+}
+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 { 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);
+    const pairedItem = { item: itemIndex };
+    if (format === 'json')
+        return { json: mapped, pairedItem };
+    if (format === 'jsonFile') {
+        const field = ctx.getNodeParameter('outputBinaryField', itemIndex);
+        const fileName = ctx.getNodeParameter('fileName', itemIndex, '') || 'output.json';
+        const binary = await ctx.helpers.prepareBinaryData(Buffer.from(JSON.stringify(mapped, null, 2), 'utf8'), fileName, 'application/json');
+        return { json: {}, binary: { [field]: binary }, pairedItem };
+    }
+    const xml = (0, xml_1.jsonToXml)(mapped, {
+        rootName: ctx.getNodeParameter('rootElement', itemIndex, '') || undefined,
+        declaration: ctx.getNodeParameter('xmlDeclaration', itemIndex, true),
+        attributeKey: '$',
+        textKey: '_',
+    });
+    if (format === 'xml') {
+        const field = ctx.getNodeParameter('outputField', itemIndex);
+        return { json: { [field]: xml }, pairedItem };
+    }
+    const field = ctx.getNodeParameter('outputBinaryField', itemIndex);
+    const fileName = ctx.getNodeParameter('fileName', itemIndex, '') || 'output.xml';
+    const binary = await ctx.helpers.prepareBinaryData(Buffer.from(xml, 'utf8'), fileName, 'application/xml');
+    return { json: {}, binary: { [field]: binary }, pairedItem };
+}
+//# sourceMappingURL=DataMapper.node.js.map