voltjs-framework 1.0.0

package/src/database/index.js

@@ -0,0 +1,461 @@
+/**
+ * VoltJS Database Module
+ * 
+ * Universal database abstraction supporting SQLite, MySQL, PostgreSQL.
+ * Includes ORM, query builder, migrations, and seeding.
+ * Uses native Node.js features — zero dependencies.
+ */
+
+'use strict';
+
+const { Model } = require('./model');
+const { QueryBuilder } = require('./query');
+const { Migration } = require('./migration');
+const { Seeder } = require('./seeder');
+
+class Database {
+  constructor(config = {}) {
+    this._config = {
+      driver: config.driver || 'memory',
+      host: config.host || 'localhost',
+      port: config.port || null,
+      name: config.name || 'volt_db',
+      user: config.user || null,
+      password: config.password || null,
+      filename: config.filename || ':memory:',
+      pool: config.pool || { min: 2, max: 10 },
+      ...config,
+    };
+
+    this._connection = null;
+    this._tables = new Map(); // In-memory store
+    this._connected = false;
+    this._queryLog = [];
+  }
+
+  /** Connect to database */
+  async connect() {
+    const driver = this._config.driver;
+
+    switch (driver) {
+      case 'memory':
+        this._connection = this._tables;
+        this._connected = true;
+        break;
+      case 'sqlite':
+        await this._connectSQLite();
+        break;
+      case 'mysql':
+        await this._connectMySQL();
+        break;
+      case 'postgres':
+      case 'postgresql':
+        await this._connectPostgres();
+        break;
+      default:
+        // Default to in-memory
+        this._connection = this._tables;
+        this._connected = true;
+    }
+
+    return this;
+  }
+
+  /** Get a query builder for a table */
+  table(tableName) {
+    return new QueryBuilder(tableName, this);
+  }
+
+  /** Create a model class bound to this database */
+  model(tableName, schema = {}) {
+    return Model.create(tableName, schema, this);
+  }
+
+  /** Run a raw query */
+  async query(sql, params = []) {
+    this._logQuery(sql, params);
+
+    if (this._config.driver === 'memory') {
+      return this._memoryQuery(sql, params);
+    }
+
+    // For real database drivers
+    if (this._connection && typeof this._connection.query === 'function') {
+      return this._connection.query(sql, params);
+    }
+
+    throw new Error('Database not connected');
+  }
+
+  /** Create table (in-memory) */
+  async createTable(tableName, schema) {
+    if (this._config.driver === 'memory') {
+      this._tables.set(tableName, {
+        schema,
+        data: [],
+        autoIncrement: 1,
+      });
+      return true;
+    }
+
+    // Generate CREATE TABLE SQL
+    const columns = Object.entries(schema).map(([name, def]) => {
+      return this._columnToSQL(name, def);
+    });
+
+    const sql = `CREATE TABLE IF NOT EXISTS ${tableName} (${columns.join(', ')})`;
+    return this.query(sql);
+  }
+
+  /** Drop table */
+  async dropTable(tableName) {
+    if (this._config.driver === 'memory') {
+      this._tables.delete(tableName);
+      return true;
+    }
+    return this.query(`DROP TABLE IF EXISTS ${tableName}`);
+  }
+
+  /** Check if table exists */
+  async tableExists(tableName) {
+    if (this._config.driver === 'memory') {
+      return this._tables.has(tableName);
+    }
+    try {
+      await this.query(`SELECT 1 FROM ${tableName} LIMIT 1`);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /** Run migrations */
+  async migrate(migrationsDir) {
+    const migration = new Migration(this, migrationsDir);
+    return migration.run();
+  }
+
+  /** Rollback migrations */
+  async rollback(migrationsDir) {
+    const migration = new Migration(this, migrationsDir);
+    return migration.rollback();
+  }
+
+  /** Run seeders */
+  async seed(seedersDir) {
+    const seeder = new Seeder(this, seedersDir);
+    return seeder.run();
+  }
+
+  /** Close connection */
+  async close() {
+    if (this._connection && typeof this._connection.end === 'function') {
+      await this._connection.end();
+    }
+    this._connected = false;
+  }
+
+  /** Get query log */
+  getQueryLog() {
+    return [...this._queryLog];
+  }
+
+  /** Clear query log */
+  clearQueryLog() {
+    this._queryLog = [];
+  }
+
+  /** Transaction support */
+  async transaction(callback) {
+    if (this._config.driver === 'memory') {
+      // Simple transaction for in-memory: snapshot and restore on error
+      const snapshot = new Map();
+      for (const [name, table] of this._tables) {
+        snapshot.set(name, { ...table, data: [...table.data.map(r => ({ ...r }))] });
+      }
+      try {
+        const result = await callback(this);
+        return result;
+      } catch (err) {
+        // Rollback
+        for (const [name, table] of snapshot) {
+          this._tables.set(name, table);
+        }
+        throw err;
+      }
+    }
+
+    await this.query('BEGIN');
+    try {
+      const result = await callback(this);
+      await this.query('COMMIT');
+      return result;
+    } catch (err) {
+      await this.query('ROLLBACK');
+      throw err;
+    }
+  }
+
+  // ===== IN-MEMORY DATABASE ENGINE =====
+
+  _memoryQuery(sql, params) {
+    // Basic SQL parser for in-memory database
+    const normalized = sql.trim();
+
+    if (normalized.toUpperCase().startsWith('INSERT')) {
+      return this._memoryInsert(normalized, params);
+    }
+    if (normalized.toUpperCase().startsWith('SELECT')) {
+      return this._memorySelect(normalized, params);
+    }
+    if (normalized.toUpperCase().startsWith('UPDATE')) {
+      return this._memoryUpdate(normalized, params);
+    }
+    if (normalized.toUpperCase().startsWith('DELETE')) {
+      return this._memoryDelete(normalized, params);
+    }
+
+    return { success: true };
+  }
+
+  _memoryInsert(sql, params) {
+    const match = sql.match(/INSERT\s+INTO\s+(\w+)\s*\(([^)]+)\)\s*VALUES\s*\(([^)]+)\)/i);
+    if (!match) throw new Error('Invalid INSERT syntax');
+
+    const tableName = match[1];
+    const table = this._tables.get(tableName);
+    if (!table) throw new Error(`Table "${tableName}" not found`);
+
+    const columns = match[2].split(',').map(c => c.trim());
+    const values = match[3].split(',').map((v, i) => {
+      if (v.trim() === '?') return params[i];
+      return v.trim().replace(/^'|'$/g, '');
+    });
+
+    const row = { id: table.autoIncrement++ };
+    columns.forEach((col, i) => {
+      row[col] = values[i];
+    });
+
+    // Set timestamps
+    if (table.schema.created_at || table.schema.createdAt) {
+      row.created_at = row.created_at || new Date().toISOString();
+    }
+    if (table.schema.updated_at || table.schema.updatedAt) {
+      row.updated_at = new Date().toISOString();
+    }
+
+    table.data.push(row);
+    return { insertId: row.id, affectedRows: 1 };
+  }
+
+  _memorySelect(sql, params) {
+    const match = sql.match(/SELECT\s+(.+?)\s+FROM\s+(\w+)(?:\s+WHERE\s+(.+?))?(?:\s+ORDER\s+BY\s+(.+?))?(?:\s+LIMIT\s+(\d+))?(?:\s+OFFSET\s+(\d+))?$/i);
+    if (!match) return [];
+
+    const tableName = match[2];
+    const table = this._tables.get(tableName);
+    if (!table) return [];
+
+    let results = [...table.data];
+
+    // Apply WHERE
+    if (match[3]) {
+      results = this._applyWhere(results, match[3], params);
+    }
+
+    // Apply ORDER BY
+    if (match[4]) {
+      const [field, direction] = match[4].trim().split(/\s+/);
+      results.sort((a, b) => {
+        if (direction?.toUpperCase() === 'DESC') return a[field] > b[field] ? -1 : 1;
+        return a[field] > b[field] ? 1 : -1;
+      });
+    }
+
+    // Apply LIMIT & OFFSET
+    const offset = match[6] ? parseInt(match[6]) : 0;
+    const limit = match[5] ? parseInt(match[5]) : results.length;
+    results = results.slice(offset, offset + limit);
+
+    // Apply column selection
+    if (match[1].trim() !== '*') {
+      const columns = match[1].split(',').map(c => c.trim());
+      results = results.map(row => {
+        const filtered = {};
+        columns.forEach(col => { filtered[col] = row[col]; });
+        return filtered;
+      });
+    }
+
+    return results;
+  }
+
+  _memoryUpdate(sql, params) {
+    const match = sql.match(/UPDATE\s+(\w+)\s+SET\s+(.+?)(?:\s+WHERE\s+(.+))?$/i);
+    if (!match) throw new Error('Invalid UPDATE syntax');
+
+    const tableName = match[1];
+    const table = this._tables.get(tableName);
+    if (!table) throw new Error(`Table "${tableName}" not found`);
+
+    const setParts = match[2].split(',').map(s => s.trim());
+    let paramIndex = 0;
+    const updates = {};
+    for (const part of setParts) {
+      const [col, val] = part.split('=').map(s => s.trim());
+      updates[col] = val === '?' ? params[paramIndex++] : val.replace(/^'|'$/g, '');
+    }
+
+    let affected = 0;
+    for (const row of table.data) {
+      if (!match[3] || this._matchesWhere(row, match[3], params.slice(paramIndex))) {
+        Object.assign(row, updates);
+        row.updated_at = new Date().toISOString();
+        affected++;
+      }
+    }
+
+    return { affectedRows: affected };
+  }
+
+  _memoryDelete(sql, params) {
+    const match = sql.match(/DELETE\s+FROM\s+(\w+)(?:\s+WHERE\s+(.+))?$/i);
+    if (!match) throw new Error('Invalid DELETE syntax');
+
+    const tableName = match[1];
+    const table = this._tables.get(tableName);
+    if (!table) throw new Error(`Table "${tableName}" not found`);
+
+    const before = table.data.length;
+    if (match[2]) {
+      table.data = table.data.filter(row => !this._matchesWhere(row, match[2], params));
+    } else {
+      table.data = [];
+    }
+
+    return { affectedRows: before - table.data.length };
+  }
+
+  _applyWhere(data, whereClause, params) {
+    return data.filter(row => this._matchesWhere(row, whereClause, params));
+  }
+
+  _matchesWhere(row, whereClause, params) {
+    // Simple WHERE parser: supports AND, OR, =, !=, >, <, >=, <=, LIKE
+    const conditions = whereClause.split(/\s+AND\s+/i);
+    let paramIdx = 0;
+
+    return conditions.every(condition => {
+      const match = condition.match(/(\w+)\s*(=|!=|<>|>=|<=|>|<|LIKE)\s*(.+)/i);
+      if (!match) return true;
+
+      const field = match[1].trim();
+      const op = match[2].toUpperCase();
+      let value = match[3].trim();
+
+      if (value === '?') {
+        value = params[paramIdx++];
+      } else {
+        value = value.replace(/^'|'$/g, '');
+      }
+
+      const rowVal = row[field];
+
+      switch (op) {
+        case '=': return rowVal == value;
+        case '!=': case '<>': return rowVal != value;
+        case '>': return rowVal > value;
+        case '<': return rowVal < value;
+        case '>=': return rowVal >= value;
+        case '<=': return rowVal <= value;
+        case 'LIKE':
+          const pattern = value.replace(/%/g, '.*').replace(/_/g, '.');
+          return new RegExp(`^${pattern}$`, 'i').test(String(rowVal));
+        default: return true;
+      }
+    });
+  }
+
+  _columnToSQL(name, def) {
+    if (typeof def === 'string') {
+      return `${name} ${def}`;
+    }
+
+    let sql = `${name} ${def.type || 'TEXT'}`;
+    if (def.primary) sql += ' PRIMARY KEY';
+    if (def.autoIncrement) sql += ' AUTOINCREMENT';
+    if (def.notNull || def.required) sql += ' NOT NULL';
+    if (def.unique) sql += ' UNIQUE';
+    if (def.default !== undefined) {
+      sql += ` DEFAULT ${typeof def.default === 'string' ? `'${def.default}'` : def.default}`;
+    }
+    if (def.references) {
+      sql += ` REFERENCES ${def.references.table}(${def.references.column || 'id'})`;
+    }
+
+    return sql;
+  }
+
+  _logQuery(sql, params) {
+    if (this._queryLog.length < 1000) { // Prevent memory leak
+      this._queryLog.push({ sql, params, timestamp: new Date() });
+    }
+  }
+
+  // ===== DRIVER CONNECTIONS =====
+
+  async _connectSQLite() {
+    try {
+      // Try to use better-sqlite3 or sqlite3
+      const sqlite3 = require('better-sqlite3');
+      this._connection = sqlite3(this._config.filename);
+      this._connected = true;
+    } catch {
+      console.warn('\x1b[33mSQLite driver not found. Install: npm install better-sqlite3\x1b[0m');
+      console.warn('\x1b[33mFalling back to in-memory database.\x1b[0m');
+      this._connection = this._tables;
+      this._connected = true;
+    }
+  }
+
+  async _connectMySQL() {
+    try {
+      const mysql = require('mysql2/promise');
+      this._connection = await mysql.createPool({
+        host: this._config.host,
+        port: this._config.port || 3306,
+        database: this._config.name,
+        user: this._config.user,
+        password: this._config.password,
+        ...this._config.pool,
+      });
+      this._connected = true;
+    } catch {
+      console.warn('\x1b[33mMySQL driver not found. Install: npm install mysql2\x1b[0m');
+      this._connection = this._tables;
+      this._connected = true;
+    }
+  }
+
+  async _connectPostgres() {
+    try {
+      const { Pool } = require('pg');
+      this._connection = new Pool({
+        host: this._config.host,
+        port: this._config.port || 5432,
+        database: this._config.name,
+        user: this._config.user,
+        password: this._config.password,
+        ...this._config.pool,
+      });
+      this._connected = true;
+    } catch {
+      console.warn('\x1b[33mPostgreSQL driver not found. Install: npm install pg\x1b[0m');
+      this._connection = this._tables;
+      this._connected = true;
+    }
+  }
+}
+
+module.exports = { Database };

