@fin.cx/skr 1.2.0 → 1.2.2

package/readme.plan.md

@@ -18,7 +18,7 @@ TypeScript module implementing SKR03 and SKR04 German accounting standards for d
   - [ ] @push.rocks/smartdata
   - [ ] @git.zone/tstest (dev dependency)
 - [ ] Create tsconfig.json based on @push.rocks/smarthash pattern
-- [ ] Create npmextra.json for additional configuration
+- [ ] Create .smartconfig.json for additional configuration
 - [ ] Create .gitignore file
 - [ ] Create directory structure
   - [ ] ts/ directory for source code

package/ts/00_commitinfo_data.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export const commitinfo = {
+  name: '@fin.cx/skr',
+  version: '1.2.2',
+  description: 'SKR03 and SKR04 German accounting standards for double-entry bookkeeping'
+}

package/ts/index.ts

@@ -1,16 +1,44 @@
 export * from './skr.types.js';
-export * from './skr.classes.account.js';
-export * from './skr.classes.transaction.js';
-export * from './skr.classes.journalentry.js';
-export * from './skr.classes.chartofaccounts.js';
-export * from './skr.classes.ledger.js';
-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';
+export { Account } from './skr.classes.account.js';
+export { Transaction } from './skr.classes.transaction.js';
+export { JournalEntry } from './skr.classes.journalentry.js';
+export { ChartOfAccounts } from './skr.classes.chartofaccounts.js';
+export { Ledger } from './skr.classes.ledger.js';
+export { Reports } from './skr.classes.reports.js';
+export { SkrApi } from './skr.api.js';
+export { SKR03_ACCOUNTS, SKR03_ACCOUNT_CLASSES } from './skr03.data.js';
+export { SKR04_ACCOUNTS, SKR04_ACCOUNT_CLASSES } from './skr04.data.js';
+export { SkrExport } from './skr.export.js';
+export type {
+  IExportOptions,
+  IExportMetadata,
+  IBagItManifest,
+  IDocumentIndex,
+} from './skr.export.js';
+export { LedgerExporter } from './skr.export.ledger.js';
+export type {
+  ITransactionDataExport,
+  IJournalEntryExport,
+  IJournalEntryLineExport,
+  ILedgerEntry,
+  ILedgerLine,
+  IDocumentRef,
+} from './skr.export.ledger.js';
+export { AccountsExporter } from './skr.export.accounts.js';
+export type {
+  IAccountDataExport,
+  IAccountExportRow,
+} from './skr.export.accounts.js';
+export { BalancesExporter } from './skr.export.balances.js';
+export type {
+  IAccountBalanceExport,
+  IBalanceExportRow,
+} from './skr.export.balances.js';
+export { PdfReportGenerator } from './skr.export.pdf.js';
+export type { IPdfReportOptions } from './skr.export.pdf.js';
+export { SecurityManager } from './skr.security.js';
+export type {
+  ISigningOptions,
+  ISignatureResult,
+  ITimestampResponse,
+} from './skr.security.js';

package/ts/plugins.ts

@@ -3,26 +3,63 @@ 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 smartfsModule from '@push.rocks/smartfs';
 import * as smarthash from '@push.rocks/smarthash';
 import * as smartpath from '@push.rocks/smartpath';
-import * as smartpdf from '@push.rocks/smartpdf';
+import * as path from 'path';
 
 // 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,
+const smartfs = new smartfsModule.SmartFs(
+  new smartfsModule.SmartFsProviderNode(),
+);
+
+const smartfile = {
+  fs: {
+    ensureDir: async (dirPath: string): Promise<void> => {
+      await smartfs.directory(dirPath).create();
+    },
+    toBuffer: async (filePath: string): Promise<Buffer> => {
+      return (await smartfs.file(filePath).read()) as Buffer;
+    },
+    toStringSync: async (filePath: string): Promise<string> => {
+      return (await smartfs.file(filePath).encoding('utf8').read()) as string;
+    },
+    fileExists: async (filePath: string): Promise<boolean> => {
+      return await smartfs.file(filePath).exists();
+    },
+    listFileTree: async (dirPath: string, pattern: string): Promise<string[]> => {
+      const suffix = pattern.replace(/^\*\*\/\*/, '');
+      try {
+        const entries = await smartfs.directory(dirPath).recursive().list();
+        return entries
+          .filter((entry) => entry.isFile && entry.path.endsWith(suffix))
+          .map((entry) => path.relative(dirPath, entry.path));
+      } catch (error) {
+        if (error instanceof Error && error.message.includes('ENOENT')) {
+          return [];
+        }
+        throw error;
+      }
+    },
+  },
+  memory: {
+    toFs: async (content: string | Buffer, filePath: string): Promise<void> => {
+      await smartfs.directory(path.dirname(filePath)).create();
+      await smartfs.file(filePath).write(content);
+    },
+  },
+};
+
+export {
+  smartdata,
+  smartunique,
+  smarttime,
+  smartlog,
+  smartfs,
+  smartfile,
+  smarthash,
+  smartpath,
   MerkleTree,
-  einvoice
 };

