@fin.cx/einvoice 5.0.2

package/dist_ts/einvoice.js

@@ -0,0 +1,505 @@
+import * as plugins from './plugins.js';
+import { business, finance } from './plugins.js';
+import { InvoiceFormat, ValidationLevel } from './interfaces/common.js';
+// Import error classes
+import { EInvoiceError, EInvoiceParsingError, EInvoiceValidationError, EInvoicePDFError, EInvoiceFormatError, ErrorContext } from './errors.js';
+// Import factories
+import { DecoderFactory } from './formats/factories/decoder.factory.js';
+import { EncoderFactory } from './formats/factories/encoder.factory.js';
+import { ValidatorFactory } from './formats/factories/validator.factory.js';
+// Import PDF utilities
+import { PDFEmbedder } from './formats/pdf/pdf.embedder.js';
+import { PDFExtractor } from './formats/pdf/pdf.extractor.js';
+// Import format detector
+import { FormatDetector } from './formats/utils/format.detector.js';
+/**
+ * Main class for working with electronic invoices.
+ * Supports various invoice formats including Factur-X, ZUGFeRD, UBL, and XRechnung
+ * Extends the TInvoice interface for seamless integration with existing systems
+ */
+export class EInvoice {
+    /**
+     * Creates an EInvoice instance from XML string
+     * @param xmlString XML string to parse
+     * @returns EInvoice instance
+     */
+    static async fromXml(xmlString) {
+        const invoice = new EInvoice();
+        await invoice.fromXmlString(xmlString);
+        return invoice;
+    }
+    /**
+     * Creates an EInvoice instance from file
+     * @param filePath Path to the file
+     * @returns EInvoice instance
+     */
+    static async fromFile(filePath) {
+        const invoice = new EInvoice();
+        await invoice.fromFile(filePath);
+        return invoice;
+    }
+    /**
+     * Creates an EInvoice instance from PDF
+     * @param pdfBuffer PDF buffer
+     * @returns EInvoice instance
+     */
+    static async fromPdf(pdfBuffer) {
+        const invoice = new EInvoice();
+        if (typeof pdfBuffer === 'string') {
+            // If given a file path
+            await invoice.fromPdfFile(pdfBuffer);
+        }
+        else {
+            // If given a buffer, extract XML and parse it
+            const extractResult = await invoice.pdfExtractor.extractXml(pdfBuffer);
+            if (!extractResult.success || !extractResult.xml) {
+                throw new EInvoicePDFError('No invoice XML found in PDF', 'extract');
+            }
+            await invoice.fromXmlString(extractResult.xml);
+        }
+        return invoice;
+    }
+    // Backward compatibility properties
+    get invoiceId() { return this.accountingDocId; }
+    set invoiceId(value) { this.accountingDocId = value; }
+    get invoiceType() {
+        return this.accountingDocType === 'invoice' ? 'invoice' :
+            this.accountingDocType === 'creditnote' ? 'creditnote' : 'debitnote';
+    }
+    set invoiceType(value) {
+        this.accountingDocType = 'invoice'; // Always set to invoice for TInvoice type
+    }
+    // Computed properties for convenience
+    get issueDate() {
+        return new Date(this.date);
+    }
+    set issueDate(value) {
+        this.date = value.getTime();
+    }
+    get totalNet() {
+        return this.calculateTotalNet();
+    }
+    get totalVat() {
+        return this.calculateTotalVat();
+    }
+    get totalGross() {
+        return this.totalNet + this.totalVat;
+    }
+    get taxBreakdown() {
+        return this.calculateTaxBreakdown();
+    }
+    /**
+     * Creates a new EInvoice instance
+     * @param options Configuration options
+     */
+    constructor(options) {
+        // TInvoice interface properties - accounting document structure
+        this.type = 'accounting-doc';
+        this.accountingDocType = 'invoice';
+        this.accountingDocId = '';
+        this.accountingDocStatus = 'issued';
+        // Business envelope properties
+        this.id = '';
+        this.date = Date.now();
+        this.status = 'issued';
+        this.subject = '';
+        this.versionInfo = {
+            type: 'draft',
+            version: '1.0.0'
+        };
+        // Additional envelope properties
+        this.incidenceId = '';
+        this.language = 'en';
+        this.objectActions = [];
+        this.pdf = null;
+        this.pdfAttachments = null;
+        this.accentColor = null;
+        this.logoUrl = null;
+        // Accounting document specific properties
+        this.items = [];
+        this.dueInDays = 30;
+        this.reverseCharge = false;
+        this.currency = 'EUR';
+        this.notes = [];
+        this.xmlString = '';
+        this.detectedFormat = InvoiceFormat.UNKNOWN;
+        this.validationErrors = [];
+        this.options = {
+            validateOnLoad: false,
+            validationLevel: ValidationLevel.SYNTAX
+        };
+        // PDF utilities
+        this.pdfEmbedder = new PDFEmbedder();
+        this.pdfExtractor = new PDFExtractor();
+        // Initialize empty contact objects
+        this.from = this.createEmptyContact();
+        this.to = this.createEmptyContact();
+        // Apply options if provided
+        if (options) {
+            this.options = { ...this.options, ...options };
+        }
+    }
+    /**
+     * Creates an empty TContact object
+     */
+    createEmptyContact() {
+        return {
+            type: 'company',
+            name: '',
+            description: '',
+            address: {
+                streetName: '',
+                houseNumber: '',
+                city: '',
+                postalCode: '',
+                country: ''
+            },
+            registrationDetails: {
+                vatId: '',
+                registrationId: '',
+                registrationName: ''
+            },
+            status: 'active',
+            foundedDate: {
+                year: new Date().getFullYear(),
+                month: new Date().getMonth() + 1,
+                day: new Date().getDate()
+            }
+        };
+    }
+    /**
+     * Exports the invoice as XML in the specified format
+     * @param format The export format
+     * @returns XML string
+     */
+    async exportXml(format) {
+        return this.toXmlString(format);
+    }
+    /**
+     * Loads invoice data from XML (alias for fromXmlString)
+     * @param xmlString The XML string to parse
+     * @returns The EInvoice instance for chaining
+     */
+    async loadXml(xmlString) {
+        return this.fromXmlString(xmlString);
+    }
+    /**
+     * Loads invoice data from an XML string
+     * @param xmlString The XML string to parse
+     * @returns The EInvoice instance for chaining
+     */
+    async fromXmlString(xmlString) {
+        try {
+            this.xmlString = xmlString;
+            // Detect format
+            this.detectedFormat = FormatDetector.detectFormat(xmlString);
+            if (this.detectedFormat === InvoiceFormat.UNKNOWN) {
+                throw new EInvoiceFormatError('Unknown invoice format', { sourceFormat: 'unknown' });
+            }
+            // Get appropriate decoder
+            const decoder = DecoderFactory.createDecoder(xmlString, !this.options.validateOnLoad);
+            const invoice = await decoder.decode();
+            // Map the decoded invoice to our properties
+            this.mapFromTInvoice(invoice);
+            // Validate if requested
+            if (this.options.validateOnLoad) {
+                await this.validate(this.options.validationLevel);
+            }
+            return this;
+        }
+        catch (error) {
+            if (error instanceof EInvoiceError) {
+                throw error;
+            }
+            throw new EInvoiceParsingError(`Failed to parse XML: ${error.message}`, {}, error);
+        }
+    }
+    /**
+     * Loads invoice data from a file
+     * @param filePath Path to the file to load
+     * @returns The EInvoice instance for chaining
+     */
+    async fromFile(filePath) {
+        try {
+            const fileBuffer = await plugins.fs.readFile(filePath);
+            // Check if it's a PDF
+            if (filePath.toLowerCase().endsWith('.pdf') || fileBuffer.subarray(0, 4).toString() === '%PDF') {
+                return this.fromPdfFile(filePath);
+            }
+            // Otherwise treat as XML
+            const xmlString = fileBuffer.toString('utf-8');
+            return this.fromXmlString(xmlString);
+        }
+        catch (error) {
+            throw new EInvoiceError(`Failed to load file: ${error.message}`, 'FILE_LOAD_ERROR', { filePath });
+        }
+    }
+    /**
+     * Loads invoice data from a PDF file
+     * @param filePath Path to the PDF file
+     * @returns The EInvoice instance for chaining
+     */
+    async fromPdfFile(filePath) {
+        try {
+            const pdfBuffer = await plugins.fs.readFile(filePath);
+            const extractResult = await this.pdfExtractor.extractXml(pdfBuffer);
+            const extractedXml = extractResult.success ? extractResult.xml : null;
+            if (!extractedXml) {
+                throw new EInvoicePDFError('No invoice XML found in PDF', 'extract', { filePath });
+            }
+            // Store the PDF for later use
+            this.pdf = {
+                name: plugins.path.basename(filePath),
+                id: plugins.crypto.createHash('md5').update(pdfBuffer).digest('hex'),
+                buffer: new Uint8Array(pdfBuffer),
+                metadata: {
+                    textExtraction: '',
+                    format: 'PDF/A-3',
+                    embeddedXml: {
+                        filename: 'factur-x.xml',
+                        description: 'Factur-X Invoice'
+                    }
+                }
+            };
+            return this.fromXmlString(extractedXml);
+        }
+        catch (error) {
+            if (error instanceof EInvoiceError) {
+                throw error;
+            }
+            throw new EInvoicePDFError(`Failed to extract invoice from PDF: ${error.message}`, 'extract', {}, error);
+        }
+    }
+    /**
+     * Maps data from a TInvoice to this EInvoice instance
+     */
+    mapFromTInvoice(invoice) {
+        // Map all properties from the decoded invoice
+        Object.assign(this, invoice);
+        // Ensure backward compatibility
+        if (!this.id && this.accountingDocId) {
+            this.id = this.accountingDocId;
+        }
+    }
+    /**
+     * Maps this EInvoice instance to a TInvoice
+     */
+    mapToTInvoice() {
+        const invoice = {
+            type: 'accounting-doc',
+            accountingDocType: this.accountingDocType,
+            accountingDocId: this.accountingDocId || this.id,
+            accountingDocStatus: this.accountingDocStatus,
+            id: this.id,
+            date: this.date,
+            status: this.status,
+            subject: this.subject,
+            versionInfo: this.versionInfo,
+            from: this.from,
+            to: this.to,
+            legalContact: this.legalContact,
+            incidenceId: this.incidenceId,
+            language: this.language,
+            objectActions: this.objectActions,
+            items: this.items,
+            dueInDays: this.dueInDays,
+            reverseCharge: this.reverseCharge,
+            currency: this.currency,
+            notes: this.notes,
+            periodOfPerformance: this.periodOfPerformance,
+            deliveryDate: this.deliveryDate,
+            buyerReference: this.buyerReference,
+            electronicAddress: this.electronicAddress,
+            paymentOptions: this.paymentOptions,
+            relatedDocuments: this.relatedDocuments,
+            printResult: this.printResult
+        };
+        // Preserve metadata for enhanced spec compliance
+        if (this.metadata) {
+            invoice.metadata = this.metadata;
+        }
+        return invoice;
+    }
+    /**
+     * Exports the invoice to an XML string in the specified format
+     * @param format The target format
+     * @returns The XML string
+     */
+    async toXmlString(format) {
+        try {
+            const encoder = EncoderFactory.createEncoder(format);
+            const invoice = this.mapToTInvoice();
+            // Import EN16931Validator dynamically to avoid circular dependency
+            const { EN16931Validator } = await import('./formats/validation/en16931.validator.js');
+            // Validate mandatory fields before encoding
+            EN16931Validator.validateMandatoryFields(invoice);
+            return await encoder.encode(invoice);
+        }
+        catch (error) {
+            throw new EInvoiceFormatError(`Failed to encode to ${format}: ${error.message}`, { targetFormat: format });
+        }
+    }
+    /**
+     * Validates the invoice
+     * @param level The validation level to use
+     * @returns The validation result
+     */
+    async validate(level = ValidationLevel.BUSINESS) {
+        try {
+            const format = this.detectedFormat || InvoiceFormat.UNKNOWN;
+            if (format === InvoiceFormat.UNKNOWN) {
+                throw new EInvoiceValidationError('Cannot validate: format unknown', []);
+            }
+            const validator = ValidatorFactory.createValidator(this.xmlString);
+            const result = validator.validate(level);
+            this.validationErrors = result.errors;
+            return result;
+        }
+        catch (error) {
+            if (error instanceof EInvoiceError) {
+                throw error;
+            }
+            throw new EInvoiceValidationError(`Validation failed: ${error.message}`, [], { validationLevel: level });
+        }
+    }
+    /**
+     * Embeds the invoice XML into a PDF
+     * @param pdfBuffer The PDF buffer to embed into
+     * @param format The format to use for embedding
+     * @returns The PDF buffer with embedded XML
+     */
+    async embedInPdf(pdfBuffer, format = 'facturx') {
+        try {
+            const xmlString = await this.toXmlString(format);
+            const embedResult = await this.pdfEmbedder.embedXml(pdfBuffer, xmlString, 'invoice.xml', `${format} Invoice`);
+            if (!embedResult.success) {
+                throw new EInvoicePDFError('Failed to embed XML in PDF', 'embed', { format });
+            }
+            return embedResult.data;
+        }
+        catch (error) {
+            throw new EInvoicePDFError(`Failed to embed XML in PDF: ${error.message}`, 'embed', { format }, error);
+        }
+    }
+    /**
+     * Saves the invoice to a file
+     * @param filePath The path to save to
+     * @param format The format to save in
+     */
+    async saveToFile(filePath, format) {
+        try {
+            // Determine format from file extension if not provided
+            if (!format && filePath.toLowerCase().endsWith('.xml')) {
+                format = this.detectedFormat === InvoiceFormat.UBL ? 'ubl' :
+                    this.detectedFormat === InvoiceFormat.ZUGFERD ? 'zugferd' :
+                        this.detectedFormat === InvoiceFormat.FACTURX ? 'facturx' :
+                            'xrechnung';
+            }
+            if (filePath.toLowerCase().endsWith('.pdf')) {
+                // Save as PDF with embedded XML
+                if (!this.pdf) {
+                    throw new EInvoiceError('No PDF available to save', 'NO_PDF_ERROR');
+                }
+                const pdfWithXml = await this.embedInPdf(Buffer.from(this.pdf.buffer), format);
+                await plugins.fs.writeFile(filePath, pdfWithXml);
+            }
+            else {
+                // Save as XML
+                const xmlString = await this.toXmlString(format || 'xrechnung');
+                await plugins.fs.writeFile(filePath, xmlString, 'utf-8');
+            }
+        }
+        catch (error) {
+            if (error instanceof EInvoiceError) {
+                throw error;
+            }
+            throw new EInvoiceError(`Failed to save file: ${error.message}`, 'FILE_SAVE_ERROR', { filePath });
+        }
+    }
+    /**
+     * Gets the validation errors
+     * @returns Array of validation errors
+     */
+    getValidationErrors() {
+        return this.validationErrors;
+    }
+    /**
+     * Checks if the invoice is valid
+     * @returns True if valid, false otherwise
+     */
+    isValid() {
+        return this.validationErrors.length === 0;
+    }
+    /**
+     * Gets the detected format
+     * @returns The detected invoice format
+     */
+    getFormat() {
+        return this.detectedFormat;
+    }
+    /**
+     * Gets the original XML string
+     * @returns The XML string
+     */
+    getXml() {
+        return this.xmlString;
+    }
+    /**
+     * Calculates the total net amount
+     */
+    calculateTotalNet() {
+        return this.items.reduce((sum, item) => {
+            return sum + (item.unitQuantity * item.unitNetPrice);
+        }, 0);
+    }
+    /**
+     * Calculates the total VAT amount
+     */
+    calculateTotalVat() {
+        return this.items.reduce((sum, item) => {
+            const net = item.unitQuantity * item.unitNetPrice;
+            return sum + (net * item.vatPercentage / 100);
+        }, 0);
+    }
+    /**
+     * Calculates tax breakdown by rate
+     */
+    calculateTaxBreakdown() {
+        const breakdown = new Map();
+        this.items.forEach(item => {
+            const net = item.unitQuantity * item.unitNetPrice;
+            const tax = net * item.vatPercentage / 100;
+            const current = breakdown.get(item.vatPercentage) || { net: 0, tax: 0 };
+            breakdown.set(item.vatPercentage, {
+                net: current.net + net,
+                tax: current.tax + tax
+            });
+        });
+        return Array.from(breakdown.entries()).map(([rate, amounts]) => ({
+            taxPercent: rate,
+            netAmount: amounts.net,
+            taxAmount: amounts.tax
+        }));
+    }
+    /**
+     * Creates a new invoice item
+     */
+    createItem(data) {
+        return {
+            position: data.position || this.items.length + 1,
+            name: data.name || '',
+            articleNumber: data.articleNumber,
+            unitType: data.unitType || 'unit',
+            unitQuantity: data.unitQuantity || 1,
+            unitNetPrice: data.unitNetPrice || 0,
+            vatPercentage: data.vatPercentage || 0
+        };
+    }
+    /**
+     * Adds an item to the invoice
+     */
+    addItem(item) {
+        this.items.push(this.createItem(item));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"einvoice.js","sourceRoot":"","sources":["../ts/einvoice.ts"],"names":[],"mappings":"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"}

package/dist_ts/errors.d.ts

@@ -0,0 +1,121 @@
+/**
+ * Base error class for all EInvoice-related errors
+ */
+export declare class EInvoiceError extends Error {
+    code: string;
+    details?: any;
+    cause?: Error;
+    constructor(message: string, code: string, details?: any, cause?: Error);
+    /**
+     * Returns a detailed error message including cause if available
+     */
+    getDetailedMessage(): string;
+}
+/**
+ * Error thrown when XML parsing fails
+ */
+export declare class EInvoiceParsingError extends EInvoiceError {
+    line?: number;
+    column?: number;
+    xmlSnippet?: string;
+    constructor(message: string, details?: {
+        line?: number;
+        column?: number;
+        xmlSnippet?: string;
+        format?: string;
+    }, cause?: Error);
+    /**
+     * Returns a user-friendly error message with location information
+     */
+    getLocationMessage(): string;
+}
+/**
+ * Error thrown when validation fails
+ */
+export declare class EInvoiceValidationError extends EInvoiceError {
+    validationErrors: Array<{
+        code: string;
+        message: string;
+        location?: string;
+        severity?: 'error' | 'warning';
+    }>;
+    constructor(message: string, validationErrors: Array<{
+        code: string;
+        message: string;
+        location?: string;
+        severity?: 'error' | 'warning';
+    }>, details?: any);
+    /**
+     * Returns a formatted validation report
+     */
+    getValidationReport(): string;
+    /**
+     * Gets validation errors by severity
+     */
+    getErrorsBySeverity(severity: 'error' | 'warning'): typeof this.validationErrors;
+}
+/**
+ * Error thrown during PDF operations
+ */
+export declare class EInvoicePDFError extends EInvoiceError {
+    operation: 'extract' | 'embed' | 'create' | 'validate';
+    pdfInfo?: {
+        filename?: string;
+        size?: number;
+        pageCount?: number;
+    };
+    constructor(message: string, operation: 'extract' | 'embed' | 'create' | 'validate', details?: any, cause?: Error);
+    /**
+     * Returns recovery suggestions based on the operation
+     */
+    getRecoverySuggestions(): string[];
+}
+/**
+ * Error thrown for format-specific issues
+ */
+export declare class EInvoiceFormatError extends EInvoiceError {
+    sourceFormat?: string;
+    targetFormat?: string;
+    unsupportedFeatures?: string[];
+    constructor(message: string, details: {
+        sourceFormat?: string;
+        targetFormat?: string;
+        unsupportedFeatures?: string[];
+        conversionPath?: string;
+    }, cause?: Error);
+    /**
+     * Returns a compatibility report
+     */
+    getCompatibilityReport(): string;
+}
+/**
+ * Error recovery helper class
+ */
+export declare class ErrorRecovery {
+    /**
+     * Attempts to recover from a parsing error by cleaning the XML
+     */
+    static attemptXMLRecovery(xmlString: string, error: EInvoiceParsingError): Promise<{
+        success: boolean;
+        cleanedXml?: string;
+        message: string;
+    }>;
+    /**
+     * Provides partial data extraction on validation failure
+     */
+    static extractPartialData(xmlString: string, format: string): {
+        success: boolean;
+        partialData?: any;
+        message: string;
+    };
+}
+/**
+ * Error context builder for detailed error information
+ */
+export declare class ErrorContext {
+    private context;
+    add(key: string, value: any): this;
+    addTimestamp(): this;
+    addEnvironment(): this;
+    build(): Record<string, any>;
+}