@fin.cx/skr 1.0.0 → 1.2.0

package/dist_ts/skr.export.js

@@ -0,0 +1,315 @@
+import * as plugins from './plugins.js';
+import * as path from 'path';
+export class SkrExport {
+    constructor(options) {
+        this.manifest = {};
+        this.tagManifest = {};
+        this.options = options;
+        this.logger = new plugins.smartlog.ConsoleLog();
+        this.exportDir = path.join(options.exportPath, `jahresabschluss_${options.fiscalYear}`);
+    }
+    /**
+     * Creates the BagIt directory structure for the export
+     */
+    async createBagItStructure() {
+        this.logger.log('info', 'Creating BagIt directory structure...');
+        // Create main directories
+        await plugins.smartfile.fs.ensureDir(this.exportDir);
+        await plugins.smartfile.fs.ensureDir(path.join(this.exportDir, 'data'));
+        await plugins.smartfile.fs.ensureDir(path.join(this.exportDir, 'data', 'metadata'));
+        await plugins.smartfile.fs.ensureDir(path.join(this.exportDir, 'data', 'metadata', 'schemas'));
+        await plugins.smartfile.fs.ensureDir(path.join(this.exportDir, 'data', 'metadata', 'schemas', 'v1'));
+        await plugins.smartfile.fs.ensureDir(path.join(this.exportDir, 'data', 'metadata', 'signatures'));
+        await plugins.smartfile.fs.ensureDir(path.join(this.exportDir, 'data', 'accounting'));
+        await plugins.smartfile.fs.ensureDir(path.join(this.exportDir, 'data', 'accounting', 'ebilanz'));
+        await plugins.smartfile.fs.ensureDir(path.join(this.exportDir, 'data', 'documents'));
+        await plugins.smartfile.fs.ensureDir(path.join(this.exportDir, 'data', 'documents', 'by-hash'));
+        await plugins.smartfile.fs.ensureDir(path.join(this.exportDir, 'data', 'reports'));
+        // Create BagIt declaration file
+        await this.createBagItDeclaration();
+        // Create README
+        await this.createReadme();
+        this.logger.log('ok', 'BagIt structure created successfully');
+    }
+    /**
+     * Creates the bagit.txt declaration file
+     */
+    async createBagItDeclaration() {
+        const bagitContent = `BagIt-Version: 1.0
+Tag-File-Character-Encoding: UTF-8`;
+        const filePath = path.join(this.exportDir, 'bagit.txt');
+        await plugins.smartfile.memory.toFs(bagitContent, filePath);
+        // Add to tag manifest
+        const hash = await this.hashFile(filePath);
+        this.tagManifest['bagit.txt'] = hash;
+    }
+    /**
+     * Creates the README.txt file with Verfahrensdokumentation
+     */
+    async createReadme() {
+        const readmeContent = `SKR Jahresabschluss Export - Verfahrensdokumentation
+=====================================================
+
+Dieses Archiv enthält einen revisionssicheren Export des Jahresabschlusses
+gemäß den Grundsätzen ordnungsmäßiger Buchführung (GoBD).
+
+Export-Datum: ${new Date().toISOString()}
+Geschäftsjahr: ${this.options.fiscalYear}
+Zeitraum: ${this.options.dateFrom.toISOString()} bis ${this.options.dateTo.toISOString()}
+
+STRUKTUR DES ARCHIVS
+--------------------
+- /data/accounting/: Buchhaltungsdaten (Journale, Konten, Salden)
+- /data/documents/: Belegdokumente (content-adressiert)
+- /data/reports/: Finanzberichte (PDF/A-3)
+- /data/metadata/: Export-Metadaten und Schemas
+- /data/metadata/signatures/: Digitale Signaturen und Zeitstempel
+
+INTEGRITÄTSSICHERUNG
+--------------------
+- Alle Dateien sind mit SHA-256 gehasht (siehe manifest-sha256.txt)
+- Optional: Digitale Signatur (CAdES) über Manifest
+- Optional: RFC 3161 Zeitstempel
+
+AUFBEWAHRUNG
+------------
+Dieses Archiv muss gemäß § 147 AO für 10 Jahre revisionssicher aufbewahrt werden.
+Empfohlen wird die Speicherung auf WORM-Medien.
+
+REIMPORT
+--------
+Das Archiv kann mit der SKR-Software vollständig reimportiert werden.
+Die Datenintegrität wird beim Import automatisch verifiziert.
+
+COMPLIANCE
+----------
+- GoBD-konform
+- E-Bilanz-fähig (XBRL)
+- ZUGFeRD/Factur-X kompatibel
+- PDF/A-3 für Langzeitarchivierung
+
+© ${new Date().getFullYear()} ${this.options.companyInfo?.name || 'Export System'}`;
+        const filePath = path.join(this.exportDir, 'readme.txt');
+        await plugins.smartfile.memory.toFs(readmeContent, filePath);
+        // Add to tag manifest
+        const hash = await this.hashFile(filePath);
+        this.tagManifest['readme.txt'] = hash;
+    }
+    /**
+     * Creates the export metadata JSON file
+     */
+    async createExportMetadata(skrType) {
+        const metadata = {
+            exportVersion: '1.0.0',
+            exportTimestamp: new Date().toISOString(),
+            generator: {
+                name: '@fin.cx/skr',
+                version: '1.1.0' // Should be read from package.json
+            },
+            company: this.options.companyInfo,
+            fiscalYear: this.options.fiscalYear,
+            dateRange: {
+                from: this.options.dateFrom.toISOString(),
+                to: this.options.dateTo.toISOString()
+            },
+            skrType: skrType,
+            schemaVersion: '1.0',
+            crypto: {
+                digestAlgorithms: ['sha256'],
+                signatureType: this.options.signExport ? 'CAdES' : undefined,
+                timestampPolicy: this.options.timestampExport ? 'RFC3161' : undefined,
+                merkleTree: true
+            },
+            options: {
+                packagedAs: 'bagit',
+                compression: 'none',
+                deduplication: true
+            }
+        };
+        const filePath = path.join(this.exportDir, 'data', 'metadata', 'export.json');
+        await plugins.smartfile.memory.toFs(JSON.stringify(metadata, null, 2), filePath);
+        // Add to manifest
+        const hash = await this.hashFile(filePath);
+        this.manifest['data/metadata/export.json'] = hash;
+    }
+    /**
+     * Creates JSON schemas for the export data structures
+     */
+    async createSchemas() {
+        // Ledger schema
+        const ledgerSchema = {
+            "$schema": "http://json-schema.org/draft-07/schema#",
+            "title": "Ledger Entry",
+            "type": "object",
+            "properties": {
+                "schema_version": { "type": "string" },
+                "entry_id": { "type": "string", "format": "uuid" },
+                "booking_date": { "type": "string", "format": "date" },
+                "posting_date": { "type": "string", "format": "date" },
+                "currency": { "type": "string" },
+                "journal": { "type": "string" },
+                "description": { "type": "string" },
+                "lines": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "posting_id": { "type": "string" },
+                            "account_code": { "type": "string" },
+                            "debit": { "type": "string" },
+                            "credit": { "type": "string" },
+                            "tax_code": { "type": "string" },
+                            "document_refs": {
+                                "type": "array",
+                                "items": {
+                                    "type": "object",
+                                    "properties": {
+                                        "content_hash": { "type": "string" },
+                                        "doc_role": { "type": "string" },
+                                        "mime": { "type": "string" }
+                                    }
+                                }
+                            }
+                        },
+                        "required": ["posting_id", "account_code", "debit", "credit"]
+                    }
+                },
+                "created_at": { "type": "string", "format": "date-time" },
+                "user": { "type": "string" }
+            },
+            "required": ["schema_version", "entry_id", "booking_date", "lines"]
+        };
+        // Accounts schema
+        const accountsSchema = {
+            "$schema": "http://json-schema.org/draft-07/schema#",
+            "title": "Accounts CSV",
+            "type": "object",
+            "properties": {
+                "account_code": { "type": "string" },
+                "name": { "type": "string" },
+                "type": { "type": "string" },
+                "parent": { "type": "string" },
+                "skr_set": { "type": "string" },
+                "tax_code_default": { "type": "string" },
+                "active_from": { "type": "string", "format": "date" },
+                "active_to": { "type": "string", "format": "date" }
+            },
+            "required": ["account_code", "name", "type", "skr_set"]
+        };
+        // Save schemas
+        const schemasDir = path.join(this.exportDir, 'data', 'metadata', 'schemas', 'v1');
+        await plugins.smartfile.memory.toFs(JSON.stringify(ledgerSchema, null, 2), path.join(schemasDir, 'ledger.schema.json'));
+        this.manifest['data/metadata/schemas/v1/ledger.schema.json'] = await this.hashFile(path.join(schemasDir, 'ledger.schema.json'));
+        await plugins.smartfile.memory.toFs(JSON.stringify(accountsSchema, null, 2), path.join(schemasDir, 'accounts.schema.json'));
+        this.manifest['data/metadata/schemas/v1/accounts.schema.json'] = await this.hashFile(path.join(schemasDir, 'accounts.schema.json'));
+    }
+    /**
+     * Writes the BagIt manifest files
+     */
+    async writeManifests() {
+        // Write data manifest
+        let manifestContent = '';
+        for (const [filePath, hash] of Object.entries(this.manifest)) {
+            manifestContent += `${hash}  ${filePath}\n`;
+        }
+        const manifestPath = path.join(this.exportDir, 'manifest-sha256.txt');
+        await plugins.smartfile.memory.toFs(manifestContent, manifestPath);
+        // Add manifest to tag manifest
+        this.tagManifest['manifest-sha256.txt'] = await this.hashFile(manifestPath);
+        // Write tag manifest
+        let tagManifestContent = '';
+        for (const [filePath, hash] of Object.entries(this.tagManifest)) {
+            tagManifestContent += `${hash}  ${filePath}\n`;
+        }
+        await plugins.smartfile.memory.toFs(tagManifestContent, path.join(this.exportDir, 'tagmanifest-sha256.txt'));
+    }
+    /**
+     * Calculates SHA-256 hash of a file
+     */
+    async hashFile(filePath) {
+        const fileContent = await plugins.smartfile.fs.toBuffer(filePath);
+        return await plugins.smarthash.sha256FromBuffer(fileContent);
+    }
+    /**
+     * Stores a document in content-addressed storage
+     */
+    async storeDocument(content, originalFilename) {
+        const hash = await plugins.smarthash.sha256FromBuffer(content);
+        // Create path based on hash (first 2 chars as directory)
+        const hashPrefix = hash.substring(0, 2);
+        const hashDir = path.join(this.exportDir, 'data', 'documents', 'by-hash', hashPrefix);
+        await plugins.smartfile.fs.ensureDir(hashDir);
+        const docPath = path.join(hashDir, hash);
+        // Only store if not already exists (deduplication)
+        if (!(await plugins.smartfile.fs.fileExists(docPath))) {
+            await plugins.smartfile.memory.toFs(content, docPath);
+            this.manifest[`data/documents/by-hash/${hashPrefix}/${hash}`] = hash;
+        }
+        return hash;
+    }
+    /**
+     * Creates a Merkle tree from all file hashes
+     */
+    async createMerkleTree() {
+        const leaves = Object.values(this.manifest).map(hash => Buffer.from(hash, 'hex'));
+        // Create a sync hash function wrapper for MerkleTree
+        const hashFn = (data) => {
+            // Convert async to sync by using crypto directly
+            const crypto = require('crypto');
+            return crypto.createHash('sha256').update(data).digest();
+        };
+        const tree = new plugins.MerkleTree(leaves, hashFn, {
+            sortPairs: true
+        });
+        const root = tree.getRoot().toString('hex');
+        // Save Merkle tree data
+        const merkleData = {
+            root: root,
+            leaves: Object.entries(this.manifest).map(([path, hash]) => ({
+                path,
+                hash
+            })),
+            timestamp: new Date().toISOString()
+        };
+        const merklePath = path.join(this.exportDir, 'data', 'metadata', 'merkle-tree.json');
+        await plugins.smartfile.memory.toFs(JSON.stringify(merkleData, null, 2), merklePath);
+        this.manifest['data/metadata/merkle-tree.json'] = await this.hashFile(merklePath);
+        return root;
+    }
+    /**
+     * Validates the BagIt structure
+     */
+    async validateBagIt() {
+        this.logger.log('info', 'Validating BagIt structure...');
+        // Check required files exist
+        const requiredFiles = [
+            'bagit.txt',
+            'manifest-sha256.txt',
+            'tagmanifest-sha256.txt',
+            'readme.txt'
+        ];
+        for (const file of requiredFiles) {
+            const filePath = path.join(this.exportDir, file);
+            if (!(await plugins.smartfile.fs.fileExists(filePath))) {
+                this.logger.log('error', `Required file missing: ${file}`);
+                return false;
+            }
+        }
+        // Verify all manifest entries
+        for (const [relPath, expectedHash] of Object.entries(this.manifest)) {
+            const fullPath = path.join(this.exportDir, relPath);
+            if (!(await plugins.smartfile.fs.fileExists(fullPath))) {
+                this.logger.log('error', `Manifest file missing: ${relPath}`);
+                return false;
+            }
+            const actualHash = await this.hashFile(fullPath);
+            if (actualHash !== expectedHash) {
+                this.logger.log('error', `Hash mismatch for ${relPath}`);
+                return false;
+            }
+        }
+        this.logger.log('ok', 'BagIt validation successful');
+        return true;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"skr.export.js","sourceRoot":"","sources":["../ts/skr.export.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,95 @@
+import type { ITransactionData, IJournalEntry, IJournalEntryLine } from './skr.types.js';
+export interface ITransactionDataExport extends ITransactionData {
+    _id?: string;
+    postingDate?: Date;
+    currency?: string;
+    createdAt?: Date | string;
+    modifiedAt?: Date | string;
+    reversalOf?: string;
+    reversedBy?: string;
+    taxCode?: string;
+    project?: string;
+    vatAccount?: string;
+}
+export interface IJournalEntryExport extends IJournalEntry {
+    _id?: string;
+    postingDate?: Date;
+    currency?: string;
+    journal?: string;
+    createdAt?: Date | string;
+    modifiedAt?: Date | string;
+    reversalOf?: string;
+    reversedBy?: string;
+}
+export interface IJournalEntryLineExport extends IJournalEntryLine {
+    taxCode?: string;
+    project?: string;
+}
+export interface ILedgerEntry {
+    schema_version: string;
+    entry_id: string;
+    booking_date: string;
+    posting_date: string;
+    period?: string;
+    currency: string;
+    journal: string;
+    description: string;
+    reference?: string;
+    lines: ILedgerLine[];
+    document_refs?: IDocumentRef[];
+    created_at: string;
+    modified_at?: string;
+    user?: string;
+    reversal_of?: string;
+    reversed_by?: string;
+}
+export interface ILedgerLine {
+    posting_id: string;
+    account_code: string;
+    debit: string;
+    credit: string;
+    tax_code?: string;
+    cost_center?: string;
+    project?: string;
+    description?: string;
+}
+export interface IDocumentRef {
+    content_hash: string;
+    doc_role: 'invoice' | 'receipt' | 'contract' | 'bank-statement' | 'other';
+    doc_mime: string;
+    doc_original_name?: string;
+}
+export declare class LedgerExporter {
+    private exportPath;
+    private stream;
+    private entryCount;
+    constructor(exportPath: string);
+    /**
+     * Initializes the NDJSON export stream
+     */
+    initialize(): Promise<void>;
+    /**
+     * Exports a transaction as a ledger entry
+     */
+    exportTransaction(transaction: ITransactionDataExport): Promise<void>;
+    /**
+     * Exports a journal entry
+     */
+    exportJournalEntry(journalEntry: IJournalEntryExport): Promise<void>;
+    /**
+     * Writes a single NDJSON line
+     */
+    private writeLine;
+    /**
+     * Formats a date to ISO date string
+     */
+    private formatDate;
+    /**
+     * Closes the export stream
+     */
+    close(): Promise<number>;
+    /**
+     * Gets the number of exported entries
+     */
+    getEntryCount(): number;
+}

package/dist_ts/skr.export.ledger.js

@@ -0,0 +1,164 @@
+import * as plugins from './plugins.js';
+import * as path from 'path';
+import { createWriteStream } from 'fs';
+export class LedgerExporter {
+    constructor(exportPath) {
+        this.stream = null;
+        this.entryCount = 0;
+        this.exportPath = exportPath;
+    }
+    /**
+     * Initializes the NDJSON export stream
+     */
+    async initialize() {
+        const ledgerPath = path.join(this.exportPath, 'data', 'accounting', 'ledger.ndjson');
+        await plugins.smartfile.fs.ensureDir(path.dirname(ledgerPath));
+        this.stream = createWriteStream(ledgerPath, {
+            encoding: 'utf8',
+            flags: 'w'
+        });
+    }
+    /**
+     * Exports a transaction as a ledger entry
+     */
+    async exportTransaction(transaction) {
+        if (!this.stream) {
+            throw new Error('Ledger exporter not initialized');
+        }
+        const entry = {
+            schema_version: '1.0',
+            entry_id: transaction._id || plugins.smartunique.shortId(),
+            booking_date: this.formatDate(transaction.date),
+            posting_date: this.formatDate(transaction.postingDate || transaction.date),
+            currency: transaction.currency || 'EUR',
+            journal: 'GL',
+            description: transaction.description,
+            reference: transaction.reference,
+            lines: [],
+            created_at: transaction.createdAt ? new Date(transaction.createdAt).toISOString() : new Date().toISOString(),
+            modified_at: transaction.modifiedAt ? new Date(transaction.modifiedAt).toISOString() : undefined,
+            reversal_of: transaction.reversalOf,
+            reversed_by: transaction.reversedBy
+        };
+        // Add debit line
+        if (transaction.amount > 0) {
+            entry.lines.push({
+                posting_id: `${entry.entry_id}-1`,
+                account_code: transaction.debitAccount,
+                debit: transaction.amount.toFixed(2),
+                credit: '0.00',
+                tax_code: transaction.taxCode,
+                cost_center: transaction.costCenter,
+                project: transaction.project
+            });
+            // Add credit line
+            entry.lines.push({
+                posting_id: `${entry.entry_id}-2`,
+                account_code: transaction.creditAccount,
+                debit: '0.00',
+                credit: transaction.amount.toFixed(2)
+            });
+        }
+        // Add VAT lines if applicable
+        if (transaction.vatAmount && transaction.vatAmount > 0) {
+            entry.lines.push({
+                posting_id: `${entry.entry_id}-3`,
+                account_code: transaction.vatAccount || '1576', // Default VAT account
+                debit: transaction.vatAmount.toFixed(2),
+                credit: '0.00',
+                description: 'Vorsteuer'
+            });
+        }
+        await this.writeLine(entry);
+    }
+    /**
+     * Exports a journal entry
+     */
+    async exportJournalEntry(journalEntry) {
+        if (!this.stream) {
+            throw new Error('Ledger exporter not initialized');
+        }
+        const entry = {
+            schema_version: '1.0',
+            entry_id: journalEntry._id || plugins.smartunique.shortId(),
+            booking_date: this.formatDate(journalEntry.date),
+            posting_date: this.formatDate(journalEntry.postingDate || journalEntry.date),
+            currency: journalEntry.currency || 'EUR',
+            journal: journalEntry.journal || 'GL',
+            description: journalEntry.description,
+            reference: journalEntry.reference,
+            lines: [],
+            created_at: journalEntry.createdAt ? new Date(journalEntry.createdAt).toISOString() : new Date().toISOString(),
+            modified_at: journalEntry.modifiedAt ? new Date(journalEntry.modifiedAt).toISOString() : undefined,
+            reversal_of: journalEntry.reversalOf,
+            reversed_by: journalEntry.reversedBy
+        };
+        // Convert journal entry lines
+        journalEntry.lines.forEach((line, index) => {
+            const extLine = line;
+            entry.lines.push({
+                posting_id: `${entry.entry_id}-${index + 1}`,
+                account_code: line.accountNumber,
+                debit: (line.debit || 0).toFixed(2),
+                credit: (line.credit || 0).toFixed(2),
+                tax_code: extLine.taxCode,
+                cost_center: line.costCenter,
+                project: extLine.project,
+                description: line.description
+            });
+        });
+        await this.writeLine(entry);
+    }
+    /**
+     * Writes a single NDJSON line
+     */
+    async writeLine(entry) {
+        return new Promise((resolve, reject) => {
+            if (!this.stream) {
+                reject(new Error('Stream not initialized'));
+                return;
+            }
+            const line = JSON.stringify(entry) + '\n';
+            this.stream.write(line, (error) => {
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    this.entryCount++;
+                    resolve();
+                }
+            });
+        });
+    }
+    /**
+     * Formats a date to ISO date string
+     */
+    formatDate(date) {
+        if (typeof date === 'string') {
+            return date.split('T')[0];
+        }
+        return date.toISOString().split('T')[0];
+    }
+    /**
+     * Closes the export stream
+     */
+    async close() {
+        return new Promise((resolve) => {
+            if (this.stream) {
+                this.stream.end(() => {
+                    resolve(this.entryCount);
+                });
+            }
+            else {
+                resolve(this.entryCount);
+            }
+        });
+    }
+    /**
+     * Gets the number of exported entries
+     */
+    getEntryCount() {
+        return this.entryCount;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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