n8n-nodes-zugferd-reader 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,171 @@
+# N8N ZUGFeRD Reader Node
+
+Ein N8N Custom Node zum Extrahieren von ZUGFeRD/Factur-X XML-Daten aus PDF-Rechnungen.
+
+## Features
+
+- ✅ Extrahiert ZUGFeRD und Factur-X XML aus PDF-Dateien
+- ✅ Automatische Erkennung der XML-Anhänge
+- ✅ Unterstützt Binary Data und Dateipfad als Input
+- ✅ Ausgabe als JSON oder Raw XML
+- ✅ Listet alle verfügbaren Anhänge auf
+
+## Installation
+
+### In N8N installieren
+
+1. **Als Community Node:**
+   ```bash
+   npm install n8n-nodes-zugferd-reader
+   ```
+
+2. **Manuell installieren:**
+   ```bash
+   # Projekt bauen
+   npm install
+   npm run build
+
+   # In N8N custom nodes Verzeichnis kopieren
+   cp -r dist ~/.n8n/custom/
+   ```
+
+3. **Entwicklungsmodus:**
+   ```bash
+   npm install
+   npm run dev
+
+   # N8N mit custom nodes starten
+   n8n start
+   ```
+
+## Verwendung
+
+### Input Modes
+
+**Binary Data (Standard):**
+- Verwendet die Binary Data aus einem vorherigen Node
+- Ideal für Workflows mit HTTP Request, Read Binary File, etc.
+
+**File Path:**
+- Liest PDF direkt vom Dateisystem
+- Nützlich für lokale Dateien
+
+### Output Formats
+
+**Parsed JSON (Standard):**
+- Wandelt XML in JSON um
+- Einfach zu verarbeiten in nachfolgenden Nodes
+
+**Raw XML:**
+- Gibt das originale XML zurück
+- Nützlich wenn du das XML weiterverarbeiten möchtest
+
+**Both:**
+- Gibt sowohl JSON als auch XML zurück
+
+### Beispiel Workflow
+
+```
+┌─────────────────┐    ┌──────────────────┐    ┌─────────────┐
+│  HTTP Request   │───▶│  ZUGFeRD Reader  │───▶│  Process    │
+│  (Get PDF)      │    │                  │    │  Invoice    │
+└─────────────────┘    └──────────────────┘    └─────────────┘
+```
+
+### Beispiel Output
+
+```json
+{
+  "attachmentName": "factur-x.xml",
+  "availableAttachments": ["factur-x.xml"],
+  "invoice": {
+    "rsm:CrossIndustryInvoice": {
+      "rsm:ExchangedDocumentContext": {
+        "ram:GuidelineSpecifiedDocumentContextParameter": {
+          "ram:ID": "urn:cen.eu:en16931:2017"
+        }
+      },
+      "rsm:ExchangedDocument": {
+        "ram:ID": "RE-2024-0001",
+        "ram:TypeCode": "380",
+        "ram:IssueDateTime": {
+          "@_format": "102",
+          "#text": "20240115"
+        }
+      },
+      "rsm:SupplyChainTradeTransaction": {
+        "ram:ApplicableHeaderTradeAgreement": {
+          "ram:SellerTradeParty": {
+            "ram:Name": "Muster GmbH"
+          },
+          "ram:BuyerTradeParty": {
+            "ram:Name": "Kunde AG"
+          }
+        },
+        "ram:ApplicableHeaderTradeSettlement": {
+          "ram:InvoiceCurrencyCode": "EUR",
+          "ram:SpecifiedTradeSettlementHeaderMonetarySummation": {
+            "ram:TaxBasisTotalAmount": "1000.00",
+            "ram:TaxTotalAmount": "190.00",
+            "ram:GrandTotalAmount": "1190.00"
+          }
+        }
+      }
+    }
+  }
+}
+```
+
+## Unterstützte Standards
+
+- ZUGFeRD 1.0 / 2.x
+- Factur-X
+- XRechnung
+- EN16931 (CII Format)
+
+## Technische Details
+
+### Dependencies
+
+- `pdf-lib`: PDF-Manipulation und Anhang-Extraktion
+- `fast-xml-parser`: Schnelles XML-zu-JSON Parsing
+
+### Wie es funktioniert
+
+1. PDF wird geladen (aus Binary Data oder Dateisystem)
+2. Eingebettete Dateien werden aus dem PDF extrahiert
+3. XML-Anhänge werden identifiziert (auto oder custom)
+4. XML wird optional zu JSON geparst
+5. Daten werden als Output zurückgegeben
+
+### Error Handling
+
+Der Node bietet detaillierte Fehlermeldungen:
+- Keine eingebetteten Dateien gefunden
+- Kein ZUGFeRD XML gefunden (mit Liste verfügbarer Anhänge)
+- PDF-Lesefehler
+- XML-Parsing-Fehler
+
+## Entwicklung
+
+```bash
+# Dependencies installieren
+npm install
+
+# TypeScript kompilieren
+npm run build
+
+# Watch mode für Entwicklung
+npm run dev
+
+# In lokalem N8N testen
+N8N_CUSTOM_EXTENSIONS=~/.n8n/custom n8n start
+```
+
+## Lizenz
+
+MIT
+
+## Support
+
+Bei Problemen oder Fragen, bitte ein Issue erstellen.

