@fin.cx/skr 1.0.0 → 1.2.0

package/ts/index.ts

@@ -8,3 +8,9 @@ export * from './skr.classes.reports.js';
 export * from './skr.api.js';
 export * from './skr03.data.js';
 export * from './skr04.data.js';
+export * from './skr.export.js';
+export * from './skr.export.ledger.js';
+export * from './skr.export.accounts.js';
+export * from './skr.export.balances.js';
+export * from './skr.export.pdf.js';
+export * from './skr.security.js';

package/ts/plugins.ts

@@ -3,5 +3,26 @@ import * as smartdata from '@push.rocks/smartdata';
 import * as smartunique from '@push.rocks/smartunique';
 import * as smarttime from '@push.rocks/smarttime';
 import * as smartlog from '@push.rocks/smartlog';
+import * as smartfile from '@push.rocks/smartfile';
+import * as smarthash from '@push.rocks/smarthash';
+import * as smartpath from '@push.rocks/smartpath';
+import * as smartpdf from '@push.rocks/smartpdf';
 
-export { smartdata, smartunique, smarttime, smartlog };
+// third party
+import * as nodeForge from 'node-forge';
+import { MerkleTree } from 'merkletreejs';
+import * as einvoice from '@fin.cx/einvoice';
+
+export { 
+  smartdata, 
+  smartunique, 
+  smarttime, 
+  smartlog, 
+  smartfile, 
+  smarthash, 
+  smartpath, 
+  smartpdf,
+  nodeForge,
+  MerkleTree,
+  einvoice
+};

package/ts/skr.api.ts

@@ -1,10 +1,28 @@
 import * as plugins from './plugins.js';
+import * as path from 'path';
 import { ChartOfAccounts } from './skr.classes.chartofaccounts.js';
 import { Ledger } from './skr.classes.ledger.js';
 import { Reports } from './skr.classes.reports.js';
 import { Account } from './skr.classes.account.js';
 import { Transaction } from './skr.classes.transaction.js';
 import { JournalEntry } from './skr.classes.journalentry.js';
