@fin.cx/skr 1.3.0 → 2.0.0

package/ts/skr.invoice.adapter.ts

@@ -69,13 +69,13 @@ export class InvoiceAdapter {
       }
       
       // Get detected format
-      const format = this.mapEInvoiceFormat(einvoice.format || 'xrechnung');
+      const format = this.mapEInvoiceFormat(this.getDetectedFormat(einvoice));
       
       // Validate the invoice (takes ~2.2ms)
       const validationResult = await this.validateInvoice(einvoice);
       
       // Extract invoice data
-      const invoiceData = einvoice.toObject();
+      const invoiceData = this.mapEInvoiceToBusinessTerms(einvoice);
       
       // Map to internal invoice model
       const invoice = await this.mapToInternalModel(
@@ -106,33 +106,9 @@ export class InvoiceAdapter {
    * Validate an invoice using multi-level validation
    */
   private async validateInvoice(einvoice: any): Promise<IValidationResult> {
-    // Perform multi-level validation
-    const validationResult = await einvoice.validate();
-    
-    // Parse validation results into our structure
-    const syntaxResult = { 
-      isValid: validationResult.syntax?.valid !== false,
-      errors: validationResult.syntax?.errors || [],
-      warnings: validationResult.syntax?.warnings || []
-    };
-    
-    const semanticResult = {
-      isValid: validationResult.semantic?.valid !== false,
-      errors: validationResult.semantic?.errors || [],
-      warnings: validationResult.semantic?.warnings || []
-    };
-    
-    const businessResult = {
-      isValid: validationResult.business?.valid !== false,
-      errors: validationResult.business?.errors || [],
-      warnings: validationResult.business?.warnings || []
-    };
-    
-    const countryResult = {
-      isValid: validationResult.country?.valid !== false,
-      errors: validationResult.country?.errors || [],
-      warnings: validationResult.country?.warnings || []
-    };
+    const syntaxResult = await this.validateInvoiceLevel(einvoice, 'syntax');
+    const semanticResult = await this.validateInvoiceLevel(einvoice, 'semantic');
+    const businessResult = await this.validateInvoiceLevel(einvoice, 'business');
     
     return {
       isValid: syntaxResult.isValid && semanticResult.isValid && businessResult.isValid,
@@ -152,15 +128,219 @@ export class InvoiceAdapter {
         warnings: businessResult.warnings || []
       },
       countrySpecific: {
-        valid: countryResult.isValid,
-        errors: countryResult.errors || [],
-        warnings: countryResult.warnings || []
+        valid: true,
+        errors: [],
+        warnings: []
       },
       validatedAt: new Date(),
-      validatorVersion: '5.1.4'
+      validatorVersion: '6.0.0'
+    };
+  }
+
+  private async validateInvoiceLevel(
+    einvoice: any,
+    level: 'syntax' | 'semantic' | 'business'
+  ): Promise<{ isValid: boolean; errors: string[]; warnings: string[] }> {
+    const validationResult = await einvoice.validate(level);
+
+    return {
+      isValid: validationResult.valid !== false,
+      errors: this.formatValidationMessages(validationResult.errors),
+      warnings: this.formatValidationMessages(validationResult.warnings),
+    };
+  }
+
+  private formatValidationMessages(messages: any[] = []): string[] {
+    return messages.map((message) => {
+      if (typeof message === 'string') {
+        return message;
+      }
+
+      return [message.code, message.message, message.location]
+        .filter(Boolean)
+        .join(': ');
+    });
+  }
+
+  private getDetectedFormat(einvoice: any): string {
+    if (typeof einvoice.getFormat === 'function') {
+      return einvoice.getFormat();
+    }
+
+    return einvoice.format || 'xrechnung';
+  }
+
+  private mapEInvoiceToBusinessTerms(einvoice: any): any {
+    const issueDate = new Date(einvoice.date || Date.now());
+    const invoiceLines = this.mapEInvoiceLinesToBusinessTerms(einvoice.items || [], Boolean(einvoice.reverseCharge));
+    const vatBreakdown = this.buildVatBreakdown(invoiceLines);
+    const lineNetAmount = invoiceLines.reduce((sum, line) => sum + line.BT131_LineNetAmount, 0);
+    const totalVATAmount = vatBreakdown.reduce((sum, vat) => sum + vat.BT117_TaxAmount, 0);
+    const taxInclusiveAmount = lineNetAmount + totalVATAmount;
+
+    return {
+      BT1_InvoiceNumber: einvoice.accountingDocId || einvoice.id || einvoice.invoiceId || '',
+      BT2_IssueDate: issueDate.toISOString(),
+      BT3_InvoiceTypeCode: einvoice.accountingDocType === 'creditnote' ? '381' : '380',
+      BT5_CurrencyCode: einvoice.currency || 'EUR',
+      BT7_TaxPointDate: einvoice.deliveryDate ? new Date(einvoice.deliveryDate).toISOString() : undefined,
+      BT9_PaymentDueDate: this.getDueDate(issueDate, einvoice.dueInDays)?.toISOString(),
+      BT10_BuyerReference: einvoice.buyerReference,
+      BT22_InvoiceNote: Array.isArray(einvoice.notes) ? einvoice.notes.join('\n') : undefined,
+      BG4_Seller: this.mapEInvoiceContactToBusinessTerms(einvoice.from, 'seller', einvoice.paymentOptions),
+      BG7_Buyer: this.mapEInvoiceContactToBusinessTerms(einvoice.to, 'buyer'),
+      BG25_InvoiceLines: invoiceLines,
+      BG20_DocumentAllowances: [],
+      BG21_DocumentCharges: [],
+      BT106_SumOfLineNetAmounts: lineNetAmount,
+      BT107_AllowanceTotalAmount: 0,
+      BT108_ChargeTotalAmount: 0,
+      BT109_TaxExclusiveAmount: lineNetAmount,
+      BT110_TotalVATAmount: totalVATAmount,
+      BT112_TaxInclusiveAmount: taxInclusiveAmount,
+      BT113_PrepaidAmount: 0,
+      BT115_PayableAmount: taxInclusiveAmount,
+      BG23_VATBreakdown: vatBreakdown,
+      BG16_PaymentInstructions: this.mapPaymentOptionsToBusinessTerms(einvoice.paymentOptions),
     };
   }
 
+  private mapEInvoiceLinesToBusinessTerms(items: any[], reverseCharge: boolean): any[] {
+    return items.map((item, index) => {
+      const quantity = Number(item.unitQuantity || 0);
+      const unitPrice = Number(item.unitNetPrice || 0);
+      const vatRate = Number(item.vatPercentage || 0);
+      const netAmount = quantity * unitPrice;
+      const vatAmount = reverseCharge ? 0 : netAmount * vatRate / 100;
+
+      return {
+        BT154_ItemDescription: item.name || '',
+        BT129_Quantity: quantity,
+        BT146_NetPrice: unitPrice,
+        BT131_LineNetAmount: netAmount,
+        BT151_ItemVATCategory: this.getVatCategoryCode(vatRate, reverseCharge),
+        BT152_ItemVATRate: vatRate,
+        BT155_ItemSellerID: item.articleNumber,
+        lineVATAmount: vatAmount,
+      };
+    });
+  }
+
+  private buildVatBreakdown(invoiceLines: any[]): any[] {
+    const vatBreakdownMap = new Map<string, { categoryCode: string; rate: number; taxableAmount: number; taxAmount: number }>();
+
+    for (const line of invoiceLines) {
+      const categoryCode = line.BT151_ItemVATCategory || 'S';
+      const rate = Number(line.BT152_ItemVATRate || 0);
+      const key = `${categoryCode}:${rate}`;
+      const existingBreakdown = vatBreakdownMap.get(key) || {
+        categoryCode,
+        rate,
+        taxableAmount: 0,
+        taxAmount: 0,
+      };
+
+      existingBreakdown.taxableAmount += Number(line.BT131_LineNetAmount || 0);
+      existingBreakdown.taxAmount += Number(line.lineVATAmount || 0);
+      vatBreakdownMap.set(key, existingBreakdown);
+    }
+
+    return Array.from(vatBreakdownMap.values()).map((vatBreakdown) => ({
+      BT118_VATCategory: vatBreakdown.categoryCode,
+      BT119_VATRate: vatBreakdown.rate,
+      BT116_TaxableAmount: vatBreakdown.taxableAmount,
+      BT117_TaxAmount: vatBreakdown.taxAmount,
+    }));
+  }
+
+  private mapEInvoiceContactToBusinessTerms(
+    contact: any,
+    role: 'seller' | 'buyer',
+    paymentOptions?: any,
+  ): any {
+    const address = contact?.address || {};
+    const registrationDetails = contact?.registrationDetails || {};
+    const countryCode = this.normalizeCountryCode(address.countryCode || address.country);
+
+    if (role === 'seller') {
+      return {
+        BT27_SellerName: contact?.name || '',
+        BT29_SellerID: registrationDetails.registrationId,
+        BT31_SellerVATID: registrationDetails.vatId,
+        BT32_SellerTaxID: registrationDetails.registrationId,
+        BT33_SellerPhone: contact?.phone,
+        BT34_SellerEmail: contact?.email,
+        BT35_SellerStreet: this.formatStreet(address),
+        BT37_SellerCity: address.city,
+        BT38_SellerPostalCode: address.postalCode,
+        BT40_SellerCountryCode: countryCode,
+        BT84_PaymentAccountID: paymentOptions?.sepaConnection?.iban,
+        BT85_PaymentAccountName: contact?.name,
+        BT86_PaymentServiceProviderID: paymentOptions?.sepaConnection?.bic,
+      };
+    }
+
+    return {
+      BT44_BuyerName: contact?.name || '',
+      BT46_BuyerID: registrationDetails.registrationId,
+      BT47_BuyerTaxID: registrationDetails.registrationId,
+      BT48_BuyerVATID: registrationDetails.vatId,
+      BT49_BuyerEmail: contact?.email,
+      BT50_BuyerStreet: this.formatStreet(address),
+      BT52_BuyerCity: address.city,
+      BT53_BuyerPostalCode: address.postalCode,
+      BT55_BuyerCountryCode: countryCode,
+    };
+  }
+
+  private mapPaymentOptionsToBusinessTerms(paymentOptions: any): any | undefined {
+    if (!paymentOptions?.sepaConnection?.iban) {
+      return undefined;
+    }
+
+    return {
+      BT81_PaymentMeansCode: '30',
+      BT84_PaymentAccountID: paymentOptions.sepaConnection.iban,
+      BT85_PaymentAccountName: paymentOptions.description,
+      BT86_PaymentServiceProviderID: paymentOptions.sepaConnection.bic,
+    };
+  }
+
+  private getDueDate(issueDate: Date, dueInDays?: number): Date | undefined {
+    if (typeof dueInDays !== 'number') {
+      return undefined;
+    }
+
+    return new Date(issueDate.getTime() + dueInDays * 24 * 60 * 60 * 1000);
+  }
+
+  private getVatCategoryCode(vatRate: number, reverseCharge: boolean): string {
+    if (reverseCharge) {
+      return 'AE';
+    }
+
+    return vatRate === 0 ? 'Z' : 'S';
+  }
+
+  private normalizeCountryCode(country?: string): string {
+    if (!country) {
+      return 'DE';
+    }
+
+    const countryMap: Record<string, string> = {
+      Germany: 'DE',
+      Deutschland: 'DE',
+    };
+
+    return countryMap[country] || country;
+  }
+
+  private formatStreet(address: any): string {
+    return [address.streetName, address.houseNumber]
+      .filter(Boolean)
+      .join(' ');
+  }
+
   /**
    * Map EN16931 Business Terms to internal invoice model
    */
@@ -559,8 +739,8 @@ export class InvoiceAdapter {
       const einvoice: any = new EInvoice();
       
       // Set invoice data
-      const businessTerms = this.mapToBusinessTerms(invoiceData);
-      Object.assign(einvoice, businessTerms);
+      const einvoiceData = this.mapToEInvoiceData(invoiceData);
+      Object.assign(einvoice, einvoiceData);
       
       // Generate XML in requested format
       const xml = await einvoice.exportXml(format as any);
@@ -585,17 +765,83 @@ export class InvoiceAdapter {
   /**
    * Map internal invoice to EN16931 Business Terms
    */
-  private mapToBusinessTerms(invoice: Partial<IInvoice>): any {
+  private mapToEInvoiceData(invoice: Partial<IInvoice>): any {
+    const issueDate = invoice.issueDate || new Date();
+
     return {
-      BT1_InvoiceNumber: invoice.invoiceNumber,
-      BT2_IssueDate: invoice.issueDate?.toISOString(),
-      BT3_InvoiceTypeCode: invoice.invoiceTypeCode || '380',
-      BT5_CurrencyCode: invoice.currencyCode || 'EUR',
-      BT7_TaxPointDate: invoice.taxPointDate?.toISOString(),
-      BT9_PaymentDueDate: invoice.paymentDueDate?.toISOString(),
-      
-      // Map other Business Terms...
-      // This would be a comprehensive mapping in production
+      id: invoice.invoiceNumber || '',
+      accountingDocId: invoice.invoiceNumber || '',
+      accountingDocType: invoice.invoiceTypeCode === '381' ? 'creditnote' : 'invoice',
+      date: issueDate.getTime(),
+      currency: invoice.currencyCode || 'EUR',
+      buyerReference: invoice.buyerReference,
+      deliveryDate: invoice.taxPointDate?.getTime(),
+      dueInDays: this.calculateDueInDays(issueDate, invoice.paymentDueDate),
+      notes: invoice.invoiceNote ? [invoice.invoiceNote] : [],
+      from: this.mapInvoicePartyToEInvoiceContact(invoice.supplier),
+      to: this.mapInvoicePartyToEInvoiceContact(invoice.customer),
+      items: (invoice.lines || []).map((line) => ({
+        position: line.lineNumber,
+        name: line.description,
+        articleNumber: line.productCode,
+        unitType: 'EA',
+        unitQuantity: line.quantity,
+        unitNetPrice: line.unitPrice,
+        vatPercentage: line.vatCategory.rate,
+      })),
+      paymentOptions: invoice.paymentMeans?.account ? {
+        description: invoice.paymentMeans.account.accountHolder,
+        sepaConnection: {
+          iban: invoice.paymentMeans.account.iban,
+          bic: invoice.paymentMeans.account.bic || '',
+        },
+        payPal: {
+          email: '',
+        },
+      } : undefined,
     };
   }
+
+  private mapInvoicePartyToEInvoiceContact(party?: IInvoiceParty): any {
+    const countryCode = this.normalizeCountryCode(party?.address?.countryCode);
+
+    return {
+      type: 'company',
+      name: party?.name || '',
+      description: '',
+      address: {
+        streetName: party?.address?.street || '',
+        houseNumber: '',
+        city: party?.address?.city || '',
+        postalCode: party?.address?.postalCode || '',
+        country: countryCode,
+        countryCode,
+      },
+      registrationDetails: {
+        vatId: party?.vatId || '',
+        registrationId: party?.id || party?.taxId || '',
+        registrationName: party?.name || '',
+      },
+      status: 'active',
+      foundedDate: {
+        year: new Date().getFullYear(),
+        month: new Date().getMonth() + 1,
+        day: new Date().getDate(),
+      },
+      email: party?.email,
+      phone: party?.phone,
+      sepaConnection: party?.bankAccount ? {
+        iban: party.bankAccount.iban,
+        bic: party.bankAccount.bic || '',
+      } : undefined,
+    };
+  }
+
+  private calculateDueInDays(issueDate: Date, paymentDueDate?: Date): number {
+    if (!paymentDueDate) {
+      return 30;
+    }
+
+    return Math.max(0, Math.round((paymentDueDate.getTime() - issueDate.getTime()) / (24 * 60 * 60 * 1000)));
+  }
 }

package/ts/skr.invoice.booking.ts

@@ -1,5 +1,7 @@
 import * as plugins from './plugins.js';
 import { JournalEntry } from './skr.classes.journalentry.js';
+import { JournalPoster } from './skr.posting.js';
+import { journalInputToDraft } from './skr.txview.js';
 import { SKRInvoiceMapper } from './skr.invoice.mapper.js';
 import { suggestPostingKey } from './skr.postingkeys.js';
 import type { TSKRType, IJournalEntry, IJournalEntryLine } from './skr.types.js';
@@ -86,13 +88,18 @@ export class InvoiceBookingEngine {
         }
       }
       
-      // Build journal entry
-      const journalEntry = await this.buildJournalEntry(invoice, rules, options);
-      
-      // Create booking info
+      // Build journal input and post it atomically via the v2 path
+      const journalData = await this.buildJournalEntry(invoice, rules, options);
+      const journalEntry = await new JournalPoster().postDraft(
+        journalInputToDraft(journalData),
+      );
+      if (invoice.status !== 'posted') {
+        invoice.status = 'posted';
+      }
+
       const bookingInfo: IBookingInfo = {
         journalEntryId: journalEntry.id,
-        transactionIds: journalEntry.transactionIds || [],
+        transactionIds: [],
         bookedAt: new Date(),
         bookedBy: 'system',
         bookingRules: {
@@ -105,23 +112,7 @@ export class InvoiceBookingEngine {
         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,
@@ -147,7 +138,7 @@ export class InvoiceBookingEngine {
     invoice: IInvoice,
     rules: IBookingRules,
     options?: IBookingOptions
-  ): Promise<JournalEntry> {
+  ): Promise<IJournalEntry> {
     const lines: IJournalEntryLine[] = [];
     const isInbound = invoice.direction === 'inbound';
     const isCredit = invoice.invoiceTypeCode === '381'; // Credit note
@@ -163,17 +154,14 @@ export class InvoiceBookingEngine {
       lines.push(...this.buildAREntry(invoice, rules, reverseDirection));
     }
     
-    // Create journal entry
-    const journalData: IJournalEntry = {
+    // Journal input data — posted through the v2 atomic path by the caller
+    return {
       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;
   }
   
   /**
@@ -555,7 +543,7 @@ export class InvoiceBookingEngine {
         }
       }
       
-      // Create journal entry for payment
+      // Create journal entry for payment (v2 atomic path)
       const journalData: IJournalEntry = {
         date: payment.paymentDate,
         description: `Payment for invoice ${invoice.invoiceNumber}`,
@@ -563,11 +551,11 @@ export class InvoiceBookingEngine {
         lines,
         skrType: this.skrType
       };
-      
-      const journalEntry = new JournalEntry(journalData);
-      await journalEntry.validate();
-      await journalEntry.post();
-      
+
+      const journalEntry = await new JournalPoster().postDraft(
+        journalInputToDraft(journalData),
+      );
+
       return {
         success: true,
         journalEntry,