package/USAGE.md

@@ -0,0 +1,207 @@
+# Verwendungsbeispiele
+
+## Beispiel 1: PDF von URL laden und verarbeiten
+
+```
+HTTP Request (GET PDF) → ZUGFeRD Reader → Set Node (Rechnung verarbeiten)
+```
+
+**HTTP Request Node:**
+- Method: GET
+- URL: `https://example.com/invoice.pdf`
+- Response Format: File
+- Binary Property: `data`
+
+**ZUGFeRD Reader Node:**
+- Input Mode: Binary Data
+- Binary Property: `data`
+- Output Format: Parsed JSON
+
+**Set Node (Rechnung verarbeiten):**
+```javascript
+// Zugriff auf Rechnungsdaten
+const invoice = $json.invoice;
+const rechnungsNr = invoice['rsm:CrossIndustryInvoice']?.['rsm:ExchangedDocument']?.['ram:ID'];
+const gesamtBetrag = invoice['rsm:CrossIndustryInvoice']?.['rsm:SupplyChainTradeTransaction']?.['ram:ApplicableHeaderTradeSettlement']?.['ram:SpecifiedTradeSettlementHeaderMonetarySummation']?.['ram:GrandTotalAmount'];
+
+return {
+  rechnungsNummer: rechnungsNr,
+  betrag: parseFloat(gesamtBetrag),
+  waehrung: 'EUR'
+};
+```
+
+## Beispiel 2: Lokale PDF-Datei lesen
+
+**ZUGFeRD Reader Node:**
+- Input Mode: File Path
+- File Path: `/path/to/invoice.pdf`
+- Output Format: Both (JSON + XML)
+
+## Beispiel 3: E-Mail-Anhang verarbeiten
+
+```
+Email Trigger → Extract Attachments → ZUGFeRD Reader → Database Insert
+```
+
+**Email Trigger:**
+- Wartet auf neue E-Mails mit PDF-Anhängen
+
+**Extract Attachments:**
+- Extrahiert PDF aus E-Mail
+
+**ZUGFeRD Reader:**
+- Input Mode: Binary Data
+- Binary Property: `data`
+- Output Format: Parsed JSON
+
+**Database Insert:**
+- Speichert Rechnungsdaten in Datenbank
+
+## Beispiel 4: Batch-Verarbeitung mehrerer PDFs
+
+```
+Read Binary Files (*.pdf) → ZUGFeRD Reader → Function Node → Spreadsheet
+```
+
+**Function Node - Daten aufbereiten:**
+```javascript
+const items = [];
+
+for (const item of $input.all()) {
+  const invoice = item.json.invoice?.['rsm:CrossIndustryInvoice'];
+
+  if (invoice) {
+    const doc = invoice['rsm:ExchangedDocument'];
+    const trade = invoice['rsm:SupplyChainTradeTransaction'];
+    const seller = trade?.['ram:ApplicableHeaderTradeAgreement']?.['ram:SellerTradeParty'];
+    const buyer = trade?.['ram:ApplicableHeaderTradeAgreement']?.['ram:BuyerTradeParty'];
+    const monetary = trade?.['ram:ApplicableHeaderTradeSettlement']?.['ram:SpecifiedTradeSettlementHeaderMonetarySummation'];
+
+    items.push({
+      json: {
+        rechnungsNummer: doc?.['ram:ID'],
+        datum: doc?.['ram:IssueDateTime']?.['#text'],
+        lieferant: seller?.['ram:Name'],
+        kunde: buyer?.['ram:Name'],
+        nettoBetrag: monetary?.['ram:TaxBasisTotalAmount'],
+        steuerBetrag: monetary?.['ram:TaxTotalAmount'],
+        bruttoBetrag: monetary?.['ram:GrandTotalAmount'],
+        waehrung: trade?.['ram:ApplicableHeaderTradeSettlement']?.['ram:InvoiceCurrencyCode']
+      }
+    });
+  }
+}
+
+return items;
+```
+
+## Beispiel 5: Fehlerbehandlung
+
+**ZUGFeRD Reader Node:**
+- Aktiviere "Continue On Fail" in den Node Settings
+- Bei Fehler wird ein Error-Objekt zurückgegeben
+
+**IF Node - Fehlerprüfung:**
+```javascript
+// Prüfe ob Fehler aufgetreten ist
+return $json.error === undefined;
+```
+
+**Bei Erfolg:** Weiter zur Verarbeitung
+**Bei Fehler:** Log-Node oder Benachrichtigung
+
+## Beispiel 6: Verschiedene ZUGFeRD-Versionen
+
+Der Node erkennt automatisch:
+- ZUGFeRD 1.0 (`ZUGFeRD-invoice.xml`)
+- ZUGFeRD 2.x (`factur-x.xml`)
+- XRechnung (`xrechnung.xml`)
+
+Wenn Auto-Detect nicht funktioniert:
+- XML Attachment Name: Custom Name
+- Custom Attachment Name: `dein-custom-name.xml`
+
+## Typische Datenstruktur (ZUGFeRD 2.x / Factur-X)
+
+```json
+{
+  "rsm:CrossIndustryInvoice": {
+    "@_xmlns:rsm": "urn:un:unece:uncefact:data:standard:CrossIndustryInvoice:100",
+    "@_xmlns:ram": "urn:un:unece:uncefact:data:standard:ReusableAggregateBusinessInformationEntity:100",
+    "@_xmlns:qdt": "urn:un:unece:uncefact:data:standard:QualifiedDataType:100",
+    "@_xmlns:udt": "urn:un:unece:uncefact:data:standard:UnqualifiedDataType:100",
+
+    "rsm:ExchangedDocumentContext": {
+      "ram:GuidelineSpecifiedDocumentContextParameter": {
+        "ram:ID": "urn:cen.eu:en16931:2017#compliant#urn:factur-x.eu:1p0:extended"
+      }
+    },
+
+    "rsm:ExchangedDocument": {
+      "ram:ID": "RE-2024-0001",
+      "ram:TypeCode": "380",
+      "ram:IssueDateTime": {
+        "@_format": "102",
+        "#text": "20240115"
+      }
+    },
+
+    "rsm:SupplyChainTradeTransaction": {
+      "ram:ApplicableHeaderTradeAgreement": {
+        "ram:SellerTradeParty": {
+          "ram:Name": "Lieferant GmbH",
+          "ram:PostalTradeAddress": {
+            "ram:PostcodeCode": "12345",
+            "ram:LineOne": "Musterstraße 1",
+            "ram:CityName": "Berlin",
+            "ram:CountryID": "DE"
+          },
+          "ram:SpecifiedTaxRegistration": {
+            "ram:ID": {
+              "@_schemeID": "VA",
+              "#text": "DE123456789"
+            }
+          }
+        },
+        "ram:BuyerTradeParty": {
+          "ram:Name": "Kunde AG"
+        }
+      },
+
+      "ram:ApplicableHeaderTradeSettlement": {
+        "ram:InvoiceCurrencyCode": "EUR",
+        "ram:SpecifiedTradeSettlementHeaderMonetarySummation": {
+          "ram:TaxBasisTotalAmount": "1000.00",
+          "ram:TaxTotalAmount": {
+            "@_currencyID": "EUR",
+            "#text": "190.00"
+          },
+          "ram:GrandTotalAmount": {
+            "@_currencyID": "EUR",
+            "#text": "1190.00"
+          },
+          "ram:DuePayableAmount": {
+            "@_currencyID": "EUR",
+            "#text": "1190.00"
+          }
+        }
+      }
+    }
+  }
+}
+```
+
+## Tipps
+
+1. **Namespace Handling:** ZUGFeRD/Factur-X verwendet XML-Namespaces (`rsm:`, `ram:`, etc.). Diese werden im JSON beibehalten.
+
+2. **Attribute vs. Text:** XML-Attribute werden mit `@_` prefix gespeichert, Text-Content als `#text`.
+
+3. **Array vs. Objekt:** Einzelne Elemente werden als Objekt geparst, mehrere als Array. Prüfe immer mit `Array.isArray()`.
+
+4. **Währungen:** Beträge haben oft ein `@_currencyID` Attribut.
+
+5. **Datumsformat:** Datum ist oft im Format `YYYYMMDD` (format="102").
+
+6. **Debugging:** Nutze "Both" als Output Format um das Original-XML zu sehen.

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "n8n-nodes-zugferd-reader",
+  "version": "1.0.0",
+  "description": "N8N node to extract ZUGFeRD/Factur-X XML from PDF invoices",
+  "main": "index.js",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch"
+  },
+  "keywords": [
+    "n8n-community-node-package",
+    "n8n",
+    "zugferd",
+    "factur-x",
+    "invoice",
+    "pdf",
+    "xml"
+  ],
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "nodes": [
+      "dist/nodes/ZugferdReader/ZugferdReader.node.js"
+    ]
+  },
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "n8n-workflow": "^1.68.0",
+    "typescript": "^5.3.3"
+  },
+  "dependencies": {
+    "pdf-lib": "^1.17.1",
+    "fast-xml-parser": "^4.3.4"
+  }
+}