package/src/database/migration.js

@@ -0,0 +1,192 @@
+/**
+ * VoltJS Migration System
+ * 
+ * @example
+ * // migrations/001_create_users.js
+ * module.exports = {
+ *   up: async (db) => {
+ *     await db.createTable('users', {
+ *       id: { type: 'INTEGER', primary: true, autoIncrement: true },
+ *       name: { type: 'TEXT', required: true },
+ *       email: { type: 'TEXT', unique: true },
+ *       created_at: 'DATETIME',
+ *       updated_at: 'DATETIME',
+ *     });
+ *   },
+ *   down: async (db) => {
+ *     await db.dropTable('users');
+ *   }
+ * };
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+class Migration {
+  constructor(db, migrationsDir) {
+    this._db = db;
+    this._dir = migrationsDir || path.join(process.cwd(), 'migrations');
+    this._tableName = '_volt_migrations';
+  }
+
+  /** Run all pending migrations */
+  async run() {
+    await this._ensureMigrationTable();
+    const completed = await this._getCompleted();
+    const files = this._getMigrationFiles();
+    const pending = files.filter(f => !completed.includes(f));
+
+    if (pending.length === 0) {
+      console.log('\x1b[33m  No pending migrations.\x1b[0m');
+      return [];
+    }
+
+    const results = [];
+    for (const file of pending) {
+      try {
+        const migration = require(path.join(this._dir, file));
+        console.log(`\x1b[36m  Migrating: ${file}\x1b[0m`);
+        await migration.up(this._db);
+        await this._markCompleted(file);
+        console.log(`\x1b[32m  ✓ Migrated: ${file}\x1b[0m`);
+        results.push({ file, status: 'success' });
+      } catch (err) {
+        console.error(`\x1b[31m  ✗ Migration failed: ${file} — ${err.message}\x1b[0m`);
+        results.push({ file, status: 'error', error: err.message });
+        break; // Stop on first failure
+      }
+    }
+
+    return results;
+  }
+
+  /** Rollback last batch of migrations */
+  async rollback() {
+    await this._ensureMigrationTable();
+    const completed = await this._getCompleted();
+
+    if (completed.length === 0) {
+      console.log('\x1b[33m  Nothing to rollback.\x1b[0m');
+      return [];
+    }
+
+    // Rollback last migration
+    const lastFile = completed[completed.length - 1];
+    try {
+      const migration = require(path.join(this._dir, lastFile));
+      if (migration.down) {
+        console.log(`\x1b[36m  Rolling back: ${lastFile}\x1b[0m`);
+        await migration.down(this._db);
+        await this._markRolledBack(lastFile);
+        console.log(`\x1b[32m  ✓ Rolled back: ${lastFile}\x1b[0m`);
+      }
+      return [{ file: lastFile, status: 'rolled_back' }];
+    } catch (err) {
+      console.error(`\x1b[31m  ✗ Rollback failed: ${lastFile} — ${err.message}\x1b[0m`);
+      return [{ file: lastFile, status: 'error', error: err.message }];
+    }
+  }
+
+  /** Get migration files sorted by name */
+  _getMigrationFiles() {
+    try {
+      if (!fs.existsSync(this._dir)) {
+        fs.mkdirSync(this._dir, { recursive: true });
+        return [];
+      }
+      return fs.readdirSync(this._dir)
+        .filter(f => f.endsWith('.js'))
+        .sort();
+    } catch {
+      return [];
+    }
+  }
+
+  /** Ensure migration tracking table exists */
+  async _ensureMigrationTable() {
+    if (this._db._config.driver === 'memory') {
+      if (!this._db._tables.has(this._tableName)) {
+        this._db._tables.set(this._tableName, {
+          schema: { id: 'INTEGER', name: 'TEXT', ran_at: 'DATETIME' },
+          data: [],
+          autoIncrement: 1,
+        });
+      }
+    } else {
+      await this._db.query(`CREATE TABLE IF NOT EXISTS ${this._tableName} (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT NOT NULL,
+        ran_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )`);
+    }
+  }
+
+  /** Get list of completed migrations */
+  async _getCompleted() {
+    if (this._db._config.driver === 'memory') {
+      const table = this._db._tables.get(this._tableName);
+      return table ? table.data.map(r => r.name) : [];
+    }
+    const results = await this._db.query(`SELECT name FROM ${this._tableName} ORDER BY id`);
+    return results.map(r => r.name);
+  }
+
+  /** Mark a migration as completed */
+  async _markCompleted(name) {
+    if (this._db._config.driver === 'memory') {
+      const table = this._db._tables.get(this._tableName);
+      table.data.push({ id: table.autoIncrement++, name, ran_at: new Date().toISOString() });
+    } else {
+      await this._db.query(`INSERT INTO ${this._tableName} (name) VALUES (?)`, [name]);
+    }
+  }
+
+  /** Mark a migration as rolled back */
+  async _markRolledBack(name) {
+    if (this._db._config.driver === 'memory') {
+      const table = this._db._tables.get(this._tableName);
+      table.data = table.data.filter(r => r.name !== name);
+    } else {
+      await this._db.query(`DELETE FROM ${this._tableName} WHERE name = ?`, [name]);
+    }
+  }
+
+  /** Generate a new migration file */
+  static generate(name, migrationsDir) {
+    const dir = migrationsDir || path.join(process.cwd(), 'migrations');
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+
+    const timestamp = new Date().toISOString().replace(/[-:T]/g, '').slice(0, 14);
+    const filename = `${timestamp}_${name}.js`;
+    const filepath = path.join(dir, filename);
+
+    const template = `/**
+ * Migration: ${name}
+ * Created: ${new Date().toISOString()}
+ */
+
+module.exports = {
+  async up(db) {
+    await db.createTable('${name}', {
+      id: { type: 'INTEGER', primary: true, autoIncrement: true },
+      // Add your columns here
+      created_at: 'DATETIME',
+      updated_at: 'DATETIME',
+    });
+  },
+
+  async down(db) {
+    await db.dropTable('${name}');
+  }
+};
+`;
+
+    fs.writeFileSync(filepath, template);
+    console.log(`\x1b[32m  ✓ Created migration: ${filename}\x1b[0m`);
+    return filepath;
+  }
+}
+
+module.exports = { Migration };