@fin.cx/skr
Version:
SKR03 and SKR04 German accounting standards for double-entry bookkeeping
434 lines • 35.6 kB
JavaScript
import * as plugins from './plugins.js';
import { Account } from './skr.classes.account.js';
import { Transaction } from './skr.classes.transaction.js';
import { JournalEntry } from './skr.classes.journalentry.js';
import { SKR03_ACCOUNTS } from './skr03.data.js';
import { SKR04_ACCOUNTS } from './skr04.data.js';
// Module-level Maps for O(1) SKR standard lookups
const STANDARD_SKR_MAP = {
SKR03: new Map(SKR03_ACCOUNTS.map(a => [a.accountNumber, a])),
SKR04: new Map(SKR04_ACCOUNTS.map(a => [a.accountNumber, a])),
};
export class Ledger {
constructor(skrType) {
this.skrType = skrType;
this.logger = new plugins.smartlog.Smartlog({
logContext: {
company: 'fin.cx',
companyunit: 'skr',
containerName: 'Ledger',
environment: 'local',
runtime: 'node',
zone: 'local',
},
});
}
/**
* Post a transaction with validation
*/
async postTransaction(transactionData) {
this.logger.log('info', `Posting transaction: ${transactionData.description}`);
// Ensure SKR type matches
const fullTransactionData = {
...transactionData,
skrType: this.skrType,
};
// Validate accounts exist
await this.validateAccounts([
transactionData.debitAccount,
transactionData.creditAccount,
]);
// Create and post transaction
const transaction = await Transaction.createTransaction(fullTransactionData);
this.logger.log('info', `Transaction ${transaction.transactionNumber} posted successfully`);
return transaction;
}
/**
* Post a journal entry with validation
*/
async postJournalEntry(journalData) {
this.logger.log('info', `Posting journal entry: ${journalData.description}`);
// Ensure SKR type matches
const fullJournalData = {
...journalData,
skrType: this.skrType,
};
// Validate all accounts exist
const accountNumbers = journalData.lines.map((line) => line.accountNumber);
await this.validateAccounts(accountNumbers);
// Validate against SKR standard (warnings only by default)
await this.validateAccountsAgainstSKR(journalData.lines, {
strict: false, // Start with warnings only
warnOnNameMismatch: false // Names vary, don't spam logs
});
// Validate journal entry is balanced
this.validateJournalBalance(journalData.lines);
// Create and post journal entry
const journalEntry = await JournalEntry.createJournalEntry(fullJournalData);
await journalEntry.post();
this.logger.log('info', `Journal entry ${journalEntry.journalNumber} posted successfully`);
return journalEntry;
}
/**
* Validate that accounts exist and are active
*/
async validateAccounts(accountNumbers) {
const uniqueAccountNumbers = [...new Set(accountNumbers)];
for (const accountNumber of uniqueAccountNumbers) {
const account = await Account.getAccountByNumber(accountNumber, this.skrType);
if (!account) {
throw new Error(`Account ${accountNumber} not found for ${this.skrType}`);
}
if (!account.isActive) {
throw new Error(`Account ${accountNumber} is not active`);
}
}
}
/**
* Validate journal entry balance
*/
validateJournalBalance(lines) {
let totalDebits = 0;
let totalCredits = 0;
for (const line of lines) {
if (line.debit)
totalDebits += line.debit;
if (line.credit)
totalCredits += line.credit;
}
const difference = Math.abs(totalDebits - totalCredits);
if (difference >= 0.01) {
throw new Error(`Journal entry is not balanced. Debits: ${totalDebits}, Credits: ${totalCredits}`);
}
}
/**
* Validate accounts against SKR standard data
*/
async validateAccountsAgainstSKR(lines, options) {
const { strict = false, warnOnNameMismatch = false } = options || {};
const skrMap = STANDARD_SKR_MAP[this.skrType];
if (!skrMap) {
this.logger.log('warn', `No SKR standard map available for ${this.skrType}`);
return;
}
const uniqueAccountNumbers = [...new Set(lines.map(line => line.accountNumber))];
for (const accountNumber of uniqueAccountNumbers) {
const standardAccount = skrMap.get(accountNumber);
if (!standardAccount) {
// Special case: SKR04 class 8 is designated for custom accounts ("frei")
if (this.skrType === 'SKR04' && accountNumber.startsWith('8')) {
this.logger.log('debug', `Account ${accountNumber} is in SKR04 class 8 (custom accounts allowed)`);
continue;
}
const message = `Account ${accountNumber} is not a standard ${this.skrType} account`;
if (strict) {
throw new Error(message);
}
else {
this.logger.log('warn', message);
}
continue;
}
// Get actual account from database to compare
const dbAccount = await Account.getAccountByNumber(accountNumber, this.skrType);
if (!dbAccount) {
// Account doesn't exist in DB, will be caught by validateAccounts()
continue;
}
// Validate type and class match SKR standard
if (dbAccount.accountType !== standardAccount.accountType) {
const message = `Account ${accountNumber} type mismatch: expected '${standardAccount.accountType}', got '${dbAccount.accountType}'`;
if (strict) {
throw new Error(message);
}
else {
this.logger.log('warn', message);
}
}
if (dbAccount.accountClass !== standardAccount.accountClass) {
const message = `Account ${accountNumber} class mismatch: expected ${standardAccount.accountClass}, got ${dbAccount.accountClass}`;
if (strict) {
throw new Error(message);
}
else {
this.logger.log('warn', message);
}
}
// Warn on name mismatch (common and acceptable in practice)
if (warnOnNameMismatch && dbAccount.accountName !== standardAccount.accountName) {
this.logger.log('info', `Account ${accountNumber} name differs from SKR standard: '${dbAccount.accountName}' vs '${standardAccount.accountName}'`);
}
}
}
/**
* Reverse a transaction
*/
async reverseTransaction(transactionId) {
this.logger.log('info', `Reversing transaction: ${transactionId}`);
const transaction = await Transaction.getTransactionById(transactionId);
if (!transaction) {
throw new Error(`Transaction ${transactionId} not found`);
}
if (transaction.skrType !== this.skrType) {
throw new Error(`Transaction ${transactionId} belongs to different SKR type`);
}
const reversalTransaction = await transaction.reverseTransaction();
this.logger.log('info', `Transaction reversed: ${reversalTransaction.transactionNumber}`);
return reversalTransaction;
}
/**
* Reverse a journal entry
*/
async reverseJournalEntry(journalId) {
this.logger.log('info', `Reversing journal entry: ${journalId}`);
const journalEntry = await JournalEntry.getInstance({ id: journalId });
if (!journalEntry) {
throw new Error(`Journal entry ${journalId} not found`);
}
if (journalEntry.skrType !== this.skrType) {
throw new Error(`Journal entry ${journalId} belongs to different SKR type`);
}
const reversalEntry = await journalEntry.reverse();
this.logger.log('info', `Journal entry reversed: ${reversalEntry.journalNumber}`);
return reversalEntry;
}
/**
* Get account history (all transactions for an account)
*/
async getAccountHistory(accountNumber, dateFrom, dateTo) {
const account = await Account.getAccountByNumber(accountNumber, this.skrType);
if (!account) {
throw new Error(`Account ${accountNumber} not found`);
}
let transactions = await Transaction.getTransactionsByAccount(accountNumber, this.skrType);
// Apply date filter if provided
if (dateFrom || dateTo) {
transactions = transactions.filter((transaction) => {
if (dateFrom && transaction.date < dateFrom)
return false;
if (dateTo && transaction.date > dateTo)
return false;
return true;
});
}
// Sort by date
transactions.sort((a, b) => a.date.getTime() - b.date.getTime());
return transactions;
}
/**
* Get account balance at a specific date
*/
async getAccountBalance(accountNumber, asOfDate) {
const account = await Account.getAccountByNumber(accountNumber, this.skrType);
if (!account) {
throw new Error(`Account ${accountNumber} not found`);
}
let transactions = await Transaction.getTransactionsByAccount(accountNumber, this.skrType);
// Filter transactions up to the specified date
if (asOfDate) {
transactions = transactions.filter((t) => t.date <= asOfDate);
}
// Calculate balance
let debitTotal = 0;
let creditTotal = 0;
for (const transaction of transactions) {
if (transaction.debitAccount === accountNumber) {
debitTotal += transaction.amount;
}
if (transaction.creditAccount === accountNumber) {
creditTotal += transaction.amount;
}
}
// Calculate net balance based on account type
let balance;
switch (account.accountType) {
case 'asset':
case 'expense':
// Normal debit accounts
balance = debitTotal - creditTotal;
break;
case 'liability':
case 'equity':
case 'revenue':
// Normal credit accounts
balance = creditTotal - debitTotal;
break;
}
return {
accountNumber,
debitTotal,
creditTotal,
balance,
lastUpdated: new Date(),
};
}
/**
* Close accounting period (create closing entries)
*/
async closeAccountingPeriod(period, // Format: YYYY-MM
closingAccountNumber = '9400') {
this.logger.log('info', `Closing accounting period: ${period}`);
const closingEntries = [];
// Get all revenue and expense accounts
const revenueAccounts = await Account.getAccountsByType('revenue', this.skrType);
const expenseAccounts = await Account.getAccountsByType('expense', this.skrType);
// Calculate totals for each account in the period
const periodTransactions = await Transaction.getTransactionsByPeriod(period, this.skrType);
// Create closing entry for revenue accounts
const revenueLines = [];
let totalRevenue = 0;
for (const account of revenueAccounts) {
const balance = await this.getAccountBalanceForPeriod(account.accountNumber, periodTransactions);
if (balance !== 0) {
// Revenue accounts have credit balance, so debit to close
revenueLines.push({
accountNumber: account.accountNumber,
debit: Math.abs(balance),
description: `Closing ${account.accountName}`,
});
totalRevenue += Math.abs(balance);
}
}
if (totalRevenue > 0) {
// Credit the closing account
revenueLines.push({
accountNumber: closingAccountNumber,
credit: totalRevenue,
description: 'Revenue closing to P&L',
});
const revenueClosingEntry = await this.postJournalEntry({
date: new Date(),
description: `Closing revenue accounts for period ${period}`,
reference: `CLOSE-REV-${period}`,
lines: revenueLines,
skrType: this.skrType,
});
closingEntries.push(revenueClosingEntry);
}
// Create closing entry for expense accounts
const expenseLines = [];
let totalExpense = 0;
for (const account of expenseAccounts) {
const balance = await this.getAccountBalanceForPeriod(account.accountNumber, periodTransactions);
if (balance !== 0) {
// Expense accounts have debit balance, so credit to close
expenseLines.push({
accountNumber: account.accountNumber,
credit: Math.abs(balance),
description: `Closing ${account.accountName}`,
});
totalExpense += Math.abs(balance);
}
}
if (totalExpense > 0) {
// Debit the closing account
expenseLines.push({
accountNumber: closingAccountNumber,
debit: totalExpense,
description: 'Expense closing to P&L',
});
const expenseClosingEntry = await this.postJournalEntry({
date: new Date(),
description: `Closing expense accounts for period ${period}`,
reference: `CLOSE-EXP-${period}`,
lines: expenseLines,
skrType: this.skrType,
});
closingEntries.push(expenseClosingEntry);
}
this.logger.log('info', `Period ${period} closed with ${closingEntries.length} entries`);
return closingEntries;
}
/**
* Calculate account balance for a specific set of transactions
*/
async getAccountBalanceForPeriod(accountNumber, transactions) {
const account = await Account.getAccountByNumber(accountNumber, this.skrType);
if (!account)
return 0;
let debitTotal = 0;
let creditTotal = 0;
for (const transaction of transactions) {
if (transaction.debitAccount === accountNumber) {
debitTotal += transaction.amount;
}
if (transaction.creditAccount === accountNumber) {
creditTotal += transaction.amount;
}
}
// Calculate net balance based on account type
switch (account.accountType) {
case 'asset':
case 'expense':
return debitTotal - creditTotal;
case 'liability':
case 'equity':
case 'revenue':
return creditTotal - debitTotal;
}
}
/**
* Validate double-entry rules
*/
validateDoubleEntry(debitAmount, creditAmount) {
return Math.abs(debitAmount - creditAmount) < 0.01;
}
/**
* Get unbalanced transactions (for audit)
*/
async getUnbalancedTransactions() {
// In a proper double-entry system, all posted transactions should be balanced
// This method is mainly for audit purposes
const allTransactions = await Transaction.getInstances({
skrType: this.skrType,
status: 'posted',
});
// Group transactions by journal entry if they have one
const unbalanced = [];
// Since our system ensures balance at posting time,
// this should typically return an empty array
// But we include it for completeness and audit purposes
return unbalanced;
}
/**
* Recalculate all account balances
*/
async recalculateAllBalances() {
this.logger.log('info', 'Recalculating all account balances');
// Get all accounts
const accounts = await Account.getInstances({ skrType: this.skrType });
for (const account of accounts) {
// Reset balances
account.debitTotal = 0;
account.creditTotal = 0;
account.balance = 0;
// Get all transactions for this account
const transactions = await Transaction.getTransactionsByAccount(account.accountNumber, this.skrType);
// Recalculate totals
for (const transaction of transactions) {
if (transaction.debitAccount === account.accountNumber) {
account.debitTotal += transaction.amount;
}
if (transaction.creditAccount === account.accountNumber) {
account.creditTotal += transaction.amount;
}
}
// Calculate balance based on account type
switch (account.accountType) {
case 'asset':
case 'expense':
account.balance = account.debitTotal - account.creditTotal;
break;
case 'liability':
case 'equity':
case 'revenue':
account.balance = account.creditTotal - account.debitTotal;
break;
}
account.updatedAt = new Date();
await account.save();
}
this.logger.log('info', `Recalculated balances for ${accounts.length} accounts`);
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"skr.classes.ledger.js","sourceRoot":"","sources":["../ts/skr.classes.ledger.ts"],"names":[],"mappings":"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"}