waengine 1.7.3 → 1.7.4

package/src/storage.js

@@ -8,7 +8,7 @@ export class WAStorage {
         this.cache = new Map();
         this.ensureBaseDir();
         
-        console.log(`💾 WAStorage initialisiert: ${baseDir}`);
+        // Schöne Console ist jetzt Standard - keine Logs mehr hier
     }
 
     // ===== SETUP =====
@@ -21,11 +21,33 @@ export class WAStorage {
     }
 
     getFilePath(fileName) {
+        // Sicherheitsvalidierung gegen Path Traversal
+        if (!fileName || typeof fileName !== 'string') {
+            throw new Error('❌ Ungültiger Dateiname');
+        }
+        
+        // Entferne gefährliche Zeichen und Pfad-Traversal-Versuche
+        let sanitizedFileName = fileName
+            .replace(/\.\./g, '') // Entferne ../
+            .replace(/[<>:"|?*]/g, '') // Entferne Windows-ungültige Zeichen
+            .replace(/^\/+/, '') // Entferne führende Slashes
+            .trim();
+            
+        if (!sanitizedFileName) {
+            throw new Error('❌ Dateiname ist nach Bereinigung leer');
+        }
+        
         // Automatisch .json hinzufügen falls nicht vorhanden
-        if (!fileName.endsWith('.json')) {
-            fileName += '.json';
+        if (!sanitizedFileName.endsWith('.json')) {
+            sanitizedFileName += '.json';
         }
-        return path.join(this.baseDir, fileName);
+        
+        // Prüfe ob Dateiname zu lang ist (Windows: 255 Zeichen)
+        if (sanitizedFileName.length > 200) {
+            throw new Error('❌ Dateiname zu lang');
+        }
+        
+        return path.join(this.baseDir, sanitizedFileName);
     }
 
     // ===== WRITE SYSTEM =====
@@ -49,14 +71,9 @@ export class WAStorage {
                     return this.setKey(fileName, key, value);
                 },
                 
-                // write.in("datei").push(value) - Für Arrays
-                push: (value) => {
-                    return this.pushToArray(fileName, value);
-                },
-                
-                // write.in("datei").increment(key, amount)
-                increment: (key, amount = 1) => {
-                    return this.incrementKey(fileName, key, amount);
+                // write.in("datei").push(item)
+                push: (item) => {
+                    return this.pushItem(fileName, item);
                 }
             };
         }
@@ -65,7 +82,7 @@ export class WAStorage {
     // ===== READ SYSTEM =====
     
     read = {
-        // read.from("datei")
+        // read.from("datei") - Liest Daten aus Datei
         from: (fileName) => {
             return {
                 // read.from("datei").all()
@@ -78,33 +95,24 @@ export class WAStorage {
                     return this.getKey(fileName, key);
                 },
                 
-                // read.from("datei").keys()
-                keys: () => {
-                    const data = this.readData(fileName);
-                    return data ? Object.keys(data) : [];
+                // read.from("datei").find(condition)
+                find: (condition) => {
+                    return this.findItem(fileName, condition);
                 },
                 
-                // read.from("datei").values()
-                values: () => {
-                    const data = this.readData(fileName);
-                    return data ? Object.values(data) : [];
+                // read.from("datei").filter(condition)
+                filter: (condition) => {
+                    return this.filterItems(fileName, condition);
                 },
                 
-                // read.from("datei").length() - Für Arrays
-                length: () => {
+                // read.from("datei").count()
+                count: () => {
                     const data = this.readData(fileName);
-                    return Array.isArray(data) ? data.length : 0;
-                },
-                
-                // read.from("datei").exists()
-                exists: () => {
-                    return this.fileExists(fileName);
+                    return Array.isArray(data) ? data.length : (data ? Object.keys(data).length : 0);
                 }
             };
         }
     };
-
-    // ===== DELETE SYSTEM =====
     
     delete = {
         // delete.from("datei")
@@ -133,12 +141,39 @@ export class WAStorage {
     writeData(fileName, data) {
         try {
             const filePath = this.getFilePath(fileName);
-            fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
-            this.cache.set(fileName, data);
-            // Stille Speicherung - keine Console-Ausgabe
+            
+            // Validiere Daten
+            if (data === undefined) {
+                throw new Error('Daten sind undefined');
+            }
+            
+            // Atomare Schreibung: Erst in temporäre Datei, dann umbenennen
+            const tempFilePath = `${filePath}.tmp`;
+            const jsonData = JSON.stringify(data, null, 2);
+            
+            // Schreibe in temporäre Datei
+            fs.writeFileSync(tempFilePath, jsonData);
+            
+            // Atomare Umbenennung (verhindert korrupte Dateien)
+            fs.renameSync(tempFilePath, filePath);
+            
+            // Cache mit Größenlimit aktualisieren
+            this.updateCache(fileName, data);
+            
             return true;
         } catch (error) {
             console.error(`❌ Fehler beim Schreiben in ${fileName}:`, error);
+            
+            // Cleanup temporäre Datei
+            try {
+                const tempFilePath = `${this.getFilePath(fileName)}.tmp`;
+                if (fs.existsSync(tempFilePath)) {
+                    fs.unlinkSync(tempFilePath);
+                }
+            } catch (cleanupError) {
+                // Stille Behandlung
+            }
+            
             return false;
         }
     }
@@ -156,11 +191,72 @@ export class WAStorage {
                 return null;
             }
             
-            const data = JSON.parse(fs.readFileSync(filePath, 'utf8'));
-            this.cache.set(fileName, data);
+            // Robuste JSON-Lesung mit Validierung
+            const fileContent = fs.readFileSync(filePath, 'utf8');
+            
+            // Prüfe auf leere oder zu kurze Dateien
+            if (!fileContent || fileContent.trim().length < 2) {
+                console.warn(`⚠️ Datei ${fileName} ist leer oder zu kurz`);
+                return null;
+            }
+            
+            // Prüfe auf unvollständige JSON
+            const trimmed = fileContent.trim();
+            if (!((trimmed.startsWith('{') && trimmed.endsWith('}')) || 
+                  (trimmed.startsWith('[') && trimmed.endsWith(']')))) {
+                console.warn(`⚠️ Datei ${fileName} hat ungültiges JSON-Format`);
+                return null;
+            }
+            
+            const data = JSON.parse(fileContent);
+            
+            // Cache mit Größenlimit aktualisieren
+            this.updateCache(fileName, data);
+            
             return data;
         } catch (error) {
-            console.error(`❌ Fehler beim Lesen von ${fileName}:`, error);
+            console.error(`❌ Fehler beim Lesen von ${fileName}:`, error.message);
+            
+            // Versuche Backup-Recovery
+            const backupData = this.tryRecoverFromBackup(fileName);
+            if (backupData) {
+                console.log(`✅ ${fileName} aus Backup wiederhergestellt`);
+                return backupData;
+            }
+            
+            return null;
+        }
+    }
+
+    // Cache-Management mit Größenlimit
+    updateCache(fileName, data) {
+        // Begrenze Cache-Größe auf 100 Einträge
+        if (this.cache.size >= 100) {
+            // Entferne älteste Einträge (FIFO)
+            const firstKey = this.cache.keys().next().value;
+            this.cache.delete(firstKey);
+        }
+        
+        this.cache.set(fileName, data);
+    }
+
+    // Backup-Recovery für korrupte Dateien
+    tryRecoverFromBackup(fileName) {
+        try {
+            const filePath = this.getFilePath(fileName);
+            const backupPath = `${filePath}.backup`;
+            
+            if (fs.existsSync(backupPath)) {
+                const backupContent = fs.readFileSync(backupPath, 'utf8');
+                const backupData = JSON.parse(backupContent);
+                
+                // Backup ist gültig - stelle wieder her
+                fs.copyFileSync(backupPath, filePath);
+                return backupData;
+            }
+            
+            return null;
+        } catch (error) {
             return null;
         }
     }
@@ -170,34 +266,29 @@ export class WAStorage {
         
         if (Array.isArray(existingData)) {
             existingData.push(newData);
+            return this.writeData(fileName, existingData);
         } else {
-            // Wenn Object, merge
-            Object.assign(existingData, newData);
+            // Für Objekte: Merge
+            const merged = { ...existingData, ...newData };
+            return this.writeData(fileName, merged);
         }
-        
-        return this.writeData(fileName, existingData);
     }
 
     setKey(fileName, key, value) {
-        let data = this.readData(fileName) || {};
+        const data = this.readData(fileName) || {};
         
-        // Nested keys unterstützen (z.B. "user.settings.theme")
-        if (key.includes('.')) {
-            const keys = key.split('.');
-            let current = data;
-            
-            for (let i = 0; i < keys.length - 1; i++) {
-                if (!current[keys[i]]) {
-                    current[keys[i]] = {};
-                }
-                current = current[keys[i]];
+        // Unterstütze nested keys mit Punkt-Notation (z.B. "user.name")
+        const keys = key.split('.');
+        let current = data;
+        
+        for (let i = 0; i < keys.length - 1; i++) {
+            if (!current[keys[i]] || typeof current[keys[i]] !== 'object') {
+                current[keys[i]] = {};
             }
-            
-            current[keys[keys.length - 1]] = value;
-        } else {
-            data[key] = value;
+            current = current[keys[i]];
         }
         
+        current[keys[keys.length - 1]] = value;
         return this.writeData(fileName, data);
     }
 
@@ -205,42 +296,44 @@ export class WAStorage {
         const data = this.readData(fileName);
         if (!data) return null;
         
-        // Nested keys unterstützen
-        if (key.includes('.')) {
-            const keys = key.split('.');
-            let current = data;
-            
-            for (const k of keys) {
-                if (current[k] === undefined) {
-                    return null;
-                }
-                current = current[k];
+        // Unterstütze nested keys mit Punkt-Notation
+        const keys = key.split('.');
+        let current = data;
+        
+        for (const k of keys) {
+            if (current === null || current === undefined || typeof current !== 'object') {
+                return null;
             }
-            
-            return current;
+            current = current[k];
         }
         
-        return data[key];
+        return current;
     }
 
-    pushToArray(fileName, value) {
-        let data = this.readData(fileName);
+    pushItem(fileName, item) {
+        const data = this.readData(fileName) || [];
         
-        if (!data) {
-            data = [];
-        } else if (!Array.isArray(data)) {
-            console.error(`❌ ${fileName} ist kein Array!`);
+        if (!Array.isArray(data)) {
+            console.error(`❌ ${fileName} ist kein Array - kann nicht pushen`);
             return false;
         }
         
-        data.push(value);
+        data.push(item);
         return this.writeData(fileName, data);
     }
 
-    incrementKey(fileName, key, amount = 1) {
-        const currentValue = this.getKey(fileName, key) || 0;
-        const newValue = currentValue + amount;
-        return this.setKey(fileName, key, newValue);
+    findItem(fileName, condition) {
+        const data = this.readData(fileName);
+        if (!Array.isArray(data)) return null;
+        
+        return data.find(condition);
+    }
+
+    filterItems(fileName, condition) {
+        const data = this.readData(fileName);
+        if (!Array.isArray(data)) return [];
+        
+        return data.filter(condition);
     }
 
     deleteFile(fileName) {
@@ -249,12 +342,10 @@ export class WAStorage {
             
             if (fs.existsSync(filePath)) {
                 fs.unlinkSync(filePath);
-                this.cache.delete(fileName);
-                // Stille Löschung
-                return true;
             }
             
-            return false;
+            this.cache.delete(fileName);
+            return true;
         } catch (error) {
             console.error(`❌ Fehler beim Löschen von ${fileName}:`, error);
             return false;
@@ -262,141 +353,102 @@ export class WAStorage {
     }
 
     deleteKey(fileName, key) {
-        let data = this.readData(fileName);
+        const data = this.readData(fileName);
         if (!data) return false;
         
-        if (key.includes('.')) {
-            // Nested key löschen
-            const keys = key.split('.');
-            let current = data;
-            
-            for (let i = 0; i < keys.length - 1; i++) {
-                if (!current[keys[i]]) {
-                    return false;
-                }
-                current = current[keys[i]];
+        // Unterstütze nested keys
+        const keys = key.split('.');
+        let current = data;
+        
+        for (let i = 0; i < keys.length - 1; i++) {
+            if (!current[keys[i]] || typeof current[keys[i]] !== 'object') {
+                return false; // Key existiert nicht
             }
-            
-            delete current[keys[keys.length - 1]];
-        } else {
-            delete data[key];
+            current = current[keys[i]];
         }
         
+        delete current[keys[keys.length - 1]];
         return this.writeData(fileName, data);
     }
 
     deleteWhere(fileName, condition) {
-        let data = this.readData(fileName);
-        if (!data) return false;
-        
-        if (Array.isArray(data)) {
-            // Array filtern
-            const originalLength = data.length;
-            data = data.filter(item => !condition(item));
-            
-            if (data.length !== originalLength) {
-                return this.writeData(fileName, data);
-            }
-        } else {
-            // Object filtern
-            let changed = false;
-            
-            for (const [key, value] of Object.entries(data)) {
-                if (condition(value, key)) {
-                    delete data[key];
-                    changed = true;
-                }
-            }
-            
-            if (changed) {
-                return this.writeData(fileName, data);
-            }
-        }
+        const data = this.readData(fileName);
+        if (!Array.isArray(data)) return false;
         
-        return false;
-    }
-
-    fileExists(fileName) {
-        const filePath = this.getFilePath(fileName);
-        return fs.existsSync(filePath);
+        const filteredData = data.filter(item => !condition(item));
+        return this.writeData(fileName, filteredData);
     }
 
     // ===== UTILITY METHODS =====
     
-    // Alle Dateien auflisten
-    listFiles() {
+    exists(fileName) {
         try {
-            const files = fs.readdirSync(this.baseDir);
-            return files.filter(file => file.endsWith('.json')).map(file => file.replace('.json', ''));
+            const filePath = this.getFilePath(fileName);
+            return fs.existsSync(filePath);
         } catch (error) {
-            console.error('❌ Fehler beim Auflisten der Dateien:', error);
-            return [];
+            return false;
         }
     }
 
-    // Cache leeren
-    clearCache() {
-        this.cache.clear();
-        // Stille Cache-Bereinigung
+    size(fileName) {
+        try {
+            const filePath = this.getFilePath(fileName);
+            if (fs.existsSync(filePath)) {
+                return fs.statSync(filePath).size;
+            }
+            return 0;
+        } catch (error) {
+            return 0;
+        }
     }
 
-    // Backup erstellen
-    backup(backupDir = './waengine-backup') {
+    backup(fileName) {
         try {
-            if (!fs.existsSync(backupDir)) {
-                fs.mkdirSync(backupDir, { recursive: true });
-            }
-            
-            const files = fs.readdirSync(this.baseDir);
-            let backedUp = 0;
+            const filePath = this.getFilePath(fileName);
+            const backupPath = `${filePath}.backup`;
             
-            for (const file of files) {
-                const srcPath = path.join(this.baseDir, file);
-                const destPath = path.join(backupDir, file);
-                fs.copyFileSync(srcPath, destPath);
-                backedUp++;
+            if (fs.existsSync(filePath)) {
+                fs.copyFileSync(filePath, backupPath);
+                return true;
             }
-            
-            // Nur bei explizitem Backup eine Meldung
-            console.log(`💾 Backup erstellt: ${backedUp} Dateien in ${backupDir}`);
-            return backupDir;
+            return false;
         } catch (error) {
-            console.error('❌ Backup Fehler:', error);
+            console.error(`❌ Backup-Fehler für ${fileName}:`, error);
             return false;
         }
     }
 
-    // Storage Statistics
+    // Bereinige Cache
+    clearCache() {
+        this.cache.clear();
+    }
+
+    // Storage-Statistiken
     getStats() {
-        const files = this.listFiles();
-        let totalSize = 0;
-        
-        for (const file of files) {
-            try {
-                const filePath = this.getFilePath(file);
-                const stats = fs.statSync(filePath);
-                totalSize += stats.size;
-            } catch (error) {
-                // Ignore
+        try {
+            const files = fs.readdirSync(this.baseDir);
+            const jsonFiles = files.filter(f => f.endsWith('.json'));
+            
+            let totalSize = 0;
+            for (const file of jsonFiles) {
+                totalSize += this.size(file.replace('.json', ''));
             }
+            
+            return {
+                totalFiles: jsonFiles.length,
+                totalSize: totalSize,
+                cacheSize: this.cache.size,
+                baseDir: this.baseDir
+            };
+        } catch (error) {
+            return {
+                totalFiles: 0,
+                totalSize: 0,
+                cacheSize: this.cache.size,
+                baseDir: this.baseDir,
+                error: error.message
+            };
         }
-        
-        return {
-            totalFiles: files.length,
-            totalSize: totalSize,
-            totalSizeFormatted: this.formatBytes(totalSize),
-            cacheSize: this.cache.size,
-            baseDir: this.baseDir,
-            files: files
-        };
-    }
-
-    formatBytes(bytes) {
-        if (bytes === 0) return '0 Bytes';
-        const k = 1024;
-        const sizes = ['Bytes', 'KB', 'MB', 'GB'];
-        const i = Math.floor(Math.log(bytes) / Math.log(k));
-        return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
     }
 }
 
@@ -404,19 +456,27 @@ export class WAStorage {
 
 let globalStorage = null;
 
-export function createStorage(baseDir) {
+export function createStorage(baseDir = './waengine-data') {
     return new WAStorage(baseDir);
 }
 
-export function getStorage() {
+export function getStorage(baseDir = './waengine-data') {
     if (!globalStorage) {
-        globalStorage = new WAStorage();
+        globalStorage = new WAStorage(baseDir);
     }
     return globalStorage;
 }
 
-// ===== SHORTHAND FUNCTIONS =====
+// ===== CONVENIENCE EXPORTS =====
+
+export const write = {
+    in: (fileName) => getStorage().write.in(fileName)
+};
+
+export const read = {
+    from: (fileName) => getStorage().read.from(fileName)
+};
 
-export const write = getStorage().write;
-export const read = getStorage().read;
-export const del = getStorage().delete;
+export const del = {
+    from: (fileName) => getStorage().delete.from(fileName)
+};