mwalajs 1.0.8 → 1.0.9

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.1.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.0.9",
   "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,150 @@
 import fs from 'fs';
 import path from 'path';
+import { execSync } from 'child_process';
 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';
 
 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 } = process.env;
 
-let connection = null;
+let conn = null;
 
-const getConnection = async () => {
-  if (connection) return connection;
+const getConn = async () => {
+  if (conn) return conn;
 
-  switch (DB_TYPE) {
-    case 'mysql':
-      connection = await mysql.createConnection({
-        host: DB_HOST, user: DB_USER, password: DB_PASSWORD, database: DB_NAME
+  try {
+    if (DB_TYPE === 'mysql') {
+      conn = await mysql.createConnection({
+        host: DB_HOST,
+        user: DB_USER,
+        password: DB_PASSWORD,
+        database: DB_NAME
+      });
+    } else if (DB_TYPE === 'postgresql') {
+      conn = new Client({
+        host: DB_HOST,
+        user: DB_USER,
+        password: DB_PASSWORD,
+        database: DB_NAME
       });
-      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':
-      connection = new sqlite3.Database(`./${DB_NAME}.sqlite`);
-      break;
+      await conn.connect();
+    } else if (DB_TYPE === 'sqlite') {
+      conn = new sqlite3.Database(`./${DB_NAME}.sqlite`);
+    } else if (DB_TYPE === 'mongodb') {
+      conn = await MongoClient.connect(`mongodb://${DB_HOST}:27017`);
+      conn = conn.db(DB_NAME);
+    }
+  } catch (err) {
+    console.error('Connection failed:', err.message);
+    process.exit(1);
   }
-  return connection;
+
+  return conn;
 };
 
 export const listTables = async () => {
-  const conn = await getConnection();
+  const connection = await getConn();
   if (DB_TYPE === 'mysql') {
-    const [rows] = await conn.query('SHOW TABLES');
-    console.log('Tables:', rows.map(r => Object.values(r)[0]));
+    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 conn.query(`SELECT tablename FROM pg_tables WHERE schemaname = 'public'`);
-    console.log('Tables:', res.rows.map(r => r.tablename));
+    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') {
-    conn.all("SELECT name FROM sqlite_master WHERE type='table'", (err, rows) => {
-      console.log('Tables:', rows.map(r => r.name));
+    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'));
     });
   }
 };
 
 export const describeTable = async (table) => {
-  const conn = await getConnection();
+  const connection = await getConn();
   if (DB_TYPE === 'mysql') {
-    const [rows] = await conn.query(`DESCRIBE \`${table}\``);
+    const [rows] = await connection.query(`DESCRIBE \`${table}\``);
     console.table(rows);
   } else if (DB_TYPE === 'postgresql') {
-    const res = await conn.query(`
-      SELECT column_name, data_type, is_nullable 
-      FROM information_schema.columns 
-      WHERE table_name = $1`, [table]);
+    const res = await connection.query(`
+      SELECT column_name, data_type, is_nullable, column_default
+      FROM information_schema.columns WHERE table_name = $1
+    `, [table]);
     console.table(res.rows);
   }
 };
 
+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}`);
+};
+
 export const truncateTable = async (table) => {
-  const conn = await getConnection();
-  await conn.query(`TRUNCATE TABLE \`${table}\` RESTART IDENTITY CASCADE`);
-  console.log(`Truncated ${table}`);
+  const connection = await getConn();
+  await connection.query(`TRUNCATE TABLE \`${table}\` RESTART IDENTITY CASCADE`);
+  console.log(`✅ ${table} truncated`);
 };
 
 export const renameTable = async (oldName, newName) => {
-  const conn = await getConnection();
-  await conn.query(`RENAME TABLE \`${oldName}\` TO \`${newName}\``);
+  const connection = await getConn();
+  await connection.query(`ALTER TABLE \`${oldName}\` RENAME TO \`${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`;
-
-  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 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}`);
+    }
+    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 (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}`);
+  if (!fs.existsSync(file)) {
+    console.error('Backup file not found');
+    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}`);
+    }
+    console.log('✅ Database restored');
+  } catch (err) {
+    console.error('Restore failed:', err.message);
   }
-  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 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 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');
+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');
+    });
+  } else {
+    console.error('Seed file not found');
+  }
+};
+export const checkTableExists = () => console.log('Check exists not implemented');