mwalajs 1.1.17 → 1.1.18

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 HEKIMA  MWALA
+Copyright (c) 2026 HEKIMA  MWALA
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/bin/mwala.mjs

@@ -39,7 +39,24 @@ const __dirname = path.dirname(__filename);
 // ────────────────────────────────────────────────
 
 let imports = {};
-let setupMwalajs, createProject, dropAllTables, getDbConnection;
+// let setupMwalajs, createProject, dropAllTables, getDbConnection;
+let {
+  setupMwalajs,
+  createProject,
+  dropAllTables,
+  getDbConnection,
+  listTables,
+  createTable,
+  dropTable,
+  migrateAll,
+  rollbackLastMigration,
+showDatabaseSize,
+  listIndexes,
+  analyzeTable,
+  vacuumDatabase,
+  showConnections,
+  killConnections,
+} = imports;
 
 try {
   const [
@@ -48,6 +65,7 @@ try {
     setup,
     proj,
     dbUtilsRaw,
+    maintenance,
   ] = await Promise.all([
     import(pathToFileURL(path.join(__dirname, '../config/createdatabase.mjs')).href),
     import(pathToFileURL(path.join(__dirname, '../runMigrations.mjs')).href),
@@ -64,16 +82,31 @@ try {
     ...normalize(setup),
     ...normalize(proj),
     ...normalize(dbUtilsRaw),
+    ...normalize(maintenance),     // ← important
   };
 
   // 🔥 IMPORTANT FIX
-  ({
-    setupMwalajs,
-    createProject,
-    dropAllTables,
-    getDbConnection
-  } = imports);
-
+({
+  setupMwalajs,
+  createProject,
+  dropAllTables,
+  getDbConnection,
+  listTables,
+  createTable,
+  dropTable,
+  migrateAll,
+  rollbackLastMigration,
+  // ongeza hizi zingine ukizihitaji baadaye
+  showDatabaseSize,
+  listIndexes,
+  analyzeTable,
+  vacuumDatabase,
+  showConnections,
+  killConnections,
+  // n.k.
+} = imports);
+
+  
 } catch (err) {
   error(`Failed to load required modules:\n${err.stack || err.message}`);
   process.exit(1);
@@ -596,38 +629,67 @@ case 'db:restore': {
 }
 
 
+      // case 'db:size':
+      //   await runSafe(showDatabaseSize, 'Database size shown');
+      //   break;
+
+      // case 'db:indexes':
+      //   if (!args[1]) return error('Table name required');
+      //   await runSafe(() => listIndexes(args[1]), `Indexes for ${args[1]}`);
+      //   break;
+
+      // case 'db:analyze':
+      //   if (!args[1]) return error('Table name required');
+      //   await runSafe(() => analyzeTable(args[1]), `Table ${args[1]} analyzed`);
+      //   break;
+
+      // case 'db:reindex':
+      //   if (!args[1]) return error('Table name required');
+      //   await runSafe(() => reindexTable(args[1]), `Table ${args[1]} reindexed`);
+      //   break;
+
+      // case 'db:vacuum':
+      //   await runSafe(vacuumDatabase, 'Database vacuumed');
+      //   break;
+
+      // case 'db:connections':
+      //   await runSafe(showConnections, 'Active connections shown');
+      //   break;
+
+
       case 'db:size':
-        await runSafe(showDatabaseSize, 'Database size shown');
-        break;
+  await runSafe(() => imports.showDatabaseSize(), 'Database size shown');
+  break;
 
-      case 'db:indexes':
-        if (!args[1]) return error('Table name required');
-        await runSafe(() => listIndexes(args[1]), `Indexes for ${args[1]}`);
-        break;
+case 'db:indexes':
+  if (!args[1]) return error('Table name required: mwala db:indexes <table>');
+  await runSafe(() => imports.listIndexes(args[1]), `Indexes for ${args[1]}`);
+  break;
 
-      case 'db:analyze':
-        if (!args[1]) return error('Table name required');
-        await runSafe(() => analyzeTable(args[1]), `Table ${args[1]} analyzed`);
-        break;
+case 'db:analyze':
+  if (!args[1]) return error('Table name required');
+  await runSafe(() => imports.analyzeTable(args[1]), `Table ${args[1]} analyzed`);
+  break;
 
-      case 'db:reindex':
-        if (!args[1]) return error('Table name required');
-        await runSafe(() => reindexTable(args[1]), `Table ${args[1]} reindexed`);
-        break;
+case 'db:vacuum':
+  await runSafe(() => imports.vacuumDatabase(), 'Database vacuumed');
+  break;
 
-      case 'db:vacuum':
-        await runSafe(vacuumDatabase, 'Database vacuumed');
-        break;
+case 'db:connections':
+  await runSafe(() => imports.showConnections(), 'Active connections shown');
+  break;
 
-      case 'db:connections':
-        await runSafe(showConnections, 'Active connections shown');
-        break;
+case 'db:kill-connections':
+  if (readlineSync.keyInYNStrict('⚠️ Kill ALL other database connections? (hatari!)')) {
+    await runSafe(() => imports.killConnections(), 'Other connections killed');
+  }
+  break;
 
-      case 'db:kill-connections':
-        if (readlineSync.keyInYNStrict('⚠️  Kill ALL other database connections?')) {
-          await runSafe(killConnections, 'Other connections killed');
-        }
-        break;
+      // case 'db:kill-connections':
+      //   if (readlineSync.keyInYNStrict('⚠️  Kill ALL other database connections?')) {
+      //     await runSafe(killConnections, 'Other connections killed');
+      //   }
+      //   break;
 
       case 'db:drop-all-tables':
         if (readlineSync.keyInYNStrict('⚠️⚠️  THIS WILL DROP **ALL** TABLES! Continue?')) {

package/package.json

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

package/runMigrations.mjs

@@ -1,3 +1,5 @@
+// runMigrations.mjs
+
 import fs from 'fs';
 import path from 'path';
 import readline from 'readline';
@@ -134,6 +136,38 @@ export const listTables = async () => {
   }
 };
 
+
+export const dropAllTables = async () => {
+  try {
+    const tables = await sequelize.getQueryInterface().showAllTables();
+    
+    if (tables.length === 0) {
+      console.log('No tables exist in the database.');
+      return;
+    }
+
+    console.log(`Dropping ${tables.length} table(s): ${tables.join(', ')}`);
+
+    // Drop in reverse order to respect foreign key dependencies if any
+    for (const table of tables.reverse()) {
+      await sequelize.getQueryInterface().dropTable(table, { cascade: true });
+      console.log(`  Dropped: ${table}`);
+    }
+
+    // Clear the migration tracking file so future migrates start clean
+    fs.writeFileSync(migrationLog, JSON.stringify([]));
+    console.log('Migration log cleared – ready for fresh migrations.');
+
+  } catch (error) {
+    console.error('Error while dropping all tables:', error.message);
+    if (error.stack) console.error(error.stack);
+    throw error; // let runSafe show the full error
+  }
+};
+
+
+
+
 const askUser = (question) => {
   return new Promise((resolve) => {
     const rl = readline.createInterface({
@@ -146,3 +180,112 @@ const askUser = (question) => {
     });
   });
 };
+
+
+
+// ────────────────────────────────────────────────
+// MAINTENANCE TOOLS (MariaDB / MySQL compatible)
+// ────────────────────────────────────────────────
+
+export const showDatabaseSize = async () => {
+  const dbName = sequelize.getDatabaseName(); // au tumia sequelize.config.database kama haifanyi kazi
+  const [results] = await sequelize.query(`
+    SELECT 
+      ROUND(SUM(data_length + index_length) / 1024 / 1024, 2) AS size_mb
+    FROM information_schema.tables 
+    WHERE table_schema = '${dbName}'
+  `);
+
+  const size = results[0]?.size_mb || '0.00';
+  console.log(`Database size: ${size} MB`);
+};
+
+export const listIndexes = async (tableName) => {
+  const dbName = sequelize.getDatabaseName();
+  const [results] = await sequelize.query(`
+    SHOW INDEXES FROM \`${tableName}\`
+  `);
+
+  if (results.length === 0) {
+    console.log(`Hakuna indexes kwenye table "${tableName}".`);
+    return;
+  }
+
+  console.log(`Indexes kwenye "${tableName}":`);
+  results.forEach(row => {
+    const unique = row.Non_unique === 0 ? 'UNIQUE' : 'NON-UNIQUE';
+    console.log(`  • ${row.Key_name.padEnd(35)} → ${unique} | Column: ${row.Column_name} | Type: ${row.Index_type}`);
+  });
+};
+
+export const analyzeTable = async (tableName) => {
+  await sequelize.query(`ANALYZE TABLE \`${tableName}\`;`);
+  console.log(`Table "${tableName}" ime-analyze (statistics zime-update).`);
+};
+
+export const vacuumDatabase = async () => {
+  // MySQL/MariaDB haina VACUUM kama PostgreSQL, lakini tunaweza optimize tables zote
+  const dbName = sequelize.getDatabaseName();
+  const [tables] = await sequelize.query(`
+    SELECT table_name 
+    FROM information_schema.tables 
+    WHERE table_schema = '${dbName}' 
+      AND table_type = 'BASE TABLE'
+  `);
+
+  if (tables.length === 0) {
+    console.log('Hakuna tables za ku-optimize.');
+    return;
+  }
+
+  console.log(`Optimizing ${tables.length} table(s)...`);
+  for (const row of tables) {
+    const table = row.table_name;
+    await sequelize.query(`OPTIMIZE TABLE \`${table}\`;`);
+    console.log(`  Optimized: ${table}`);
+  }
+  console.log('Optimization imekamilika (space reclaimed na stats updated).');
+};
+
+export const showConnections = async () => {
+  const [results] = await sequelize.query(`
+    SHOW PROCESSLIST
+  `);
+
+  const active = results.filter(row => row.Command !== 'Sleep' && row.Id !== 0); // exclude idle + our connection
+
+  if (active.length === 0) {
+    console.log('Hakuna connections zingine active (isipokuwa yako).');
+    return;
+  }
+
+  console.log(`Active connections (${active.length}):`);
+  active.forEach(r => {
+    const querySnippet = r.Info ? r.Info.substring(0, 60) + '...' : '(idle)';
+    console.log(`  ID ${r.Id} | User: ${r.User} | Host: ${r.Host} | State: ${r.State} | Query: ${querySnippet}`);
+  });
+};
+
+export const killConnections = async () => {
+  const [results] = await sequelize.query(`
+    SHOW PROCESSLIST
+  `);
+
+  const toKill = results.filter(row => row.Id !== 0 && row.Command !== 'Sleep'); // exclude our connection + idle
+
+  if (toKill.length === 0) {
+    console.log('Hakuna connections za ku-kill.');
+    return;
+  }
+
+  console.log(`Killing ${toKill.length} connection(s)...`);
+  for (const row of toKill) {
+    try {
+      await sequelize.query(`KILL ${row.Id};`);
+      console.log(`  Killed ID ${row.Id}`);
+    } catch (e) {
+      console.warn(`  Failed to kill ${row.Id}: ${e.message}`);
+    }
+  }
+  console.log('Kill operation imekamilika.');
+};