package/ts/skr.api.ts

@@ -534,6 +534,10 @@ export class SkrApi {
    */
   private async generatePdfReports(exporter: SkrExport, options: IExportOptions): Promise<void> {
     if (!this.reports) throw new Error('Reports not initialized');
+    const skrType = this.currentSKRType;
+    if (!skrType) {
+      throw new Error('API not initialized. Call initialize() first.');
+    }
 
     const pdfOptions: IPdfReportOptions = {
       companyName: options.companyInfo?.name || 'Unternehmen',
@@ -554,19 +558,19 @@ export class SkrApi {
       const trialBalance = await this.reports.getTrialBalance({
         dateFrom: options.dateFrom,
         dateTo: options.dateTo,
-        skrType: this.currentSKRType
+        skrType,
       });
 
       const incomeStatement = await this.reports.getIncomeStatement({
         dateFrom: options.dateFrom,
         dateTo: options.dateTo,
-        skrType: this.currentSKRType
+        skrType,
       });
 
       const balanceSheet = await this.reports.getBalanceSheet({
         dateFrom: options.dateFrom,
         dateTo: options.dateTo,
-        skrType: this.currentSKRType
+        skrType,
       });
 
       // Generate PDFs
@@ -702,7 +706,7 @@ export class SkrApi {
         const transaction = await this.postTransaction(transactions[i]);
         results.push(transaction);
       } catch (error) {
-        errors.push({ index: i, error: error.message });
+        errors.push({ index: i, error: error instanceof Error ? error.message : String(error) });
       }
     }
 
@@ -735,7 +739,7 @@ export class SkrApi {
         const account = await this.createAccount(accounts[i]);
         results.push(account);
       } catch (error) {
-        errors.push({ index: i, error: error.message });
+        errors.push({ index: i, error: error instanceof Error ? error.message : String(error) });
       }
     }
 

package/ts/skr.classes.account.ts

@@ -2,65 +2,86 @@ import * as plugins from './plugins.js';
 import { getDb, getDbSync } from './skr.database.js';
 import type { TAccountType, TSKRType, IAccountData } from './skr.types.js';
 
-const { SmartDataDbDoc, svDb, unI, index, searchable } = plugins.smartdata;
+declare abstract class SmartDataDbDocBase {
+  public save(): Promise<void>;
+  public delete(): Promise<void>;
+  public static getInstance<T>(
+    this: new (...args: any[]) => T,
+    query: Record<string, any>,
+  ): Promise<T | null>;
+  public static getInstances<T>(
+    this: new (...args: any[]) => T,
+    query: Record<string, any>,
+  ): Promise<T[]>;
+}
+
+const SmartDataDbDoc = plugins.smartdata.SmartDataDbDoc as unknown as typeof SmartDataDbDocBase;
+const Collection = plugins.smartdata.Collection as any;
+const svDb = plugins.smartdata.svDb as any;
+const unI = plugins.smartdata.unI as any;
+const index = plugins.smartdata.index as any;
+const searchable = plugins.smartdata.searchable as any;
 
-@plugins.smartdata.Collection(() => getDbSync())
-export class Account extends SmartDataDbDoc<Account, Account> {
+@Collection(() => getDbSync())
+export class Account extends SmartDataDbDoc {
   @unI()
-  public id: string;
+  public id!: string;
 
   @svDb()
   @index()
-  public accountNumber: string;
+  public accountNumber!: string;
 
   @svDb()
   @searchable()
-  public accountName: string;
+  public accountName!: string;
 
   @svDb()
   @index()
-  public accountClass: number;
+  public accountClass!: number;
 
   @svDb()
-  public accountGroup: number;
+  public accountGroup!: number;
 
   @svDb()
-  public accountSubgroup: number;
+  public accountSubgroup!: number;
 
   @svDb()
-  public accountType: TAccountType;
+  public accountType!: TAccountType;
 
   @svDb()
   @index()
-  public skrType: TSKRType;
+  public skrType!: TSKRType;
 
   @svDb()
   @searchable()
-  public description: string;
+  public description!: string;
 
   @svDb()
-  public vatRate: number;
+  public vatRate!: number;
 
   @svDb()
-  public balance: number;
+  public balance!: number;
 
   @svDb()
-  public debitTotal: number;
+  public debitTotal!: number;
 
   @svDb()
-  public creditTotal: number;
+  public creditTotal!: number;
 
   @svDb()
-  public isActive: boolean;
+  public isActive!: boolean;
 
   @svDb()
-  public isSystemAccount: boolean;
+  public isSystemAccount!: boolean;
 
   @svDb()
-  public createdAt: Date;
+  public isAutomaticAccount!: boolean;
 
   @svDb()
-  public updatedAt: Date;
+  public createdAt!: Date;
+
+  @svDb()
+  public updatedAt!: Date;
 
   constructor(data?: Partial<IAccountData>) {
     super();
@@ -90,6 +111,7 @@ export class Account extends SmartDataDbDoc<Account, Account> {
       this.debitTotal = 0;
       this.creditTotal = 0;
       this.isSystemAccount = true;
+      this.isAutomaticAccount = data.isAutomaticAccount || false;
       this.createdAt = new Date();
       this.updatedAt = new Date();
     }
@@ -157,6 +179,85 @@ export class Account extends SmartDataDbDoc<Account, Account> {
     );
   }
 
+  /**
+   * Check if account number is in debtor range (10000-69999)
+   * Debtor accounts (Debitorenkonten) are individual customer accounts
+   */
+  public static isInDebtorRange(accountNumber: string): boolean {
+    const num = parseInt(accountNumber);
+    return num >= 10000 && num <= 69999;
+  }
+
+  /**
+   * Check if account number is in creditor range (70000-99999)
+   * Creditor accounts (Kreditorenkonten) are individual vendor accounts
+   */
+  public static isInCreditorRange(accountNumber: string): boolean {
+    const num = parseInt(accountNumber);
+    return num >= 70000 && num <= 99999;
+  }
+
+  /**
+   * Check if account is an automatic account (Automatikkonto)
+   * Automatic accounts like 1400/1600 cannot be posted to directly
+   */
+  public static isAutomaticAccount(accountNumber: string, skrType: TSKRType): boolean {
+    // SKR03: 1400 (Forderungen), 1600 (Verbindlichkeiten)
+    // SKR04: 1400 (Forderungen), 1600 (Verbindlichkeiten)
+    // Note: In SKR04, 3300 is "Fahrzeugkosten" (vehicle costs), NOT an automatic account
+    if (skrType === 'SKR03') {
+      return accountNumber === '1400' || accountNumber === '1600';
+    } else {
+      return accountNumber === '1400' || accountNumber === '1600';
+    }
+  }
+
+  /**
+   * Validate account for posting - throws error if account cannot be posted to
+   */
+  public static async validateAccountForPosting(
+    accountNumber: string,
+    skrType: TSKRType,
+  ): Promise<void> {
+    // Check if automatic account
+    if (Account.isAutomaticAccount(accountNumber, skrType)) {
+      throw new Error(
+        `Account ${accountNumber} is an automatic account (Automatikkonto) and cannot be posted to directly. ` +
+        `Use debtor accounts (10000-69999) or creditor accounts (70000-99999) instead.`
+      );
+    }
+
+    // Get account to verify it exists
+    const account = await Account.getAccountByNumber(accountNumber, skrType);
+    if (!account) {
+      throw new Error(
+        `Account ${accountNumber} not found in ${skrType}. ` +
+        `Please create the account before posting.`
+      );
+    }
+
+    // Check if account is active
+    if (!account.isActive) {
+      throw new Error(
+        `Account ${accountNumber} is inactive and cannot be posted to.`
+      );
+    }
+  }
+
+  /**
+   * Check if this account instance is a debtor account
+   */
+  public isDebtorAccount(): boolean {
+    return Account.isInDebtorRange(this.accountNumber);
+  }
+
+  /**
+   * Check if this account instance is a creditor account
+   */
+  public isCreditorAccount(): boolean {
+    return Account.isInCreditorRange(this.accountNumber);
+  }
+
   public async updateBalance(
     debitAmount: number = 0,
     creditAmount: number = 0,
@@ -209,19 +310,33 @@ export class Account extends SmartDataDbDoc<Account, Account> {
 
   public async beforeSave(): Promise<void> {
     // Validate account number format
-    if (!this.accountNumber || this.accountNumber.length !== 4) {
+    const accountLength = this.accountNumber?.length || 0;
+    if (!this.accountNumber || (accountLength !== 4 && accountLength !== 5)) {
       throw new Error(
-        `Invalid account number format: ${this.accountNumber}. Must be 4 digits.`,
+        `Invalid account number format: ${this.accountNumber}. Must be 4 digits (standard SKR) or 5 digits (debtor/creditor).`,
       );
     }
 
     // Validate account number is numeric
-    if (!/^\d{4}$/.test(this.accountNumber)) {
+    if (!/^\d{4,5}$/.test(this.accountNumber)) {
       throw new Error(
         `Account number must contain only digits: ${this.accountNumber}`,
       );
     }
 
+    // For 5-digit accounts, validate they are in debtor (10000-69999) or creditor (70000-99999) ranges
+    if (accountLength === 5) {
+      const accountNum = parseInt(this.accountNumber);
+      const isDebtor = accountNum >= 10000 && accountNum <= 69999;
+      const isCreditor = accountNum >= 70000 && accountNum <= 99999;
+      
+      if (!isDebtor && !isCreditor) {
+        throw new Error(
+          `5-digit account number ${this.accountNumber} must be in debtor range (10000-69999) or creditor range (70000-99999).`,
+        );
+      }
+    }
+
     // Validate account class matches first digit
     const firstDigit = parseInt(this.accountNumber[0]);
     if (this.accountClass !== firstDigit) {
@@ -234,5 +349,11 @@ export class Account extends SmartDataDbDoc<Account, Account> {
     if (this.skrType !== 'SKR03' && this.skrType !== 'SKR04') {
       throw new Error(`Invalid SKR type: ${this.skrType}`);
     }
+
+    // Mark automatic accounts (Automatikkonten)
+    // These are summary accounts that cannot be posted to directly
+    if (Account.isAutomaticAccount(this.accountNumber, this.skrType)) {
+      this.isAutomaticAccount = true;
+    }
   }
 }

package/ts/skr.classes.chartofaccounts.ts

@@ -262,6 +262,9 @@ export class ChartOfAccounts {
    * Search accounts
    */
   public async searchAccounts(searchTerm: string): Promise<Account[]> {
+    if (!this.skrType) {
+      throw new Error('SKR type not set. Initialize SKR03 or SKR04 first.');
+    }
     return await Account.searchAccounts(searchTerm, this.skrType);
   }
 
@@ -287,10 +290,11 @@ export class ChartOfAccounts {
 
     // Apply text search if provided
     if (filter?.searchTerm) {
-      const lowerSearchTerm = filter.searchTerm.toLowerCase();
+      const searchTerm = filter.searchTerm;
+      const lowerSearchTerm = searchTerm.toLowerCase();
       return accounts.filter(
         (account) =>
-          account.accountNumber.includes(filter.searchTerm) ||
+          account.accountNumber.includes(searchTerm) ||
           account.accountName.toLowerCase().includes(lowerSearchTerm) ||
           account.description.toLowerCase().includes(lowerSearchTerm),
       );
@@ -468,9 +472,10 @@ export class ChartOfAccounts {
           await this.createCustomAccount(accountData);
           importedCount++;
         } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
           this.logger.log(
             'warn',
-            `Failed to import account ${parts[0]}: ${error.message}`,
+            `Failed to import account ${parts[0]}: ${errorMessage}`,
           );
         }
       }