@fin.cx/skr 1.0.0

package/dist_ts/skr.classes.journalentry.js

@@ -0,0 +1,296 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var JournalEntry_1;
+import * as plugins from './plugins.js';
+import { getDbSync } from './skr.database.js';
+import { Account } from './skr.classes.account.js';
+import { Transaction } from './skr.classes.transaction.js';
+const { SmartDataDbDoc, svDb, unI, index, searchable } = plugins.smartdata;
+let JournalEntry = JournalEntry_1 = class JournalEntry extends SmartDataDbDoc {
+    constructor(data) {
+        super();
+        if (data) {
+            this.id = plugins.smartunique.shortId();
+            this.journalNumber = this.generateJournalNumber();
+            this.date = data.date || new Date();
+            this.description = data.description || '';
+            this.reference = data.reference || '';
+            this.lines = data.lines || [];
+            this.skrType = data.skrType || 'SKR03';
+            this.totalDebits = 0;
+            this.totalCredits = 0;
+            this.isBalanced = false;
+            this.status = 'draft';
+            this.transactionIds = [];
+            // Set period and fiscal year
+            const entryDate = new Date(this.date);
+            this.period = `${entryDate.getFullYear()}-${String(entryDate.getMonth() + 1).padStart(2, '0')}`;
+            this.fiscalYear = entryDate.getFullYear();
+            this.createdAt = new Date();
+            this.postedAt = null;
+            this.createdBy = 'system';
+            // Calculate totals
+            this.calculateTotals();
+        }
+    }
+    generateJournalNumber() {
+        const timestamp = Date.now();
+        const random = Math.floor(Math.random() * 1000);
+        return `JE-${timestamp}-${random}`;
+    }
+    calculateTotals() {
+        this.totalDebits = 0;
+        this.totalCredits = 0;
+        for (const line of this.lines) {
+            if (line.debit) {
+                this.totalDebits += line.debit;
+            }
+            if (line.credit) {
+                this.totalCredits += line.credit;
+            }
+        }
+        // Check if balanced (allowing for small rounding differences)
+        const difference = Math.abs(this.totalDebits - this.totalCredits);
+        this.isBalanced = difference < 0.01;
+    }
+    static async createJournalEntry(data) {
+        const journalEntry = new JournalEntry_1(data);
+        await journalEntry.validate();
+        await journalEntry.save();
+        return journalEntry;
+    }
+    addLine(line) {
+        // Validate line
+        if (!line.accountNumber) {
+            throw new Error('Account number is required for journal entry line');
+        }
+        if (!line.debit && !line.credit) {
+            throw new Error('Either debit or credit amount is required');
+        }
+        if (line.debit && line.credit) {
+            throw new Error('A line cannot have both debit and credit amounts');
+        }
+        if (line.debit && line.debit < 0) {
+            throw new Error('Debit amount must be positive');
+        }
+        if (line.credit && line.credit < 0) {
+            throw new Error('Credit amount must be positive');
+        }
+        this.lines.push(line);
+        this.calculateTotals();
+    }
+    removeLine(index) {
+        if (index >= 0 && index < this.lines.length) {
+            this.lines.splice(index, 1);
+            this.calculateTotals();
+        }
+    }
+    async validate() {
+        // Check if entry is balanced
+        if (!this.isBalanced) {
+            throw new Error(`Journal entry is not balanced. Debits: ${this.totalDebits}, Credits: ${this.totalCredits}`);
+        }
+        // Check minimum lines
+        if (this.lines.length < 2) {
+            throw new Error('Journal entry must have at least 2 lines');
+        }
+        // Validate all accounts exist and are active
+        for (const line of this.lines) {
+            const account = await Account.getAccountByNumber(line.accountNumber, this.skrType);
+            if (!account) {
+                throw new Error(`Account ${line.accountNumber} not found for ${this.skrType}`);
+            }
+            if (!account.isActive) {
+                throw new Error(`Account ${line.accountNumber} is not active`);
+            }
+        }
+    }
+    async post() {
+        if (this.status === 'posted') {
+            throw new Error('Journal entry is already posted');
+        }
+        // Validate before posting
+        await this.validate();
+        // Create individual transactions for each debit-credit pair
+        const transactions = [];
+        // Simple posting logic: match debits with credits
+        // For complex entries, this could be enhanced with specific pairing logic
+        const debitLines = this.lines.filter((l) => l.debit);
+        const creditLines = this.lines.filter((l) => l.credit);
+        if (debitLines.length === 1 && creditLines.length === 1) {
+            // Simple entry: one debit, one credit
+            const transaction = await Transaction.createTransaction({
+                date: this.date,
+                debitAccount: debitLines[0].accountNumber,
+                creditAccount: creditLines[0].accountNumber,
+                amount: debitLines[0].debit,
+                description: this.description,
+                reference: this.reference,
+                skrType: this.skrType,
+                costCenter: debitLines[0].costCenter,
+            });
+            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);
+                    if (amount > 0) {
+                        const transaction = await Transaction.createTransaction({
+                            date: this.date,
+                            debitAccount: debitLine.accountNumber,
+                            creditAccount: creditLine.accountNumber,
+                            amount: amount,
+                            description: `${this.description} - ${debitLine.description || creditLine.description || ''}`,
+                            reference: this.reference,
+                            skrType: this.skrType,
+                            costCenter: debitLine.costCenter || creditLine.costCenter,
+                        });
+                        transactions.push(transaction);
+                        // Reduce amounts for tracking
+                        if (debitLine.debit)
+                            debitLine.debit -= amount;
+                        if (creditLine.credit)
+                            creditLine.credit -= amount;
+                    }
+                }
+            }
+        }
+        // Store transaction IDs
+        this.transactionIds = transactions.map((t) => t.id);
+        // Update status
+        this.status = 'posted';
+        this.postedAt = new Date();
+        await this.save();
+    }
+    async reverse() {
+        if (this.status !== 'posted') {
+            throw new Error('Can only reverse posted journal entries');
+        }
+        // Create reversal entry with swapped debits and credits
+        const reversalLines = this.lines.map((line) => ({
+            accountNumber: line.accountNumber,
+            debit: line.credit, // Swap
+            credit: line.debit, // Swap
+            description: `Reversal: ${line.description || ''}`,
+            costCenter: line.costCenter,
+        }));
+        const reversalEntry = new JournalEntry_1({
+            date: new Date(),
+            description: `Reversal of ${this.journalNumber}: ${this.description}`,
+            reference: `REV-${this.journalNumber}`,
+            lines: reversalLines,
+            skrType: this.skrType,
+        });
+        await reversalEntry.validate();
+        await reversalEntry.post();
+        // Update original entry status
+        this.status = 'reversed';
+        await this.save();
+        return reversalEntry;
+    }
+    async beforeSave() {
+        // Recalculate totals before saving
+        this.calculateTotals();
+        // Validate required fields
+        if (!this.date) {
+            throw new Error('Journal entry date is required');
+        }
+        if (!this.description) {
+            throw new Error('Journal entry description is required');
+        }
+        if (this.lines.length === 0) {
+            throw new Error('Journal entry must have at least one line');
+        }
+    }
+};
+__decorate([
+    unI(),
+    __metadata("design:type", String)
+], JournalEntry.prototype, "id", void 0);
+__decorate([
+    svDb(),
+    index(),
+    __metadata("design:type", String)
+], JournalEntry.prototype, "journalNumber", void 0);
+__decorate([
+    svDb(),
+    index(),
+    __metadata("design:type", Date)
+], JournalEntry.prototype, "date", void 0);
+__decorate([
+    svDb(),
+    searchable(),
+    __metadata("design:type", String)
+], JournalEntry.prototype, "description", void 0);
+__decorate([
+    svDb(),
+    index(),
+    __metadata("design:type", String)
+], JournalEntry.prototype, "reference", void 0);
+__decorate([
+    svDb(),
+    __metadata("design:type", Array)
+], JournalEntry.prototype, "lines", void 0);
+__decorate([
+    svDb(),
+    index(),
+    __metadata("design:type", String)
+], JournalEntry.prototype, "skrType", void 0);
+__decorate([
+    svDb(),
+    __metadata("design:type", Number)
+], JournalEntry.prototype, "totalDebits", void 0);
+__decorate([
+    svDb(),
+    __metadata("design:type", Number)
+], JournalEntry.prototype, "totalCredits", void 0);
+__decorate([
+    svDb(),
+    __metadata("design:type", Boolean)
+], JournalEntry.prototype, "isBalanced", void 0);
+__decorate([
+    svDb(),
+    index(),
+    __metadata("design:type", String)
+], JournalEntry.prototype, "status", void 0);
+__decorate([
+    svDb(),
+    __metadata("design:type", Array)
+], JournalEntry.prototype, "transactionIds", void 0);
+__decorate([
+    svDb(),
+    index(),
+    __metadata("design:type", String)
+], JournalEntry.prototype, "period", void 0);
+__decorate([
+    svDb(),
+    __metadata("design:type", Number)
+], JournalEntry.prototype, "fiscalYear", void 0);
+__decorate([
+    svDb(),
+    __metadata("design:type", Date)
+], JournalEntry.prototype, "createdAt", void 0);
+__decorate([
+    svDb(),
+    __metadata("design:type", Date)
+], JournalEntry.prototype, "postedAt", void 0);
+__decorate([
+    svDb(),
+    __metadata("design:type", String)
+], JournalEntry.prototype, "createdBy", void 0);
+JournalEntry = JournalEntry_1 = __decorate([
+    plugins.smartdata.Collection(() => getDbSync()),
+    __metadata("design:paramtypes", [Object])
+], JournalEntry);
+export { JournalEntry };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"skr.classes.journalentry.js","sourceRoot":"","sources":["../ts/skr.classes.journalentry.ts"],"names":[],"mappings":"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"}