+import { SkrExport, type IExportOptions } from './skr.export.js';
+import { LedgerExporter } from './skr.export.ledger.js';
+import { AccountsExporter } from './skr.export.accounts.js';
+import { BalancesExporter } from './skr.export.balances.js';
+import { PdfReportGenerator, type IPdfReportOptions } from './skr.export.pdf.js';
+import { SecurityManager, type ISigningOptions } from './skr.security.js';
+import { InvoiceAdapter } from './skr.invoice.adapter.js';
+import { InvoiceStorage } from './skr.invoice.storage.js';
+import { InvoiceBookingEngine, type IBookingOptions, type IBookingResult } from './skr.invoice.booking.js';
+import type {
+  IInvoice,
+  IInvoiceFilter,
+  IInvoiceImportOptions,
+  IInvoiceExportOptions,
+  IBookingRules,
+  TInvoiceDirection,
+} from './skr.invoice.entity.js';
 import type {
   IDatabaseConfig,
   TSKRType,
@@ -17,6 +35,7 @@ import type {
   ITrialBalanceReport,
   IIncomeStatement,
   IBalanceSheet,
+  IAccountBalance,
 } from './skr.types.js';
 
 /**
@@ -29,6 +48,9 @@ export class SkrApi {
   private logger: plugins.smartlog.Smartlog;
   private initialized: boolean = false;
   private currentSKRType: TSKRType | null = null;
+  private invoiceAdapter: InvoiceAdapter | null = null;
+  private invoiceStorage: InvoiceStorage | null = null;
+  private invoiceBookingEngine: InvoiceBookingEngine | null = null;
 
   constructor(private config: IDatabaseConfig) {
     this.chartOfAccounts = new ChartOfAccounts(config);
@@ -62,6 +84,13 @@ export class SkrApi {
     this.currentSKRType = skrType;
     this.ledger = new Ledger(skrType);
     this.reports = new Reports(skrType);
+    
+    // Initialize invoice components
+    this.invoiceAdapter = new InvoiceAdapter();
+    const invoicePath = this.config.invoiceExportPath || path.resolve(process.cwd(), 'exports', 'invoices');
+    this.invoiceStorage = new InvoiceStorage(invoicePath);
+    this.invoiceBookingEngine = new InvoiceBookingEngine(skrType);
+    
     this.initialized = true;
 
     this.logger.log('info', 'SKR API initialized successfully');
@@ -158,7 +187,8 @@ export class SkrApi {
     transactionData: ITransactionData,
   ): Promise<Transaction> {
     this.ensureInitialized();
-    return await this.chartOfAccounts.postTransaction(transactionData);
+    if (!this.ledger) throw new Error('Ledger not initialized');
+    return await this.ledger.postTransaction(transactionData);
   }
 
   /**
@@ -168,7 +198,8 @@ export class SkrApi {
     journalData: IJournalEntry,
   ): Promise<JournalEntry> {
     this.ensureInitialized();
-    return await this.chartOfAccounts.postJournalEntry(journalData);
+    if (!this.ledger) throw new Error('Ledger not initialized');
+    return await this.ledger.postJournalEntry(journalData);
   }
 
   /**
@@ -348,6 +379,262 @@ export class SkrApi {
     return await this.chartOfAccounts.exportAccountsToCSV();
   }
 
+  /**
+   * Export Jahresabschluss in GoBD-compliant BagIt format
+   * Creates a revision-safe export for 10-year archival
+   */
+  public async exportJahresabschluss(options: IExportOptions): Promise<string> {
+    this.ensureInitialized();
+    if (!this.ledger || !this.reports || !this.currentSKRType) {
+      throw new Error('API not fully initialized');
+    }
+
+    this.logger.log('info', `Starting Jahresabschluss export for fiscal year ${options.fiscalYear}`);
+
+    // Create export instance
+    const exporter = new SkrExport(options);
+    
+    // Create BagIt structure
+    await exporter.createBagItStructure();
+    await exporter.createExportMetadata(this.currentSKRType);
+    await exporter.createSchemas();
+
+    // Export accounting data
+    await this.exportLedgerData(exporter, options);
+    await this.exportAccountData(exporter, options);
+    await this.exportBalanceData(exporter, options);
+
+    // Generate PDF reports if requested
+    if (options.generatePdfReports) {
+      await this.generatePdfReports(exporter, options);
+    }
+
+    // Sign export if requested
+    if (options.signExport) {
+      await this.signExport(exporter, options);
+    }
+
+    // Create manifests and validate
+    await exporter.writeManifests();
+    const merkleRoot = await exporter.createMerkleTree();
+    
+    const isValid = await exporter.validateBagIt();
+    if (!isValid) {
+      throw new Error('BagIt validation failed');
+    }
+
+    this.logger.log('ok', `Jahresabschluss export completed. Merkle root: ${merkleRoot}`);
+    
+    return options.exportPath;
+  }
+
+  /**
+   * Export ledger data in NDJSON format
+   */
+  private async exportLedgerData(exporter: SkrExport, options: IExportOptions): Promise<void> {
+    if (!this.ledger) throw new Error('Ledger not initialized');
+    
+    const ledgerExporter = new LedgerExporter(options.exportPath);
+    await ledgerExporter.initialize();
+
+    // Get all transactions for the period
+    const transactions = await this.chartOfAccounts.getTransactions({
+      dateFrom: options.dateFrom,
+      dateTo: options.dateTo
+    });
+
+    // Export each transaction
+    for (const transaction of transactions) {
+      const transactionData = transaction;
+      await ledgerExporter.exportTransaction(transactionData as any);
+    }
+
+    // Get all journal entries for the period
+    // Use MongoDB query syntax for date range
+    const journalEntries = await JournalEntry.getInstances({
+      date: {
+        $gte: options.dateFrom,
+        $lte: options.dateTo
+      } as any, // SmartData supports MongoDB query operators
+      skrType: this.currentSKRType
+    });
+
+    // Export each journal entry
+    for (const entry of journalEntries) {
+      const entryData = entry;
+      await ledgerExporter.exportJournalEntry(entryData as any);
+    }
+
+    const entryCount = await ledgerExporter.close();
+    this.logger.log('info', `Exported ${entryCount} ledger entries`);
+  }
+
+  /**
+   * Export account data in CSV format
+   */
+  private async exportAccountData(exporter: SkrExport, options: IExportOptions): Promise<void> {
+    const accountsExporter = new AccountsExporter(options.exportPath);
+
+    // Get all accounts
+    const accounts = await this.chartOfAccounts.getAllAccounts();
+
+    // Add each account to export
+    for (const account of accounts) {
+      const accountData = account;
+      accountsExporter.addAccount(accountData as any);
+    }
+
+    // Export to CSV and JSON
+    await accountsExporter.exportToCSV();
+    await accountsExporter.exportToJSON();
+
+    this.logger.log('info', `Exported ${accountsExporter.getAccountCount()} accounts`);
+  }
+
+  /**
+   * Export balance data in CSV format
+   */
+  private async exportBalanceData(exporter: SkrExport, options: IExportOptions): Promise<void> {
+    if (!this.ledger) throw new Error('Ledger not initialized');
+    
+    const balancesExporter = new BalancesExporter(
+      options.exportPath,
+      options.fiscalYear
+    );
+
+    // Get all accounts with balances
+    const accounts = await this.chartOfAccounts.getAllAccounts();
+
+    for (const account of accounts) {
+      const balance = await this.ledger.getAccountBalance(
+        account.accountNumber,
+        options.dateTo
+      );
+      
+      if (balance) {
+        balancesExporter.addBalance(
+          account.accountNumber,
+          account.accountName,
+          balance as IAccountBalance,
+          `${options.fiscalYear}`
+        );
+      }
+    }
+
+    // Export balance reports
+    await balancesExporter.exportToCSV();
+    await balancesExporter.exportTrialBalance();
+    await balancesExporter.exportClassSummary();
+
+    this.logger.log('info', `Exported ${balancesExporter.getBalanceCount()} account balances`);
+  }
+
+  /**
+   * Generate PDF reports for the export
+   */
+  private async generatePdfReports(exporter: SkrExport, options: IExportOptions): Promise<void> {
+    if (!this.reports) throw new Error('Reports not initialized');
+
+    const pdfOptions: IPdfReportOptions = {
+      companyName: options.companyInfo?.name || 'Unternehmen',
+      companyAddress: options.companyInfo?.address,
+      taxId: options.companyInfo?.taxId,
+      registrationNumber: options.companyInfo?.registrationNumber,
+      fiscalYear: options.fiscalYear,
+      dateFrom: options.dateFrom,
+      dateTo: options.dateTo,
+      preparedDate: new Date()
+    };
+
+    const pdfGenerator = new PdfReportGenerator(options.exportPath, pdfOptions);
+    await pdfGenerator.initialize();
+
+    try {
+      // Generate reports
+      const trialBalance = await this.reports.getTrialBalance({
+        dateFrom: options.dateFrom,
+        dateTo: options.dateTo,
+        skrType: this.currentSKRType
+      });
+
+      const incomeStatement = await this.reports.getIncomeStatement({
+        dateFrom: options.dateFrom,
+        dateTo: options.dateTo,
+        skrType: this.currentSKRType
+      });
+
+      const balanceSheet = await this.reports.getBalanceSheet({
+        dateFrom: options.dateFrom,
+        dateTo: options.dateTo,
+        skrType: this.currentSKRType
+      });
+
+      // Generate PDFs
+      const jahresabschlussPdf = await pdfGenerator.generateJahresabschlussPdf(
+        trialBalance,
+        incomeStatement,
+        balanceSheet
+      );
+
+      // Save PDFs
+      await pdfGenerator.savePdfReport('jahresabschluss.pdf', jahresabschlussPdf);
+      
+      // Store in BagIt structure
+      await exporter.storeDocument(jahresabschlussPdf, 'jahresabschluss.pdf');
+
+      this.logger.log('info', 'PDF reports generated successfully');
+    } finally {
+      await pdfGenerator.close();
+    }
+  }
+
+  /**
+   * Sign the export with CAdES signature
+   */
+  private async signExport(exporter: SkrExport, options: IExportOptions): Promise<void> {
+    const signingOptions: ISigningOptions = {
+      certificatePem: options.signExport ? undefined : undefined, // Use provided cert or generate
+      privateKeyPem: options.signExport ? undefined : undefined,
+      includeTimestamp: options.timestampExport !== false
+    };
+
+    const security = new SecurityManager(signingOptions);
+
+    // Generate self-signed certificate if none provided
+    let cert: string, key: string;
+    if (!signingOptions.certificatePem) {
+      const generated = await security.generateSelfSignedCertificate(
+        options.companyInfo?.name || 'SKR Export System'
+      );
+      cert = generated.certificate;
+      key = generated.privateKey;
+    } else {
+      cert = signingOptions.certificatePem;
+      key = signingOptions.privateKeyPem!;
+    }
+
+    // Sign the manifest
+    const manifestPath = path.resolve(
+      options.exportPath,
+      `jahresabschluss_${options.fiscalYear}`,
+      'manifest-sha256.txt'
+    );
+    
+    await security.createDetachedSignature(
+      manifestPath,
+      path.resolve(
+        options.exportPath,
+        `jahresabschluss_${options.fiscalYear}`,
+        'data',
+        'metadata',
+        'signatures',
+        'manifest.cades'
+      )
+    );
+
+    this.logger.log('info', 'Export signed with CAdES signature');
+  }
+
   // ========== Utility Methods ==========
 
   /**
@@ -530,4 +817,204 @@ export class SkrApi {
       totalPages,
     };
   }
+
+  // ========== Invoice Management ==========
+
+  /**
+   * Import an invoice from file or buffer
+   * Parses, validates, and optionally books the invoice
+   */
+  public async importInvoice(
+    file: Buffer | string,
+    direction: TInvoiceDirection,
+    options?: IInvoiceImportOptions
+  ): Promise<IInvoice> {
+    this.ensureInitialized();
+    if (!this.invoiceAdapter || !this.invoiceStorage || !this.invoiceBookingEngine) {
+      throw new Error('Invoice components not initialized');
+    }
+
+    this.logger.log('info', `Importing ${direction} invoice`);
+
+    // Parse and validate invoice
+    const invoice = await this.invoiceAdapter.parseInvoice(file, direction);
+
+    // Store invoice
+    await this.invoiceStorage.initialize();
+    const contentHash = await this.invoiceStorage.storeInvoice(invoice);
+    invoice.contentHash = contentHash;
+
+    // Auto-book if requested
+    if (options?.autoBook) {
+      const bookingResult = await this.bookInvoice(
+        invoice,
+        options.bookingRules,
+        {
+          autoBook: true,
+          confidenceThreshold: options.confidenceThreshold || 80,
+          skipValidation: options.validateOnly
+        }
+      );
+
+      if (bookingResult.success && bookingResult.bookingInfo) {
+        invoice.bookingInfo = bookingResult.bookingInfo;
+        invoice.status = 'posted';
+        
+        // Update stored metadata with booking information
+        await this.invoiceStorage.updateMetadata(invoice.contentHash, {
+          journalEntryId: bookingResult.bookingInfo.journalEntryId,
+          transactionIds: bookingResult.bookingInfo.transactionIds
+        });
+      }
+    }
+
+    this.logger.log('info', `Invoice imported successfully: ${invoice.invoiceNumber}`);
+    return invoice;
+  }
+
+  /**
+   * Book an invoice to the ledger
+   */
+  public async bookInvoice(
+    invoice: IInvoice,
+    bookingRules?: Partial<IBookingRules>,
+    options?: IBookingOptions
+  ): Promise<IBookingResult> {
+    this.ensureInitialized();
+    if (!this.invoiceBookingEngine) {
+      throw new Error('Invoice booking engine not initialized');
+    }
+
+    this.logger.log('info', `Booking invoice ${invoice.invoiceNumber}`);
+    
+    const result = await this.invoiceBookingEngine.bookInvoice(
+      invoice,
+      bookingRules,
+      options
+    );
+
+    if (result.success) {
+      this.logger.log('info', `Invoice booked successfully with confidence ${result.confidence}%`);
+      
+      // Update stored metadata if invoice has a content hash
+      if (invoice.contentHash && result.bookingInfo && this.invoiceStorage) {
+        await this.invoiceStorage.updateMetadata(invoice.contentHash, {
+          journalEntryId: result.bookingInfo.journalEntryId,
+          transactionIds: result.bookingInfo.transactionIds
+        });
+      }
+    } else {
+      this.logger.log('error', `Invoice booking failed: ${result.errors?.join(', ')}`);
+    }
+
+    return result;
+  }
+
+  /**
+   * Export an invoice in a different format
+   */
+  public async exportInvoice(
+    invoice: IInvoice,
+    options: IInvoiceExportOptions
+  ): Promise<{ xml: string; pdf?: Buffer }> {
+    this.ensureInitialized();
+    if (!this.invoiceAdapter) {
+      throw new Error('Invoice adapter not initialized');
+    }
+
+    this.logger.log('info', `Exporting invoice ${invoice.invoiceNumber} to ${options.format}`);
+
+    // Convert format if needed
+    const xml = await this.invoiceAdapter.convertFormat(invoice, options.format);
+
+    // Generate PDF if requested
+    let pdf: Buffer | undefined;
+    if (options.embedInPdf) {
+      const result = await this.invoiceAdapter.generateInvoice(invoice, options.format);
+      pdf = result.pdf;
+    }
+
+    return { xml, pdf };
+  }
+
+  /**
+   * Search invoices by filter
+   */
+  public async searchInvoices(filter: IInvoiceFilter): Promise<IInvoice[]> {
+    this.ensureInitialized();
+    if (!this.invoiceStorage) {
+      throw new Error('Invoice storage not initialized');
+    }
+
+    await this.invoiceStorage.initialize();
+    const metadata = await this.invoiceStorage.searchInvoices(filter);
+    
+    const invoices: IInvoice[] = [];
+    for (const meta of metadata) {
+      const invoice = await this.invoiceStorage.retrieveInvoice(meta.contentHash);
+      if (invoice) {
+        invoices.push(invoice);
+      }
+    }
+
+    return invoices;
+  }
+
+  /**
+   * Get invoice by content hash
+   */
+  public async getInvoice(contentHash: string): Promise<IInvoice | null> {
+    this.ensureInitialized();
+    if (!this.invoiceStorage) {
+      throw new Error('Invoice storage not initialized');
+    }
+
+    await this.invoiceStorage.initialize();
+    return await this.invoiceStorage.retrieveInvoice(contentHash);
+  }
+
+  /**
+   * Get invoice storage statistics
+   */
+  public async getInvoiceStatistics(): Promise<any> {
+    this.ensureInitialized();
+    if (!this.invoiceStorage) {
+      throw new Error('Invoice storage not initialized');
+    }
+
+    await this.invoiceStorage.initialize();
+    return await this.invoiceStorage.getStatistics();
+  }
+
+  /**
+   * Create EN16931 compliance report for invoices
+   */
+  public async createInvoiceComplianceReport(): Promise<void> {
+    this.ensureInitialized();
+    if (!this.invoiceStorage) {
+      throw new Error('Invoice storage not initialized');
+    }
+
+    await this.invoiceStorage.initialize();
+    await this.invoiceStorage.createComplianceReport();
+    
+    this.logger.log('info', 'Invoice compliance report created');
+  }
+
+  /**
+   * Generate an invoice from internal data
+   */
+  public async generateInvoice(
+    invoiceData: Partial<IInvoice>,
+    format: IInvoiceExportOptions['format']
+  ): Promise<{ xml: string; pdf?: Buffer }> {
+    this.ensureInitialized();
+    if (!this.invoiceAdapter) {
+      throw new Error('Invoice adapter not initialized');
+    }
+
+    this.logger.log('info', `Generating invoice in ${format} format`);
+    
+    return await this.invoiceAdapter.generateInvoice(invoiceData, format);
+  }
 }