package/src/index.ts

@@ -0,0 +1 @@
+export { ZugferdReader } from './nodes/ZugferdReader/ZugferdReader.node';

package/src/nodes/ZugferdReader/ZugferdReader.node.ts

@@ -0,0 +1,331 @@
+import {
+	IExecuteFunctions,
+	INodeExecutionData,
+	INodeType,
+	INodeTypeDescription,
+	NodeOperationError,
+} from 'n8n-workflow';
+
+import { PDFDocument } from 'pdf-lib';
+import { XMLParser } from 'fast-xml-parser';
+
+interface EmbeddedFile {
+	name: string;
+	data: string;
+}
+
+function extractNamesArray(obj: any): any[] {
+	if (obj.lookup) {
+		const kids = obj.lookup('Kids');
+		if (kids && Array.isArray(kids)) {
+			let result: any[] = [];
+			for (const kid of kids) {
+				result = result.concat(extractNamesArray(kid));
+			}
+			return result;
+		}
+
+		const names = obj.lookup('Names');
+		if (names && Array.isArray(names)) {
+			return names;
+		}
+	}
+
+	return [];
+}
+
+function getEmbeddedFiles(pdfDoc: PDFDocument): EmbeddedFile[] {
+	const embeddedFiles: EmbeddedFile[] = [];
+
+	try {
+		const context = pdfDoc.context;
+		const catalog = context.lookup(context.trailerInfo.Root) as any;
+
+		if (!catalog || !catalog.get) {
+			return embeddedFiles;
+		}
+
+		const names = catalog.lookup('Names');
+		if (!names) {
+			return embeddedFiles;
+		}
+
+		const embeddedFilesRef = names.lookup('EmbeddedFiles');
+		if (!embeddedFilesRef) {
+			return embeddedFiles;
+		}
+
+		const namesArray = extractNamesArray(embeddedFilesRef);
+
+		for (let i = 0; i < namesArray.length; i += 2) {
+			const fileName = namesArray[i];
+			const fileSpec = namesArray[i + 1];
+
+			if (fileSpec && fileSpec.lookup) {
+				const efDict = fileSpec.lookup('EF');
+				if (efDict && efDict.lookup) {
+					const fileStream = efDict.lookup('F');
+					if (fileStream && fileStream.contents) {
+						const contents = fileStream.contents;
+						const decoder = new TextDecoder('utf-8');
+						const text = decoder.decode(contents);
+						embeddedFiles.push({
+							name: fileName,
+							data: text,
+						});
+					}
+				}
+			}
+		}
+	} catch (error) {
+		// If extraction fails, return empty array
+	}
+
+	return embeddedFiles;
+}
+
+export class ZugferdReader implements INodeType {
+	description: INodeTypeDescription = {
+		displayName: 'ZUGFeRD Reader',
+		name: 'zugferdReader',
+		icon: 'file:zugferd.svg',
+		group: ['transform'],
+		version: 1,
+		description: 'Extract ZUGFeRD/Factur-X XML data from PDF invoices',
+		defaults: {
+			name: 'ZUGFeRD Reader',
+		},
+		inputs: ['main'],
+		outputs: ['main'],
+		properties: [
+			{
+				displayName: 'Input Mode',
+				name: 'inputMode',
+				type: 'options',
+				options: [
+					{
+						name: 'Binary Data',
+						value: 'binary',
+						description: 'Read PDF from binary data property',
+					},
+					{
+						name: 'File Path',
+						value: 'filepath',
+						description: 'Read PDF from file system path',
+					},
+				],
+				default: 'binary',
+				description: 'How to provide the PDF file',
+			},
+			{
+				displayName: 'Binary Property',
+				name: 'binaryProperty',
+				type: 'string',
+				default: 'data',
+				required: true,
+				displayOptions: {
+					show: {
+						inputMode: ['binary'],
+					},
+				},
+				description: 'Name of the binary property containing the PDF',
+			},
+			{
+				displayName: 'File Path',
+				name: 'filePath',
+				type: 'string',
+				default: '',
+				required: true,
+				displayOptions: {
+					show: {
+						inputMode: ['filepath'],
+					},
+				},
+				description: 'Path to the PDF file on the file system',
+			},
+			{
+				displayName: 'Output Format',
+				name: 'outputFormat',
+				type: 'options',
+				options: [
+					{
+						name: 'Parsed JSON',
+						value: 'json',
+						description: 'Parse XML and return as JSON object',
+					},
+					{
+						name: 'Raw XML',
+						value: 'xml',
+						description: 'Return raw XML string',
+					},
+					{
+						name: 'Both',
+						value: 'both',
+						description: 'Return both parsed JSON and raw XML',
+					},
+				],
+				default: 'json',
+				description: 'Format of the output data',
+			},
+			{
+				displayName: 'XML Attachment Name',
+				name: 'xmlAttachmentName',
+				type: 'options',
+				options: [
+					{
+						name: 'Auto-Detect',
+						value: 'auto',
+						description: 'Automatically detect ZUGFeRD/Factur-X XML',
+					},
+					{
+						name: 'Custom Name',
+						value: 'custom',
+						description: 'Specify custom attachment name',
+					},
+				],
+				default: 'auto',
+				description: 'Name of the XML attachment in the PDF',
+			},
+			{
+				displayName: 'Custom Attachment Name',
+				name: 'customAttachmentName',
+				type: 'string',
+				default: '',
+				displayOptions: {
+					show: {
+						xmlAttachmentName: ['custom'],
+					},
+				},
+				description: 'Custom name of the XML attachment to extract',
+			},
+		],
+	};
+
+	async execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
+		const items = this.getInputData();
+		const returnData: INodeExecutionData[] = [];
+
+		for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
+			try {
+				const inputMode = this.getNodeParameter('inputMode', itemIndex) as string;
+				const outputFormat = this.getNodeParameter('outputFormat', itemIndex) as string;
+				const xmlAttachmentName = this.getNodeParameter('xmlAttachmentName', itemIndex) as string;
+
+				let pdfBytes: Uint8Array;
+
+				// Get PDF data based on input mode
+				if (inputMode === 'binary') {
+					const binaryProperty = this.getNodeParameter('binaryProperty', itemIndex) as string;
+					const binaryData = this.helpers.assertBinaryData(itemIndex, binaryProperty);
+					pdfBytes = await this.helpers.getBinaryDataBuffer(itemIndex, binaryProperty);
+				} else {
+					const filePath = this.getNodeParameter('filePath', itemIndex) as string;
+					const fs = await import('fs/promises');
+					pdfBytes = await fs.readFile(filePath);
+				}
+
+				// Load PDF document
+				const pdfDoc = await PDFDocument.load(pdfBytes);
+
+				// Get embedded files
+				const embeddedFiles = getEmbeddedFiles(pdfDoc);
+
+				if (embeddedFiles.length === 0) {
+					throw new NodeOperationError(
+						this.getNode(),
+						'No embedded files found in PDF',
+						{ itemIndex }
+					);
+				}
+
+				// Find ZUGFeRD/Factur-X XML
+				let xmlData: string | null = null;
+				let foundAttachmentName: string | null = null;
+
+				if (xmlAttachmentName === 'auto') {
+					// Auto-detect common ZUGFeRD/Factur-X names
+					const commonNames = [
+						'factur-x.xml',
+						'FacturX.xml',
+						'zugferd-invoice.xml',
+						'ZUGFeRD-invoice.xml',
+						'xrechnung.xml',
+						'XRechnung.xml',
+					];
+
+					for (const file of embeddedFiles) {
+						const fileName = file.name.toLowerCase();
+						if (
+							commonNames.some(name => fileName.includes(name.toLowerCase())) ||
+							fileName.endsWith('.xml')
+						) {
+							xmlData = file.data;
+							foundAttachmentName = file.name;
+							break;
+						}
+					}
+				} else {
+					const customName = this.getNodeParameter('customAttachmentName', itemIndex) as string;
+					const file = embeddedFiles.find((f: EmbeddedFile) => f.name === customName);
+					if (file) {
+						xmlData = file.data;
+						foundAttachmentName = file.name;
+					}
+				}
+
+				if (!xmlData) {
+					throw new NodeOperationError(
+						this.getNode(),
+						`No ZUGFeRD/Factur-X XML found. Available attachments: ${embeddedFiles.map((f: EmbeddedFile) => f.name).join(', ')}`,
+						{ itemIndex }
+					);
+				}
+
+				// Prepare output based on format
+				let json: any = {};
+
+				if (outputFormat === 'json' || outputFormat === 'both') {
+					const parser = new XMLParser({
+						ignoreAttributes: false,
+						attributeNamePrefix: '@_',
+						textNodeName: '#text',
+						parseAttributeValue: true,
+						parseTagValue: true,
+					});
+					json = parser.parse(xmlData);
+				}
+
+				const outputData: any = {
+					attachmentName: foundAttachmentName,
+					availableAttachments: embeddedFiles.map((f: EmbeddedFile) => f.name),
+				};
+
+				if (outputFormat === 'json') {
+					outputData.invoice = json;
+				} else if (outputFormat === 'xml') {
+					outputData.xml = xmlData;
+				} else {
+					outputData.invoice = json;
+					outputData.xml = xmlData;
+				}
+
+				returnData.push({
+					json: outputData,
+				});
+
+			} catch (error) {
+				if (this.continueOnFail()) {
+					returnData.push({
+						json: {
+							error: error instanceof Error ? error.message : String(error),
+						},
+					});
+					continue;
+				}
+				throw error;
+			}
+		}
+
+		return [returnData];
+	}
+}

package/src/nodes/ZugferdReader/zugferd.svg

@@ -0,0 +1,10 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+  <!-- PDF Document -->
+  <path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"/>
+  <polyline points="14 2 14 8 20 8"/>
+
+  <!-- XML/Code Symbol -->
+  <path d="M9 15l-2 2 2 2"/>
+  <path d="M15 15l2 2-2 2"/>
+  <line x1="11" y1="19" x2="13" y2="13"/>
+</svg>

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "declaration": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "moduleResolution": "node"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}