mwalajs 1.0.8 → 1.1.0

package/bin/mwala.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-import { execSync } from 'child_process';
+import { spawn } from 'child_process';
 import fs from 'fs';
 import path from 'path';
 import { fileURLToPath, pathToFileURL } from 'url';
@@ -9,19 +9,20 @@ import readlineSync from 'readline-sync';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
+const args = process.argv.slice(2);
+const command = args[0];
+
 // Dynamic imports
 const { getDbConnection } = await import(pathToFileURL(path.join(__dirname, '../config/createdatabase.mjs')).href);
-const { createTable, dropTable, migrateAll, rollbackLastMigration } = await import(pathToFileURL(path.join(__dirname, '../runMigrations.mjs')).href);
 const { setupMwalajs } = await import(pathToFileURL(path.join(__dirname, '../setupMwalajs.mjs')).href);
 const { createProject } = await import(pathToFileURL(path.join(__dirname, '../createProject.mjs')).href);
 
-// Import new DB helpers (we'll define these later)
-const { 
-  listTables, 
-  describeTable, 
-  truncateTable, 
-  renameTable, 
-  backupDatabase, 
+const {
+  listTables,
+  describeTable,
+  truncateTable,
+  renameTable,
+  backupDatabase,
   restoreDatabase,
   seedDatabase,
   showDatabaseSize,
@@ -37,88 +38,74 @@ const {
   showConnections,
   killConnections,
   checkTableExists
-} = await import(pathToFileURL(path.join(__dirname, '../dbUtils.mjs')).href);
-
-const args = process.argv.slice(2);
-const command = args[0];
+} = await import(pathToFileURL(path.join(__dirname, '../utils/dbUtils.mjs')).href);
 
 if (!command || command === 'help' || command === 'h') {
   console.log(`
-    ╔══════════════════════════════════════════════════╗
-    ║              MwalaJS CLI v1.1.0                  ║
-    ╚══════════════════════════════════════════════════╝
-
-  General Commands:
-  - mwala -v | --version       → Show version
-  - mwala help | h             → Show this help
-
-  Project Management:
-  - mwala create-project       → Create new project
-  - mwala init                 → Initialize MwalaJS
-
-  Run Application:
-  - mwala serve | app.mjs      → Start server
-
-  Code Generation:
-  - mwala generate model <name>
-  - mwala generate controller <name>
-  - mwala generate route <name>
-  - mwala generate view <name>
-  - mwala generate midware <name>
-
-  ════════════════════════════════════════════════════
-                  DATABASE COMMANDS
-  ════════════════════════════════════════════════════
-
-  Setup & Config:
-  - mwala create-db                    → Create/connect database (interactive)
-  - mwala db:config                    → Reconfigure .env database settings
-
-  Table Management:
-  - mwala db:table list                → List all tables
-  - mwala db:table create <name>       → Create table
-  - mwala db:table drop <name>         → Drop table
-  - mwala db:table truncate <name>     → Truncate table
-  - mwala db:table rename <old> <new>  → Rename table
-  - mwala db:table copy <src> <dest>   → Copy table structure + data
-  - mwala db:table exists <name>       → Check if table exists
-  - mwala db:table describe <name>     → Show table structure
-  - mwala db:table count <name>        → Count rows in table
-
-  Migrations:
-  - mwala migrate all                  → Run all pending migrations
-  - mwala rollback last                → Rollback last migration
-  - mwala rollback all                 → Rollback all migrations
-
-  Data & Backup:
-  - mwala db:seed <file.js>            → Run seed file
-  - mwala db:backup                    → Backup database
-  - mwala db:restore <file.sql>        → Restore from backup
-  - mwala db:export <table> <file.csv> → Export table to CSV
-  - mwala db:import <file.csv> <table> → Import CSV into table
-
-  Maintenance & Stats:
-  - mwala db:size                      → Show database size
-  - mwala db:indexes <table>           → List indexes on table
-  - mwala db:analyze <table>           → Analyze table (PostgreSQL)
-  - mwala db:reindex <table>           → Rebuild indexes
-  - mwala db:vacuum                    → Vacuum database (SQLite/PostgreSQL)
-  - mwala db:connections               → Show active connections
-  - mwala db:kill-connections          → Kill all other connections (admin)
-  - mwala db:drop-all-tables           → ⚠️ Drop ALL tables (dangerous!)
-
-  Use: mwala <command> [options]
+╔══════════════════════════════════════════════════════════╗
+║                  MwalaJS CLI v1.2.0                     ║
+╚══════════════════════════════════════════════════════════╝
+
+General:
+  mwala -v | --version         → Show version
+  mwala help | h               → Show this help
+
+Project:
+  mwala create-project         → Create new project
+  mwala init                   → Initialize MwalaJS
+
+Run:
+  mwala serve                  → Start the server (runs app.mjs)
+
+Generate:
+  mwala generate model <name>
+  mwala generate controller <name>
+  mwala generate route <name>
+  mwala generate view <name>
+  mwala generate midware <name>
+
+Database Setup:
+  mwala create-db              → Interactive DB setup & creation
+  mwala db:config              → Reconfigure database (.env)
+
+Database Commands:
+  mwala db:table list                          → List all tables
+  mwala db:table describe <name>               → Show table structure
+  mwala db:table count <name>                  → Count rows
+  mwala db:table truncate <name>               → Empty table
+  mwala db:table rename <old> <new>            → Rename table
+  mwala db:table copy <src> <dest>             → Copy table
+  mwala db:table exists <name>                 → Check if exists
+
+  mwala db:backup                              → Backup database
+  mwala db:restore <file.sql>                  → Restore from backup
+  mwala db:size                                → Show database size
+  mwala db:indexes <table>                     → List indexes
+  mwala db:vacuum                              → Optimize (SQLite/PostgreSQL)
+  mwala db:connections                         → Show active connections
+  mwala db:kill-connections                    → Kill other connections (admin)
+  mwala db:drop-all-tables                     →  DROP ALL TABLES!
+
+  mwala db:export <table> <file.csv>           → Export to CSV
+  mwala db:import <file.csv> <table>           → Import from CSV
+  mwala db:seed <seedFile.mjs>                 → Run seed file
+
+Migrations:
+  mwala migrate all                            → Run all migrations
+  mwala rollback last                          → Rollback last migration
+
+Enjoy building with MwalaJS! 
   `);
   process.exit(0);
 }
 
+// ====================== COMMAND SWITCH ======================
 switch (command) {
-
-  case 'version':
   case '-v':
+  case 'version':
   case '--version':
     console.log('MwalaJS Version: 1.1.0');
-    break;
+    process.exit(0);
 
   case 'create-project':
     createProject();
@@ -129,143 +116,178 @@ switch (command) {
     break;
 
   case 'serve':
-  case 'app.mjs':
-    const { spawn } = require('child_process');
-    const child = spawn('node', ['app.mjs'], { stdio: 'inherit', cwd: process.cwd() });
+    const child = spawn('node', ['app.mjs'], {
+      stdio: 'inherit',
+      cwd: process.cwd()
+    });
 
     process.on('SIGINT', () => child.kill('SIGINT'));
     process.on('SIGTERM', () => child.kill('SIGTERM'));
 
-    child.on('exit', (code) => process.exit(code || 0));
+    child.on('exit', (code) => process.exit(code ?? 0));
     child.on('error', (err) => {
       console.error(`Failed to start app: ${err.message}`);
       process.exit(1);
     });
     break;
 
-  case 'generate':
-    // ... (your existing generate logic remains unchanged)
-    // (kept same as before for brevity)
+  case 'generate': {
+    const type = args[1]?.toLowerCase();
+    const name = args[2];
+
+    if (!type || !name) {
+      console.error('Usage: mwala generate <model|controller|route|view|midware> <name>');
+      process.exit(1);
+    }
+
+    const folders = {
+      model: 'models',
+      controller: 'controllers',
+      route: 'routes',
+      view: 'views',
+      midware: 'middlewares'
+    };
+
+    if (!folders[type]) {
+      console.error(`Invalid type. Use: ${Object.keys(folders).join(', ')}`);
+      process.exit(1);
+    }
+
+    const filePath = path.join(process.cwd(), folders[type], `${name}.mjs`);
+
+    if (fs.existsSync(filePath)) {
+      console.error(`${name} ${type} already exists.`);
+      process.exit(1);
+    }
+
+    let content = '';
+    switch (type) {
+      case 'model':
+        content = `export const ${name}Model = {};\n`;
+        break;
+      case 'controller':
+        content = `export const ${name}Controller = {\n  getPage: (req, res) => {\n    res.render('${name}', { title: '${name}' });\n  }\n};\n`;
+        break;
+      case 'route':
+        content = `import mwalajs from 'mwalajs';\nimport { ${name}Controller } from '../controllers/${name}.mjs';\n\nconst router = mwalajs.Router();\nrouter.get('/', ${name}Controller.getPage);\nexport { router as ${name}Route };\n`;
+        break;
+      case 'view':
+        content = `<!DOCTYPE html>\n<html lang="en">\n<head>\n  <meta charset="UTF-8">\n  <title>${name}</title>\n</head>\n<body>\n  <h1>Welcome to ${name} Page</h1>\n</body>\n</html>\n`;
+        break;
+      case 'midware':
+        content = `export const ${name} = (req, res, next) => {\n  next();\n};\n`;
+        break;
+    }
+
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, content);
+    console.log(`✅ ${name} ${type} created at ${folders[type]}/${name}.mjs`);
     break;
+  }
 
-  // ====================== DATABASE COMMANDS ======================
+  // ==================== DATABASE COMMANDS ====================
 
   case 'create-db':
-    getDbConnection().then(() => console.log('✅ Database ready.')).catch(err => {
-      console.error(`❌ Failed: ${err.message}`);
-      process.exit(1);
-    });
+    getDbConnection()
+      .then(() => console.log('✅ Database configured and connected successfully!'))
+      .catch(err => {
+        console.error('❌ Database setup failed:', err.message);
+        process.exit(1);
+      });
     break;
 
   case 'db:config':
-    getDbConnection(); // Re-runs interactive setup
+    getDbConnection();
     break;
 
   case 'db:table':
-    const sub = args[1];
+    const action = args[1];
     const tableName = args[2];
-    const extra = args[3];
+    const extraArg = args[3];
 
-    if (!sub) {
-      console.log('Usage: mwala db:table <list|create|drop|truncate|rename|copy|exists|describe|count> [args]');
+    if (!action) {
+      console.error('Usage: mwala db:table <list|describe|count|truncate|rename|copy|exists> [args]');
       process.exit(1);
     }
 
-    switch (sub) {
+    switch (action) {
       case 'list':
         listTables();
         break;
-      case 'create':
-        if (!tableName) return console.error('Table name required');
-        createTable(tableName);
+      case 'describe':
+        if (!tableName) {
+          console.error('Table name required');
+          process.exit(1);
+        }
+        describeTable(tableName);
         break;
-      case 'drop':
-        if (!tableName) return console.error('Table name required');
-        dropTable(tableName);
+      case 'count':
+        if (!tableName) {
+          console.error('Table name required');
+          process.exit(1);
+        }
+        countRows(tableName);
         break;
       case 'truncate':
-        if (!tableName) return console.error('Table name required');
-        truncateTable(tableName);
+        if (!tableName) {
+          console.error('Table name required');
+          process.exit(1);
+        }
+        if (readlineSync.keyInYN(`Truncate ${tableName}? This cannot be undone.`)) {
+          truncateTable(tableName);
+        }
         break;
       case 'rename':
-        if (!tableName || !extra) return console.error('Usage: rename <old> <new>');
-        renameTable(tableName, extra);
+        if (!tableName || !extraArg) {
+          console.error('Usage: mwala db:table rename <oldName> <newName>');
+          process.exit(1);
+        }
+        renameTable(tableName, extraArg);
         break;
       case 'copy':
-        if (!tableName || !extra) return console.error('Usage: copy <source> <destination>');
-        copyTable(tableName, extra);
+        if (!tableName || !extraArg) {
+          console.error('Usage: mwala db:table copy <source> <destination>');
+          process.exit(1);
+        }
+        copyTable(tableName, extraArg);
         break;
       case 'exists':
-        if (!tableName) return console.error('Table name required');
+        if (!tableName) {
+          console.error('Table name required');
+          process.exit(1);
+        }
         checkTableExists(tableName);
         break;
-      case 'describe':
-        if (!tableName) return console.error('Table name required');
-        describeTable(tableName);
-        break;
-      case 'count':
-        if (!tableName) return console.error('Table name required');
-        countRows(tableName);
-        break;
       default:
-        console.log('Invalid db:table subcommand');
+        console.error(`Unknown db:table action: ${action}`);
+        process.exit(1);
     }
     break;
 
-  case 'migrate':
-    if (args[1] === 'all') migrateAll();
-    else console.error('Use: mwala migrate all');
-    break;
-
-  case 'rollback':
-    if (args[1] === 'last') rollbackLastMigration();
-    else if (args[1] === 'all') dropAllTables(); // or full rollback
-    else console.error('Use: mwala rollback last');
-    break;
-
-  case 'db:seed':
-    if (!args[1]) return console.error('Seed file required');
-    seedDatabase(args[1]);
-    break;
-
   case 'db:backup':
     backupDatabase();
     break;
 
   case 'db:restore':
-    if (!args[1]) return console.error('Backup file required');
+    if (!args[1]) {
+      console.error('Usage: mwala db:restore <backup-file.sql>');
+      process.exit(1);
+    }
     restoreDatabase(args[1]);
     break;
 
-  case 'db:export':
-    if (!args[1] || !args[2]) return console.error('Usage: db:export <table> <file.csv>');
-    exportTableToCsv(args[1], args[2]);
-    break;
-
-  case 'db:import':
-    if (!args[1] || !args[2]) return console.error('Usage: db:import <file.csv> <table>');
-    importCsvToTable(args[1], args[2]);
-    break;
-
   case 'db:size':
     showDatabaseSize();
     break;
 
   case 'db:indexes':
-    if (!args[1]) return console.error('Table name required');
+    if (!args[1]) {
+      console.error('Table name required');
+      process.exit(1);
+    }
     listIndexes(args[1]);
     break;
 
-  case 'db:analyze':
-    if (!args[1]) return console.error('Table name required');
-    analyzeTable(args[1]);
-    break;
-
-  case 'db:reindex':
-    if (!args[1]) return console.error('Table name required');
-    reindexTable(args[1]);
-    break;
-
   case 'db:vacuum':
     vacuumDatabase();
     break;
@@ -275,18 +297,49 @@ switch (command) {
     break;
 
   case 'db:kill-connections':
-    if (readlineSync.keyInYN('⚠️ Kill all other connections?')) {
+    if (readlineSync.keyInYN(' Kill all other database connections?')) {
       killConnections();
+    } else {
+      console.log('Cancelled.');
     }
     break;
 
   case 'db:drop-all-tables':
-    if (readlineSync.keyInYN('⚠️⚠️ This will DROP ALL TABLES! Continue?')) {
-      dropAllTables();
+    if (readlineSync.keyInYN(' DROP ALL TABLES PERMANENTLY? Type YES to confirm:')) {
+      if (readlineSync.question('Type database name to confirm: ') === process.env.DB_NAME) {
+        dropAllTables();
+      } else {
+        console.log('Database name mismatch. Aborted.');
+      }
     }
     break;
 
+  case 'db:export':
+    if (!args[1] || !args[2]) {
+      console.error('Usage: mwala db:export <table> <output.csv>');
+      process.exit(1);
+    }
+    exportTableToCsv(args[1], args[2]);
+    break;
+
+  case 'db:import':
+    if (!args[1] || !args[2]) {
+      console.error('Usage: mwala db:import <input.csv> <table>');
+      process.exit(1);
+    }
+    importCsvToTable(args[1], args[2]);
+    break;
+
+  case 'db:seed':
+    if (!args[1]) {
+      console.error('Usage: mwala db:seed <seedFile.mjs>');
+      process.exit(1);
+    }
+    seedDatabase(args[1]);
+    break;
+
   default:
-    console.error(`Unknown command: ${command}\nRun "mwala help" for list.`);
+    console.error(`Unknown command: ${command}`);
+    console.log('Run "mwala help" for available commands.');
     process.exit(1);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mwalajs",
-  "version": "1.0.8",
+  "version": "1.1.0",
   "description": "MwalaJS Framework CLI Tool and Web Framework for Backend and Frontend Development.",
   "type": "module",
   "main": "app.mjs",

package/utils/dbUtils.mjs

@@ -1,124 +1,517 @@
 import fs from 'fs';
 import path from 'path';
+import { execSync } from 'child_process';
+import { createWriteStream, createReadStream } from 'fs';
+import csv from 'csv-parser';
+import { stringify } from 'csv-stringify';
 import dotenv from 'dotenv';
 import mysql from 'mysql2/promise';
 import { Client } from 'pg';
 import { MongoClient } from 'mongodb';
 import sqlite3 from 'sqlite3';
-import { execSync } from 'child_process';
 import readlineSync from 'readline-sync';
+import { fileURLToPath } from 'url';
 
+// Load .env
 dotenv.config();
 
-const { DB_TYPE, DB_HOST, DB_USER, DB_PASSWORD, DB_NAME } = process.env;
+const { DB_TYPE, DB_HOST = 'localhost', DB_USER, DB_PASSWORD, DB_NAME, DB_PORT } = process.env;
+
+// Helper to check if DB is configured
+const isDbConfigured = () => {
+  return DB_TYPE && DB_NAME && (DB_TYPE === 'sqlite' || (DB_USER && DB_PASSWORD));
+};
+
+const suggestDbSetup = () => {
+  console.log('\n⚠️  Database not configured or connection failed.');
+  console.log('   Run: mwala create-db   → to set up your database interactively');
+  console.log('   Or manually create a .env file with:');
+  console.log('   DB_TYPE=mysql|postgresql|sqlite|mongodb');
+  console.log('   DB_NAME=your_db_name');
+  console.log('   DB_HOST=localhost');
+  console.log('   DB_USER=your_user');
+  console.log('   DB_PASSWORD=your_pass\n');
+};
 
+// Global connection cache
 let connection = null;
 
 const getConnection = async () => {
+  if (!isDbConfigured()) {
+    suggestDbSetup();
+    process.exit(1);
+  }
+
   if (connection) return connection;
 
-  switch (DB_TYPE) {
-    case 'mysql':
+  try {
+    if (DB_TYPE === 'mysql') {
       connection = await mysql.createConnection({
-        host: DB_HOST, user: DB_USER, password: DB_PASSWORD, database: DB_NAME
+        host: DB_HOST,
+        user: DB_USER,
+        password: DB_PASSWORD,
+        database: DB_NAME,
+        port: DB_PORT || 3306
+      });
+    } else if (DB_TYPE === 'postgresql') {
+      connection = new Client({
+        host: DB_HOST,
+        user: DB_USER,
+        password: DB_PASSWORD,
+        database: DB_NAME,
+        port: DB_PORT || 5432
       });
-      break;
-    case 'postgresql':
-      connection = new Client({ host: DB_HOST, user: DB_USER, password: DB_PASSWORD, database: DB_NAME });
       await connection.connect();
-      break;
-    case 'mongodb':
-      connection = await MongoClient.connect(`mongodb://${DB_HOST}:27017/${DB_NAME}`);
-      break;
-    case 'sqlite':
+    } else if (DB_TYPE === 'sqlite') {
       connection = new sqlite3.Database(`./${DB_NAME}.sqlite`);
-      break;
+      connection.serialize();
+    } else if (DB_TYPE === 'mongodb') {
+      const client = await MongoClient.connect(`mongodb://${DB_HOST}:${DB_PORT || 27017}`);
+      connection = client.db(DB_NAME);
+    } else {
+      console.error(' Unsupported DB_TYPE:', DB_TYPE);
+      process.exit(1);
+    }
+  } catch (err) {
+    console.error(' Failed to connect to database:', err.message);
+    suggestDbSetup();
+    process.exit(1);
   }
+
   return connection;
 };
 
+// ====================== IMPLEMENTED COMMANDS ======================
+
 export const listTables = async () => {
   const conn = await getConnection();
+
   if (DB_TYPE === 'mysql') {
     const [rows] = await conn.query('SHOW TABLES');
-    console.log('Tables:', rows.map(r => Object.values(r)[0]));
-  } else if (DB_TYPE === 'postgresql') {
-    const res = await conn.query(`SELECT tablename FROM pg_tables WHERE schemaname = 'public'`);
-    console.log('Tables:', res.rows.map(r => r.tablename));
-  } else if (DB_TYPE === 'sqlite') {
-    conn.all("SELECT name FROM sqlite_master WHERE type='table'", (err, rows) => {
-      console.log('Tables:', rows.map(r => r.name));
+    const tables = rows.map(r => Object.values(r)[0]);
+    console.log('📋 Tables in database:');
+    tables.forEach(t => console.log(`   • ${t}`));
+    if (tables.length === 0) console.log('   (No tables found)');
+  } 
+  else if (DB_TYPE === 'postgresql') {
+    const res = await conn.query("SELECT tablename FROM pg_tables WHERE schemaname = 'public'");
+    console.log('📋 Tables:');
+    res.rows.forEach(r => console.log(`   • ${r.tablename}`));
+  } 
+  else if (DB_TYPE === 'sqlite') {
+    return new Promise((resolve) => {
+      conn.all("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'", (err, rows) => {
+        if (err) return console.error(err.message);
+        console.log('📋 Tables:');
+        rows.forEach(r => console.log(`   • ${r.name}`));
+        if (rows.length === 0) console.log('   (No tables found)');
+        resolve();
+      });
     });
+  } 
+  else if (DB_TYPE === 'mongodb') {
+    const collections = await conn.listCollections().toArray();
+    console.log('📋 Collections:');
+    collections.forEach(c => console.log(`   • ${c.name}`));
   }
 };
 
 export const describeTable = async (table) => {
   const conn = await getConnection();
+
   if (DB_TYPE === 'mysql') {
     const [rows] = await conn.query(`DESCRIBE \`${table}\``);
     console.table(rows);
-  } else if (DB_TYPE === 'postgresql') {
+  } 
+  else if (DB_TYPE === 'postgresql') {
     const res = await conn.query(`
-      SELECT column_name, data_type, is_nullable 
+      SELECT column_name, data_type, is_nullable, column_default
       FROM information_schema.columns 
-      WHERE table_name = $1`, [table]);
+      WHERE table_name = $1
+      ORDER BY ordinal_position
+    `, [table]);
     console.table(res.rows);
+  } 
+  else if (DB_TYPE === 'sqlite') {
+    return new Promise((resolve) => {
+      conn.all(`PRAGMA table_info(\`${table}\`)`, (err, rows) => {
+        if (err) return console.error('Table not found or error:', err.message);
+        console.table(rows);
+        resolve();
+      });
+    });
+  } 
+  else if (DB_TYPE === 'mongodb') {
+    const sample = await conn.collection(table).findOne();
+    if (!sample) {
+      console.log(`Collection "${table}" is empty.`);
+      return;
+    }
+    console.log(`📄 Sample document from "${table}":`);
+    console.dir(sample, { depth: null, colors: true });
+  }
+};
+
+export const countRows = async (table) => {
+  const conn = await getConnection();
+
+  if (DB_TYPE === 'mysql' || DB_TYPE === 'postgresql') {
+    const [res] = await conn.query(`SELECT COUNT(*) AS count FROM \`${table}\``);
+    console.log(`📊 Rows in "${table}": ${res[0].count}`);
+  } 
+  else if (DB_TYPE === 'sqlite') {
+    return new Promise((resolve) => {
+      conn.get(`SELECT COUNT(*) AS count FROM \`${table}\``, (err, row) => {
+        if (err) return console.error(err.message);
+        console.log(`📊 Rows in "${table}": ${row.count}`);
+        resolve();
+      });
+    });
+  } 
+  else if (DB_TYPE === 'mongodb') {
+    const count = await conn.collection(table).estimatedDocumentCount();
+    console.log(`📊 Documents in "${table}": ${count}`);
   }
 };
 
 export const truncateTable = async (table) => {
   const conn = await getConnection();
-  await conn.query(`TRUNCATE TABLE \`${table}\` RESTART IDENTITY CASCADE`);
-  console.log(`Truncated ${table}`);
+
+  if (DB_TYPE === 'mysql') {
+    await conn.query(`TRUNCATE TABLE \`${table}\``);
+  } 
+  else if (DB_TYPE === 'postgresql') {
+    await conn.query(`TRUNCATE TABLE "${table}" RESTART IDENTITY CASCADE`);
+  } 
+  else if (DB_TYPE === 'sqlite') {
+    await new Promise((resolve, reject) => {
+      conn.run(`DELETE FROM \`${table}\``, function(err) {
+        if (err) reject(err);
+        conn.run(`DELETE FROM sqlite_sequence WHERE name='${table}'`, () => resolve());
+      });
+    });
+  } 
+  else if (DB_TYPE === 'mongodb') {
+    await conn.collection(table).deleteMany({});
+  }
+
+  console.log(` "${table}" truncated successfully`);
 };
 
 export const renameTable = async (oldName, newName) => {
   const conn = await getConnection();
-  await conn.query(`RENAME TABLE \`${oldName}\` TO \`${newName}\``);
-  console.log(`Renamed ${oldName} → ${newName}`);
+
+  if (DB_TYPE === 'mysql') {
+    await conn.query(`ALTER TABLE \`${oldName}\` RENAME TO \`${newName}\``);
+  } 
+  else if (DB_TYPE === 'postgresql') {
+    await conn.query(`ALTER TABLE "${oldName}" RENAME TO "${newName}"`);
+  } 
+  else if (DB_TYPE === 'sqlite') {
+    await new Promise((resolve, reject) => {
+      conn.run(`ALTER TABLE \`${oldName}\` RENAME TO \`${newName}\``, err => {
+        err ? reject(err) : resolve();
+      });
+    });
+  } 
+  else if (DB_TYPE === 'mongodb') {
+    await conn.collection(oldName).rename(newName);
+  }
+
+  console.log(` Renamed "${oldName}" → "${newName}"`);
 };
 
-export const backupDatabase = () => {
-  const timestamp = new Date().toISOString().slice(0,19).replace(/:/g, '-');
-  const backupFile = `backup-${DB_NAME}-${timestamp}.sql`;
+export const checkTableExists = async (table) => {
+  const conn = await getConnection();
 
+  let exists = false;
   if (DB_TYPE === 'mysql') {
-    execSync(`mysqldump -h ${DB_HOST} -u ${DB_USER} -p${DB_PASSWORD} ${DB_NAME} > ${backupFile}`);
-  } else if (DB_TYPE === 'postgresql') {
-    execSync(`pg_dump -h ${DB_HOST} -U ${DB_USER} ${DB_NAME} > ${backupFile}`);
+    const [rows] = await conn.query(`SHOW TABLES LIKE '${table}'`);
+    exists = rows.length > 0;
+  } 
+  else if (DB_TYPE === 'postgresql') {
+    const res = await conn.query(`SELECT to_regclass('public.${table}')`);
+    exists = res.rows[0].to_regclass !== null;
+  } 
+  else if (DB_TYPE === 'sqlite') {
+    await new Promise((resolve) => {
+      conn.get(`SELECT name FROM sqlite_master WHERE type='table' AND name='${table}'`, (err, row) => {
+        exists = !!row;
+        resolve();
+      });
+    });
+  } 
+  else if (DB_TYPE === 'mongodb') {
+    const collections = await conn.listCollections({ name: table }).toArray();
+    exists = collections.length > 0;
+  }
+
+  console.log(`Table/collection "${table}" ${exists ? ' exists' : ' does not exist'}`);
+};
+
+export const copyTable = async (source, destination) => {
+  const conn = await getConnection();
+
+  if (DB_TYPE === 'mysql' || DB_TYPE === 'postgresql') {
+    const sql = DB_TYPE === 'mysql'
+      ? `CREATE TABLE \`${destination}\` LIKE \`${source}\`; INSERT INTO \`${destination}\` SELECT * FROM \`${source}\`;`
+      : `CREATE TABLE "${destination}" AS TABLE "${source}" WITH DATA;`;
+    await conn.query(sql);
+  } 
+  else if (DB_TYPE === 'sqlite') {
+    await new Promise((resolve, reject) => {
+      conn.run(`CREATE TABLE \`${destination}\` AS SELECT * FROM \`${source}\``, err => {
+        err ? reject(err) : resolve();
+      });
+    });
+  }
+
+  console.log(` Copied "${source}" → "${destination}"`);
+};
+
+export const backupDatabase = () => {
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const file = `backup-${DB_NAME}-${timestamp}.sql`;
+
+  try {
+    if (DB_TYPE === 'mysql') {
+      execSync(`mysqldump -h ${DB_HOST} -u ${DB_USER} -p${DB_PASSWORD} ${DB_NAME} > "${file}"`);
+    } 
+    else if (DB_TYPE === 'postgresql') {
+      process.env.PGPASSWORD = DB_PASSWORD;
+      execSync(`pg_dump -h ${DB_HOST} -U ${DB_USER} ${DB_NAME} > "${file}"`);
+    } 
+    else if (DB_TYPE === 'sqlite') {
+      fs.copyFileSync(`./${DB_NAME}.sqlite`, file.replace('.sql', '.sqlite'));
+    }
+
+    console.log(` Backup saved: ${file}`);
+  } catch (err) {
+    console.error(' Backup failed:', err.message);
   }
-  console.log(`Backup saved: ${backupFile}`);
 };
 
 export const restoreDatabase = (file) => {
-  if (!fs.existsSync(file)) return console.error('File not found');
+  if (!fs.existsSync(file)) {
+    console.error(' Backup file not found:', file);
+    return;
+  }
+
+  try {
+    if (DB_TYPE === 'mysql') {
+      execSync(`mysql -h ${DB_HOST} -u ${DB_USER} -p${DB_PASSWORD} ${DB_NAME} < "${file}"`);
+    } 
+    else if (DB_TYPE === 'postgresql') {
+      process.env.PGPASSWORD = DB_PASSWORD;
+      execSync(`psql -h ${DB_HOST} -U ${DB_USER} -d ${DB_NAME} -f "${file}"`);
+    } 
+    else if (DB_TYPE === 'sqlite') {
+      fs.copyFileSync(file, `./${DB_NAME}.sqlite`);
+    }
+
+    console.log(' Database restored from:', file);
+  } catch (err) {
+    console.error(' Restore failed:', err.message);
+  }
+};
+
+export const showDatabaseSize = async () => {
+  const conn = await getConnection();
 
   if (DB_TYPE === 'mysql') {
-    execSync(`mysql -h ${DB_HOST} -u ${DB_USER} -p${DB_PASSWORD} ${DB_NAME} < ${file}`);
-  } else if (DB_TYPE === 'postgresql') {
-    execSync(`psql -h ${DB_HOST} -U ${DB_USER} -d ${DB_NAME} -f ${file}`);
-  }
-  console.log('Database restored');
-};
-
-// Add more functions similarly: exportTableToCsv, countRows, etc.
-// (You can expand this file further as needed)
-
-export const showDatabaseSize = () => {
-  console.log(`Size estimation not implemented for ${DB_TYPE} yet.`);
-};
-
-// Placeholder for other commands...
-export const seedDatabase = (file) => console.log(`Seeding from ${file} not yet implemented`);
-export const listIndexes = () => console.log('Indexes list coming soon');
-export const vacuumDatabase = () => console.log('VACUUM executed');
-export const dropAllTables = () => console.log('All tables dropped (dangerous!)');
-export const copyTable = () => console.log('Table copied');
-export const exportTableToCsv = () => console.log('Exported to CSV');
-export const importCsvToTable = () => console.log('Imported CSV');
-export const countRows = () => console.log('Row count shown');
-export const analyzeTable = () => console.log('Table analyzed');
-export const reindexTable = () => console.log('Indexes rebuilt');
-export const showConnections = () => console.log('Active connections listed');
-export const killConnections = () => console.log('Connections killed');
-export const checkTableExists = () => console.log('Table existence checked');
+    const [res] = await conn.query(`
+      SELECT table_schema AS "Database", 
+             ROUND(SUM(data_length + index_length) / 1024 / 1024, 2) AS "Size (MB)" 
+      FROM information_schema.TABLES 
+      WHERE table_schema = '${DB_NAME}'
+      GROUP BY table_schema
+    `);
+    console.table(res);
+  } 
+  else if (DB_TYPE === 'postgresql') {
+    const res = await conn.query(`SELECT pg_size_pretty(pg_database_size('${DB_NAME}')) AS size`);
+    console.log(`Database size: ${res.rows[0].size}`);
+  } 
+  else if (DB_TYPE === 'sqlite') {
+    const stats = fs.statSync(`./${DB_NAME}.sqlite`);
+    console.log(`Database file size: ${(stats.size / 1024 / 1024).toFixed(2)} MB`);
+  } 
+  else if (DB_TYPE === 'mongodb') {
+    const stats = await conn.stats();
+    console.log(`Database size: ${(stats.dataSize / 1024 / 1024).toFixed(2)} MB`);
+  }
+};
+
+export const listIndexes = async (table) => {
+  const conn = await getConnection();
+
+  if (DB_TYPE === 'mysql') {
+    const [rows] = await conn.query(`SHOW INDEX FROM \`${table}\``);
+    console.table(rows);
+  } 
+  else if (DB_TYPE === 'postgresql') {
+    const res = await conn.query(`
+      SELECT indexname, indexdef 
+      FROM pg_indexes 
+      WHERE tablename = $1
+    `, [table]);
+    console.table(res.rows);
+  }
+};
+
+export const vacuumDatabase = async () => {
+  const conn = await getConnection();
+
+  if (DB_TYPE === 'postgresql') {
+    await conn.query('VACUUM ANALYZE');
+    console.log(' VACUUM ANALYZE completed');
+  } 
+  else if (DB_TYPE === 'sqlite') {
+    await new Promise((resolve) => {
+      conn.exec('VACUUM', () => {
+        console.log(' VACUUM completed');
+        resolve();
+      });
+    });
+  } 
+  else {
+    console.log('VACUUM not supported for', DB_TYPE);
+  }
+};
+
+export const showConnections = async () => {
+  const conn = await getConnection();
+
+  if (DB_TYPE === 'postgresql') {
+    const res = await conn.query(`
+      SELECT count(*), state FROM pg_stat_activity 
+      WHERE datname = '${DB_NAME}' 
+      GROUP BY state
+    `);
+    console.table(res.rows);
+  } 
+  else if (DB_TYPE === 'mysql') {
+    const [rows] = await conn.query('SHOW PROCESSLIST');
+    console.log(`Active connections: ${rows.length}`);
+  }
+};
+
+export const killConnections = async () => {
+  const conn = await getConnection();
+
+  if (DB_TYPE === 'postgresql') {
+    await conn.query(`
+      SELECT pg_terminate_backend(pg_stat_activity.pid)
+      FROM pg_stat_activity
+      WHERE pg_stat_activity.datname = '${DB_NAME}' 
+        AND pid <> pg_backend_pid()
+    `);
+    console.log(' All other connections terminated');
+  }
+};
+
+export const dropAllTables = async () => {
+  const conn = await getConnection();
+
+  if (DB_TYPE === 'mysql') {
+    await conn.query('SET FOREIGN_KEY_CHECKS = 0');
+    const [tables] = await conn.query('SHOW TABLES');
+    for (const t of tables) {
+      const tableName = Object.values(t)[0];
+      await conn.query(`DROP TABLE IF EXISTS \`${tableName}\``);
+    }
+    await conn.query('SET FOREIGN_KEY_CHECKS = 1');
+  } 
+  else if (DB_TYPE === 'postgresql') {
+    const res = await conn.query("SELECT tablename FROM pg_tables WHERE schemaname = 'public'");
+    for (const row of res.rows) {
+      await conn.query(`DROP TABLE IF EXISTS "${row.tablename}" CASCADE`);
+    }
+  } 
+  else if (DB_TYPE === 'mongodb') {
+    const collections = await conn.listCollections().toArray();
+    for (const col of collections) {
+      await conn.collection(col.name).drop();
+    }
+  }
+
+  console.log('⚠️ All tables/collections dropped!');
+};
+
+export const exportTableToCsv = async (table, csvFile) => {
+  const conn = await getConnection();
+
+  const writableStream = createWriteStream(csvFile);
+
+  if (DB_TYPE === 'mysql' || DB_TYPE === 'postgresql') {
+    const [rows] = await conn.query(`SELECT * FROM \`${table}\``);
+    const stringifier = stringify({ header: true });
+    stringifier.pipe(writableStream);
+    rows.forEach(row => stringifier.write(row));
+    stringifier.end();
+  } 
+  else if (DB_TYPE === 'sqlite') {
+    await new Promise((resolve) => {
+      conn.all(`SELECT * FROM \`${table}\``, (err, rows) => {
+        const stringifier = stringify({ header: true });
+        stringifier.pipe(writableStream);
+        rows.forEach(row => stringifier.write(row));
+        stringifier.end();
+        resolve();
+      });
+    });
+  }
+
+  console.log(` Exported "${table}" → ${csvFile}`);
+};
+
+export const importCsvToTable = async (csvFile, table) => {
+  if (!fs.existsSync(csvFile)) {
+    console.error('CSV file not found:', csvFile);
+    return;
+  }
+
+  const conn = await getConnection();
+  const results = [];
+
+  createReadStream(csvFile)
+    .pipe(csv())
+    .on('data', (data) => results.push(data))
+    .on('end', async () => {
+      if (results.length === 0) {
+        console.log('No data to import');
+        return;
+      }
+
+      const columns = Object.keys(results[0]).map(c => `\`${c}\``).join(', ');
+      const placeholders = Object.keys(results[0]).map(() => '?').join(', ');
+
+      for (const row of results) {
+        const values = Object.values(row);
+        await conn.query(`INSERT INTO \`${table}\` (${columns}) VALUES (${placeholders})`, values);
+      }
+
+      console.log(` Imported ${results.length} rows into "${table}"`);
+    });
+};
+
+export const seedDatabase = async (seedFile) => {
+  const fullPath = path.resolve(seedFile);
+
+  if (!fs.existsSync(fullPath)) {
+    console.error(' Seed file not found:', fullPath);
+    return;
+  }
+
+  try {
+    const seedModule = await import(`file://${fullPath}`);
+    if (typeof seedModule.default === 'function') {
+      await seedModule.default();
+      console.log(' Seed completed');
+    } else {
+      console.log('Seed file should export a default async function');
+    }
+  } catch (err) {
+    console.error(' Seed failed:', err.message);
+  }
+};