package/ts/skr.classes.journalentry.ts

@@ -96,6 +96,8 @@ export class JournalEntry extends SmartDataDbDoc<JournalEntry, JournalEntry> {
       this.postedAt = null;
       this.createdBy = 'system';
 
+      // Normalize any negative amounts to the correct side
+      this.sanitizeLines();
       // Calculate totals
       this.calculateTotals();
     }
@@ -107,6 +109,36 @@ export class JournalEntry extends SmartDataDbDoc<JournalEntry, JournalEntry> {
     return `JE-${timestamp}-${random}`;
   }
 
+  private sanitizeLines(): void {
+    for (const line of this.lines) {
+      // Check if both debit and credit are set (not allowed)
+      if (line.debit !== undefined && line.debit !== 0 && 
+          line.credit !== undefined && line.credit !== 0) {
+        throw new Error('A line cannot have both debit and credit amounts');
+      }
+      
+      // Handle negative debit - convert to positive credit
+      if (line.debit !== undefined && line.debit < 0) {
+        line.credit = Math.abs(line.debit);
+        delete (line as any).debit;
+      }
+      
+      // Handle negative credit - convert to positive debit
+      if (line.credit !== undefined && line.credit < 0) {
+        line.debit = Math.abs(line.credit);
+        delete (line as any).credit;
+      }
+      
+      // Check that at least one side has a positive value
+      const hasDebit = line.debit !== undefined && line.debit > 0;
+      const hasCredit = line.credit !== undefined && line.credit > 0;
+      
+      if (!hasDebit && !hasCredit) {
+        throw new Error('Either debit or credit must be a positive number');
+      }
+    }
+  }
+
   private calculateTotals(): void {
     this.totalDebits = 0;
     this.totalCredits = 0;
@@ -204,6 +236,8 @@ export class JournalEntry extends SmartDataDbDoc<JournalEntry, JournalEntry> {
       throw new Error('Journal entry is already posted');
     }
 
+    // Normalize any negative amounts to the correct side
+    this.sanitizeLines();
     // Validate before posting
     await this.validate();
 
@@ -230,28 +264,41 @@ export class JournalEntry extends SmartDataDbDoc<JournalEntry, JournalEntry> {
       transactions.push(transaction);
     } else {
       // Complex entry: multiple debits and/or credits
-      // Create transactions to balance the entry
-      for (const debitLine of debitLines) {
-        for (const creditLine of creditLines) {
-          const amount = Math.min(debitLine.debit || 0, creditLine.credit || 0);
+      // Build working queues with remaining amounts (don't mutate original lines)
+      const debitQueue = debitLines.map(l => ({ 
+        line: l, 
+        remaining: l.debit || 0 
+      }));
+      
+      const creditQueue = creditLines.map(l => ({ 
+        line: l, 
+        remaining: l.credit || 0 
+      }));
 
-          if (amount > 0) {
+      // Create transactions to balance the entry
+      for (const d of debitQueue) {
+        for (const c of creditQueue) {
+          const amount = Math.min(d.remaining, c.remaining);
+          
+          if (amount > 0.0000001) { // small epsilon to avoid float artifacts
             const transaction = await Transaction.createTransaction({
               date: this.date,
-              debitAccount: debitLine.accountNumber,
-              creditAccount: creditLine.accountNumber,
-              amount: amount,
-              description: `${this.description} - ${debitLine.description || creditLine.description || ''}`,
+              debitAccount: d.line.accountNumber,
+              creditAccount: c.line.accountNumber,
+              amount: Math.round(amount * 100) / 100, // round to 2 decimals
+              description: `${this.description} - ${d.line.description || c.line.description || ''}`,
               reference: this.reference,
               skrType: this.skrType,
-              costCenter: debitLine.costCenter || creditLine.costCenter,
+              costCenter: d.line.costCenter || c.line.costCenter,
             });
             transactions.push(transaction);
-
-            // Reduce amounts for tracking
-            if (debitLine.debit) debitLine.debit -= amount;
-            if (creditLine.credit) creditLine.credit -= amount;
+            
+            // Reduce remaining amounts in working copies (not original lines)
+            d.remaining -= amount;
+            c.remaining -= amount;
           }
+          
+          if (d.remaining <= 0.0000001) break;
         }
       }
     }
@@ -299,6 +346,8 @@ export class JournalEntry extends SmartDataDbDoc<JournalEntry, JournalEntry> {
   }
 
   public async beforeSave(): Promise<void> {
+    // Normalize any negative amounts to the correct side
+    this.sanitizeLines();
     // Recalculate totals before saving
     this.calculateTotals();