package/dist_ts/skr.classes.ledger.d.ts

@@ -0,0 +1,61 @@
+import { Transaction } from './skr.classes.transaction.js';
+import { JournalEntry } from './skr.classes.journalentry.js';
+import type { TSKRType, ITransactionData, IJournalEntry, IAccountBalance } from './skr.types.js';
+export declare class Ledger {
+    private skrType;
+    private logger;
+    constructor(skrType: TSKRType);
+    /**
+     * Post a transaction with validation
+     */
+    postTransaction(transactionData: ITransactionData): Promise<Transaction>;
+    /**
+     * Post a journal entry with validation
+     */
+    postJournalEntry(journalData: IJournalEntry): Promise<JournalEntry>;
+    /**
+     * Validate that accounts exist and are active
+     */
+    private validateAccounts;
+    /**
+     * Validate journal entry balance
+     */
+    private validateJournalBalance;
+    /**
+     * Reverse a transaction
+     */
+    reverseTransaction(transactionId: string): Promise<Transaction>;
+    /**
+     * Reverse a journal entry
+     */
+    reverseJournalEntry(journalId: string): Promise<JournalEntry>;
+    /**
+     * Get account history (all transactions for an account)
+     */
+    getAccountHistory(accountNumber: string, dateFrom?: Date, dateTo?: Date): Promise<Transaction[]>;
+    /**
+     * Get account balance at a specific date
+     */
+    getAccountBalance(accountNumber: string, asOfDate?: Date): Promise<IAccountBalance>;
+    /**
+     * Close accounting period (create closing entries)
+     */
+    closeAccountingPeriod(period: string, // Format: YYYY-MM
+    closingAccountNumber?: string): Promise<JournalEntry[]>;
+    /**
+     * Calculate account balance for a specific set of transactions
+     */
+    private getAccountBalanceForPeriod;
+    /**
+     * Validate double-entry rules
+     */
+    validateDoubleEntry(debitAmount: number, creditAmount: number): boolean;
+    /**
+     * Get unbalanced transactions (for audit)
+     */
+    getUnbalancedTransactions(): Promise<Transaction[]>;
+    /**
+     * Recalculate all account balances
+     */
+    recalculateAllBalances(): Promise<void>;
+}