waengine 1.0.7 → 1.0.9

package/src/storage.js

@@ -0,0 +1,422 @@
+// WAEngine Storage System - Einfaches Daten-Management
+import fs from 'fs';
+import path from 'path';
+
+export class WAStorage {
+    constructor(baseDir = './waengine-data') {
+        this.baseDir = baseDir;
+        this.cache = new Map();
+        this.ensureBaseDir();
+        
+        console.log(`💾 WAStorage initialisiert: ${baseDir}`);
+    }
+
+    // ===== SETUP =====
+    
+    ensureBaseDir() {
+        if (!fs.existsSync(this.baseDir)) {
+            fs.mkdirSync(this.baseDir, { recursive: true });
+            // Stille Directory-Erstellung
+        }
+    }
+
+    getFilePath(fileName) {
+        // Automatisch .json hinzufügen falls nicht vorhanden
+        if (!fileName.endsWith('.json')) {
+            fileName += '.json';
+        }
+        return path.join(this.baseDir, fileName);
+    }
+
+    // ===== WRITE SYSTEM =====
+    
+    write = {
+        // write.in("datei") - Schreibt Daten in Datei
+        in: (fileName) => {
+            return {
+                // write.in("datei").data(object)
+                data: (data) => {
+                    return this.writeData(fileName, data);
+                },
+                
+                // write.in("datei").append(object)
+                append: (data) => {
+                    return this.appendData(fileName, data);
+                },
+                
+                // write.in("datei").set(key, value)
+                set: (key, value) => {
+                    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);
+                }
+            };
+        }
+    };
+
+    // ===== READ SYSTEM =====
+    
+    read = {
+        // read.from("datei")
+        from: (fileName) => {
+            return {
+                // read.from("datei").all()
+                all: () => {
+                    return this.readData(fileName);
+                },
+                
+                // read.from("datei").get(key)
+                get: (key) => {
+                    return this.getKey(fileName, key);
+                },
+                
+                // read.from("datei").keys()
+                keys: () => {
+                    const data = this.readData(fileName);
+                    return data ? Object.keys(data) : [];
+                },
+                
+                // read.from("datei").values()
+                values: () => {
+                    const data = this.readData(fileName);
+                    return data ? Object.values(data) : [];
+                },
+                
+                // read.from("datei").length() - Für Arrays
+                length: () => {
+                    const data = this.readData(fileName);
+                    return Array.isArray(data) ? data.length : 0;
+                },
+                
+                // read.from("datei").exists()
+                exists: () => {
+                    return this.fileExists(fileName);
+                }
+            };
+        }
+    };
+
+    // ===== DELETE SYSTEM =====
+    
+    delete = {
+        // delete.from("datei")
+        from: (fileName) => {
+            return {
+                // delete.from("datei").all()
+                all: () => {
+                    return this.deleteFile(fileName);
+                },
+                
+                // delete.from("datei").key(key)
+                key: (key) => {
+                    return this.deleteKey(fileName, key);
+                },
+                
+                // delete.from("datei").where(condition)
+                where: (condition) => {
+                    return this.deleteWhere(fileName, condition);
+                }
+            };
+        }
+    };
+
+    // ===== CORE METHODS =====
+    
+    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
+            return true;
+        } catch (error) {
+            console.error(`❌ Fehler beim Schreiben in ${fileName}:`, error);
+            return false;
+        }
+    }
+
+    readData(fileName) {
+        try {
+            // Cache prüfen
+            if (this.cache.has(fileName)) {
+                return this.cache.get(fileName);
+            }
+            
+            const filePath = this.getFilePath(fileName);
+            
+            if (!fs.existsSync(filePath)) {
+                return null;
+            }
+            
+            const data = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+            this.cache.set(fileName, data);
+            return data;
+        } catch (error) {
+            console.error(`❌ Fehler beim Lesen von ${fileName}:`, error);
+            return null;
+        }
+    }
+
+    appendData(fileName, newData) {
+        const existingData = this.readData(fileName) || [];
+        
+        if (Array.isArray(existingData)) {
+            existingData.push(newData);
+        } else {
+            // Wenn Object, merge
+            Object.assign(existingData, newData);
+        }
+        
+        return this.writeData(fileName, existingData);
+    }
+
+    setKey(fileName, key, value) {
+        let 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]];
+            }
+            
+            current[keys[keys.length - 1]] = value;
+        } else {
+            data[key] = value;
+        }
+        
+        return this.writeData(fileName, data);
+    }
+
+    getKey(fileName, key) {
+        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];
+            }
+            
+            return current;
+        }
+        
+        return data[key];
+    }
+
+    pushToArray(fileName, value) {
+        let data = this.readData(fileName);
+        
+        if (!data) {
+            data = [];
+        } else if (!Array.isArray(data)) {
+            console.error(`❌ ${fileName} ist kein Array!`);
+            return false;
+        }
+        
+        data.push(value);
+        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);
+    }
+
+    deleteFile(fileName) {
+        try {
+            const filePath = this.getFilePath(fileName);
+            
+            if (fs.existsSync(filePath)) {
+                fs.unlinkSync(filePath);
+                this.cache.delete(fileName);
+                // Stille Löschung
+                return true;
+            }
+            
+            return false;
+        } catch (error) {
+            console.error(`❌ Fehler beim Löschen von ${fileName}:`, error);
+            return false;
+        }
+    }
+
+    deleteKey(fileName, key) {
+        let 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]];
+            }
+            
+            delete current[keys[keys.length - 1]];
+        } else {
+            delete data[key];
+        }
+        
+        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);
+            }
+        }
+        
+        return false;
+    }
+
+    fileExists(fileName) {
+        const filePath = this.getFilePath(fileName);
+        return fs.existsSync(filePath);
+    }
+
+    // ===== UTILITY METHODS =====
+    
+    // Alle Dateien auflisten
+    listFiles() {
+        try {
+            const files = fs.readdirSync(this.baseDir);
+            return files.filter(file => file.endsWith('.json')).map(file => file.replace('.json', ''));
+        } catch (error) {
+            console.error('❌ Fehler beim Auflisten der Dateien:', error);
+            return [];
+        }
+    }
+
+    // Cache leeren
+    clearCache() {
+        this.cache.clear();
+        // Stille Cache-Bereinigung
+    }
+
+    // Backup erstellen
+    backup(backupDir = './waengine-backup') {
+        try {
+            if (!fs.existsSync(backupDir)) {
+                fs.mkdirSync(backupDir, { recursive: true });
+            }
+            
+            const files = fs.readdirSync(this.baseDir);
+            let backedUp = 0;
+            
+            for (const file of files) {
+                const srcPath = path.join(this.baseDir, file);
+                const destPath = path.join(backupDir, file);
+                fs.copyFileSync(srcPath, destPath);
+                backedUp++;
+            }
+            
+            // Nur bei explizitem Backup eine Meldung
+            console.log(`💾 Backup erstellt: ${backedUp} Dateien in ${backupDir}`);
+            return backupDir;
+        } catch (error) {
+            console.error('❌ Backup Fehler:', error);
+            return false;
+        }
+    }
+
+    // Storage Statistics
+    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
+            }
+        }
+        
+        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];
+    }
+}
+
+// ===== GLOBAL STORAGE INSTANCE =====
+
+let globalStorage = null;
+
+export function createStorage(baseDir) {
+    return new WAStorage(baseDir);
+}
+
+export function getStorage() {
+    if (!globalStorage) {
+        globalStorage = new WAStorage();
+    }
+    return globalStorage;
+}
+
+// ===== SHORTHAND FUNCTIONS =====
+
+export const write = getStorage().write;
+export const read = getStorage().read;
+export const del = getStorage().delete;