@fin.cx/skr 1.1.0 → 1.2.1

package/dist_ts/skr.invoice.booking.js

@@ -0,0 +1,578 @@
+import * as plugins from './plugins.js';
+import { JournalEntry } from './skr.classes.journalentry.js';
+import { SKRInvoiceMapper } from './skr.invoice.mapper.js';
+import { suggestPostingKey } from './skr.postingkeys.js';
+/**
+ * Automatic booking engine for invoices
+ * Creates journal entries from invoice data based on SKR mapping rules
+ */
+export class InvoiceBookingEngine {
+    constructor(skrType) {
+        this.skrType = skrType;
+        this.mapper = new SKRInvoiceMapper(skrType);
+        this.logger = new plugins.smartlog.ConsoleLog();
+    }
+    /**
+     * Book an invoice to the ledger
+     */
+    async bookInvoice(invoice, bookingRules, options) {
+        try {
+            // Get complete booking rules
+            const rules = this.mapper.mapInvoiceToSKR(invoice, bookingRules);
+            // Calculate confidence
+            const confidence = this.mapper.calculateConfidence(invoice, rules);
+            // Check if auto-booking is allowed
+            if (options?.autoBook && confidence < (options.confidenceThreshold || 80)) {
+                return {
+                    success: false,
+                    confidence,
+                    warnings: [`Confidence score ${confidence}% is below threshold ${options.confidenceThreshold || 80}%`]
+                };
+            }
+            // Validate invoice before booking
+            if (!options?.skipValidation) {
+                const validationErrors = this.validateInvoice(invoice);
+                if (validationErrors.length > 0) {
+                    return {
+                        success: false,
+                        confidence,
+                        errors: validationErrors
+                    };
+                }
+            }
+            // Build journal entry
+            const journalEntry = await this.buildJournalEntry(invoice, rules, options);
+            // Create booking info
+            const bookingInfo = {
+                journalEntryId: journalEntry.id,
+                transactionIds: journalEntry.transactionIds || [],
+                bookedAt: new Date(),
+                bookedBy: 'system',
+                bookingRules: {
+                    vendorAccount: rules.vendorControlAccount,
+                    customerAccount: rules.customerControlAccount,
+                    expenseAccounts: this.getUsedExpenseAccounts(invoice, rules),
+                    revenueAccounts: this.getUsedRevenueAccounts(invoice, rules),
+                    vatAccounts: this.getUsedVATAccounts(invoice, rules)
+                },
+                confidence,
+                autoBooked: options?.autoBook || false
+            };
+            // Post the journal entry
+            // TODO: When MongoDB transactions are available, wrap this in a transaction
+            // Example: await db.withTransaction(async (session) => { ... })
+            try {
+                await journalEntry.validate();
+                await journalEntry.post();
+                // Mark invoice as posted if we have a reference to it
+                if (invoice.status !== 'posted') {
+                    invoice.status = 'posted';
+                }
+            }
+            catch (postError) {
+                this.logger.log('error', `Failed to post journal entry: ${postError}`);
+                throw postError; // Re-throw to trigger rollback when transactions are available
+            }
+            return {
+                success: true,
+                journalEntry,
+                bookingInfo,
+                confidence,
+                warnings: this.generateWarnings(invoice, rules)
+            };
+        }
+        catch (error) {
+            this.logger.log('error', `Failed to book invoice: ${error}`);
+            return {
+                success: false,
+                confidence: 0,
+                errors: [`Booking failed: ${error.message}`]
+            };
+        }
+    }
+    /**
+     * Build journal entry from invoice
+     */
+    async buildJournalEntry(invoice, rules, options) {
+        const lines = [];
+        const isInbound = invoice.direction === 'inbound';
+        const isCredit = invoice.invoiceTypeCode === '381'; // Credit note
+        // Determine if we need to reverse the normal booking direction
+        const reverseDirection = isCredit;
+        if (isInbound) {
+            // Inbound invoice (AP)
+            lines.push(...this.buildAPEntry(invoice, rules, reverseDirection));
+        }
+        else {
+            // Outbound invoice (AR)
+            lines.push(...this.buildAREntry(invoice, rules, reverseDirection));
+        }
+        // Create journal entry
+        const journalData = {
+            date: options?.bookingDate || invoice.issueDate,
+            description: this.buildDescription(invoice),
+            reference: options?.bookingReference || invoice.invoiceNumber,
+            lines,
+            skrType: this.skrType
+        };
+        const journalEntry = new JournalEntry(journalData);
+        return journalEntry;
+    }
+    /**
+     * Build AP (Accounts Payable) journal entry lines
+     */
+    buildAPEntry(invoice, rules, reverseDirection) {
+        const lines = [];
+        // Group lines by account
+        const accountGroups = this.groupLinesByAccount(invoice, rules);
+        // Create expense/asset entries
+        for (const [accountNumber, group] of Object.entries(accountGroups)) {
+            const amount = group.reduce((sum, line) => sum + line.netAmount, 0);
+            if (reverseDirection) {
+                // Credit note: credit expense account
+                lines.push({
+                    accountNumber,
+                    credit: Math.abs(amount),
+                    description: this.getAccountDescription(accountNumber, group),
+                    postingKey: 9 // 19% input VAT for expenses
+                });
+            }
+            else {
+                // Regular invoice: debit expense account
+                lines.push({
+                    accountNumber,
+                    debit: Math.abs(amount),
+                    description: this.getAccountDescription(accountNumber, group),
+                    postingKey: 9 // 19% input VAT for expenses
+                });
+            }
+        }
+        // Create VAT entries
+        const vatLines = this.buildVATLines(invoice, rules, 'input', reverseDirection);
+        lines.push(...vatLines);
+        // Create vendor control account entry
+        const controlAccount = this.mapper.getControlAccount(invoice, rules);
+        const totalAmount = Math.abs(invoice.payableAmount);
+        if (reverseDirection) {
+            // Credit note: debit vendor account
+            lines.push({
+                accountNumber: controlAccount,
+                debit: totalAmount,
+                description: `${invoice.supplier.name} - Credit Note ${invoice.invoiceNumber}`,
+                postingKey: 40 // Tax-free for control account
+            });
+        }
+        else {
+            // Regular invoice: credit vendor account
+            lines.push({
+                accountNumber: controlAccount,
+                credit: totalAmount,
+                description: `${invoice.supplier.name} - Invoice ${invoice.invoiceNumber}`,
+                postingKey: 40 // Tax-free for control account
+            });
+        }
+        return lines;
+    }
+    /**
+     * Build AR (Accounts Receivable) journal entry lines
+     */
+    buildAREntry(invoice, rules, reverseDirection) {
+        const lines = [];
+        // Group lines by account
+        const accountGroups = this.groupLinesByAccount(invoice, rules);
+        // Create revenue entries
+        for (const [accountNumber, group] of Object.entries(accountGroups)) {
+            const amount = group.reduce((sum, line) => sum + line.netAmount, 0);
+            if (reverseDirection) {
+                // Credit note: debit revenue account
+                lines.push({
+                    accountNumber,
+                    debit: Math.abs(amount),
+                    description: this.getAccountDescription(accountNumber, group),
+                    postingKey: 9 // 19% output VAT for revenue
+                });
+            }
+            else {
+                // Regular invoice: credit revenue account
+                lines.push({
+                    accountNumber,
+                    credit: Math.abs(amount),
+                    description: this.getAccountDescription(accountNumber, group),
+                    postingKey: 9 // 19% output VAT for revenue
+                });
+            }
+        }
+        // Create VAT entries
+        const vatLines = this.buildVATLines(invoice, rules, 'output', reverseDirection);
+        lines.push(...vatLines);
+        // Create customer control account entry
+        const controlAccount = this.mapper.getControlAccount(invoice, rules);
+        const totalAmount = Math.abs(invoice.payableAmount);
+        if (reverseDirection) {
+            // Credit note: credit customer account
+            lines.push({
+                accountNumber: controlAccount,
+                credit: totalAmount,
+                description: `${invoice.customer.name} - Credit Note ${invoice.invoiceNumber}`,
+                postingKey: 40 // Tax-free for control account
+            });
+        }
+        else {
+            // Regular invoice: debit customer account
+            lines.push({
+                accountNumber: controlAccount,
+                debit: totalAmount,
+                description: `${invoice.customer.name} - Invoice ${invoice.invoiceNumber}`,
+                postingKey: 40 // Tax-free for control account
+            });
+        }
+        return lines;
+    }
+    /**
+     * Build VAT lines
+     */
+    buildVATLines(invoice, rules, direction, reverseDirection) {
+        const lines = [];
+        const taxScenario = invoice.taxScenario || 'domestic_taxed';
+        // Handle reverse charge specially
+        if (taxScenario === 'reverse_charge') {
+            return this.buildReverseChargeVATLines(invoice, rules);
+        }
+        // Standard VAT booking
+        for (const vatBreak of invoice.vatBreakdown) {
+            if (vatBreak.taxAmount === 0)
+                continue;
+            const vatAccount = this.mapper.getVATAccount(vatBreak.vatCategory, direction, taxScenario);
+            const amount = Math.abs(vatBreak.taxAmount);
+            const description = `VAT ${vatBreak.vatCategory.rate}%`;
+            const vatRate = vatBreak.vatCategory.rate;
+            // Select posting key based on VAT rate: 8 for 7%, 9 for 19%
+            const postingKey = vatRate === 7 ? 8 : 9;
+            if (direction === 'input') {
+                // Input VAT (Vorsteuer)
+                if (reverseDirection) {
+                    lines.push({ accountNumber: vatAccount, credit: amount, description, postingKey });
+                }
+                else {
+                    lines.push({ accountNumber: vatAccount, debit: amount, description, postingKey });
+                }
+            }
+            else {
+                // Output VAT (Umsatzsteuer)
+                if (reverseDirection) {
+                    lines.push({ accountNumber: vatAccount, debit: amount, description, postingKey });
+                }
+                else {
+                    lines.push({ accountNumber: vatAccount, credit: amount, description, postingKey });
+                }
+            }
+        }
+        return lines;
+    }
+    /**
+     * Calculate VAT amount from taxable amount and rate
+     */
+    calculateVAT(taxableAmount, rate) {
+        return Math.round(taxableAmount * rate / 100 * 100) / 100; // Round to 2 decimals
+    }
+    /**
+     * Calculate effective VAT rate for the invoice (weighted average)
+     */
+    calculateEffectiveVATRate(invoice) {
+        const totalTaxable = invoice.vatBreakdown.reduce((sum, vb) => sum + vb.taxableAmount, 0);
+        if (totalTaxable === 0) {
+            return 19; // Default to standard German VAT rate
+        }
+        // Calculate weighted average VAT rate
+        const weightedRate = invoice.vatBreakdown.reduce((sum, vb) => {
+            return sum + (vb.vatCategory.rate * vb.taxableAmount);
+        }, 0);
+        return Math.round(weightedRate / totalTaxable * 100) / 100;
+    }
+    /**
+     * Build reverse charge VAT lines (§13b UStG)
+     */
+    buildReverseChargeVATLines(invoice, rules) {
+        const lines = [];
+        // For reverse charge, we book both input and output VAT
+        for (const vatBreak of invoice.vatBreakdown) {
+            // For reverse charge, calculate VAT if not provided
+            const amount = vatBreak.taxAmount > 0
+                ? Math.abs(vatBreak.taxAmount)
+                : this.calculateVAT(Math.abs(vatBreak.taxableAmount), vatBreak.vatCategory.rate);
+            // Input VAT (deductible)
+            const inputVATAccount = this.mapper.getVATAccount(vatBreak.vatCategory, 'input', 'reverse_charge');
+            // Output VAT (payable)
+            const outputVATAccount = this.mapper.getVATAccount(vatBreak.vatCategory, 'output', 'reverse_charge');
+            lines.push({
+                accountNumber: inputVATAccount,
+                debit: amount,
+                description: `Reverse charge input VAT ${vatBreak.vatCategory.rate}%`,
+                postingKey: 94 // Reverse charge posting key
+            }, {
+                accountNumber: outputVATAccount,
+                credit: amount,
+                description: `Reverse charge output VAT ${vatBreak.vatCategory.rate}%`,
+                postingKey: 94 // Reverse charge posting key
+            });
+        }
+        return lines;
+    }
+    /**
+     * Group invoice lines by account
+     */
+    groupLinesByAccount(invoice, rules) {
+        const groups = {};
+        for (const line of invoice.lines) {
+            const account = this.mapper.mapInvoiceLineToAccount(line, invoice, rules);
+            if (!groups[account]) {
+                groups[account] = [];
+            }
+            groups[account].push(line);
+        }
+        return groups;
+    }
+    /**
+     * Book payment for an invoice
+     */
+    async bookPayment(invoice, payment, rules) {
+        try {
+            const lines = [];
+            const isInbound = invoice.direction === 'inbound';
+            const controlAccount = this.mapper.getControlAccount(invoice, rules);
+            // Check for skonto
+            const skontoAmount = payment.skontoTaken || 0;
+            const paymentAmount = payment.amount;
+            const fullAmount = paymentAmount + skontoAmount;
+            if (isInbound) {
+                // Payment for vendor invoice
+                lines.push({
+                    accountNumber: controlAccount,
+                    debit: fullAmount,
+                    description: `Payment to ${invoice.supplier.name}`,
+                    postingKey: 3 // Payment with VAT
+                }, {
+                    accountNumber: '1000', // Bank account (would be configurable)
+                    credit: paymentAmount,
+                    description: `Bank payment ${payment.endToEndId || payment.paymentId}`,
+                    postingKey: 40 // Tax-free for bank account
+                });
+                // Book skonto if taken
+                if (skontoAmount > 0) {
+                    const skontoAccounts = this.mapper.getSkontoAccounts(invoice);
+                    lines.push({
+                        accountNumber: skontoAccounts.skontoAccount,
+                        credit: skontoAmount,
+                        description: `Skonto received`,
+                        postingKey: 40 // Tax-free for skonto
+                    });
+                    // VAT correction for skonto
+                    if (rules.skontoMethod === 'gross') {
+                        const effectiveRate = this.calculateEffectiveVATRate(invoice);
+                        const vatCorrection = Math.round(skontoAmount * effectiveRate / (100 + effectiveRate) * 100) / 100;
+                        lines.push({
+                            accountNumber: skontoAccounts.vatCorrectionAccount,
+                            credit: vatCorrection,
+                            description: `Skonto VAT correction`,
+                            postingKey: 40 // Tax-free for correction
+                        });
+                    }
+                }
+            }
+            else {
+                // Payment from customer
+                lines.push({
+                    accountNumber: '1000', // Bank account
+                    debit: paymentAmount,
+                    description: `Payment from ${invoice.customer.name}`,
+                    postingKey: 40 // Tax-free for bank account
+                }, {
+                    accountNumber: controlAccount,
+                    credit: fullAmount,
+                    description: `Customer payment ${payment.endToEndId || payment.paymentId}`,
+                    postingKey: 3 // Payment with VAT
+                });
+                // Book skonto if granted
+                if (skontoAmount > 0) {
+                    const skontoAccounts = this.mapper.getSkontoAccounts(invoice);
+                    lines.push({
+                        accountNumber: skontoAccounts.skontoAccount,
+                        debit: skontoAmount,
+                        description: `Skonto granted`,
+                        postingKey: 40 // Tax-free for skonto
+                    });
+                    // VAT correction for skonto
+                    if (rules.skontoMethod === 'gross') {
+                        const effectiveRate = this.calculateEffectiveVATRate(invoice);
+                        const vatCorrection = Math.round(skontoAmount * effectiveRate / (100 + effectiveRate) * 100) / 100;
+                        lines.push({
+                            accountNumber: skontoAccounts.vatCorrectionAccount,
+                            debit: vatCorrection,
+                            description: `Skonto VAT correction`,
+                            postingKey: 40 // Tax-free for correction
+                        });
+                    }
+                }
+            }
+            // Create journal entry for payment
+            const journalData = {
+                date: payment.paymentDate,
+                description: `Payment for invoice ${invoice.invoiceNumber}`,
+                reference: payment.endToEndId || payment.remittanceInfo || payment.paymentId,
+                lines,
+                skrType: this.skrType
+            };
+            const journalEntry = new JournalEntry(journalData);
+            await journalEntry.validate();
+            await journalEntry.post();
+            return {
+                success: true,
+                journalEntry,
+                confidence: 100
+            };
+        }
+        catch (error) {
+            this.logger.log('error', `Failed to book payment: ${error}`);
+            return {
+                success: false,
+                confidence: 0,
+                errors: [`Payment booking failed: ${error.message}`]
+            };
+        }
+    }
+    /**
+     * Validate invoice before booking
+     */
+    validateInvoice(invoice) {
+        const errors = [];
+        // Check required fields
+        if (!invoice.invoiceNumber) {
+            errors.push('Invoice number is required');
+        }
+        if (!invoice.issueDate) {
+            errors.push('Issue date is required');
+        }
+        if (!invoice.supplier || !invoice.supplier.name) {
+            errors.push('Supplier information is required');
+        }
+        if (!invoice.customer || !invoice.customer.name) {
+            errors.push('Customer information is required');
+        }
+        if (invoice.lines.length === 0) {
+            errors.push('Invoice must have at least one line item');
+        }
+        // Validate amounts
+        const calculatedNet = invoice.lines.reduce((sum, line) => sum + line.netAmount, 0);
+        const tolerance = 0.01;
+        if (Math.abs(calculatedNet - invoice.lineNetAmount) > tolerance) {
+            errors.push(`Line net amount mismatch: calculated ${calculatedNet}, stated ${invoice.lineNetAmount}`);
+        }
+        // Validate VAT
+        const calculatedVAT = invoice.vatBreakdown.reduce((sum, vb) => sum + vb.taxAmount, 0);
+        if (Math.abs(calculatedVAT - invoice.totalVATAmount) > tolerance) {
+            errors.push(`VAT amount mismatch: calculated ${calculatedVAT}, stated ${invoice.totalVATAmount}`);
+        }
+        // Validate total
+        const calculatedTotal = invoice.taxExclusiveAmount + invoice.totalVATAmount;
+        if (Math.abs(calculatedTotal - invoice.taxInclusiveAmount) > tolerance) {
+            errors.push(`Total amount mismatch: calculated ${calculatedTotal}, stated ${invoice.taxInclusiveAmount}`);
+        }
+        return errors;
+    }
+    /**
+     * Generate warnings for the booking
+     */
+    generateWarnings(invoice, rules) {
+        const warnings = [];
+        // Warn about default account usage
+        const hasDefaultAccounts = invoice.lines.some(line => !line.accountNumber && !line.productCode);
+        if (hasDefaultAccounts) {
+            warnings.push('Some lines are using default expense/revenue accounts');
+        }
+        // Warn about mixed VAT rates
+        if (invoice.vatBreakdown.length > 1) {
+            warnings.push('Invoice contains mixed VAT rates');
+        }
+        // Warn about reverse charge
+        if (invoice.taxScenario === 'reverse_charge') {
+            warnings.push('Reverse charge procedure applied - verify VAT treatment');
+        }
+        // Warn about credit notes
+        if (invoice.invoiceTypeCode === '381') {
+            warnings.push('This is a credit note - amounts will be reversed');
+        }
+        // Warn about foreign currency
+        if (invoice.currencyCode !== 'EUR') {
+            warnings.push(`Invoice is in foreign currency: ${invoice.currencyCode}`);
+        }
+        return warnings;
+    }
+    /**
+     * Build description for journal entry
+     */
+    buildDescription(invoice) {
+        const type = invoice.invoiceTypeCode === '381' ? 'Credit Note' : 'Invoice';
+        const party = invoice.direction === 'inbound'
+            ? invoice.supplier.name
+            : invoice.customer.name;
+        return `${type} ${invoice.invoiceNumber} - ${party}`;
+    }
+    /**
+     * Get account description for a group of lines
+     */
+    getAccountDescription(accountNumber, lines) {
+        if (lines.length === 1) {
+            return lines[0].description;
+        }
+        return `${this.mapper.getAccountDescription(accountNumber)} (${lines.length} items)`;
+    }
+    /**
+     * Get used expense accounts
+     */
+    getUsedExpenseAccounts(invoice, rules) {
+        if (invoice.direction !== 'inbound')
+            return [];
+        const accounts = new Set();
+        for (const line of invoice.lines) {
+            const account = this.mapper.mapInvoiceLineToAccount(line, invoice, rules);
+            accounts.add(account);
+        }
+        return Array.from(accounts);
+    }
+    /**
+     * Get used revenue accounts
+     */
+    getUsedRevenueAccounts(invoice, rules) {
+        if (invoice.direction !== 'outbound')
+            return [];
+        const accounts = new Set();
+        for (const line of invoice.lines) {
+            const account = this.mapper.mapInvoiceLineToAccount(line, invoice, rules);
+            accounts.add(account);
+        }
+        return Array.from(accounts);
+    }
+    /**
+     * Get used VAT accounts
+     */
+    getUsedVATAccounts(invoice, rules) {
+        const accounts = new Set();
+        const direction = invoice.direction === 'inbound' ? 'input' : 'output';
+        const taxScenario = invoice.taxScenario || 'domestic_taxed';
+        for (const vatBreak of invoice.vatBreakdown) {
+            const account = this.mapper.getVATAccount(vatBreak.vatCategory, direction, taxScenario);
+            accounts.add(account);
+        }
+        // Add reverse charge accounts if applicable
+        if (taxScenario === 'reverse_charge') {
+            for (const vatBreak of invoice.vatBreakdown) {
+                const inputAccount = this.mapper.getVATAccount(vatBreak.vatCategory, 'input', 'reverse_charge');
+                const outputAccount = this.mapper.getVATAccount(vatBreak.vatCategory, 'output', 'reverse_charge');
+                accounts.add(inputAccount);
+                accounts.add(outputAccount);
+            }
+        }
+        return Array.from(accounts);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"skr.invoice.booking.js","sourceRoot":"","sources":["../ts/skr.invoice.booking.ts"],"names":[],"mappings":"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"}