@fin.cx/einvoice 5.0.3 → 5.1.2

package/dist_ts/formats/validation/facturx.validator.js

@@ -0,0 +1,522 @@
+/**
+ * Factur-X validator for profile-specific compliance
+ * Implements validation for MINIMUM, BASIC, EN16931, and EXTENDED profiles
+ */
+/**
+ * Factur-X Profile definitions
+ */
+export var FacturXProfile;
+(function (FacturXProfile) {
+    FacturXProfile["MINIMUM"] = "MINIMUM";
+    FacturXProfile["BASIC"] = "BASIC";
+    FacturXProfile["BASIC_WL"] = "BASIC_WL";
+    FacturXProfile["EN16931"] = "EN16931";
+    FacturXProfile["EXTENDED"] = "EXTENDED";
+})(FacturXProfile || (FacturXProfile = {}));
+/**
+ * Factur-X Validator
+ * Validates invoices according to Factur-X profile specifications
+ */
+export class FacturXValidator {
+    constructor() {
+        /**
+         * Profile requirements mapping
+         */
+        this.profileRequirements = {
+            [FacturXProfile.MINIMUM]: {
+                mandatory: [
+                    'accountingDocId', // BT-1: Invoice number
+                    'issueDate', // BT-2: Invoice issue date
+                    'accountingDocType', // BT-3: Invoice type code
+                    'currency', // BT-5: Invoice currency code
+                    'from.name', // BT-27: Seller name
+                    'from.vatNumber', // BT-31: Seller VAT identifier
+                    'to.name', // BT-44: Buyer name
+                    'totalInvoiceAmount', // BT-112: Invoice total amount with VAT
+                    'totalNetAmount', // BT-109: Invoice total amount without VAT
+                    'totalVatAmount', // BT-110: Invoice total VAT amount
+                ],
+                optional: []
+            },
+            [FacturXProfile.BASIC]: {
+                mandatory: [
+                    // All MINIMUM fields plus:
+                    'accountingDocId',
+                    'issueDate',
+                    'accountingDocType',
+                    'currency',
+                    'from.name',
+                    'from.vatNumber',
+                    'from.address', // BT-35: Seller postal address
+                    'from.country', // BT-40: Seller country code
+                    'to.name',
+                    'to.address', // BT-50: Buyer postal address
+                    'to.country', // BT-55: Buyer country code
+                    'items', // BG-25: Invoice line items
+                    'items[].name', // BT-153: Item name
+                    'items[].unitQuantity', // BT-129: Invoiced quantity
+                    'items[].unitNetPrice', // BT-146: Item net price
+                    'items[].vatPercentage', // BT-152: Invoiced item VAT rate
+                    'totalInvoiceAmount',
+                    'totalNetAmount',
+                    'totalVatAmount',
+                    'dueDate', // BT-9: Payment due date
+                ],
+                optional: [
+                    'metadata.buyerReference', // BT-10: Buyer reference
+                    'metadata.purchaseOrderReference', // BT-13: Purchase order reference
+                    'metadata.salesOrderReference', // BT-14: Sales order reference
+                    'metadata.contractReference', // BT-12: Contract reference
+                    'projectReference', // BT-11: Project reference
+                ]
+            },
+            [FacturXProfile.BASIC_WL]: {
+                // Basic without lines - for summary invoices
+                mandatory: [
+                    'accountingDocId',
+                    'issueDate',
+                    'accountingDocType',
+                    'currency',
+                    'from.name',
+                    'from.vatNumber',
+                    'from.address',
+                    'from.country',
+                    'to.name',
+                    'to.address',
+                    'to.country',
+                    'totalInvoiceAmount',
+                    'totalNetAmount',
+                    'totalVatAmount',
+                    'dueDate',
+                    // No items required
+                ],
+                optional: [
+                    'metadata.buyerReference',
+                    'metadata.purchaseOrderReference',
+                    'metadata.contractReference',
+                ]
+            },
+            [FacturXProfile.EN16931]: {
+                // Full EN16931 compliance - all mandatory fields from the standard
+                mandatory: [
+                    // Document level
+                    'accountingDocId',
+                    'issueDate',
+                    'accountingDocType',
+                    'currency',
+                    'metadata.buyerReference',
+                    // Seller information
+                    'from.name',
+                    'from.address',
+                    'from.city',
+                    'from.postalCode',
+                    'from.country',
+                    'from.vatNumber',
+                    // Buyer information
+                    'to.name',
+                    'to.address',
+                    'to.city',
+                    'to.postalCode',
+                    'to.country',
+                    // Line items
+                    'items',
+                    'items[].name',
+                    'items[].unitQuantity',
+                    'items[].unitType',
+                    'items[].unitNetPrice',
+                    'items[].vatPercentage',
+                    // Totals
+                    'totalInvoiceAmount',
+                    'totalNetAmount',
+                    'totalVatAmount',
+                    'dueDate',
+                ],
+                optional: [
+                    // All other EN16931 fields
+                    'metadata.purchaseOrderReference',
+                    'metadata.salesOrderReference',
+                    'metadata.contractReference',
+                    'metadata.deliveryDate',
+                    'metadata.paymentTerms',
+                    'metadata.paymentMeans',
+                    'to.vatNumber',
+                    'to.legalRegistration',
+                    'items[].articleNumber',
+                    'items[].description',
+                    'paymentAccount',
+                ]
+            },
+            [FacturXProfile.EXTENDED]: {
+                // Extended profile allows all fields
+                mandatory: [
+                    // Same as EN16931 core
+                    'accountingDocId',
+                    'issueDate',
+                    'accountingDocType',
+                    'currency',
+                    'from.name',
+                    'from.vatNumber',
+                    'to.name',
+                    'totalInvoiceAmount',
+                ],
+                optional: [
+                // All fields are allowed in EXTENDED profile
+                ]
+            }
+        };
+    }
+    /**
+     * Singleton pattern for validator instance
+     */
+    static create() {
+        if (!FacturXValidator.instance) {
+            FacturXValidator.instance = new FacturXValidator();
+        }
+        return FacturXValidator.instance;
+    }
+    /**
+     * Main validation entry point for Factur-X
+     */
+    validateFacturX(invoice, profile) {
+        const results = [];
+        // Detect profile if not provided
+        const detectedProfile = profile || this.detectProfile(invoice);
+        // Skip if not a Factur-X invoice
+        if (!detectedProfile) {
+            return results;
+        }
+        // Validate according to profile
+        results.push(...this.validateProfileRequirements(invoice, detectedProfile));
+        results.push(...this.validateProfileSpecificRules(invoice, detectedProfile));
+        // Add profile-specific business rules
+        if (detectedProfile === FacturXProfile.MINIMUM) {
+            results.push(...this.validateMinimumProfile(invoice));
+        }
+        else if (detectedProfile === FacturXProfile.BASIC || detectedProfile === FacturXProfile.BASIC_WL) {
+            results.push(...this.validateBasicProfile(invoice, detectedProfile));
+        }
+        else if (detectedProfile === FacturXProfile.EN16931) {
+            results.push(...this.validateEN16931Profile(invoice));
+        }
+        else if (detectedProfile === FacturXProfile.EXTENDED) {
+            results.push(...this.validateExtendedProfile(invoice));
+        }
+        return results;
+    }
+    /**
+     * Detect Factur-X profile from invoice metadata
+     */
+    detectProfile(invoice) {
+        const profileId = invoice.metadata?.profileId || '';
+        const customizationId = invoice.metadata?.customizationId || '';
+        const format = invoice.metadata?.format;
+        // Check if it's a Factur-X invoice
+        if (!format?.includes('facturx') && !profileId.includes('facturx') &&
+            !customizationId.includes('facturx') && !profileId.includes('zugferd')) {
+            return null;
+        }
+        // Detect specific profile
+        const profileLower = profileId.toLowerCase();
+        const customLower = customizationId.toLowerCase();
+        if (profileLower.includes('minimum') || customLower.includes('minimum')) {
+            return FacturXProfile.MINIMUM;
+        }
+        else if (profileLower.includes('basic_wl') || customLower.includes('basicwl')) {
+            return FacturXProfile.BASIC_WL;
+        }
+        else if (profileLower.includes('basic') || customLower.includes('basic')) {
+            return FacturXProfile.BASIC;
+        }
+        else if (profileLower.includes('en16931') || customLower.includes('en16931') ||
+            profileLower.includes('comfort') || customLower.includes('comfort')) {
+            return FacturXProfile.EN16931;
+        }
+        else if (profileLower.includes('extended') || customLower.includes('extended')) {
+            return FacturXProfile.EXTENDED;
+        }
+        // Default to BASIC if format is Factur-X but profile unclear
+        return FacturXProfile.BASIC;
+    }
+    /**
+     * Validate field requirements for a specific profile
+     */
+    validateProfileRequirements(invoice, profile) {
+        const results = [];
+        const requirements = this.profileRequirements[profile];
+        // Check mandatory fields
+        for (const field of requirements.mandatory) {
+            const value = this.getFieldValue(invoice, field);
+            if (value === undefined || value === null || value === '') {
+                results.push({
+                    ruleId: `FX-${profile}-M01`,
+                    severity: 'error',
+                    message: `Field '${field}' is mandatory for Factur-X ${profile} profile`,
+                    field: field,
+                    source: 'FACTURX'
+                });
+            }
+        }
+        // Check forbidden fields (if any)
+        if (requirements.forbidden) {
+            for (const field of requirements.forbidden) {
+                const value = this.getFieldValue(invoice, field);
+                if (value !== undefined && value !== null) {
+                    results.push({
+                        ruleId: `FX-${profile}-F01`,
+                        severity: 'error',
+                        message: `Field '${field}' is not allowed in Factur-X ${profile} profile`,
+                        field: field,
+                        value: value,
+                        source: 'FACTURX'
+                    });
+                }
+            }
+        }
+        return results;
+    }
+    /**
+     * Get field value from invoice using dot notation
+     */
+    getFieldValue(invoice, fieldPath) {
+        // Handle special calculated fields
+        if (fieldPath === 'totalInvoiceAmount') {
+            return invoice.totalGross || invoice.totalInvoiceAmount;
+        }
+        if (fieldPath === 'totalNetAmount') {
+            return invoice.totalNet || invoice.totalNetAmount;
+        }
+        if (fieldPath === 'totalVatAmount') {
+            return invoice.totalVat || invoice.totalVatAmount;
+        }
+        if (fieldPath === 'dueDate') {
+            // Check for dueInDays which is used in EInvoice
+            if (invoice.dueInDays !== undefined && invoice.dueInDays !== null) {
+                return true; // Has payment terms
+            }
+            return invoice.dueDate;
+        }
+        const parts = fieldPath.split('.');
+        let value = invoice;
+        for (const part of parts) {
+            if (part.includes('[')) {
+                // Array field like items[]
+                const fieldName = part.substring(0, part.indexOf('['));
+                const arrayField = part.substring(part.indexOf('[') + 1, part.indexOf(']'));
+                if (!value[fieldName] || !Array.isArray(value[fieldName])) {
+                    return undefined;
+                }
+                if (arrayField === '') {
+                    // Check if array exists and has items
+                    return value[fieldName].length > 0 ? value[fieldName] : undefined;
+                }
+                else {
+                    // Check specific field in array items
+                    return value[fieldName].every((item) => item[arrayField] !== undefined);
+                }
+            }
+            else {
+                value = value?.[part];
+            }
+        }
+        return value;
+    }
+    /**
+     * Profile-specific validation rules
+     */
+    validateProfileSpecificRules(invoice, profile) {
+        const results = [];
+        // Validate according to profile level
+        switch (profile) {
+            case FacturXProfile.MINIMUM:
+                // MINIMUM requires at least gross amounts
+                // Check both calculated totals and direct properties (for test compatibility)
+                const totalGross = invoice.totalGross || invoice.totalInvoiceAmount;
+                if (!totalGross || totalGross <= 0) {
+                    results.push({
+                        ruleId: 'FX-MIN-01',
+                        severity: 'error',
+                        message: 'MINIMUM profile requires positive total invoice amount',
+                        field: 'totalInvoiceAmount',
+                        value: totalGross,
+                        source: 'FACTURX'
+                    });
+                }
+                break;
+            case FacturXProfile.BASIC:
+            case FacturXProfile.BASIC_WL:
+                // BASIC requires VAT breakdown
+                const totalVat = invoice.totalVat;
+                if (!invoice.metadata?.extensions?.taxDetails && totalVat > 0) {
+                    results.push({
+                        ruleId: 'FX-BAS-01',
+                        severity: 'warning',
+                        message: 'BASIC profile should include VAT breakdown when VAT is present',
+                        field: 'metadata.extensions.taxDetails',
+                        source: 'FACTURX'
+                    });
+                }
+                break;
+            case FacturXProfile.EN16931:
+                // EN16931 requires full compliance - additional checks handled by EN16931 validator
+                if (!invoice.metadata?.buyerReference && !invoice.metadata?.extensions?.purchaseOrderReference) {
+                    results.push({
+                        ruleId: 'FX-EN-01',
+                        severity: 'error',
+                        message: 'EN16931 profile requires either buyer reference or purchase order reference',
+                        field: 'metadata.buyerReference',
+                        source: 'FACTURX'
+                    });
+                }
+                break;
+        }
+        return results;
+    }
+    /**
+     * Validate MINIMUM profile specific rules
+     */
+    validateMinimumProfile(invoice) {
+        const results = [];
+        // MINIMUM profile allows only essential fields
+        // Check that complex structures are not present
+        if (invoice.items && invoice.items.length > 0) {
+            // Lines are optional but if present must be minimal
+            invoice.items.forEach((item, index) => {
+                if (item.allowances || item.charges) {
+                    results.push({
+                        ruleId: 'FX-MIN-02',
+                        severity: 'warning',
+                        message: `Line ${index + 1}: MINIMUM profile should not include line allowances/charges`,
+                        field: `items[${index}]`,
+                        source: 'FACTURX'
+                    });
+                }
+            });
+        }
+        return results;
+    }
+    /**
+     * Validate BASIC profile specific rules
+     */
+    validateBasicProfile(invoice, profile) {
+        const results = [];
+        // BASIC requires line items (except BASIC_WL)
+        // Only check for line items in BASIC profile, not BASIC_WL
+        if (profile === FacturXProfile.BASIC) {
+            if (!invoice.items || invoice.items.length === 0) {
+                results.push({
+                    ruleId: 'FX-BAS-02',
+                    severity: 'error',
+                    message: 'BASIC profile requires at least one invoice line item',
+                    field: 'items',
+                    source: 'FACTURX'
+                });
+            }
+        }
+        // Payment information should be present
+        if (!invoice.dueInDays && invoice.dueInDays !== 0) {
+            results.push({
+                ruleId: 'FX-BAS-03',
+                severity: 'warning',
+                message: 'BASIC profile should include payment terms (due in days)',
+                field: 'dueInDays',
+                source: 'FACTURX'
+            });
+        }
+        return results;
+    }
+    /**
+     * Validate EN16931 profile specific rules
+     */
+    validateEN16931Profile(invoice) {
+        const results = [];
+        // EN16931 requires complete address information
+        const fromAny = invoice.from;
+        const toAny = invoice.to;
+        if (!fromAny?.city || !fromAny?.postalCode) {
+            results.push({
+                ruleId: 'FX-EN-02',
+                severity: 'error',
+                message: 'EN16931 profile requires complete seller address including city and postal code',
+                field: 'from.address',
+                source: 'FACTURX'
+            });
+        }
+        if (!toAny?.city || !toAny?.postalCode) {
+            results.push({
+                ruleId: 'FX-EN-03',
+                severity: 'error',
+                message: 'EN16931 profile requires complete buyer address including city and postal code',
+                field: 'to.address',
+                source: 'FACTURX'
+            });
+        }
+        // Line items must have unit type
+        if (invoice.items) {
+            invoice.items.forEach((item, index) => {
+                if (!item.unitType) {
+                    results.push({
+                        ruleId: 'FX-EN-04',
+                        severity: 'error',
+                        message: `Line ${index + 1}: EN16931 profile requires unit of measure`,
+                        field: `items[${index}].unitType`,
+                        source: 'FACTURX'
+                    });
+                }
+            });
+        }
+        return results;
+    }
+    /**
+     * Validate EXTENDED profile specific rules
+     */
+    validateExtendedProfile(invoice) {
+        const results = [];
+        // EXTENDED profile is most permissive - mainly check for data consistency
+        if (invoice.metadata?.extensions) {
+            // Extended profile can include additional structured data
+            // Validate that extended data is well-formed
+            const extensions = invoice.metadata.extensions;
+            if (extensions.attachments && Array.isArray(extensions.attachments)) {
+                extensions.attachments.forEach((attachment, index) => {
+                    if (!attachment.filename || !attachment.mimeType) {
+                        results.push({
+                            ruleId: 'FX-EXT-01',
+                            severity: 'warning',
+                            message: `Attachment ${index + 1}: Should include filename and MIME type`,
+                            field: `metadata.extensions.attachments[${index}]`,
+                            source: 'FACTURX'
+                        });
+                    }
+                });
+            }
+        }
+        return results;
+    }
+    /**
+     * Get profile display name
+     */
+    getProfileDisplayName(profile) {
+        const names = {
+            [FacturXProfile.MINIMUM]: 'Factur-X MINIMUM',
+            [FacturXProfile.BASIC]: 'Factur-X BASIC',
+            [FacturXProfile.BASIC_WL]: 'Factur-X BASIC WL',
+            [FacturXProfile.EN16931]: 'Factur-X EN16931',
+            [FacturXProfile.EXTENDED]: 'Factur-X EXTENDED'
+        };
+        return names[profile];
+    }
+    /**
+     * Get profile compliance level (for reporting)
+     */
+    getProfileComplianceLevel(profile) {
+        const levels = {
+            [FacturXProfile.MINIMUM]: 1,
+            [FacturXProfile.BASIC_WL]: 2,
+            [FacturXProfile.BASIC]: 3,
+            [FacturXProfile.EN16931]: 4,
+            [FacturXProfile.EXTENDED]: 5
+        };
+        return levels[profile];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"facturx.validator.js","sourceRoot":"","sources":["../../../ts/formats/validation/facturx.validator.ts"],"names":[],"mappings":"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"}

package/dist_ts/formats/validation/integrated.validator.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Main integrated validator combining all validation capabilities
+ * Orchestrates TypeScript validators, Schematron, and profile-specific rules
+ */
+import type { ValidationOptions, ValidationReport } from './validation.types.js';
+import type { EInvoice } from '../../einvoice.js';
+/**
+ * Main validator that combines all validation capabilities
+ */
+export declare class MainValidator {
+    private integratedValidator;
+    private xrechnungValidator;
+    private peppolValidator;
+    private facturxValidator;
+    private businessRulesValidator;
+    private codeListValidator;
+    private schematronEnabled;
+    constructor();
+    /**
+     * Initialize Schematron validation for better coverage
+     */
+    initializeSchematron(profile?: 'EN16931' | 'PEPPOL' | 'XRECHNUNG'): Promise<void>;
+    /**
+     * Validate an invoice with all available validators
+     */
+    validate(invoice: EInvoice, xmlContent?: string, options?: ValidationOptions): Promise<ValidationReport>;
+    /**
+     * Detect profile from invoice metadata
+     */
+    private detectProfile;
+    /**
+     * Check if invoice is XRechnung
+     */
+    private isXRechnungInvoice;
+    /**
+     * Check if invoice is PEPPOL
+     */
+    private isPeppolInvoice;
+    /**
+     * Check if invoice is Factur-X
+     */
+    private isFacturXInvoice;
+    /**
+     * Detect format from XML content
+     */
+    private detectFormat;
+    /**
+     * Remove duplicate validation results
+     */
+    private deduplicateResults;
+    /**
+     * Estimate total rules for coverage calculation
+     */
+    private estimateTotalRules;
+    /**
+     * Validate with automatic format and profile detection
+     */
+    validateAuto(invoice: EInvoice, xmlContent?: string): Promise<ValidationReport>;
+    /**
+     * Get validation capabilities
+     */
+    getCapabilities(): {
+        schematron: boolean;
+        xrechnung: boolean;
+        peppol: boolean;
+        facturx: boolean;
+        calculations: boolean;
+        codeLists: boolean;
+    };
+    /**
+     * Format validation report as text
+     */
+    formatReport(report: ValidationReport): string;
+}
+/**
+ * Create a pre-configured validator instance
+ */
+export declare function createValidator(options?: {
+    profile?: 'EN16931' | 'PEPPOL' | 'XRECHNUNG';
+    enableSchematron?: boolean;
+}): Promise<MainValidator>;
+export type { ValidationReport, ValidationResult, ValidationOptions } from './validation.types.js';