mwalajs 1.0.9 → 1.1.0

package/bin/mwala.mjs

@@ -43,7 +43,7 @@ const {
 if (!command || command === 'help' || command === 'h') {
   console.log(`
 ╔══════════════════════════════════════════════════════════╗
-║                  MwalaJS CLI v1.1.0                      ║
+║                  MwalaJS CLI v1.2.0                     ║
 ╚══════════════════════════════════════════════════════════╝
 
 General:
@@ -84,7 +84,7 @@ Database Commands:
   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:drop-all-tables                     →  DROP ALL TABLES!
 
   mwala db:export <table> <file.csv>           → Export to CSV
   mwala db:import <file.csv> <table>           → Import from CSV
@@ -94,7 +94,7 @@ Migrations:
   mwala migrate all                            → Run all migrations
   mwala rollback last                          → Rollback last migration
 
-Enjoy building with MwalaJS! 🚀
+Enjoy building with MwalaJS! 
   `);
   process.exit(0);
 }
@@ -297,7 +297,7 @@ switch (command) {
     break;
 
   case 'db:kill-connections':
-    if (readlineSync.keyInYN('⚠️ Kill all other database connections?')) {
+    if (readlineSync.keyInYN(' Kill all other database connections?')) {
       killConnections();
     } else {
       console.log('Cancelled.');
@@ -305,7 +305,7 @@ switch (command) {
     break;
 
   case 'db:drop-all-tables':
-    if (readlineSync.keyInYN('⚠️⚠️⚠️ DROP ALL TABLES PERMANENTLY? Type YES to confirm:')) {
+    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 {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mwalajs",
-  "version": "1.0.9",
+  "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,97 +1,272 @@
 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 readlineSync from 'readline-sync';
+import { fileURLToPath } from 'url';
 
+// Load .env
 dotenv.config();
 
-const { DB_TYPE, DB_HOST = 'localhost', DB_USER, DB_PASSWORD, DB_NAME } = process.env;
+const { DB_TYPE, DB_HOST = 'localhost', DB_USER, DB_PASSWORD, DB_NAME, DB_PORT } = process.env;
 
-let conn = null;
+// 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 getConn = async () => {
-  if (conn) return conn;
+const getConnection = async () => {
+  if (!isDbConfigured()) {
+    suggestDbSetup();
+    process.exit(1);
+  }
+
+  if (connection) return connection;
 
   try {
     if (DB_TYPE === 'mysql') {
-      conn = await mysql.createConnection({
+      connection = await mysql.createConnection({
         host: DB_HOST,
         user: DB_USER,
         password: DB_PASSWORD,
-        database: DB_NAME
+        database: DB_NAME,
+        port: DB_PORT || 3306
       });
     } else if (DB_TYPE === 'postgresql') {
-      conn = new Client({
+      connection = new Client({
         host: DB_HOST,
         user: DB_USER,
         password: DB_PASSWORD,
-        database: DB_NAME
+        database: DB_NAME,
+        port: DB_PORT || 5432
       });
-      await conn.connect();
+      await connection.connect();
     } else if (DB_TYPE === 'sqlite') {
-      conn = new sqlite3.Database(`./${DB_NAME}.sqlite`);
+      connection = new sqlite3.Database(`./${DB_NAME}.sqlite`);
+      connection.serialize();
     } else if (DB_TYPE === 'mongodb') {
-      conn = await MongoClient.connect(`mongodb://${DB_HOST}:27017`);
-      conn = conn.db(DB_NAME);
+      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('Connection failed:', err.message);
+    console.error(' Failed to connect to database:', err.message);
+    suggestDbSetup();
     process.exit(1);
   }
 
-  return conn;
+  return connection;
 };
 
+// ====================== IMPLEMENTED COMMANDS ======================
+
 export const listTables = async () => {
-  const connection = await getConn();
+  const conn = await getConnection();
+
   if (DB_TYPE === 'mysql') {
-    const [rows] = await connection.query('SHOW TABLES');
-    console.log('Tables:\n', rows.map(r => Object.values(r)[0]).join('\n'));
-  } else if (DB_TYPE === 'postgresql') {
-    const res = await connection.query("SELECT tablename FROM pg_tables WHERE schemaname = 'public'");
-    console.log('Tables:\n', res.rows.map(r => r.tablename).join('\n'));
-  } else if (DB_TYPE === 'sqlite') {
-    connection.all("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'", (_, rows) => {
-      console.log('Tables:\n', rows.map(r => r.name).join('\n'));
+    const [rows] = await conn.query('SHOW TABLES');
+    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 connection = await getConn();
+  const conn = await getConnection();
+
   if (DB_TYPE === 'mysql') {
-    const [rows] = await connection.query(`DESCRIBE \`${table}\``);
+    const [rows] = await conn.query(`DESCRIBE \`${table}\``);
     console.table(rows);
-  } else if (DB_TYPE === 'postgresql') {
-    const res = await connection.query(`
+  } 
+  else if (DB_TYPE === 'postgresql') {
+    const res = await conn.query(`
       SELECT column_name, data_type, is_nullable, column_default
-      FROM information_schema.columns WHERE table_name = $1
+      FROM information_schema.columns 
+      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 connection = await getConn();
-  const [res] = await connection.query(`SELECT COUNT(*) AS count FROM \`${table}\``);
-  console.log(`Rows in ${table}: ${res[0].count}`);
+  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 connection = await getConn();
-  await connection.query(`TRUNCATE TABLE \`${table}\` RESTART IDENTITY CASCADE`);
-  console.log(`✅ ${table} truncated`);
+  const conn = await getConnection();
+
+  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 connection = await getConn();
-  await connection.query(`ALTER TABLE \`${oldName}\` RENAME TO \`${newName}\``);
-  console.log(`Renamed ${oldName} → ${newName}`);
+  const conn = await getConnection();
+
+  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 checkTableExists = async (table) => {
+  const conn = await getConnection();
+
+  let exists = false;
+  if (DB_TYPE === 'mysql') {
+    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 = () => {
@@ -100,51 +275,243 @@ export const backupDatabase = () => {
 
   try {
     if (DB_TYPE === 'mysql') {
-      execSync(`mysqldump -h ${DB_HOST} -u ${DB_USER} -p${DB_PASSWORD} ${DB_NAME} > ${file}`);
-    } else if (DB_TYPE === 'postgresql') {
+      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}`);
+      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}`);
+
+    console.log(` Backup saved: ${file}`);
   } catch (err) {
-    console.error('Backup failed:', err.message);
+    console.error(' Backup failed:', err.message);
   }
 };
 
 export const restoreDatabase = (file) => {
   if (!fs.existsSync(file)) {
-    console.error('Backup file not found');
+    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') {
+      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}`);
+      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');
+
+    console.log(' Database restored from:', file);
   } catch (err) {
-    console.error('Restore failed:', err.message);
-  }
-};
-
-export const showDatabaseSize = () => console.log(`Size info not implemented for ${DB_TYPE} yet`);
-export const listIndexes = () => console.log('Indexes list coming soon');
-export const vacuumDatabase = () => console.log('VACUUM/optimize not implemented yet');
-export const showConnections = () => console.log('Connections list not implemented');
-export const killConnections = () => console.log('Kill connections not implemented');
-export const dropAllTables = () => console.log('Drop all tables not implemented (too dangerous without confirmation logic)');
-export const copyTable = () => console.log('Copy table not implemented');
-export const exportTableToCsv = () => console.log('CSV export not implemented');
-export const importCsvToTable = () => console.log('CSV import not implemented');
-export const seedDatabase = (file) => {
-  if (fs.existsSync(file)) {
-    import(pathToFileURL(path.resolve(file)).href).then(mod => {
-      console.log('Seed executed');
+    console.error(' Restore failed:', err.message);
+  }
+};
+
+export const showDatabaseSize = async () => {
+  const conn = await getConnection();
+
+  if (DB_TYPE === 'mysql') {
+    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();
+      });
     });
-  } else {
-    console.error('Seed file not found');
   }
+
+  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 checkTableExists = () => console.log('Check exists not implemented');
+
+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);
+  }
+};