@fin.cx/einvoice 5.0.3 → 5.1.2

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

@@ -0,0 +1,188 @@
+import { CodeLists } from './validation.types.js';
+/**
+ * Code List Validator for EN16931 compliance
+ * Validates against standard code lists (ISO, UNCL, UNECE)
+ */
+export class CodeListValidator {
+    constructor() {
+        this.results = [];
+    }
+    /**
+     * Validate all code lists in an invoice
+     */
+    validate(invoice) {
+        this.results = [];
+        // Currency validation
+        this.validateCurrency(invoice);
+        // Country codes
+        this.validateCountryCodes(invoice);
+        // Document type
+        this.validateDocumentType(invoice);
+        // Tax categories
+        this.validateTaxCategories(invoice);
+        // Payment means
+        this.validatePaymentMeans(invoice);
+        // Unit codes
+        this.validateUnitCodes(invoice);
+        return this.results;
+    }
+    /**
+     * Validate currency codes (ISO 4217)
+     */
+    validateCurrency(invoice) {
+        // Document currency (BT-5)
+        if (invoice.currency) {
+            if (!CodeLists.ISO4217.codes.has(invoice.currency.toUpperCase())) {
+                this.addError('BR-CL-03', `Invalid currency code: ${invoice.currency}. Must be ISO 4217`, 'EN16931', 'currency', 'BT-5', invoice.currency, Array.from(CodeLists.ISO4217.codes).join(', '));
+            }
+        }
+        // VAT accounting currency (BT-6)
+        const vatCurrency = invoice.metadata?.vatAccountingCurrency;
+        if (vatCurrency && !CodeLists.ISO4217.codes.has(vatCurrency.toUpperCase())) {
+            this.addError('BR-CL-04', `Invalid VAT accounting currency: ${vatCurrency}. Must be ISO 4217`, 'EN16931', 'metadata.vatAccountingCurrency', 'BT-6', vatCurrency, Array.from(CodeLists.ISO4217.codes).join(', '));
+        }
+    }
+    /**
+     * Validate country codes (ISO 3166-1 alpha-2)
+     */
+    validateCountryCodes(invoice) {
+        // Seller country (BT-40)
+        const sellerCountry = invoice.from?.address?.countryCode;
+        if (sellerCountry && !CodeLists.ISO3166.codes.has(sellerCountry.toUpperCase())) {
+            this.addError('BR-CL-14', `Invalid seller country code: ${sellerCountry}. Must be ISO 3166-1 alpha-2`, 'EN16931', 'from.address.countryCode', 'BT-40', sellerCountry, 'Two-letter country code (e.g., DE, FR, IT)');
+        }
+        // Buyer country (BT-55)
+        const buyerCountry = invoice.to?.address?.countryCode;
+        if (buyerCountry && !CodeLists.ISO3166.codes.has(buyerCountry.toUpperCase())) {
+            this.addError('BR-CL-15', `Invalid buyer country code: ${buyerCountry}. Must be ISO 3166-1 alpha-2`, 'EN16931', 'to.address.countryCode', 'BT-55', buyerCountry, 'Two-letter country code (e.g., DE, FR, IT)');
+        }
+        // Delivery country (BT-80)
+        const deliveryCountry = invoice.metadata?.deliveryAddress?.countryCode;
+        if (deliveryCountry && !CodeLists.ISO3166.codes.has(deliveryCountry.toUpperCase())) {
+            this.addError('BR-CL-16', `Invalid delivery country code: ${deliveryCountry}. Must be ISO 3166-1 alpha-2`, 'EN16931', 'metadata.deliveryAddress.countryCode', 'BT-80', deliveryCountry, 'Two-letter country code (e.g., DE, FR, IT)');
+        }
+    }
+    /**
+     * Validate document type code (UNCL1001)
+     */
+    validateDocumentType(invoice) {
+        const typeCode = invoice.metadata?.documentTypeCode ||
+            (invoice.accountingDocType === 'invoice' ? '380' :
+                invoice.accountingDocType === 'creditnote' ? '381' :
+                    invoice.accountingDocType === 'debitnote' ? '383' : null);
+        if (typeCode && !CodeLists.UNCL1001.codes.has(typeCode)) {
+            this.addError('BR-CL-01', `Invalid document type code: ${typeCode}. Must be UNCL1001`, 'EN16931', 'metadata.documentTypeCode', 'BT-3', typeCode, Array.from(CodeLists.UNCL1001.codes.entries()).map(([k, v]) => `${k} (${v})`).join(', '));
+        }
+    }
+    /**
+     * Validate tax category codes (UNCL5305)
+     */
+    validateTaxCategories(invoice) {
+        // Document level tax breakdown
+        // Note: taxBreakdown is a computed property that doesn't have metadata
+        // We would need to access the raw tax breakdown data from metadata if it exists
+        invoice.taxBreakdown?.forEach((breakdown, index) => {
+            // Since the computed taxBreakdown doesn't have metadata, 
+            // we'll skip the tax category code validation for now
+            // This would need to be implemented differently to access the raw data
+            // TODO: Access raw tax breakdown data with metadata from invoice.metadata.taxBreakdown
+            // when that structure is implemented
+        });
+        // Line level tax categories
+        invoice.items?.forEach((item, index) => {
+            // Cast to extended type to access metadata
+            const extendedItem = item;
+            const categoryCode = extendedItem.metadata?.vatCategoryCode;
+            if (categoryCode && !CodeLists.UNCL5305.codes.has(categoryCode)) {
+                this.addError('BR-CL-10', `Invalid line tax category: ${categoryCode}. Must be UNCL5305`, 'EN16931', `items[${index}].metadata.vatCategoryCode`, 'BT-151', categoryCode, Array.from(CodeLists.UNCL5305.codes.entries()).map(([k, v]) => `${k} (${v})`).join(', '));
+            }
+        });
+    }
+    /**
+     * Validate payment means codes (UNCL4461)
+     */
+    validatePaymentMeans(invoice) {
+        const paymentMeans = invoice.metadata?.paymentMeansCode;
+        if (paymentMeans && !CodeLists.UNCL4461.codes.has(paymentMeans)) {
+            this.addError('BR-CL-16', `Invalid payment means code: ${paymentMeans}. Must be UNCL4461`, 'EN16931', 'metadata.paymentMeansCode', 'BT-81', paymentMeans, Array.from(CodeLists.UNCL4461.codes.entries()).map(([k, v]) => `${k} (${v})`).join(', '));
+        }
+        // Validate payment requirements based on means code
+        if (paymentMeans === '30' || paymentMeans === '58') { // Credit transfer
+            if (!invoice.metadata?.paymentAccount?.iban) {
+                this.addWarning('BR-CL-16-1', `Payment means ${paymentMeans} (${CodeLists.UNCL4461.codes.get(paymentMeans)}) typically requires IBAN`, 'EN16931', 'metadata.paymentAccount.iban', 'BT-84');
+            }
+        }
+    }
+    /**
+     * Validate unit codes (UNECE Rec 20)
+     */
+    validateUnitCodes(invoice) {
+        invoice.items?.forEach((item, index) => {
+            const unitCode = item.unitType;
+            if (unitCode && !CodeLists.UNECERec20.codes.has(unitCode)) {
+                this.addError('BR-CL-23', `Invalid unit code: ${unitCode}. Must be UNECE Rec 20`, 'EN16931', `items[${index}].unitCode`, 'BT-130', unitCode, 'Common codes: C62 (one), KGM (kilogram), HUR (hour), DAY (day), MTR (metre)');
+            }
+            // Validate quantity is positive for standard units
+            if (unitCode && item.unitQuantity <= 0 && unitCode !== 'LS') { // LS = Lump sum can be 1
+                this.addError('BR-25', `Quantity must be positive for unit ${unitCode}`, 'EN16931', `items[${index}].quantity`, 'BT-129', item.unitQuantity, '> 0');
+            }
+        });
+    }
+    /**
+     * Add validation error
+     */
+    addError(ruleId, message, source, field, btReference, value, expected) {
+        this.results.push({
+            ruleId,
+            source,
+            severity: 'error',
+            message,
+            field,
+            btReference,
+            value,
+            expected,
+            codeList: this.getCodeListForRule(ruleId)
+        });
+    }
+    /**
+     * Add validation warning
+     */
+    addWarning(ruleId, message, source, field, btReference, value, expected) {
+        this.results.push({
+            ruleId,
+            source,
+            severity: 'warning',
+            message,
+            field,
+            btReference,
+            value,
+            expected,
+            codeList: this.getCodeListForRule(ruleId)
+        });
+    }
+    /**
+     * Get code list metadata for a rule
+     */
+    getCodeListForRule(ruleId) {
+        if (ruleId.includes('CL-03') || ruleId.includes('CL-04')) {
+            return { name: 'ISO4217', version: CodeLists.ISO4217.version };
+        }
+        if (ruleId.includes('CL-14') || ruleId.includes('CL-15') || ruleId.includes('CL-16')) {
+            return { name: 'ISO3166', version: CodeLists.ISO3166.version };
+        }
+        if (ruleId.includes('CL-01')) {
+            return { name: 'UNCL1001', version: CodeLists.UNCL1001.version };
+        }
+        if (ruleId.includes('CL-10')) {
+            return { name: 'UNCL5305', version: CodeLists.UNCL5305.version };
+        }
+        if (ruleId.includes('CL-16')) {
+            return { name: 'UNCL4461', version: CodeLists.UNCL4461.version };
+        }
+        if (ruleId.includes('CL-23')) {
+            return { name: 'UNECERec20', version: CodeLists.UNECERec20.version };
+        }
+        return undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"codelist.validator.js","sourceRoot":"","sources":["../../../ts/formats/validation/codelist.validator.ts"],"names":[],"mappings":"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"}

package/dist_ts/formats/validation/conformance.harness.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Conformance Test Harness for EN16931 Validation
+ * Tests validators against official samples and generates coverage reports
+ */
+/**
+ * Coverage report for all rules
+ */
+interface CoverageReport {
+    totalRules: number;
+    coveredRules: number;
+    coveragePercentage: number;
+    ruleDetails: Map<string, {
+        covered: boolean;
+        samplesCovering: string[];
+        errorCount: number;
+        warningCount: number;
+    }>;
+    uncoveredRules: string[];
+    byCategory: {
+        document: {
+            total: number;
+            covered: number;
+        };
+        calculation: {
+            total: number;
+            covered: number;
+        };
+        vat: {
+            total: number;
+            covered: number;
+        };
+        lineLevel: {
+            total: number;
+            covered: number;
+        };
+        codeLists: {
+            total: number;
+            covered: number;
+        };
+    };
+}
+/**
+ * Conformance Test Harness
+ */
+export declare class ConformanceTestHarness {
+    private integratedValidator;
+    private businessRulesValidator;
+    private codeListValidator;
+    private vatCategoriesValidator;
+    private xmlConverter;
+    private testSamples;
+    private results;
+    constructor();
+    /**
+     * Load test samples from directory
+     */
+    loadTestSamples(baseDir?: string): Promise<void>;
+    /**
+     * Run all validators against a single test sample
+     */
+    private runTestSample;
+    /**
+     * Run conformance tests on all samples
+     */
+    runConformanceTests(): Promise<void>;
+    /**
+     * Generate BR coverage matrix
+     */
+    generateCoverageMatrix(): CoverageReport;
+    /**
+     * Print test summary
+     */
+    private printSummary;
+    /**
+     * Generate HTML coverage report
+     */
+    generateHTMLReport(outputPath?: string): Promise<void>;
+    /**
+     * Get all EN16931 business rules
+     */
+    private getAllEN16931Rules;
+    /**
+     * Get category for a rule
+     */
+    private getRuleCategory;
+    /**
+     * Get description from filename
+     */
+    private getDescriptionFromFilename;
+    /**
+     * Get focus rules from filename
+     */
+    private getFocusRulesFromFilename;
+}
+/**
+ * Export convenience function to run conformance tests
+ */
+export declare function runConformanceTests(samplesDir?: string, generateReport?: boolean): Promise<void>;
+export {};