@fin.cx/skr 1.3.0 → 2.0.0

package/dist_ts/skr.posting.d.ts

@@ -0,0 +1,74 @@
+/**
+ * JournalPoster — the atomic v2 posting path.
+ *
+ * Flow per posting: pure pre-flight validation (stateless core) → one MongoDB
+ * transaction containing period-lock re-check, gapless sequence allocation,
+ * hash computation, entry save, and a compare-and-swap on the chain head.
+ * The driver's withTransaction() retries transient conflicts; an abort rolls
+ * the sequence $inc back, so numbering stays gapless.
+ *
+ * JournalEntry (schemaVersion 2) is the single source of truth — no
+ * Transaction-pair explosion. Balances are aggregations (skr.balances.ts).
+ */
+import * as core from './core/index.js';
+import { JournalEntry } from './skr.classes.journalentry.js';
+export interface IPostDraftOptions {
+    policy?: core.IAccountPolicy;
+    postedAt?: Date;
+    createdBy?: string;
+}
+/**
+ * The exact structure whose canonical form is hashed into the chain.
+ * Built identically by the poster (from the draft) and the verifier (from the
+ * persisted document) — every optional is normalized so both sides match.
+ */
+export declare function buildHashPayload(entry: {
+    sequenceNumber: number;
+    skrType: string;
+    fiscalYear: number;
+    date: Date;
+    postedAt: Date;
+    description: string;
+    reference?: string | null;
+    taxScenario?: string | null;
+    currency?: string | null;
+    reversalOf?: string | null;
+    lines: Array<{
+        accountNumber: string;
+        counterAccount?: string | null;
+        side?: string | null;
+        amountCents?: number | null;
+        buKey?: string | null;
+        buchungstext?: string | null;
+        belegfeld1?: string | null;
+        costCenter1?: string | null;
+        docLink?: string | null;
+        vatAmountCents?: number | null;
+    }>;
+}): Record<string, unknown>;
+export declare class JournalPoster {
+    /**
+     * Create the indexes the v2 posting path relies on. Idempotent.
+     */
+    ensureIndexes(): Promise<void>;
+    /**
+     * Probe transaction support with a no-op transaction. Fails hard —
+     * filing-grade posting has no non-transactional fallback.
+     */
+    assertTransactionSupport(): Promise<void>;
+    /**
+     * Validate and atomically post a journal draft. Returns the persisted,
+     * hashed, immutable JournalEntry.
+     */
+    postDraft(draft: core.IJournalDraft, options?: IPostDraftOptions): Promise<JournalEntry>;
+    /**
+     * Storno: post a reversal entry for a hashed entry WITHOUT mutating the
+     * original (GoBD). The reversal references the original via belegfeld1 and
+     * reference; reversal state is derived by querying, never stored on the
+     * original.
+     */
+    postStorno(original: JournalEntry, options?: IPostDraftOptions & {
+        date?: Date;
+        description?: string;
+    }): Promise<JournalEntry>;
+}

package/dist_ts/skr.posting.js

