@fin.cx/skr 1.1.0 → 1.2.1

package/dist_ts/skr.postingkeys.js

@@ -0,0 +1,196 @@
+/**
+ * DATEV Posting Keys (Buchungsschlüssel) for German Accounting
+ *
+ * Posting keys control automatic VAT booking and are automatically checked
+ * in German tax audits (Betriebsprüfungen). Using incorrect posting keys
+ * can have serious tax consequences.
+ *
+ * Reference: DATEV Buchungsschlüssel-Verzeichnis
+ */
+/**
+ * Posting key definitions with validation rules
+ */
+export const POSTING_KEY_RULES = {
+    3: {
+        key: 3,
+        description: 'Zahlungseingang mit 19% Umsatzsteuer',
+        vatRate: 19,
+        requiresVAT: true,
+        disablesVATAutomatism: false,
+        allowedScenarios: ['domestic_taxed']
+    },
+    8: {
+        key: 8,
+        description: '7% Vorsteuer',
+        vatRate: 7,
+        requiresVAT: true,
+        disablesVATAutomatism: false,
+        allowedScenarios: ['domestic_taxed']
+    },
+    9: {
+        key: 9,
+        description: '19% Vorsteuer',
+        vatRate: 19,
+        requiresVAT: true,
+        disablesVATAutomatism: false,
+        allowedScenarios: ['domestic_taxed']
+    },
+    19: {
+        key: 19,
+        description: '19% Vorsteuer bei innergemeinschaftlichen Lieferungen',
+        vatRate: 19,
+        requiresVAT: true,
+        disablesVATAutomatism: false,
+        allowedScenarios: ['intra_eu']
+    },
+    40: {
+        key: 40,
+        description: 'Steuerfrei / Aufhebung der Automatik',
+        vatRate: 0,
+        requiresVAT: false,
+        disablesVATAutomatism: true,
+        allowedScenarios: ['tax_free', 'export', 'reverse_charge']
+    },
+    94: {
+        key: 94,
+        description: '19% Vorsteuer/Umsatzsteuer bei Erwerb aus EU oder Drittland (Reverse Charge)',
+        vatRate: 19,
+        requiresVAT: true,
+        disablesVATAutomatism: false,
+        allowedScenarios: ['reverse_charge', 'intra_eu', 'third_country']
+    }
+};
+/**
+ * Validate posting key for a journal entry line
+ */
+export function validatePostingKey(postingKey, accountNumber, amount, vatAmount, taxScenario) {
+    const errors = [];
+    const warnings = [];
+    // Get posting key rule
+    const rule = POSTING_KEY_RULES[postingKey];
+    if (!rule) {
+        errors.push(`Invalid posting key: ${postingKey}`);
+        return { isValid: false, errors, warnings };
+    }
+    // Validate VAT requirement
+    // Skip VAT amount requirement if:
+    // 1. Posting TO a VAT account (the line itself IS the VAT)
+    // 2. Posting TO a debtor/creditor account (receivable/payable settlement - VAT was already recorded)
+    const isVATAccount = accountNumber === '1571' || accountNumber === '1771' || accountNumber === '1576';
+    const accountNum = parseInt(accountNumber);
+    const isDebtorCreditorAccount = (accountNum >= 10000 && accountNum <= 69999) || (accountNum >= 70000 && accountNum <= 99999);
+    if (rule.requiresVAT && !vatAmount && !isVATAccount && !isDebtorCreditorAccount) {
+        errors.push(`Posting key ${postingKey} requires VAT amount, but none provided. ` +
+            `Description: ${rule.description}`);
+    }
+    // Validate VAT rate if specified
+    if (rule.vatRate && vatAmount && rule.vatRate > 0) {
+        const expectedVAT = Math.round(amount * rule.vatRate) / 100;
+        const tolerance = 0.02; // 2 cent tolerance for rounding
+        if (Math.abs(vatAmount - expectedVAT) > tolerance) {
+            warnings.push(`VAT amount ${vatAmount} does not match expected ${expectedVAT.toFixed(2)} ` +
+                `for posting key ${postingKey} (${rule.vatRate}%)`);
+        }
+    }
+    // Validate tax scenario
+    if (rule.allowedScenarios && taxScenario) {
+        if (!rule.allowedScenarios.includes(taxScenario)) {
+            errors.push(`Posting key ${postingKey} is not valid for tax scenario '${taxScenario}'. ` +
+                `Allowed scenarios: ${rule.allowedScenarios.join(', ')}`);
+        }
+    }
+    // Validate automatism disabling
+    if (rule.disablesVATAutomatism && vatAmount && vatAmount > 0) {
+        warnings.push(`Posting key ${postingKey} disables VAT automatism but VAT amount is provided. ` +
+            `This may cause incorrect tax reporting.`);
+    }
+    return {
+        isValid: errors.length === 0,
+        errors,
+        warnings
+    };
+}
+/**
+ * Get posting key description
+ */
+export function getPostingKeyDescription(postingKey) {
+    const rule = POSTING_KEY_RULES[postingKey];
+    return rule ? rule.description : `Unknown posting key: ${postingKey}`;
+}
+/**
+ * Get appropriate posting key for a transaction
+ */
+export function suggestPostingKey(params) {
+    const { vatRate, taxScenario, isPayment } = params;
+    // Tax-free or reverse charge scenarios
+    if (taxScenario === 'tax_free' || taxScenario === 'export') {
+        return 40;
+    }
+    // Reverse charge
+    if (taxScenario === 'reverse_charge' || taxScenario === 'third_country') {
+        return 94;
+    }
+    // Intra-EU with VAT
+    if (taxScenario === 'intra_eu' && vatRate === 19) {
+        return 19;
+    }
+    // Payment with 19% VAT
+    if (isPayment && vatRate === 19) {
+        return 3;
+    }
+    // Input VAT based on rate
+    if (vatRate === 19) {
+        return 9;
+    }
+    if (vatRate === 7) {
+        return 8;
+    }
+    // Default to tax-free if no VAT
+    if (vatRate === 0) {
+        return 40;
+    }
+    // Fallback to 19% input VAT
+    return 9;
+}
+/**
+ * Validate all posting keys for consistency
+ */
+export function validatePostingKeyConsistency(lines) {
+    const errors = [];
+    const warnings = [];
+    // Check for mixing tax-free and taxed transactions
+    const hasTaxFree = lines.some(line => line.postingKey === 40);
+    const hasTaxed = lines.some(line => [3, 8, 9, 19, 94].includes(line.postingKey));
+    if (hasTaxFree && hasTaxed) {
+        warnings.push('Journal entry mixes tax-free (key 40) and taxed transactions. ' +
+            'Verify this is intentional.');
+    }
+    // Check for reverse charge consistency
+    const hasReverseCharge = lines.some(line => line.postingKey === 94);
+    if (hasReverseCharge) {
+        const reverseChargeLines = lines.filter(line => line.postingKey === 94);
+        if (reverseChargeLines.length % 2 !== 0) {
+            errors.push('Reverse charge (posting key 94) requires both input and output VAT entries. ' +
+                'Found odd number of reverse charge lines.');
+        }
+    }
+    return {
+        isValid: errors.length === 0,
+        errors,
+        warnings
+    };
+}
+/**
+ * Check if posting key requires automatic VAT booking
+ */
+export function requiresAutomaticVAT(postingKey) {
+    const rule = POSTING_KEY_RULES[postingKey];
+    return rule ? !rule.disablesVATAutomatism : false;
+}
+/**
+ * Get all valid posting keys
+ */
+export function getAllPostingKeys() {
+    return Object.keys(POSTING_KEY_RULES).map(k => Number(k));
+}
+//# sourceMappingURL=data:application/json;base64,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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>;
+}

