/** * The classic inputs — a debit/credit transaction (`ITransactionData`) and a * float-amount journal entry (`IJournalEntry`) — booked on the hashed journal. * SkrApi, Ledger and ChartOfAccounts all post, reverse and list through here, * so every path gets the same validation, gapless sequencing, hash chain and * transaction as `JournalPoster`; nothing writes the frozen v1 shapes. */ import * as plugins from './plugins.js'; import { Account } from './skr.classes.account.js'; import { JournalEntry } from './skr.classes.journalentry.js'; import { JournalPoster } from './skr.posting.js'; import { entryToTransactionView, journalInputToDraft, transactionDataToDraft, } from './skr.txview.js'; import type { IJournalEntry, ITransactionData, ITransactionFilter, ITransactionView, TSKRType, } from './skr.types.js'; /** * Validate and post a debit/credit transaction as a two-line journal entry. * Returns its transaction-shaped view. */ export async function postTransactionInput( skrType: TSKRType, transactionData: ITransactionData, poster: JournalPoster = new JournalPoster(), ): Promise { if (transactionData.amount <= 0) { throw new Error('Transaction amount must be greater than zero'); } if (transactionData.debitAccount === transactionData.creditAccount) { throw new Error('Debit and credit accounts cannot be the same'); } for (const [label, accountNumber] of [ ['Debit', transactionData.debitAccount], ['Credit', transactionData.creditAccount], ] as const) { const account = await Account.getAccountByNumber(accountNumber, skrType); if (account && !account.isActive) { throw new Error(`${label} account ${accountNumber} is not active`); } await Account.validateAccountForPosting(accountNumber, skrType); } const entry = await poster.postDraft(transactionDataToDraft({ ...transactionData, skrType })); const view = entryToTransactionView(entry); if (!view) { throw new Error(`Posted entry ${entry.id} is not a two-line transaction`); } return view; } /** * Validate and post a float-amount journal entry; amounts become exact cents * with a drift guard. Returns the hashed, immutable entry. */ export async function postJournalInput( skrType: TSKRType, journalData: IJournalEntry, poster: JournalPoster = new JournalPoster(), ): Promise { for (const line of journalData.lines) { await Account.validateAccountForPosting(line.accountNumber, skrType); } return poster.postDraft(journalInputToDraft({ ...journalData, skrType })); } /** A hashed entry of this chart, or a clear error. */ async function loadHashedEntry(entryId: string, skrType: TSKRType, label: string): Promise { const entry = await JournalEntry.getInstance({ id: entryId }); if (!entry || entry.schemaVersion !== 2) { throw new Error(`${label} ${entryId} not found`); } if (entry.skrType !== skrType) { throw new Error(`${label} ${entryId} belongs to different SKR type`); } return entry; } /** * Reverse an entry via Storno — the original is never mutated (GoBD). * Returns the Storno entry. */ export async function reverseJournalInput( skrType: TSKRType, entryId: string, poster: JournalPoster = new JournalPoster(), ): Promise { return poster.postStorno(await loadHashedEntry(entryId, skrType, 'Journal entry')); } /** Reverse a two-line entry via Storno; returns the Storno's transaction view. */ export async function reverseTransactionInput( skrType: TSKRType, transactionId: string, poster: JournalPoster = new JournalPoster(), ): Promise { const storno = await poster.postStorno(await loadHashedEntry(transactionId, skrType, 'Transaction')); const view = entryToTransactionView(storno); if (!view) { throw new Error(`Transaction ${transactionId} is no two-line entry; reverse it as a journal entry`); } return view; } /** * Transaction views (two-line posted/finalized entries) of a chart, filtered * like the classic transaction list. */ export async function listTransactionViews( skrType: TSKRType, filter?: ITransactionFilter, ): Promise { const query: plugins.nosqldb.MongoFilter = { skrType: filter?.skrType ?? skrType, schemaVersion: 2, status: { $in: ['posted', 'finalized'] }, }; if (filter?.dateFrom || filter?.dateTo) { query.date = { ...(filter.dateFrom ? { $gte: filter.dateFrom } : {}), ...(filter.dateTo ? { $lte: filter.dateTo } : {}), }; } const cursor = await JournalEntry.getCursor(query, { sort: { date: 1, sequenceNumber: 1 } }); const entries = await cursor.toArray(); let views = entries .map((entry) => entryToTransactionView(entry)) .filter((view): view is ITransactionView => view !== null); if (filter?.accountNumber) { views = views.filter( (view) => view.debitAccount === filter.accountNumber || view.creditAccount === filter.accountNumber, ); } if (filter?.minAmount !== undefined) { views = views.filter((view) => view.amount >= filter.minAmount!); } if (filter?.maxAmount !== undefined) { views = views.filter((view) => view.amount <= filter.maxAmount!); } if (filter?.searchTerm) { const term = filter.searchTerm.toLowerCase(); views = views.filter( (view) => view.description.toLowerCase().includes(term) || view.reference.toLowerCase().includes(term), ); } return views; }