lumisjs 1.0.0

package/src/cache/SQLiteAdapter.js

@@ -0,0 +1,280 @@
+'use strict';
+
+const Logger = require('../utils/Logger');
+
+class SQLiteAdapter {
+  
+  constructor(options = {}) {
+    this.table = options.table || 'lumis_cache';
+    this.defaultTTL = options.ttl || 0;
+    this.logger = new Logger({ prefix: 'SQLiteCache', level: 'info' });
+
+    try {
+      const Database = require('better-sqlite3');
+      this.db = new Database(options.path || ':memory:');
+
+      this.db.pragma('journal_mode = WAL');
+
+      // Validate table name to avoid SQL injection via identifiers
+      if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(this.table)) {
+        throw new TypeError('Invalid table name for SQLiteAdapter. Use only letters, numbers, and underscores, starting with a letter or underscore.');
+      }
+
+      const tableName = `"${this.table}"`;
+
+      this.db.exec(`
+        CREATE TABLE IF NOT EXISTS ${tableName} (
+          key TEXT PRIMARY KEY,
+          value TEXT NOT NULL,
+          expires_at INTEGER
+        )
+      `);
+
+      this._stmts = {
+        get: this.db.prepare(`SELECT value, expires_at FROM ${tableName} WHERE key = ?`),
+        set: this.db.prepare(
+          `INSERT OR REPLACE INTO ${tableName} (key, value, expires_at) VALUES (?, ?, ?)`
+        ),
+        delete: this.db.prepare(`DELETE FROM ${tableName} WHERE key = ?`),
+        has: this.db.prepare(`SELECT 1 FROM ${tableName} WHERE key = ?`),
+        clear: this.db.prepare(`DELETE FROM ${tableName}`),
+        size: this.db.prepare(`SELECT COUNT(*) as count FROM ${tableName}`),
+        all: this.db.prepare(`SELECT key, value FROM ${tableName}`),
+        keys: this.db.prepare(`SELECT key FROM ${tableName}`),
+        cleanup: this.db.prepare(`DELETE FROM ${tableName} WHERE expires_at IS NOT NULL AND expires_at < ?`),
+      };
+
+      this.logger.info('SQLite cache started.');
+    } catch (error) {
+      throw new Error(
+        'SQLite adapter requires "better-sqlite3" package. Installation: npm install better-sqlite3'
+      );
+    }
+  }
+
+  async get(key) {
+    this._cleanup();
+    const row = this._stmts.get.get(key);
+    if (!row) return undefined;
+
+    if (row.expires_at && Date.now() > row.expires_at) {
+      this._stmts.delete.run(key);
+      return undefined;
+    }
+
+    try {
+      return JSON.parse(row.value);
+    } catch {
+      return row.value;
+    }
+  }
+
+  async set(key, value, ttl) {
+    const effectiveTTL = ttl ?? this.defaultTTL;
+    const expiresAt = effectiveTTL > 0 ? Date.now() + (effectiveTTL * 1000) : null;
+    const serialized = JSON.stringify(value);
+    this._stmts.set.run(key, serialized, expiresAt);
+  }
+
+  async delete(key) {
+    const result = this._stmts.delete.run(key);
+    return result.changes > 0;
+  }
+
+  async has(key) {
+    const value = await this.get(key);
+    return value !== undefined;
+  }
+
+  async clear() {
+    this._stmts.clear.run();
+  }
+
+  async size() {
+    this._cleanup();
+    const row = this._stmts.size.get();
+    return row.count;
+  }
+
+  async values() {
+    this._cleanup();
+    const rows = this._stmts.all.all();
+    return rows.map((row) => {
+      try { return JSON.parse(row.value); } catch { return row.value; }
+    });
+  }
+
+  async keys() {
+    this._cleanup();
+    return this._stmts.keys.all().map((row) => row.key);
+  }
+
+  async filter(fn) {
+    this._cleanup();
+    const rows = this._stmts.all.all();
+    const results = [];
+    for (const row of rows) {
+      let value;
+      try { value = JSON.parse(row.value); } catch { value = row.value; }
+      if (fn(value, row.key)) {
+        results.push(value);
+      }
+    }
+    return results;
+  }
+
+  _cleanup() {
+    this._stmts.cleanup.run(Date.now());
+  }
+
+  async destroy() {
+    if (this.db) {
+      this.db.close();
+      this.logger.info('SQLite cache closed.');
+    }
+  }
+
+  // ── Advanced SQLite Features ───────────────────────────────────────────────────
+
+  /**
+   * Get multiple keys at once.
+   * @param {string[]} keys
+   * @returns {Promise<Map<string, any>>}
+   */
+  async getMany(keys) {
+    if (keys.length === 0) return new Map();
+    
+    const placeholders = keys.map(() => '?').join(',');
+    const query = `SELECT key, value, expires_at FROM "${this.table}" WHERE key IN (${placeholders})`;
+    const rows = this.db.prepare(query).all(...keys);
+    
+    const result = new Map();
+    const now = Date.now();
+    
+    for (const row of rows) {
+      if (row.expires_at && now > row.expires_at) {
+        this._stmts.delete.run(row.key);
+        continue;
+      }
+      
+      try {
+        result.set(row.key, JSON.parse(row.value));
+      } catch {
+        result.set(row.key, row.value);
+      }
+    }
+    
+    return result;
+  }
+
+  /**
+   * Set multiple keys at once in a transaction.
+   * @param {Array<[string, any, number?]>} entries
+   * @returns {Promise<void>}
+   */
+  async setMany(entries) {
+    if (entries.length === 0) return;
+    
+    const effectiveTTL = entries.map(([_, __, ttl]) => ttl ?? this.defaultTTL);
+    const expiresAts = effectiveTTL.map(ttl => ttl > 0 ? Date.now() + ttl * 1000 : null);
+    
+    const insert = this.db.prepare(
+      `INSERT OR REPLACE INTO "${this.table}" (key, value, expires_at) VALUES (?, ?, ?)`
+    );
+    
+    const insertMany = this.db.transaction((entries) => {
+      for (const [key, value, expiresAt] of entries) {
+        const serialized = JSON.stringify(value);
+        insert.run(key, serialized, expiresAt);
+      }
+    });
+    
+    const transactionEntries = entries.map(([key, value, _], i) => [
+      key,
+      value,
+      expiresAts[i]
+    ]);
+    
+    insertMany(transactionEntries);
+  }
+
+  /**
+   * Get TTL of a key.
+   * @param {string} key
+   * @returns {Promise<number|null>} TTL in milliseconds, or null if no expiry
+   */
+  async getTTL(key) {
+    const row = this._stmts.get.get(key);
+    if (!row || !row.expires_at) return null;
+    
+    const remaining = row.expires_at - Date.now();
+    return remaining > 0 ? remaining : 0;
+  }
+
+  /**
+   * Set TTL on existing key.
+   * @param {string} key
+   * @param {number} ttl TTL in seconds
+   * @returns {Promise<boolean>}
+   */
+  async setTTL(key, ttl) {
+    const row = this._stmts.get.get(key);
+    if (!row) return false;
+    
+    const expiresAt = ttl > 0 ? Date.now() + ttl * 1000 : null;
+    const update = this.db.prepare(
+      `UPDATE "${this.table}" SET expires_at = ? WHERE key = ?`
+    );
+    const result = update.run(expiresAt, key);
+    
+    return result.changes > 0;
+  }
+
+  /**
+   * Get cache statistics.
+   * @returns {Promise<object>}
+   */
+  async getStats() {
+    this._cleanup();
+    
+    const sizeRow = this._stmts.size.get();
+    const totalSize = this.db.prepare(
+      `SELECT SUM(LENGTH(value)) as total FROM "${this.table}"`
+    ).get();
+    
+    const expiredCount = this.db.prepare(
+      `SELECT COUNT(*) as count FROM "${this.table}" WHERE expires_at IS NOT NULL AND expires_at < ?`
+    ).get(Date.now());
+    
+    return {
+      size: sizeRow.count,
+      memoryUsage: totalSize.total || 0,
+      expiredCount: expiredCount.count,
+      table: this.table,
+    };
+  }
+
+  /**
+   * Vacuum the database to reclaim space.
+   * @returns {Promise<void>}
+   */
+  async vacuum() {
+    this.db.exec('VACUUM');
+    this.logger.info('SQLite cache vacuumed.');
+  }
+
+  /**
+   * Get database file size in bytes.
+   * @returns {Promise<number>}
+   */
+  async getDatabaseSize() {
+    if (this.db.inMemory) return 0;
+    
+    const result = this.db.prepare('PRAGMA page_count').get();
+    const pageSize = this.db.prepare('PRAGMA page_size').get();
+    
+    return result.page_count * pageSize.page_size;
+  }
+}
+
+module.exports = SQLiteAdapter;

package/src/cache/index.js

@@ -0,0 +1,15 @@
+'use strict';
+
+const CacheManager = require('./CacheManager');
+const MemoryAdapter = require('./MemoryAdapter');
+const RedisAdapter = require('./RedisAdapter');
+const SQLiteAdapter = require('./SQLiteAdapter');
+const MultiLevelCache = require('./MultiLevelCache');
+
+module.exports = {
+  CacheManager,
+  MemoryAdapter,
+  RedisAdapter,
+  SQLiteAdapter,
+  MultiLevelCache,
+};