package/dist_ts/skr.security.js

@@ -0,0 +1,319 @@
+import * as plugins from './plugins.js';
+import * as path from 'path';
+import * as crypto from 'crypto';
+import * as https from 'https';
+export class SecurityManager {
+    constructor(options = {}) {
+        this.options = {
+            timestampServerUrl: options.timestampServerUrl || 'http://timestamp.digicert.com',
+            includeTimestamp: options.includeTimestamp !== false,
+            ...options
+        };
+        this.logger = new plugins.smartlog.ConsoleLog();
+    }
+    /**
+     * Creates a CAdES-B (Basic) signature for data
+     */
+    async createCadesSignature(data, certificatePem, privateKeyPem) {
+        const cert = certificatePem || this.options.certificatePem;
+        const key = privateKeyPem || this.options.privateKeyPem;
+        if (!cert || !key) {
+            throw new Error('Certificate and private key are required for signing');
+        }
+        try {
+            // Parse certificate and key
+            const certificate = plugins.nodeForge.pki.certificateFromPem(cert);
+            const privateKey = this.options.privateKeyPassphrase
+                ? plugins.nodeForge.pki.decryptRsaPrivateKey(key, this.options.privateKeyPassphrase)
+                : plugins.nodeForge.pki.privateKeyFromPem(key);
+            // Create PKCS#7 signed data (CMS)
+            const p7 = plugins.nodeForge.pkcs7.createSignedData();
+            // Add content
+            if (typeof data === 'string') {
+                p7.content = plugins.nodeForge.util.createBuffer(data, 'utf8');
+            }
+            else {
+                p7.content = plugins.nodeForge.util.createBuffer(data.toString('latin1'));
+            }
+            // Add certificate
+            p7.addCertificate(certificate);
+            // Add signer
+            p7.addSigner({
+                key: privateKey,
+                certificate: certificate,
+                digestAlgorithm: plugins.nodeForge.pki.oids.sha256,
+                authenticatedAttributes: [
+                    {
+                        type: plugins.nodeForge.pki.oids.contentType,
+                        value: plugins.nodeForge.pki.oids.data
+                    },
+                    {
+                        type: plugins.nodeForge.pki.oids.messageDigest
+                    },
+                    {
+                        type: plugins.nodeForge.pki.oids.signingTime,
+                        value: new Date().toISOString()
+                    }
+                ]
+            });
+            // Sign the data
+            p7.sign({ detached: true });
+            // Convert to PEM
+            const pem = plugins.nodeForge.pkcs7.messageToPem(p7);
+            // Extract base64 signature
+            const signature = pem
+                .replace(/-----BEGIN PKCS7-----/, '')
+                .replace(/-----END PKCS7-----/, '')
+                .replace(/\r?\n/g, '');
+            const result = {
+                signature: signature,
+                signatureFormat: 'CAdES-B',
+                signingTime: new Date().toISOString(),
+                certificateChain: [cert]
+            };
+            // Add timestamp if requested
+            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}`);
+                }
+            }
+            return result;
+        }
+        catch (error) {
+            throw new Error(`Failed to create CAdES signature: ${error}`);
+        }
+    }
+    /**
+     * Requests an RFC 3161 timestamp from a TSA
+     */
+    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();
+        });
+    }
+    /**
+     * Verifies a CAdES signature
+     */
+    async verifyCadesSignature(data, signature, certificatePem) {
+        try {
+            // Add PEM headers if not present
+            let pemSignature = signature;
+            if (!signature.includes('BEGIN PKCS7')) {
+                pemSignature = `-----BEGIN PKCS7-----\n${signature}\n-----END PKCS7-----`;
+            }
+            // Parse the PKCS#7 message
+            const p7 = plugins.nodeForge.pkcs7.messageFromPem(pemSignature);
+            // Prepare content for verification
+            let content;
+            if (typeof data === 'string') {
+                content = plugins.nodeForge.util.createBuffer(data, 'utf8');
+            }
+            else {
+                content = plugins.nodeForge.util.createBuffer(data.toString('latin1'));
+            }
+            // Verify the signature
+            const verified = p7.verify({
+                content: content,
+                detached: true
+            });
+            return verified;
+        }
+        catch (error) {
+            this.logger.log('error', `Signature verification failed: ${error}`);
+            return false;
+        }
+    }
+    /**
+     * Generates a self-signed certificate for testing
+     */
+    async generateSelfSignedCertificate(commonName = 'SKR Export System', validDays = 365) {
+        const keys = plugins.nodeForge.pki.rsa.generateKeyPair(2048);
+        const cert = plugins.nodeForge.pki.createCertificate();
+        cert.publicKey = keys.publicKey;
+        cert.serialNumber = '01';
+        cert.validity.notBefore = new Date();
+        cert.validity.notAfter = new Date();
+        cert.validity.notAfter.setDate(cert.validity.notAfter.getDate() + validDays);
+        const attrs = [
+            { name: 'commonName', value: commonName },
+            { name: 'countryName', value: 'DE' },
+            { name: 'organizationName', value: 'SKR Export System' },
+            { shortName: 'OU', value: 'Accounting' }
+        ];
+        cert.setSubject(attrs);
+        cert.setIssuer(attrs);
+        cert.setExtensions([
+            {
+                name: 'basicConstraints',
+                cA: true
+            },
+            {
+                name: 'keyUsage',
+                keyCertSign: true,
+                digitalSignature: true,
+                nonRepudiation: true,
+                keyEncipherment: true,
+                dataEncipherment: true
+            },
+            {
+                name: 'extKeyUsage',
+                serverAuth: true,
+                clientAuth: true,
+                codeSigning: true,
+                emailProtection: true,
+                timeStamping: true
+            },
+            {
+                name: 'nsCertType',
+                client: true,
+                server: true,
+                email: true,
+                objsign: true,
+                sslCA: true,
+                emailCA: true,
+                objCA: true
+            },
+            {
+                name: 'subjectAltName',
+                altNames: [
+                    { type: 2, value: commonName }
+                ]
+            }
+        ]);
+        // Self-sign certificate
+        cert.sign(keys.privateKey, plugins.nodeForge.md.sha256.create());
+        // Convert to PEM
+        const certificatePem = plugins.nodeForge.pki.certificateToPem(cert);
+        const privateKeyPem = plugins.nodeForge.pki.privateKeyToPem(keys.privateKey);
+        return {
+            certificate: certificatePem,
+            privateKey: privateKeyPem
+        };
+    }
+    /**
+     * Creates a detached signature file
+     */
+    async createDetachedSignature(dataPath, outputPath) {
+        const data = await plugins.smartfile.fs.toBuffer(dataPath);
+        const signature = await this.createCadesSignature(data);
+        const signatureData = {
+            signature: signature.signature,
+            format: signature.signatureFormat,
+            signingTime: signature.signingTime,
+            timestamp: signature.timestampToken,
+            timestampTime: signature.timestampTime,
+            algorithm: 'SHA256withRSA',
+            signedFile: path.basename(dataPath)
+        };
+        await plugins.smartfile.memory.toFs(JSON.stringify(signatureData, null, 2), outputPath);
+    }
+    /**
+     * Verifies a detached signature file
+     */
+    async verifyDetachedSignature(dataPath, signaturePath) {
+        try {
+            const data = await plugins.smartfile.fs.toBuffer(dataPath);
+            const signatureJson = await plugins.smartfile.fs.toStringSync(signaturePath);
+            const signatureData = JSON.parse(signatureJson);
+            return await this.verifyCadesSignature(data, signatureData.signature);
+        }
+        catch (error) {
+            this.logger.log('error', `Failed to verify detached signature: ${error}`);
+            return false;
+        }
+    }
+    /**
+     * Adds Long-Term Validation (LTV) information
+     */
+    async addLtvInformation(signature, ocspResponse, crlData) {
+        // Add OCSP response and CRL data for long-term validation
+        const ltv = {
+            ...signature,
+            signatureFormat: 'CAdES-LT',
+            ocsp: ocspResponse?.toString('base64'),
+            crl: crlData?.toString('base64'),
+            ltvTime: new Date().toISOString()
+        };
+        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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"}

package/dist_ts/skr.types.d.ts

@@ -1,7 +1,23 @@
 export type TAccountType = 'asset' | 'liability' | 'equity' | 'revenue' | 'expense';
 export type TSKRType = 'SKR03' | 'SKR04';
 export type TTransactionStatus = 'pending' | 'posted' | 'reversed';
+/**
+ * DATEV posting keys (Buchungsschlüssel) for German accounting
+ * These keys control automatic VAT booking and are checked in tax audits
+ */
+export type TPostingKey = 3 | 8 | 9 | 19 | 40 | 94;
 export type TReportType = 'trial_balance' | 'income_statement' | 'balance_sheet' | 'general_ledger' | 'cash_flow';
+/**
+ * Posting key validation rule
+ */
+export interface IPostingKeyRule {
+    key: TPostingKey;
+    description: string;
+    vatRate?: number;
+    requiresVAT: boolean;
+    disablesVATAutomatism: boolean;
+    allowedScenarios?: string[];
+}
 export interface IAccountData {
     accountNumber: string;
     accountName: string;
@@ -11,6 +27,7 @@ export interface IAccountData {
     description?: string;
     vatRate?: number;
     isActive?: boolean;
+    isAutomaticAccount?: boolean;
 }
 export interface ITransactionData {
     date: Date;
@@ -36,6 +53,7 @@ export interface IJournalEntryLine {
     credit?: number;
     description?: string;
     costCenter?: string;
+    postingKey: TPostingKey;
 }
 export interface ITrialBalanceEntry {
     accountNumber: string;
@@ -110,6 +128,7 @@ export interface ITransactionFilter {
 export interface IDatabaseConfig {
     mongoDbUrl: string;
     dbName?: string;
+    invoiceExportPath?: string;
 }
 export interface IReportParams {
     dateFrom?: Date;