sehawq.db 2.4.2 → 4.0.0

package/src/core/Database.js

@@ -0,0 +1,295 @@
+/**
+ * SehawqDB - The main database class
+ * 
+ * Started as a simple JSON store, now with performance optimizations
+ * Because waiting for databases to load is boring 😴
+ */
+
+const EventEmitter = require('events');
+const path = require('path');
+const fs = require('fs').promises;
+
+class SehawqDB extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    
+    // Config with some sensible defaults
+    this.config = {
+      path: './sehawq-data.json',
+      autoSave: true,
+      saveInterval: 5000,
+      cacheEnabled: true,
+      cacheSize: 1000,
+      ...options
+    };
+
+    // Performance optimizations
+    this.data = new Map(); // Using Map for better performance
+    this.cache = new Map(); // Hot data cache
+    this.indexes = new Map(); // Query indexes
+    
+    // Runtime stats (for debugging)
+    this.stats = {
+      reads: 0,
+      writes: 0,
+      cacheHits: 0,
+      cacheMisses: 0
+    };
+
+    this._initialized = false;
+    this._saveTimeout = null;
+
+    // Initialize - but don't block the constructor
+    this._init().catch(error => {
+      console.error('🚨 SehawqDB init failed:', error);
+    });
+  }
+
+  /**
+   * Async initialization
+   * Because sometimes we need to wait for things...
+   */
+  async _init() {
+    if (this._initialized) return;
+
+    try {
+      // Try to load existing data
+      await this._loadFromDisk();
+      
+      // Start auto-save if enabled
+      if (this.config.autoSave) {
+        this._startAutoSave();
+      }
+
+      this._initialized = true;
+      this.emit('ready');
+      
+      if (this.config.debug) {
+        console.log('✅ SehawqDB ready - Performance mode: ON');
+      }
+    } catch (error) {
+      this.emit('error', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Set a value - the bread and butter
+   */
+  set(key, value) {
+    if (!this._initialized) {
+      throw new Error('Database not initialized. Wait for ready event.');
+    }
+
+    const oldValue = this.data.get(key);
+    this.data.set(key, value);
+    
+    // Cache the hot data
+    if (this.config.cacheEnabled) {
+      this._updateCache(key, value);
+    }
+
+    // Update indexes if any
+    this._updateIndexes(key, value, oldValue);
+
+    this.stats.writes++;
+    this.emit('set', { key, value, oldValue });
+
+    // Immediate save for important data, otherwise batch it
+    if (this.config.autoSave) {
+      this._queueSave();
+    }
+
+    return this;
+  }
+
+  /**
+   * Get a value - faster than your morning coffee
+   */
+  get(key) {
+    if (!this._initialized) {
+      throw new Error('Database not initialized.');
+    }
+
+    this.stats.reads++;
+
+    // Check cache first (hot path)
+    if (this.config.cacheEnabled && this.cache.has(key)) {
+      this.stats.cacheHits++;
+      return this.cache.get(key);
+    }
+
+    this.stats.cacheMisses++;
+    const value = this.data.get(key);
+
+    // Cache it for next time
+    if (this.config.cacheEnabled && value !== undefined) {
+      this._updateCache(key, value);
+    }
+
+    return value;
+  }
+
+  /**
+   * Delete a key - poof! gone.
+   */
+  delete(key) {
+    if (!this.data.has(key)) return false;
+
+    const oldValue = this.data.get(key);
+    this.data.delete(key);
+    this.cache.delete(key);
+    this._removeFromIndexes(key, oldValue);
+
+    this.emit('delete', { key, oldValue });
+    this._queueSave();
+
+    return true;
+  }
+
+  /**
+   * Check if key exists - no guessing games
+   */
+  has(key) {
+    return this.data.has(key);
+  }
+
+  /**
+   * Get all data - use carefully!
+   */
+  all() {
+    return Object.fromEntries(this.data);
+  }
+
+  /**
+   * Clear everything - the nuclear option
+   */
+  clear() {
+    const size = this.data.size;
+    this.data.clear();
+    this.cache.clear();
+    this.indexes.clear();
+
+    this.emit('clear', { size });
+    this._queueSave();
+
+    return this;
+  }
+
+  /**
+   * Smart cache management
+   */
+  _updateCache(key, value) {
+    // Simple LRU-like cache eviction
+    if (this.cache.size >= this.config.cacheSize) {
+      const firstKey = this.cache.keys().next().value;
+      this.cache.delete(firstKey);
+    }
+    
+    this.cache.set(key, value);
+  }
+
+  /**
+   * Index management for faster queries
+   */
+  _updateIndexes(key, newValue, oldValue) {
+    // TODO: Implement in IndexManager.js
+    // This will make queries lightning fast ⚡
+  }
+
+  _removeFromIndexes(key, oldValue) {
+    // TODO: Remove from indexes
+  }
+
+  /**
+   * File operations with error handling
+   */
+  async _loadFromDisk() {
+    try {
+      const data = await fs.readFile(this.config.path, 'utf8');
+      const parsed = JSON.parse(data);
+      
+      // Convert object to Map for better performance
+      for (const [key, value] of Object.entries(parsed)) {
+        this.data.set(key, value);
+      }
+
+      if (this.config.debug) {
+        console.log(`📁 Loaded ${this.data.size} records from disk`);
+      }
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        // File doesn't exist yet - that's fine
+        if (this.config.debug) {
+          console.log('📁 No existing data file - starting fresh');
+        }
+      } else {
+        throw error;
+      }
+    }
+  }
+
+  async _saveToDisk() {
+    try {
+      const data = JSON.stringify(Object.fromEntries(this.data), null, 2);
+      
+      // Atomic write - prevent corruption
+      const tempPath = this.config.path + '.tmp';
+      await fs.writeFile(tempPath, data);
+      await fs.rename(tempPath, this.config.path);
+
+      if (this.config.debug) {
+        console.log(`💾 Saved ${this.data.size} records to disk`);
+      }
+
+      this.emit('save', { recordCount: this.data.size });
+    } catch (error) {
+      this.emit('error', error);
+    }
+  }
+
+  /**
+   * Batch save operations for performance
+   */
+  _queueSave() {
+    if (this._saveTimeout) clearTimeout(this._saveTimeout);
+    
+    this._saveTimeout = setTimeout(() => {
+      this._saveToDisk();
+    }, 100); // Batch saves within 100ms window
+  }
+
+  _startAutoSave() {
+    setInterval(() => {
+      if (this._initialized) {
+        this._saveToDisk();
+      }
+    }, this.config.saveInterval);
+  }
+
+  /**
+   * Performance monitoring
+   */
+  getStats() {
+    return {
+      ...this.stats,
+      cacheHitRate: this.stats.reads > 0 
+        ? (this.stats.cacheHits / this.stats.reads * 100).toFixed(2) + '%'
+        : '0%',
+      totalRecords: this.data.size,
+      cacheSize: this.cache.size
+    };
+  }
+
+  /**
+   * Clean shutdown - be nice to your data
+   */
+  async close() {
+    if (this._saveTimeout) clearTimeout(this._saveTimeout);
+    await this._saveToDisk();
+    this._initialized = false;
+    this.emit('close');
+  }
+}
+
+module.exports = SehawqDB;

package/src/core/Events.js

@@ -0,0 +1,286 @@
+/**
+ * Event System - Makes everything reactive ⚡
+ * 
+ * Listen to database changes, system events, anything!
+ * Because sometimes you need to know when stuff happens
+ */
+
+class Events {
+  constructor() {
+    this.events = new Map();
+    this.maxListeners = 100;
+    this.stats = {
+      eventsEmitted: 0,
+      listenersCalled: 0,
+      errors: 0
+    };
+  }
+
+  /**
+   * Add event listener
+   */
+  on(event, listener, options = {}) {
+    if (typeof listener !== 'function') {
+      throw new Error('Listener must be a function');
+    }
+
+    if (!this.events.has(event)) {
+      this.events.set(event, []);
+    }
+
+    const listeners = this.events.get(event);
+    
+    // Check max listeners
+    if (listeners.length >= this.maxListeners) {
+      console.warn(`⚠️  Event '${event}' has ${listeners.length} listeners, possible memory leak`);
+    }
+
+    // Add listener with options
+    listeners.push({
+      fn: listener,
+      once: options.once || false,
+      async: options.async || false,
+      id: options.id || this._generateId()
+    });
+
+    return this;
+  }
+
+  /**
+   * Add one-time event listener
+   */
+  once(event, listener, options = {}) {
+    return this.on(event, listener, { ...options, once: true });
+  }
+
+  /**
+   * Remove event listener
+   */
+  off(event, listener) {
+    if (!this.events.has(event)) {
+      return this;
+    }
+
+    const listeners = this.events.get(event);
+    
+    if (listener) {
+      // Remove specific listener
+      const index = listeners.findIndex(l => l.fn === listener);
+      if (index > -1) {
+        listeners.splice(index, 1);
+      }
+    } else {
+      // Remove all listeners for event
+      this.events.delete(event);
+    }
+
+    return this;
+  }
+
+  /**
+   * Emit event
+   */
+  emit(event, ...args) {
+    this.stats.eventsEmitted++;
+
+    if (!this.events.has(event)) {
+      return false;
+    }
+
+    const listeners = this.events.get(event).slice(); // Copy array
+    let hasListeners = false;
+
+    for (const listener of listeners) {
+      hasListeners = true;
+
+      // Remove one-time listeners
+      if (listener.once) {
+        this.off(event, listener.fn);
+      }
+
+      // Call listener
+      this._callListener(listener, event, args);
+    }
+
+    return hasListeners;
+  }
+
+  /**
+   * Call listener with error handling
+   */
+  _callListener(listener, event, args) {
+    const callListener = () => {
+      try {
+        listener.fn.apply(this, args);
+        this.stats.listenersCalled++;
+      } catch (error) {
+        this.stats.errors++;
+        console.error(`🚨 Event listener error for '${event}':`, error);
+        
+        // Emit error event
+        if (this.events.has('error')) {
+          this.emit('error', error, event, listener);
+        }
+      }
+    };
+
+    if (listener.async) {
+      setImmediate(callListener);
+    } else {
+      callListener();
+    }
+  }
+
+  /**
+   * Get all event names
+   */
+  eventNames() {
+    return Array.from(this.events.keys());
+  }
+
+  /**
+   * Get listeners for event
+   */
+  listeners(event) {
+    return this.events.has(event) 
+      ? this.events.get(event).map(l => l.fn)
+      : [];
+  }
+
+  /**
+   * Get listener count for event
+   */
+  listenerCount(event) {
+    return this.events.has(event) ? this.events.get(event).length : 0;
+  }
+
+  /**
+   * Remove all listeners
+   */
+  removeAllListeners(event = null) {
+    if (event) {
+      this.events.delete(event);
+    } else {
+      this.events.clear();
+    }
+    return this;
+  }
+
+  /**
+   * Set max listeners
+   */
+  setMaxListeners(n) {
+    this.maxListeners = n;
+    return this;
+  }
+
+  /**
+   * Get max listeners
+   */
+  getMaxListeners() {
+    return this.maxListeners;
+  }
+
+  /**
+   * Generate unique ID for listener
+   */
+  _generateId() {
+    return `listener_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+
+  /**
+   * Wait for event (Promise-based)
+   */
+  waitFor(event, timeout = 0) {
+    return new Promise((resolve, reject) => {
+      let timeoutId;
+
+      const listener = (...args) => {
+        if (timeoutId) clearTimeout(timeoutId);
+        resolve(args);
+      };
+
+      this.once(event, listener);
+
+      if (timeout > 0) {
+        timeoutId = setTimeout(() => {
+          this.off(event, listener);
+          reject(new Error(`Event '${event}' timeout after ${timeout}ms`));
+        }, timeout);
+      }
+    });
+  }
+
+  /**
+   * Pipe events to another emitter
+   */
+  pipe(event, targetEmitter, targetEvent = null) {
+    const targetEventName = targetEvent || event;
+    
+    return this.on(event, (...args) => {
+      targetEmitter.emit(targetEventName, ...args);
+    });
+  }
+
+  /**
+   * Create namespaced event emitter
+   */
+  namespace(namespace) {
+    const namespaced = new Events();
+    
+    // Pipe all events with namespace prefix
+    this.on('*', (event, ...args) => {
+      namespaced.emit(event, ...args);
+    });
+
+    // Pipe namespaced events back to parent
+    namespaced.on('*', (event, ...args) => {
+      this.emit(`${namespace}.${event}`, ...args);
+    });
+
+    return namespaced;
+  }
+
+  /**
+   * Get event statistics
+   */
+  getStats() {
+    const events = {};
+    
+    for (const [event, listeners] of this.events) {
+      events[event] = {
+        listeners: listeners.length,
+        once: listeners.filter(l => l.once).length,
+        async: listeners.filter(l => l.async).length
+      };
+    }
+
+    return {
+      ...this.stats,
+      totalEvents: this.events.size,
+      totalListeners: Array.from(this.events.values()).reduce((sum, listeners) => sum + listeners.length, 0),
+      events
+    };
+  }
+
+  /**
+   * Debug: log all events
+   */
+  debug(enable = true) {
+    if (enable) {
+      this.on('*', (event, ...args) => {
+        console.log(`🎯 Event: ${event}`, args);
+      });
+    } else {
+      this.off('*');
+    }
+    return this;
+  }
+}
+
+// Wildcard event support
+Events.prototype.on('*', function(event, ...args) {
+  // This will be called for every event
+});
+
+module.exports = Events;