@@ -0,0 +1,209 @@
+/**
+ * JournalPoster — the atomic v2 posting path.
+ *
+ * Flow per posting: pure pre-flight validation (stateless core) → one MongoDB
+ * transaction containing period-lock re-check, gapless sequence allocation,
+ * hash computation, entry save, and a compare-and-swap on the chain head.
+ * The driver's withTransaction() retries transient conflicts; an abort rolls
+ * the sequence $inc back, so numbering stays gapless.
+ *
+ * JournalEntry (schemaVersion 2) is the single source of truth — no
+ * Transaction-pair explosion. Balances are aggregations (skr.balances.ts).
+ */
+import * as core from './core/index.js';
+import { getDbSync } from './skr.database.js';
+import { JournalEntry } from './skr.classes.journalentry.js';
+import { allocateSequence, advanceHead, ensureSequenceIndexes } from './skr.sequence.js';
+import { assertPeriodOpen, ensurePeriodIndexes, fiscalYearOf, periodOf, JOURNAL_ENTRY_COLLECTION, } from './skr.period.js';
+import { PeriodLockedError, TransactionsUnsupportedError } from './skr.errors.js';
+/**
+ * The exact structure whose canonical form is hashed into the chain.
+ * Built identically by the poster (from the draft) and the verifier (from the
+ * persisted document) — every optional is normalized so both sides match.
+ */
+export function buildHashPayload(entry) {
+    return {
+        sequenceNumber: entry.sequenceNumber,
+        skrType: entry.skrType,
+        fiscalYear: entry.fiscalYear,
+        date: entry.date,
+        postedAt: entry.postedAt,
+        description: entry.description ?? '',
+        reference: entry.reference ?? '',
+        taxScenario: entry.taxScenario ?? '',
+        currency: entry.currency ?? 'EUR',
+        reversalOf: entry.reversalOf ?? '',
+        lines: entry.lines.map((line) => ({
+            accountNumber: line.accountNumber,
+            counterAccount: line.counterAccount ?? '',
+            side: line.side ?? '',
+            amountCents: line.amountCents ?? 0,
+            buKey: line.buKey ?? '',
+            buchungstext: line.buchungstext ?? '',
+            belegfeld1: line.belegfeld1 ?? '',
+            costCenter1: line.costCenter1 ?? '',
+            docLink: line.docLink ?? '',
+            vatAmountCents: line.vatAmountCents ?? 0,
+        })),
+    };
+}
+export class JournalPoster {
+    /**
+     * Create the indexes the v2 posting path relies on. Idempotent.
+     */
+    async ensureIndexes() {
+        await ensureSequenceIndexes();
+        await ensurePeriodIndexes();
+        await getDbSync()
+            .mongoDb.collection(JOURNAL_ENTRY_COLLECTION)
+            .createIndex({ skrType: 1, fiscalYear: 1, sequenceNumber: 1 }, {
+            unique: true,
+            // only chained entries — migration inserts docs before sequencing
+            partialFilterExpression: {
+                schemaVersion: 2,
+                sequenceNumber: { $exists: true },
+            },
+        });
+    }
+    /**
+     * Probe transaction support with a no-op transaction. Fails hard —
+     * filing-grade posting has no non-transactional fallback.
+     */
+    async assertTransactionSupport() {
+        const db = getDbSync();
+        const session = db.startSession();
+        try {
+            await session.withTransaction(async () => {
+                await db.mongoDb
+                    .collection(JOURNAL_ENTRY_COLLECTION)
+                    .findOne({ _id: 'txn-probe' }, { session });
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new TransactionsUnsupportedError(message);
+        }
+        finally {
+            await session.endSession();
+        }
+    }
+    /**
+     * Validate and atomically post a journal draft. Returns the persisted,
+     * hashed, immutable JournalEntry.
+     */
+    async postDraft(draft, options) {
+        const validation = core.validateJournalDraft(draft, options?.policy);
+        if (!validation.valid) {
+            throw new Error(`Journal draft invalid: ${validation.errors.join('; ')}`);
+        }
+        const normalized = validation.normalized;
+        const period = periodOf(normalized.date);
+        const fiscalYear = fiscalYearOf(normalized.date);
+        const postedAt = options?.postedAt ?? new Date();
+        const db = getDbSync();
+        const session = db.startSession();
+        try {
+            let posted = null;
+            await session.withTransaction(async () => {
+                await assertPeriodOpen(normalized.skrType, period, session);
+                const { sequenceNumber, prevHash } = await allocateSequence(normalized.skrType, fiscalYear, session);
+                const lines = normalized.lines.map((line) => ({
+                    accountNumber: line.accountNumber,
+                    // legacy float mirrors keep v1 reports readable during migration
+                    debit: line.side === 'debit' ? line.amountCents / 100 : 0,
+                    credit: line.side === 'credit' ? line.amountCents / 100 : 0,
+                    description: line.buchungstext,
+                    side: line.side,
+                    amountCents: line.amountCents,
+                    counterAccount: line.counterAccount,
+                    buKey: line.buKey,
+                    buchungstext: line.buchungstext,
+                    belegfeld1: line.belegfeld1,
+                    costCenter1: line.costCenter1,
+                    docLink: line.docLink,
+                    vatAmountCents: line.vatAmountCents,
+                }));
+                const entry = new JournalEntry({
+                    date: normalized.date,
+                    description: normalized.description,
+                    reference: normalized.reference,
+                    skrType: normalized.skrType,
+                    lines,
+                });
+                entry.schemaVersion = 2;
+                entry.sequenceNumber = sequenceNumber;
+                entry.prevHash = prevHash;
+                entry.taxScenario = normalized.taxScenario;
+                entry.currency = normalized.currency;
+                entry.reversalOf = normalized.reversalOf;
+                entry.status = 'posted';
+                entry.postedAt = postedAt;
+                entry.finalizedAt = null;
+                entry.createdBy = options?.createdBy ?? 'system';
+                // period/fiscalYear are UTC-derived here; the constructor derives them
+                // from local time, so overwrite for determinism
+                entry.period = period;
+                entry.fiscalYear = fiscalYear;
+                entry.entryHash = core.entryHash(prevHash, buildHashPayload({
+                    sequenceNumber,
+                    skrType: normalized.skrType,
+                    fiscalYear,
+                    date: normalized.date,
+                    postedAt,
+                    description: normalized.description,
+                    reference: normalized.reference,
+                    taxScenario: normalized.taxScenario,
+                    currency: normalized.currency,
+                    reversalOf: normalized.reversalOf,
+                    lines,
+                }));
+                await entry.save({ session });
+                await advanceHead(normalized.skrType, fiscalYear, prevHash, entry.entryHash, session);
+                posted = entry;
+            });
+            if (!posted) {
+                throw new Error('Posting transaction did not complete');
+            }
+            return posted;
+        }
+        catch (error) {
+            if (error instanceof PeriodLockedError)
+                throw error;
+            throw error;
+        }
+        finally {
+            await session.endSession();
+        }
+    }
+    /**
+     * Storno: post a reversal entry for a hashed entry WITHOUT mutating the
+     * original (GoBD). The reversal references the original via belegfeld1 and
+     * reference; reversal state is derived by querying, never stored on the
+     * original.
+     */
+    async postStorno(original, options) {
+        if (original.schemaVersion !== 2 || !original.entryHash) {
+            throw new Error('postStorno only reverses schemaVersion-2 (hashed) entries');
+        }
+        const draft = {
+            date: options?.date ?? new Date(),
+            description: options?.description ?? `Storno ${original.journalNumber}: ${original.description}`,
+            reference: `STORNO-${original.journalNumber}`,
+            skrType: original.skrType,
+            reversalOf: original.id,
+            currency: original.currency ?? 'EUR',
+            taxScenario: original.taxScenario,
+            lines: original.lines.map((line) => ({
+                accountNumber: line.accountNumber,
+                counterAccount: line.counterAccount ?? '',
+                side: line.side === 'debit' ? 'credit' : 'debit',
+                amountCents: line.amountCents ?? 0,
+                buKey: (line.buKey ?? ''),
+                buchungstext: `Storno: ${line.buchungstext ?? ''}`,
+                belegfeld1: original.journalNumber,
+            })),
+        };
+        return this.postDraft(draft, options);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"skr.posting.js","sourceRoot":"","sources":["../ts/skr.posting.ts"],"names":[],"mappings":"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"}

package/dist_ts/skr.security.d.ts

@@ -28,17 +28,14 @@ export declare class SecurityManager {
      */
     createCadesSignature(data: Buffer | string, certificatePem?: string, privateKeyPem?: string): Promise<ISignatureResult>;
     /**
-     * Requests an RFC 3161 timestamp from a TSA
+     * RFC 3161 timestamping — NOT implemented.
+     *
+     * The previous implementation posted a JSON blob pretending to be an ASN.1
+     * TimeStampReq — every real TSA rejects that, and failures were silently
+     * swallowed (fake CAdES-T). Until a real RFC 3161 client (DER-encoded TSQ)
+     * exists, this fails loudly; use CAdES-B (includeTimestamp: false).
      */
     requestTimestamp(dataHash: string | Buffer): Promise<ITimestampResponse>;
-    /**
-     * Creates a timestamp request (simplified version)
-     */
-    private createTimestampRequest;
-    /**
-     * Sends timestamp request to TSA server
-     */
-    private sendTimestampRequest;
     /**
      * Verifies a CAdES signature
      */

package/dist_ts/skr.security.js

@@ -1,8 +1,8 @@
 import * as plugins from './plugins.js';
 import * as path from 'path';
 import * as crypto from 'crypto';
-import * as https from 'https';
 import * as nodeForge from 'node-forge';
+import { NotImplementedError } from './skr.errors.js';
 export class SecurityManager {
     options;
     logger;
@@ -74,17 +74,13 @@ export class SecurityManager {
                 signingTime: new Date().toISOString(),
                 certificateChain: [cert]
             };
-            // Add timestamp if requested
+            // Add timestamp if requested — no silent downgrade: if a timestamp was
+            // asked for and cannot be produced, the signing call fails loudly.
             if (this.options.includeTimestamp && this.options.timestampServerUrl) {
-                try {
-                    const timestampResponse = await this.requestTimestamp(signature);
-                    result.timestampToken = timestampResponse.token;
-                    result.timestampTime = timestampResponse.time;
-                    result.signatureFormat = 'CAdES-T';
-                }
-                catch (error) {
-                    this.logger.log('warn', `Failed to obtain timestamp: ${error}`);
-                }
+                const timestampResponse = await this.requestTimestamp(signature);
+                result.timestampToken = timestampResponse.token;
+                result.timestampTime = timestampResponse.time;
+                result.signatureFormat = 'CAdES-T';
             }
             return result;
         }
@@ -93,85 +89,16 @@ export class SecurityManager {
         }
     }
     /**
-     * Requests an RFC 3161 timestamp from a TSA
+     * RFC 3161 timestamping — NOT implemented.
+     *
+     * The previous implementation posted a JSON blob pretending to be an ASN.1
+     * TimeStampReq — every real TSA rejects that, and failures were silently
+     * swallowed (fake CAdES-T). Until a real RFC 3161 client (DER-encoded TSQ)
+     * exists, this fails loudly; use CAdES-B (includeTimestamp: false).
      */
     async requestTimestamp(dataHash) {
-        try {
-            // Create hash of the data
-            let hash;
-            if (typeof dataHash === 'string') {
-                hash = crypto.createHash('sha256').update(dataHash).digest();
-            }
-            else {
-                hash = crypto.createHash('sha256').update(dataHash).digest();
-            }
-            // Create timestamp request (simplified - in production use proper ASN.1 encoding)
-            const tsRequest = this.createTimestampRequest(hash);
-            // Send request to TSA
-            const response = await this.sendTimestampRequest(tsRequest);
-            return {
-                token: response.toString('base64'),
-                time: new Date().toISOString(),
-                serverUrl: this.options.timestampServerUrl,
-                hashAlgorithm: 'sha256'
-            };
-        }
-        catch (error) {
-            throw new Error(`Failed to obtain timestamp: ${error}`);
-        }
-    }
-    /**
-     * Creates a timestamp request (simplified version)
-     */
-    createTimestampRequest(hash) {
-        // In production, use proper ASN.1 encoding library
-        // This is a simplified placeholder
-        const request = {
-            version: 1,
-            messageImprint: {
-                hashAlgorithm: { algorithm: '2.16.840.1.101.3.4.2.1' }, // SHA-256 OID
-                hashedMessage: hash
-            },
-            reqPolicy: null,
-            nonce: crypto.randomBytes(8),
-            certReq: true
-        };
-        // Convert to DER-encoded ASN.1 (simplified)
-        return Buffer.from(JSON.stringify(request));
-    }
-    /**
-     * Sends timestamp request to TSA server
-     */
-    async sendTimestampRequest(request) {
-        return new Promise((resolve, reject) => {
-            const url = new URL(this.options.timestampServerUrl);
-            const options = {
-                hostname: url.hostname,
-                port: url.port || 443,
-                path: url.pathname,
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/timestamp-query',
-                    'Content-Length': request.length
-                }
-            };
-            const req = https.request(options, (res) => {
-                const chunks = [];
-                res.on('data', (chunk) => chunks.push(chunk));
-                res.on('end', () => {
-                    const response = Buffer.concat(chunks);
-                    if (res.statusCode === 200) {
-                        resolve(response);
-                    }
-                    else {
-                        reject(new Error(`TSA server returned status ${res.statusCode}`));
-                    }
-                });
-            });
-            req.on('error', reject);
-            req.write(request);
-            req.end();
-        });
+        void dataHash;
+        throw new NotImplementedError('RFC 3161 timestamping is not implemented — CAdES-T/LT unavailable, use CAdES-B (includeTimestamp: false)');
     }
     /**
      * Verifies a CAdES signature
@@ -319,4 +246,4 @@ export class SecurityManager {
         return ltv;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"skr.security.js","sourceRoot":"","sources":["../ts/skr.security.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"skr.security.js","sourceRoot":"","sources":["../ts/skr.security.ts"],"names":[],"mappings":"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"}

package/dist_ts/skr.sequence.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Gapless ledger sequences + hash-chain heads, one document per
+ * (skrType, fiscalYear). This is the only module that touches the raw
+ * MongoDB driver for sequence allocation — everything runs inside the
+ * caller's transaction session, so an aborted posting rolls the $inc back
+ * and gaplessness holds.
+ */
+import { type TDbSession } from './skr.database.js';
+import type { TSKRType } from './skr.types.js';
+export declare const LEDGER_SEQUENCE_COLLECTION = "LedgerSequence";
+export interface ILedgerSequenceAllocation {
+    sequenceNumber: number;
+    prevHash: string;
+}
+export interface ILedgerSequenceState {
+    skrType: TSKRType;
+    fiscalYear: number;
+    value: number;
+    headHash: string;
+}
+export declare function ensureSequenceIndexes(): Promise<void>;
+/**
+ * Allocate the next sequence number and return the current chain head.
+ * Must run inside a transaction — the $inc participates in the rollback.
+ */
+export declare function allocateSequence(skrType: TSKRType, fiscalYear: number, session: TDbSession): Promise<ILedgerSequenceAllocation>;
+/**
+ * Compare-and-swap the chain head. The filter on the old head serializes
+ * concurrent posters — a lost race aborts the surrounding transaction.
+ */
+export declare function advanceHead(skrType: TSKRType, fiscalYear: number, prevHash: string, newHash: string, session: TDbSession): Promise<void>;
+export declare function getSequenceState(skrType: TSKRType, fiscalYear: number): Promise<ILedgerSequenceState | null>;

package/dist_ts/skr.sequence.js

@@ -0,0 +1,51 @@
+/**
+ * Gapless ledger sequences + hash-chain heads, one document per
+ * (skrType, fiscalYear). This is the only module that touches the raw
+ * MongoDB driver for sequence allocation — everything runs inside the
+ * caller's transaction session, so an aborted posting rolls the $inc back
+ * and gaplessness holds.
+ */
+import { getDbSync } from './skr.database.js';
+import { genesisHash } from './core/core.hash.js';
+import { SequenceConflictError } from './skr.errors.js';
+export const LEDGER_SEQUENCE_COLLECTION = 'LedgerSequence';
+function sequenceCollection() {
+    return getDbSync().mongoDb.collection(LEDGER_SEQUENCE_COLLECTION);
+}
+export async function ensureSequenceIndexes() {
+    await sequenceCollection().createIndex({ skrType: 1, fiscalYear: 1 }, { unique: true });
+}
+/**
+ * Allocate the next sequence number and return the current chain head.
+ * Must run inside a transaction — the $inc participates in the rollback.
+ */
+export async function allocateSequence(skrType, fiscalYear, session) {
+    const genesis = genesisHash(skrType, fiscalYear);
+    const doc = await sequenceCollection().findOneAndUpdate({ skrType, fiscalYear }, { $inc: { value: 1 }, $setOnInsert: { headHash: genesis } }, { upsert: true, returnDocument: 'after', session });
+    if (!doc) {
+        throw new Error(`Sequence allocation failed for ${skrType}/${fiscalYear}`);
+    }
+    return { sequenceNumber: doc.value, prevHash: doc.headHash };
+}
+/**
+ * Compare-and-swap the chain head. The filter on the old head serializes
+ * concurrent posters — a lost race aborts the surrounding transaction.
+ */
+export async function advanceHead(skrType, fiscalYear, prevHash, newHash, session) {
+    const result = await sequenceCollection().updateOne({ skrType, fiscalYear, headHash: prevHash }, { $set: { headHash: newHash } }, { session });
+    if (result.matchedCount !== 1) {
+        throw new SequenceConflictError(skrType, fiscalYear);
+    }
+}
+export async function getSequenceState(skrType, fiscalYear) {
+    const doc = await sequenceCollection().findOne({ skrType, fiscalYear });
+    if (!doc)
+        return null;
+    return {
+        skrType,
+        fiscalYear,
+        value: doc.value,
+        headHash: doc.headHash,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/skr.txview.d.ts

@@ -0,0 +1,46 @@
+import * as core from './core/index.js';
+import type { IJournalEntry, IJournalEntryLine, ITransactionData, ITransactionView, IReportParams, TSKRType } from './skr.types.js';
+export declare function mapNumericPostingKey(postingKey?: number): core.TBuKey;
+/**
+ * v1 postTransaction input -> two-line v2 draft. The amount is NOT split into
+ * net/VAT (v1 semantics: vatAmount was informational) so ledger figures stay
+ * identical across the migration.
+ */
+export declare function transactionDataToDraft(data: ITransactionData): core.IJournalDraft;
+/**
+ * v1 postJournalEntry input -> v2 draft. Gegenkonto derivation: when one side
+ * of the entry has exactly one line, it is the counter account for every line
+ * of the other side (the dominant v1 usage); otherwise the first line of the
+ * opposite side is used (documented heuristic — v1 stored no Gegenkonto).
+ */
+export declare function journalInputToDraft(entry: IJournalEntry): core.IJournalDraft;
+interface IEntryDocLike {
+    id: string;
+    journalNumber?: string;
+    date: Date;
+    description: string;
+    reference?: string;
+    skrType: TSKRType;
+    status: string;
+    period?: string;
+    fiscalYear?: number;
+    postedAt?: Date | null;
+    reversalOf?: string;
+    lines: IJournalEntryLine[];
+}
+/**
+ * Project a two-line v2 entry back into the classic transaction shape.
+ * Returns null for entries with more than two lines (journal-only view).
+ */
+export declare function entryToTransactionView(entry: IEntryDocLike): ITransactionView | null;
+/**
+ * Load v2 entries of a date range as core drafts (for DATEV export).
+ */
+export declare function loadDraftsForExport(skrType: TSKRType, dateFrom: Date, dateTo: Date): Promise<core.IJournalDraft[]>;
+/**
+ * Per-account activity as transaction-shaped line views from v2 entries —
+ * the data source for reports (trial balance, general ledger, cash flow).
+ * Each view carries the line's own side and its Gegenkonto.
+ */
+export declare function accountLineViews(accountNumber: string, skrType: TSKRType, params?: IReportParams): Promise<ITransactionView[]>;
+export {};