sehawq.db 2.4.2 → 4.0.0

package/src/utils/dot-notation.js

@@ -0,0 +1,248 @@
+/**
+ * Dot Notation Parser - For nested object access 🔍
+ * 
+ * Turns user.profile.name into actual value
+ * Because brackets are so 2010 😄
+ */
+
+class DotNotation {
+  /**
+   * Get value using dot notation
+   */
+  static get(obj, path, defaultValue = undefined) {
+    if (!this.isObject(obj) || typeof path !== 'string') {
+      return defaultValue;
+    }
+
+    const keys = path.split('.');
+    let current = obj;
+
+    for (const key of keys) {
+      if (current === null || current === undefined) {
+        return defaultValue;
+      }
+
+      // Handle array indices
+      if (Array.isArray(current) && !isNaN(key)) {
+        current = current[parseInt(key)];
+      } else if (this.isObject(current)) {
+        current = current[key];
+      } else {
+        return defaultValue;
+      }
+    }
+
+    return current !== undefined ? current : defaultValue;
+  }
+
+  /**
+   * Set value using dot notation
+   */
+  static set(obj, path, value) {
+    if (!this.isObject(obj) || typeof path !== 'string') {
+      return false;
+    }
+
+    const keys = path.split('.');
+    let current = obj;
+
+    for (let i = 0; i < keys.length - 1; i++) {
+      const key = keys[i];
+      const nextKey = keys[i + 1];
+
+      // Create nested objects if they don't exist
+      if (current[key] === undefined || current[key] === null) {
+        // Check if next key is numeric (array)
+        current[key] = !isNaN(nextKey) ? [] : {};
+      }
+
+      current = current[key];
+    }
+
+    const lastKey = keys[keys.length - 1];
+    
+    // Handle array indices
+    if (Array.isArray(current) && !isNaN(lastKey)) {
+      const index = parseInt(lastKey);
+      current[index] = value;
+    } else {
+      current[lastKey] = value;
+    }
+
+    return true;
+  }
+
+  /**
+   * Check if path exists
+   */
+  static has(obj, path) {
+    if (!this.isObject(obj) || typeof path !== 'string') {
+      return false;
+    }
+
+    const keys = path.split('.');
+    let current = obj;
+
+    for (const key of keys) {
+      if (current === null || current === undefined) {
+        return false;
+      }
+
+      if (Array.isArray(current) && !isNaN(key)) {
+        const index = parseInt(key);
+        if (index < 0 || index >= current.length) {
+          return false;
+        }
+        current = current[index];
+      } else if (this.isObject(current)) {
+        if (!current.hasOwnProperty(key)) {
+          return false;
+        }
+        current = current[key];
+      } else {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  /**
+   * Delete value using dot notation
+   */
+  static delete(obj, path) {
+    if (!this.isObject(obj) || typeof path !== 'string') {
+      return false;
+    }
+
+    const keys = path.split('.');
+    let current = obj;
+
+    for (let i = 0; i < keys.length - 1; i++) {
+      const key = keys[i];
+      
+      if (current[key] === undefined || current[key] === null) {
+        return false;
+      }
+
+      current = current[key];
+    }
+
+    const lastKey = keys[keys.length - 1];
+    
+    if (Array.isArray(current) && !isNaN(lastKey)) {
+      const index = parseInt(lastKey);
+      if (index >= 0 && index < current.length) {
+        current.splice(index, 1);
+        return true;
+      }
+    } else if (this.isObject(current)) {
+      if (current.hasOwnProperty(lastKey)) {
+        delete current[lastKey];
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Get all paths in an object
+   */
+  static getAllPaths(obj, prefix = '') {
+    if (!this.isObject(obj)) return [];
+
+    const paths = [];
+
+    for (const key in obj) {
+      if (obj.hasOwnProperty(key)) {
+        const currentPath = prefix ? `${prefix}.${key}` : key;
+        const value = obj[key];
+
+        if (this.isObject(value) && !Array.isArray(value)) {
+          // Recursively get paths for nested objects
+          paths.push(...this.getAllPaths(value, currentPath));
+        } else if (Array.isArray(value)) {
+          // Handle arrays - include index paths
+          paths.push(currentPath);
+          for (let i = 0; i < value.length; i++) {
+            const arrayPath = `${currentPath}.${i}`;
+            if (this.isObject(value[i])) {
+              paths.push(...this.getAllPaths(value[i], arrayPath));
+            } else {
+              paths.push(arrayPath);
+            }
+          }
+        } else {
+          paths.push(currentPath);
+        }
+      }
+    }
+
+    return paths;
+  }
+
+  /**
+   * Flatten object using dot notation
+   */
+  static flatten(obj) {
+    const result = {};
+
+    function flattenHelper(current, path) {
+      if (DotNotation.isObject(current) && !Array.isArray(current)) {
+        for (const key in current) {
+          if (current.hasOwnProperty(key)) {
+            const newPath = path ? `${path}.${key}` : key;
+            flattenHelper(current[key], newPath);
+          }
+        }
+      } else if (Array.isArray(current)) {
+        for (let i = 0; i < current.length; i++) {
+          const newPath = `${path}.${i}`;
+          flattenHelper(current[i], newPath);
+        }
+      } else {
+        result[path] = current;
+      }
+    }
+
+    flattenHelper(obj, '');
+    return result;
+  }
+
+  /**
+   * Unflatten object (reverse of flatten)
+   */
+  static unflatten(flatObj) {
+    const result = {};
+
+    for (const path in flatObj) {
+      if (flatObj.hasOwnProperty(path)) {
+        this.set(result, path, flatObj[path]);
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Check if value is an object
+   */
+  static isObject(value) {
+    return value !== null && typeof value === 'object';
+  }
+
+  /**
+   * Parse path into keys array
+   */
+  static parsePath(path) {
+    if (typeof path !== 'string') return [];
+    
+    // Handle array indices and nested objects
+    return path.split('.').map(key => {
+      return !isNaN(key) ? parseInt(key) : key;
+    });
+  }
+}
+
+module.exports = DotNotation;

package/src/utils/helpers.js

@@ -0,0 +1,276 @@
+/**
+ * Helper Functions - The Swiss Army knife of utilities 🔧
+ * 
+ * Random useful stuff that makes life easier
+ * Collected from years of "oh, I need that again" moments
+ */
+
+class Helpers {
+  /**
+   * Deep clone an object
+   */
+  static deepClone(obj) {
+    if (obj === null || typeof obj !== 'object') return obj;
+    if (obj instanceof Date) return new Date(obj.getTime());
+    if (obj instanceof Array) return obj.map(item => Helpers.deepClone(item));
+    
+    const cloned = {};
+    for (const key in obj) {
+      if (obj.hasOwnProperty(key)) {
+        cloned[key] = Helpers.deepClone(obj[key]);
+      }
+    }
+    return cloned;
+  }
+
+  /**
+   * Deep merge objects
+   */
+  static deepMerge(target, ...sources) {
+    if (!sources.length) return target;
+    const source = sources.shift();
+
+    if (Helpers.isObject(target) && Helpers.isObject(source)) {
+      for (const key in source) {
+        if (Helpers.isObject(source[key])) {
+          if (!target[key]) Object.assign(target, { [key]: {} });
+          Helpers.deepMerge(target[key], source[key]);
+        } else {
+          Object.assign(target, { [key]: source[key] });
+        }
+      }
+    }
+
+    return Helpers.deepMerge(target, ...sources);
+  }
+
+  /**
+   * Check if value is an object
+   */
+  static isObject(item) {
+    return item && typeof item === 'object' && !Array.isArray(item);
+  }
+
+  /**
+   * Generate random ID
+   */
+  static generateId(length = 16) {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    let result = '';
+    for (let i = 0; i < length; i++) {
+      result += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    return result;
+  }
+
+  /**
+   * Sleep/delay function
+   */
+  static sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+
+  /**
+   * Debounce function
+   */
+  static debounce(func, wait, immediate = false) {
+    let timeout;
+    return function executedFunction(...args) {
+      const later = () => {
+        timeout = null;
+        if (!immediate) func(...args);
+      };
+      const callNow = immediate && !timeout;
+      clearTimeout(timeout);
+      timeout = setTimeout(later, wait);
+      if (callNow) func(...args);
+    };
+  }
+
+  /**
+   * Throttle function
+   */
+  static throttle(func, limit) {
+    let inThrottle;
+    return function(...args) {
+      if (!inThrottle) {
+        func.apply(this, args);
+        inThrottle = true;
+        setTimeout(() => inThrottle = false, limit);
+      }
+    };
+  }
+
+  /**
+   * Check if value is empty
+   */
+  static isEmpty(value) {
+    if (value === null || value === undefined) return true;
+    if (typeof value === 'string') return value.trim().length === 0;
+    if (Array.isArray(value)) return value.length === 0;
+    if (Helpers.isObject(value)) return Object.keys(value).length === 0;
+    return false;
+  }
+
+  /**
+   * Get object size (bytes estimation)
+   */
+  static getObjectSize(obj) {
+    const seen = new WeakSet();
+    
+    function sizeOf(obj) {
+      if (obj === null || obj === undefined) return 0;
+      if (seen.has(obj)) return 0;
+      
+      seen.add(obj);
+      
+      switch (typeof obj) {
+        case 'number':
+          return 8;
+        case 'string':
+          return obj.length * 2;
+        case 'boolean':
+          return 4;
+        case 'object':
+          if (Array.isArray(obj)) {
+            return obj.reduce((size, item) => size + sizeOf(item), 0);
+          } else if (obj instanceof Map) {
+            let size = 0;
+            for (const [key, value] of obj) {
+              size += sizeOf(key) + sizeOf(value);
+            }
+            return size;
+          } else if (obj instanceof Set) {
+            let size = 0;
+            for (const value of obj) {
+              size += sizeOf(value);
+            }
+            return size;
+          } else {
+            let size = 0;
+            for (const key in obj) {
+              if (obj.hasOwnProperty(key)) {
+                size += sizeOf(key) + sizeOf(obj[key]);
+              }
+            }
+            return size;
+          }
+        default:
+          return 0;
+      }
+    }
+    
+    return sizeOf(obj);
+  }
+
+  /**
+   * Format bytes to human readable
+   */
+  static formatBytes(bytes, decimals = 2) {
+    if (bytes === 0) return '0 Bytes';
+
+    const k = 1024;
+    const dm = decimals < 0 ? 0 : decimals;
+    const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
+
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + ' ' + sizes[i];
+  }
+
+  /**
+   * Safe JSON parse
+   */
+  static safeJsonParse(str, defaultValue = null) {
+    try {
+      return JSON.parse(str);
+    } catch (error) {
+      return defaultValue;
+    }
+  }
+
+  /**
+   * Safe JSON stringify
+   */
+  static safeJsonStringify(obj, defaultValue = '{}') {
+    try {
+      return JSON.stringify(obj);
+    } catch (error) {
+      return defaultValue;
+    }
+  }
+
+  /**
+   * Filter object properties
+   */
+  static filterObject(obj, predicate) {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      if (predicate(value, key)) {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+
+  /**
+   * Map object properties
+   */
+  static mapObject(obj, mapper) {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = mapper(value, key);
+    }
+    return result;
+  }
+
+  /**
+   * Retry function with exponential backoff
+   */
+  static async retry(fn, retries = 3, delay = 1000) {
+    try {
+      return await fn();
+    } catch (error) {
+      if (retries === 0) throw error;
+      await Helpers.sleep(delay);
+      return Helpers.retry(fn, retries - 1, delay * 2);
+    }
+  }
+
+  /**
+   * Generate timestamp
+   */
+  static timestamp() {
+    return Date.now();
+  }
+
+  /**
+   * Generate UUID v4
+   */
+  static uuid() {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
+      const r = Math.random() * 16 | 0;
+      const v = c == 'x' ? r : (r & 0x3 | 0x8);
+      return v.toString(16);
+    });
+  }
+
+  /**
+   * Check if running in Node.js
+   */
+  static isNode() {
+    return typeof process !== 'undefined' && 
+           process.versions != null && 
+           process.versions.node != null;
+  }
+
+  /**
+   * Check if running in browser
+   */
+  static isBrowser() {
+    return typeof window !== 'undefined' && 
+           typeof window.document !== 'undefined';
+  }
+}
+
+module.exports = Helpers;

package/src/utils/profiler.js

@@ -0,0 +1,71 @@
+const fs = require("fs").promises;
+
+class Storage {
+  constructor(filePath) {
+    this.filePath = filePath;
+    this.writeQueue = [];
+    this.isWriting = false;
+    this.debounceTimer = null;
+  }
+
+  async init() {
+    try {
+      await fs.access(this.filePath);
+    } catch {
+      await fs.writeFile(this.filePath, JSON.stringify({}), "utf8");
+    }
+
+    try {
+      const content = await fs.readFile(this.filePath, "utf8");
+      return JSON.parse(content);
+    } catch {
+      return {};
+    }
+  }
+
+  // Debounced write - waits 100ms before writing
+  async write(data, immediate = false) {
+    if (immediate) {
+      return this._writeNow(data);
+    }
+
+    // Clear existing timer
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+    }
+
+    // Set new timer
+    return new Promise((resolve) => {
+      this.debounceTimer = setTimeout(async () => {
+        await this._writeNow(data);
+        resolve();
+      }, 100);
+    });
+  }
+
+  async _writeNow(data) {
+    const tmpPath = `${this.filePath}.tmp`;
+    
+    try {
+      await fs.writeFile(tmpPath, JSON.stringify(data, null, 2), "utf8");
+      await fs.rename(tmpPath, this.filePath);
+    } catch (err) {
+      // Cleanup temp file if it exists
+      try {
+        await fs.unlink(tmpPath);
+      } catch {}
+      throw err;
+    }
+  }
+
+  async backup(backupPath, data) {
+    await fs.writeFile(backupPath, JSON.stringify(data, null, 2), "utf8");
+  }
+
+  async restore(backupPath) {
+    const content = await fs.readFile(backupPath, "utf8");
+    return JSON.parse(content);
+  }
+}
+
+module.exports = Storage;

package/src/version.js

@@ -0,0 +1,38 @@
+/**
+ * SehawqDB Version Information
+ * 
+ * Because knowing your version is kinda important 😅
+ */
+
+const packageJson = require('../package.json');
+
+module.exports = {
+  version: packageJson.version,
+  name: packageJson.name,
+  description: packageJson.description,
+  author: packageJson.author,
+  license: packageJson.license,
+  
+  getVersion() {
+    return this.version;
+  },
+  
+  getInfo() {
+    return {
+      name: this.name,
+      version: this.version,
+      description: this.description,
+      author: this.author,
+      license: this.license
+    };
+  },
+  
+  // Compatibility check
+  isCompatibleWith(version) {
+    const current = this.version.split('.').map(Number);
+    const target = version.split('.').map(Number);
+    
+    // Major version must match, minor can be equal or higher
+    return current[0] === target[0] && current[1] >= target[1];
+  }
+};