@fin.cx/skr 1.0.0 → 1.2.0

package/dist_ts/skr.invoice.storage.js

@@ -0,0 +1,529 @@
+import * as plugins from './plugins.js';
+import * as path from 'path';
+/**
+ * Content-addressed storage for invoices
+ * Integrates with BagIt archive structure for GoBD compliance
+ */
+export class InvoiceStorage {
+    constructor(exportPath) {
+        this.MAX_CACHE_SIZE = 10000; // Maximum number of cached entries
+        this.cacheAccessOrder = []; // Track access order for LRU eviction
+        this.MAX_PDF_SIZE = 50 * 1024 * 1024; // 50MB max
+        this.exportPath = exportPath;
+        this.logger = new plugins.smartlog.ConsoleLog();
+        this.registryPath = path.join(exportPath, 'data', 'documents', 'invoices', 'registry.ndjson');
+        this.metadataCache = new Map();
+    }
+    /**
+     * Manage cache size using LRU eviction
+     */
+    manageCacheSize() {
+        if (this.metadataCache.size > this.MAX_CACHE_SIZE) {
+            // Remove least recently used entries
+            const entriesToRemove = Math.min(100, Math.floor(this.MAX_CACHE_SIZE * 0.1)); // Remove 10% or 100 entries
+            const keysToRemove = this.cacheAccessOrder.splice(0, entriesToRemove);
+            for (const key of keysToRemove) {
+                this.metadataCache.delete(key);
+            }
+            this.logger.log('info', `Evicted ${entriesToRemove} entries from metadata cache`);
+        }
+    }
+    /**
+     * Update cache access order for LRU
+     */
+    touchCacheEntry(key) {
+        const index = this.cacheAccessOrder.indexOf(key);
+        if (index > -1) {
+            this.cacheAccessOrder.splice(index, 1);
+        }
+        this.cacheAccessOrder.push(key);
+    }
+    /**
+     * Initialize storage directories
+     */
+    async initialize() {
+        const dirs = [
+            path.join(this.exportPath, 'data', 'documents', 'invoices', 'inbound'),
+            path.join(this.exportPath, 'data', 'documents', 'invoices', 'inbound', 'metadata'),
+            path.join(this.exportPath, 'data', 'documents', 'invoices', 'outbound'),
+            path.join(this.exportPath, 'data', 'documents', 'invoices', 'outbound', 'metadata'),
+            path.join(this.exportPath, 'data', 'validation')
+        ];
+        for (const dir of dirs) {
+            await plugins.smartfile.fs.ensureDir(dir);
+        }
+        // Load existing registry if it exists
+        await this.loadRegistry();
+    }
+    /**
+     * Store an invoice with content addressing
+     */
+    async storeInvoice(invoice, pdfBuffer) {
+        try {
+            // Validate PDF size if provided
+            if (pdfBuffer && pdfBuffer.length > this.MAX_PDF_SIZE) {
+                throw new Error(`PDF file too large: ${pdfBuffer.length} bytes (max ${this.MAX_PDF_SIZE} bytes)`);
+            }
+            // Calculate hashes
+            const xmlHash = await this.calculateHash(invoice.xmlContent || '');
+            const pdfHash = pdfBuffer ? await this.calculateHash(pdfBuffer) : undefined;
+            const contentHash = xmlHash; // Primary content hash is XML
+            // Check for duplicates
+            const duplicateCheck = await this.checkDuplicate(invoice, contentHash);
+            if (duplicateCheck.isDuplicate) {
+                this.logger.log('warn', `Duplicate invoice detected: ${invoice.invoiceNumber}`);
+                return duplicateCheck.matchedContentHash || contentHash;
+            }
+            // Determine storage path
+            const direction = invoice.direction;
+            const basePath = path.join(this.exportPath, 'data', 'documents', 'invoices', direction);
+            // Create filename with content hash
+            const dateStr = invoice.issueDate.toISOString().split('T')[0];
+            const sanitizedNumber = invoice.invoiceNumber.replace(/[^a-zA-Z0-9-_]/g, '_');
+            const xmlFilename = `${contentHash.substring(0, 8)}_${dateStr}_${sanitizedNumber}.xml`;
+            const xmlPath = path.join(basePath, xmlFilename);
+            // Store XML
+            await plugins.smartfile.memory.toFs(invoice.xmlContent || '', xmlPath);
+            // Store PDF if available
+            let pdfFilename;
+            if (pdfBuffer) {
+                pdfFilename = xmlFilename.replace('.xml', '.pdf');
+                const pdfPath = path.join(basePath, pdfFilename);
+                await plugins.smartfile.memory.toFs(pdfBuffer, pdfPath);
+                // Also store PDF/A-3 with embedded XML if supported
+                if (invoice.format === 'zugferd' || invoice.format === 'facturx') {
+                    const pdfA3Filename = xmlFilename.replace('.xml', '_pdfa3.pdf');
+                    const pdfA3Path = path.join(basePath, pdfA3Filename);
+                    // The PDF should already have embedded XML if it's ZUGFeRD/Factur-X
+                    await plugins.smartfile.memory.toFs(pdfBuffer, pdfA3Path);
+                }
+            }
+            // Create and store metadata
+            const metadata = {
+                invoiceId: invoice.id,
+                invoiceNumber: invoice.invoiceNumber,
+                direction: invoice.direction,
+                issueDate: invoice.issueDate.toISOString(),
+                supplierName: invoice.supplier.name,
+                customerName: invoice.customer.name,
+                totalAmount: invoice.payableAmount,
+                currency: invoice.currencyCode,
+                contentHash,
+                pdfHash,
+                xmlHash,
+                journalEntryId: invoice.bookingInfo?.journalEntryId,
+                transactionIds: invoice.bookingInfo?.transactionIds,
+                validationResult: {
+                    isValid: invoice.validationResult?.isValid || false,
+                    errors: this.countErrors(invoice.validationResult),
+                    warnings: this.countWarnings(invoice.validationResult)
+                },
+                parserVersion: invoice.metadata?.parserVersion || '5.1.4',
+                storedAt: new Date().toISOString(),
+                storedBy: invoice.createdBy
+            };
+            const metadataPath = path.join(basePath, 'metadata', `${contentHash}.json`);
+            await plugins.smartfile.memory.toFs(JSON.stringify(metadata, null, 2), metadataPath);
+            // Update registry
+            await this.updateRegistry(invoice.id, contentHash, metadata);
+            // Cache metadata with LRU management
+            this.setCacheEntry(contentHash, metadata);
+            this.logger.log('info', `Invoice stored: ${invoice.invoiceNumber} (${contentHash})`);
+            return contentHash;
+        }
+        catch (error) {
+            this.logger.log('error', `Failed to store invoice: ${error}`);
+            throw new Error(`Invoice storage failed: ${error.message}`);
+        }
+    }
+    /**
+     * Retrieve an invoice by content hash
+     */
+    async retrieveInvoice(contentHash) {
+        try {
+            // Check cache first
+            const metadata = this.getCacheEntry(contentHash);
+            if (!metadata) {
+                this.logger.log('warn', `Invoice not found: ${contentHash}`);
+                return null;
+            }
+            // Load XML content
+            const xmlPath = await this.findInvoiceFile(contentHash, '.xml');
+            if (!xmlPath) {
+                throw new Error(`XML file not found for invoice ${contentHash}`);
+            }
+            const xmlContent = await plugins.smartfile.fs.toStringSync(xmlPath);
+            // Load PDF if exists
+            let pdfContent;
+            const pdfPath = await this.findInvoiceFile(contentHash, '.pdf');
+            if (pdfPath) {
+                pdfContent = await plugins.smartfile.fs.toBuffer(pdfPath);
+            }
+            // Reconstruct invoice object (partial)
+            const invoice = {
+                id: metadata.invoiceId,
+                invoiceNumber: metadata.invoiceNumber,
+                direction: metadata.direction,
+                issueDate: new Date(metadata.issueDate),
+                supplier: {
+                    name: metadata.supplierName,
+                    id: '',
+                    address: { countryCode: 'DE' }
+                },
+                customer: {
+                    name: metadata.customerName,
+                    id: '',
+                    address: { countryCode: 'DE' }
+                },
+                payableAmount: metadata.totalAmount,
+                currencyCode: metadata.currency,
+                contentHash: metadata.contentHash,
+                xmlContent,
+                pdfContent,
+                pdfHash: metadata.pdfHash
+            };
+            return invoice;
+        }
+        catch (error) {
+            this.logger.log('error', `Failed to retrieve invoice: ${error}`);
+            return null;
+        }
+    }
+    /**
+     * Check for duplicate invoices
+     */
+    async checkDuplicate(invoice, contentHash) {
+        // Check by content hash (exact match)
+        const existing = this.getCacheEntry(contentHash);
+        if (existing) {
+            return {
+                isDuplicate: true,
+                matchedInvoiceId: existing.invoiceId,
+                matchedContentHash: contentHash,
+                matchedFields: ['contentHash'],
+                confidence: 100
+            };
+        }
+        // Check by invoice number and supplier/customer
+        for (const [hash, metadata] of this.metadataCache.entries()) {
+            if (metadata.invoiceNumber === invoice.invoiceNumber &&
+                metadata.direction === invoice.direction) {
+                // Same invoice number and direction
+                if (invoice.direction === 'inbound' && metadata.supplierName === invoice.supplier.name) {
+                    // Same supplier
+                    return {
+                        isDuplicate: true,
+                        matchedInvoiceId: metadata.invoiceId,
+                        matchedContentHash: hash,
+                        matchedFields: ['invoiceNumber', 'supplier'],
+                        confidence: 95
+                    };
+                }
+                else if (invoice.direction === 'outbound' && metadata.customerName === invoice.customer.name) {
+                    // Same customer
+                    return {
+                        isDuplicate: true,
+                        matchedInvoiceId: metadata.invoiceId,
+                        matchedContentHash: hash,
+                        matchedFields: ['invoiceNumber', 'customer'],
+                        confidence: 95
+                    };
+                }
+            }
+            // Check by amount and date within tolerance
+            const dateTolerance = 7 * 24 * 60 * 60 * 1000; // 7 days
+            const amountTolerance = 0.01;
+            if (Math.abs(metadata.totalAmount - invoice.payableAmount) < amountTolerance &&
+                Math.abs(new Date(metadata.issueDate).getTime() - invoice.issueDate.getTime()) < dateTolerance &&
+                metadata.direction === invoice.direction) {
+                if ((invoice.direction === 'inbound' && metadata.supplierName === invoice.supplier.name) ||
+                    (invoice.direction === 'outbound' && metadata.customerName === invoice.customer.name)) {
+                    return {
+                        isDuplicate: true,
+                        matchedInvoiceId: metadata.invoiceId,
+                        matchedContentHash: hash,
+                        matchedFields: ['amount', 'date', 'party'],
+                        confidence: 85
+                    };
+                }
+            }
+        }
+        return {
+            isDuplicate: false,
+            confidence: 0
+        };
+    }
+    /**
+     * Search invoices by filter
+     */
+    async searchInvoices(filter) {
+        const results = [];
+        for (const metadata of this.metadataCache.values()) {
+            if (this.matchesFilter(metadata, filter)) {
+                results.push(metadata);
+            }
+        }
+        // Sort by date descending
+        results.sort((a, b) => new Date(b.issueDate).getTime() - new Date(a.issueDate).getTime());
+        return results;
+    }
+    /**
+     * Get storage statistics
+     */
+    async getStatistics() {
+        let totalSize = 0;
+        let inboundCount = 0;
+        let outboundCount = 0;
+        for (const metadata of this.metadataCache.values()) {
+            if (metadata.direction === 'inbound') {
+                inboundCount++;
+            }
+            else {
+                outboundCount++;
+            }
+            // Estimate size (would need actual file sizes in production)
+            totalSize += 50000; // Rough estimate
+        }
+        return {
+            totalInvoices: this.metadataCache.size,
+            inboundCount,
+            outboundCount,
+            totalSize,
+            duplicatesDetected: 0, // Would track this in production
+            lastUpdate: new Date()
+        };
+    }
+    /**
+     * Create EN16931 compliance report
+     */
+    async createComplianceReport() {
+        const report = {
+            timestamp: new Date().toISOString(),
+            totalInvoices: this.metadataCache.size,
+            validInvoices: 0,
+            invalidInvoices: 0,
+            warnings: 0,
+            byFormat: {},
+            byDirection: {
+                inbound: 0,
+                outbound: 0
+            },
+            validationErrors: [],
+            complianceLevel: 'EN16931',
+            validatorVersion: '5.1.4'
+        };
+        for (const metadata of this.metadataCache.values()) {
+            if (metadata.validationResult.isValid) {
+                report.validInvoices++;
+            }
+            else {
+                report.invalidInvoices++;
+            }
+            report.warnings += metadata.validationResult.warnings;
+            if (metadata.direction === 'inbound') {
+                report.byDirection.inbound++;
+            }
+            else {
+                report.byDirection.outbound++;
+            }
+        }
+        const reportPath = path.join(this.exportPath, 'data', 'validation', 'en16931_compliance.json');
+        await plugins.smartfile.memory.toFs(JSON.stringify(report, null, 2), reportPath);
+    }
+    /**
+     * Load registry from disk
+     */
+    async loadRegistry() {
+        try {
+            if (await plugins.smartfile.fs.fileExists(this.registryPath)) {
+                const content = await plugins.smartfile.fs.toStringSync(this.registryPath);
+                const lines = content.split('\n').filter(line => line.trim());
+                for (const line of lines) {
+                    try {
+                        const entry = JSON.parse(line);
+                        this.setCacheEntry(entry.hash, entry.metadata);
+                    }
+                    catch (e) {
+                        this.logger.log('warn', `Invalid registry entry: ${line}`);
+                    }
+                }
+                this.logger.log('info', `Loaded ${this.metadataCache.size} invoices from registry`);
+            }
+        }
+        catch (error) {
+            this.logger.log('error', `Failed to load registry: ${error}`);
+        }
+    }
+    /**
+     * Update registry with new entry
+     */
+    async updateRegistry(invoiceId, contentHash, metadata) {
+        try {
+            const entry = {
+                id: invoiceId,
+                hash: contentHash,
+                metadata
+            };
+            // Append to NDJSON file
+            const line = JSON.stringify(entry) + '\n';
+            await plugins.smartfile.fs.ensureDir(path.dirname(this.registryPath));
+            // Use native fs for atomic append (better performance and concurrency safety)
+            const fs = await import('fs/promises');
+            await fs.appendFile(this.registryPath, line, 'utf8');
+        }
+        catch (error) {
+            this.logger.log('error', `Failed to update registry: ${error}`);
+        }
+    }
+    /**
+     * Find invoice file by hash and extension
+     */
+    async findInvoiceFile(contentHash, extension) {
+        const dirs = [
+            path.join(this.exportPath, 'data', 'documents', 'invoices', 'inbound'),
+            path.join(this.exportPath, 'data', 'documents', 'invoices', 'outbound')
+        ];
+        for (const dir of dirs) {
+            const files = await plugins.smartfile.fs.listFileTree(dir, '**/*' + extension);
+            for (const file of files) {
+                if (file.includes(contentHash.substring(0, 8))) {
+                    return path.join(dir, file);
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * Calculate SHA-256 hash
+     */
+    async calculateHash(data) {
+        if (typeof data === 'string') {
+            return await plugins.smarthash.sha256FromString(data);
+        }
+        else {
+            return await plugins.smarthash.sha256FromBuffer(data);
+        }
+    }
+    /**
+     * Check if metadata matches filter
+     */
+    matchesFilter(metadata, filter) {
+        if (filter.direction && metadata.direction !== filter.direction) {
+            return false;
+        }
+        if (filter.dateFrom && new Date(metadata.issueDate) < filter.dateFrom) {
+            return false;
+        }
+        if (filter.dateTo && new Date(metadata.issueDate) > filter.dateTo) {
+            return false;
+        }
+        if (filter.minAmount && metadata.totalAmount < filter.minAmount) {
+            return false;
+        }
+        if (filter.maxAmount && metadata.totalAmount > filter.maxAmount) {
+            return false;
+        }
+        if (filter.invoiceNumber && !metadata.invoiceNumber.includes(filter.invoiceNumber)) {
+            return false;
+        }
+        if (filter.supplierId && !metadata.supplierName.includes(filter.supplierId)) {
+            return false;
+        }
+        if (filter.customerId && !metadata.customerName.includes(filter.customerId)) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Count errors in validation result
+     */
+    countErrors(validationResult) {
+        if (!validationResult)
+            return 0;
+        return (validationResult.syntax.errors.length +
+            validationResult.semantic.errors.length +
+            validationResult.businessRules.errors.length +
+            (validationResult.countrySpecific?.errors.length || 0));
+    }
+    /**
+     * Count warnings in validation result
+     */
+    countWarnings(validationResult) {
+        if (!validationResult)
+            return 0;
+        return (validationResult.syntax.warnings.length +
+            validationResult.semantic.warnings.length +
+            validationResult.businessRules.warnings.length +
+            (validationResult.countrySpecific?.warnings.length || 0));
+    }
+    /**
+     * Clean up old invoices (for testing only)
+     */
+    async cleanup(olderThanDays = 365) {
+        let removed = 0;
+        const cutoffDate = new Date();
+        cutoffDate.setDate(cutoffDate.getDate() - olderThanDays);
+        for (const [hash, metadata] of this.metadataCache.entries()) {
+            if (new Date(metadata.issueDate) < cutoffDate) {
+                this.metadataCache.delete(hash);
+                removed++;
+            }
+        }
+        this.logger.log('info', `Removed ${removed} old invoices from cache`);
+        return removed;
+    }
+    /**
+     * Set cache entry with LRU eviction
+     */
+    setCacheEntry(key, value) {
+        // Remove from access order if already exists
+        const existingIndex = this.cacheAccessOrder.indexOf(key);
+        if (existingIndex > -1) {
+            this.cacheAccessOrder.splice(existingIndex, 1);
+        }
+        // Add to end (most recently used)
+        this.cacheAccessOrder.push(key);
+        this.metadataCache.set(key, value);
+        // Evict oldest if cache is too large
+        while (this.metadataCache.size > this.MAX_CACHE_SIZE) {
+            const oldestKey = this.cacheAccessOrder.shift();
+            if (oldestKey) {
+                this.metadataCache.delete(oldestKey);
+                this.logger.log('debug', `Evicted invoice from cache: ${oldestKey}`);
+            }
+        }
+    }
+    /**
+     * Get cache entry and update access order
+     */
+    getCacheEntry(key) {
+        const value = this.metadataCache.get(key);
+        if (value) {
+            // Move to end (most recently used)
+            const index = this.cacheAccessOrder.indexOf(key);
+            if (index > -1) {
+                this.cacheAccessOrder.splice(index, 1);
+            }
+            this.cacheAccessOrder.push(key);
+        }
+        return value;
+    }
+    /**
+     * Update metadata in storage and cache
+     */
+    async updateMetadata(contentHash, updates) {
+        const metadata = this.getCacheEntry(contentHash);
+        if (!metadata) {
+            this.logger.log('warn', `Cannot update metadata - invoice not found: ${contentHash}`);
+            return;
+        }
+        // Update metadata
+        const updatedMetadata = { ...metadata, ...updates };
+        this.setCacheEntry(contentHash, updatedMetadata);
+        // Persist to disk
+        const metadataPath = path.join(this.exportPath, 'data', 'documents', 'invoices', metadata.direction, 'metadata', `${contentHash}.json`);
+        await plugins.smartfile.memory.toFs(JSON.stringify(updatedMetadata, null, 2), metadataPath);
+        this.logger.log('info', `Updated metadata for invoice: ${contentHash}`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"skr.invoice.storage.js","sourceRoot":"","sources":["../ts/skr.invoice.storage.ts"],"names":[],"mappings":"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"}

package/dist_ts/skr.security.d.ts

@@ -0,0 +1,65 @@
+export interface ISigningOptions {
+    certificatePem?: string;
+    privateKeyPem?: string;
+    privateKeyPassphrase?: string;
+    timestampServerUrl?: string;
+    includeTimestamp?: boolean;
+}
+export interface ISignatureResult {
+    signature: string;
+    signatureFormat: 'CAdES-B' | 'CAdES-T' | 'CAdES-LT';
+    signingTime: string;
+    certificateChain?: string[];
+    timestampToken?: string;
+    timestampTime?: string;
+}
+export interface ITimestampResponse {
+    token: string;
+    time: string;
+    serverUrl: string;
+    hashAlgorithm: string;
+}
+export declare class SecurityManager {
+    private options;
+    private logger;
+    constructor(options?: ISigningOptions);
+    /**
+     * Creates a CAdES-B (Basic) signature for data
+     */
+    createCadesSignature(data: Buffer | string, certificatePem?: string, privateKeyPem?: string): Promise<ISignatureResult>;
+    /**
+     * Requests an RFC 3161 timestamp from a TSA
+     */
+    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
+     */
+    verifyCadesSignature(data: Buffer | string, signature: string, certificatePem?: string): Promise<boolean>;
+    /**
+     * Generates a self-signed certificate for testing
+     */
+    generateSelfSignedCertificate(commonName?: string, validDays?: number): Promise<{
+        certificate: string;
+        privateKey: string;
+    }>;
+    /**
+     * Creates a detached signature file
+     */
+    createDetachedSignature(dataPath: string, outputPath: string): Promise<void>;
+    /**
+     * Verifies a detached signature file
+     */
+    verifyDetachedSignature(dataPath: string, signaturePath: string): Promise<boolean>;
+    /**
+     * Adds Long-Term Validation (LTV) information
+     */
+    addLtvInformation(signature: ISignatureResult, ocspResponse?: Buffer, crlData?: Buffer): Promise<ISignatureResult>;
+}