mwalajs 1.0.7 → 1.0.9

package/config/createdatabase copy.mjs

@@ -0,0 +1,362 @@
+import fs from 'fs';
+import readlineSync from 'readline-sync';
+import mysql from 'mysql2/promise';
+import { MongoClient } from 'mongodb';
+import sqlite3 from 'sqlite3';
+import pkg from 'pg';
+import dotenv from 'dotenv';
+
+const { Client } = pkg;
+
+/* -----------------------------------------------------------
+   NEW FUNCTION: CREATE BACKUP OF .ENV BEFORE DELETE
+----------------------------------------------------------- */
+const backupEnvFile = () => {
+  try {
+    if (!fs.existsSync('.env')) {
+      console.log(' ⚠️ No .env file found to backup.');
+      return;
+    }
+
+    const timestamp = new Date()
+      .toISOString()
+      .replace(/[:.]/g, '-'); // safe filename
+
+    const backupName = `.env.backup-${timestamp}`;
+
+    fs.copyFileSync('.env', backupName);
+
+    console.log(` 📦 Backup created: ${backupName}`);
+  } catch (error) {
+    console.error(' ❌ Failed to create .env backup:', error.message);
+  }
+};
+
+/* -----------------------------------------------------------
+   RESET ENV FILE
+----------------------------------------------------------- */
+const resetEnvFile = () => {
+  try {
+    fs.writeFileSync('.env', '', 'utf8');
+    console.log(' 🧹 Cleared .env file.');
+  } catch (error) {
+    console.error(' ❌ Failed to clear .env file:', error.message);
+  }
+};
+
+/* -----------------------------------------------------------
+   WRITE DATA TO .ENV
+----------------------------------------------------------- */
+const writeToEnv = (data) => {
+  const envContent = Object.keys(data)
+    .map(key => `${key}=${data[key]}`)
+    .join('\n');
+
+  fs.writeFileSync('.env', envContent, 'utf8');
+};
+
+/* -----------------------------------------------------------
+   MAIN FUNCTION: CREATE/CONNECT DATABASE
+----------------------------------------------------------- */
+export const getDbConnection = async () => {
+
+  // 🔥 FIRST CREATE BACKUP
+  backupEnvFile();
+
+  // 🔥 THEN CLEAR OLD ENV
+  resetEnvFile();
+
+  // Reload environment
+  dotenv.config();
+
+  const supportedDbTypes = {
+    mysql: 'mysql',
+    my: 'mysql',
+    postgresql: 'postgresql',
+    pg: 'postgresql',
+    mongodb: 'mongodb',
+    mn: 'mongodb',
+    sqlite: 'sqlite',
+    sq: 'sqlite'
+  };
+
+  let dbType;
+  while (true) {
+    dbType = readlineSync.question(
+      'Enter DB type (mysql/my, postgresql/pg, mongodb/mn, sqlite/sq): '
+    ).toLowerCase();
+
+    if (supportedDbTypes[dbType]) {
+      dbType = supportedDbTypes[dbType];
+      break;
+    } else {
+      console.log(' ❌ Invalid database type. Try again.');
+    }
+  }
+
+  const dbName = readlineSync.question('Enter the database name: ').trim();
+  if (!dbName) {
+    console.log(' ❌ Database name cannot be empty.');
+    return;
+  }
+
+  let dbHost = 'localhost';
+  let dbUser = '';
+  let dbPassword = '';
+
+  if (dbType !== 'sqlite') {
+    dbHost = readlineSync.question('Enter DB host (default: localhost): ') || 'localhost';
+    dbUser = readlineSync.question('Enter DB user: ').trim();
+    dbPassword = readlineSync.question('Enter DB password: ', { hideEchoBack: true }).trim();
+  }
+
+  const envData = {
+    DB_TYPE: dbType,
+    DB_NAME: dbName,
+    DB_HOST: dbHost,
+    DB_USER: dbUser,
+    DB_PASSWORD: dbPassword
+  };
+
+  writeToEnv(envData);
+  console.log('  Database credentials saved to .env');
+
+  let connection;
+
+  try {
+    /* -------------------- MYSQL -------------------- */
+    if (dbType === 'mysql') {
+      const tempConnection = await mysql.createConnection({
+        host: dbHost,
+        user: dbUser,
+        password: dbPassword
+      });
+
+      const [rows] = await tempConnection.query(`SHOW DATABASES LIKE '${dbName}'`);
+      if (rows.length === 0) {
+        await tempConnection.query(`CREATE DATABASE \`${dbName}\``);
+        console.log(`  MySQL database "${dbName}" created.`);
+      } else {
+        console.log(`  MySQL database "${dbName}" already exists.`);
+      }
+
+      connection = await mysql.createConnection({
+        host: dbHost,
+        user: dbUser,
+        password: dbPassword,
+        database: dbName
+      });
+
+      await tempConnection.end();
+    }
+
+    /* -------------------- POSTGRESQL -------------------- */
+    else if (dbType === 'postgresql') {
+      const tempClient = new Client({
+        host: dbHost,
+        user: dbUser,
+        password: dbPassword
+      });
+
+      await tempClient.connect();
+
+      const checkDb = await tempClient.query(
+        `SELECT datname FROM pg_database WHERE datname = '${dbName}'`
+      );
+
+      if (checkDb.rows.length === 0) {
+        await tempClient.query(`CREATE DATABASE ${dbName}`);
+        console.log(`  PostgreSQL database "${dbName}" created.`);
+      } else {
+        console.log(`  PostgreSQL database "${dbName}" already exists.`);
+      }
+
+      await tempClient.end();
+
+      connection = new Client({
+        host: dbHost,
+        user: dbUser,
+        password: dbPassword,
+        database: dbName
+      });
+
+      await connection.connect();
+    }
+
+    /* -------------------- MONGODB -------------------- */
+    else if (dbType === 'mongodb') {
+      connection = await MongoClient.connect(`mongodb://${dbHost}:27017`);
+      console.log(`  MongoDB connected.`);
+    }
+
+    /* -------------------- SQLITE -------------------- */
+    else if (dbType === 'sqlite') {
+      connection = new sqlite3.Database(`./${dbName}.sqlite`);
+      console.log(`  SQLite database "${dbName}.sqlite" ready.`);
+    }
+
+  } catch (error) {
+    console.error(` ❌ Failed to create database: ${error.message}`);
+    return;
+  }
+
+  return connection;
+};
+
+// import fs from 'fs';
+// import readlineSync from 'readline-sync';
+// import mysql from 'mysql2/promise';
+// import { MongoClient } from 'mongodb';
+// import sqlite3 from 'sqlite3';
+// import pkg from 'pg';
+// import dotenv from 'dotenv';
+
+// const { Client } = pkg;
+
+// // Function to reset the .env file before processing
+// const resetEnvFile = () => {
+//   try {
+//     fs.writeFileSync('.env', '', 'utf8'); // Empty the .env file
+//     console.log(' Cleared .env file.');
+//   } catch (error) {
+//     console.error(' Failed to clear .env file:', error.message);
+//   }
+// };
+
+// // Function to write data to the .env file
+// const writeToEnv = (data) => {
+//   const envContent = Object.keys(data)
+//     .map(key => `${key}=${data[key]}`)
+//     .join('\n');
+
+//   fs.writeFileSync('.env', envContent, 'utf8');
+// };
+
+
+// // Function to create the database connection
+// export const getDbConnection = async () => {
+//   resetEnvFile(); // Clear .env file before proceeding
+
+//   dotenv.config(); // Reload the (now empty) .env file
+
+//   // Supported database types
+//   const supportedDbTypes = {
+//     mysql: 'mysql',
+//     my: 'mysql',
+//     postgresql: 'postgresql',
+//     pg: 'postgresql',
+//     mongodb: 'mongodb',
+//     mn: 'mongodb',
+//     sqlite: 'sqlite',
+//     sq: 'sqlite'
+//   };
+
+//   let dbType;
+//   while (true) {
+//     dbType = readlineSync.question('Enter the database type (mysql/my, postgresql/pg, mongodb/mn, sqlite/sq): ').toLowerCase();
+//     if (supportedDbTypes[dbType]) {
+//       dbType = supportedDbTypes[dbType]; // Normalize input
+//       break;
+//     } else {
+//       console.log('❌ Invalid database type. Please enter a valid option.');
+//     }
+//   }
+
+//   // Prompt for database details
+//   const dbName = readlineSync.question('Enter the database name: ').trim();
+//   if (!dbName) {
+//     console.log(' Database name cannot be empty.');
+//     return;
+//   }
+
+//   let dbHost = 'localhost';
+//   let dbUser = '';
+//   let dbPassword = '';
+
+//   if (dbType !== 'sqlite') {
+//     dbHost = readlineSync.question('Enter the database host (default: localhost): ') || 'localhost';
+//     dbUser = readlineSync.question('Enter the database user: ').trim();
+//     dbPassword = readlineSync.question('Enter the database password: ', { hideEchoBack: true }).trim();
+//   }
+
+//   // Save valid details to .env
+//   const envData = {
+//     DB_TYPE: dbType,
+//     DB_NAME: dbName,
+//     DB_HOST: dbHost,
+//     DB_USER: dbUser,
+//     DB_PASSWORD: dbPassword,
+//   };
+
+//   writeToEnv(envData);
+//   console.log(' Database credentials saved to .env file.');
+
+//   let connection;
+
+//   try {
+//     if (dbType === 'mysql') {
+//       const tempConnection = await mysql.createConnection({
+//         host: dbHost,
+//         user: dbUser,
+//         password: dbPassword,
+//       });
+
+//       const [rows] = await tempConnection.query(`SHOW DATABASES LIKE '${dbName}'`);
+//       if (rows.length === 0) {
+//         await tempConnection.query(`CREATE DATABASE \`${dbName}\``);
+//         console.log(` MySQL Database "${dbName}" created successfully.`);
+//       } else {
+//         console.log(` MySQL Database "${dbName}" already exists.`);
+//       }
+
+//       connection = await mysql.createConnection({
+//         host: dbHost,
+//         user: dbUser,
+//         password: dbPassword,
+//         database: dbName,
+//       });
+
+//       await tempConnection.end();
+//     } else if (dbType === 'postgresql') {
+//       const tempClient = new Client({
+//         host: dbHost,
+//         user: dbUser,
+//         password: dbPassword,
+//       });
+
+//       await tempClient.connect();
+
+//       const checkDb = await tempClient.query(`SELECT datname FROM pg_database WHERE datname = '${dbName}'`);
+//       if (checkDb.rows.length === 0) {
+//         await tempClient.query(`CREATE DATABASE ${dbName}`);
+//         console.log(` PostgreSQL Database "${dbName}" created successfully.`);
+//       } else {
+//         console.log(` PostgreSQL Database "${dbName}" already exists.`);
+//       }
+
+//       await tempClient.end();
+
+//       connection = new Client({
+//         host: dbHost,
+//         user: dbUser,
+//         password: dbPassword,
+//         database: dbName,
+//       });
+
+//       await connection.connect();
+//     } else if (dbType === 'mongodb') {
+//       connection = await MongoClient.connect(`mongodb://${dbHost}:27017`);
+//       console.log(` MongoDB connection to "${dbName}" established.`);
+//     } else if (dbType === 'sqlite') {
+//       connection = new sqlite3.Database(`./${dbName}.sqlite`);
+//       console.log(` SQLite Database "${dbName}.sqlite" is ready.`);
+//     } else {
+//       throw new Error(` Unsupported DB type: ${dbType}`);
+//     }
+//   } catch (error) {
+//     console.error(` Failed to create database: ${error.message}`);
+//     return;
+//   }
+
+//   return connection;
+// };

package/config/createdatabase.mjs

@@ -202,161 +202,3 @@ export const getDbConnection = async () => {
 
   return connection;
 };
-
-// import fs from 'fs';
-// import readlineSync from 'readline-sync';
-// import mysql from 'mysql2/promise';
-// import { MongoClient } from 'mongodb';
-// import sqlite3 from 'sqlite3';
-// import pkg from 'pg';
-// import dotenv from 'dotenv';
-
-// const { Client } = pkg;
-
-// // Function to reset the .env file before processing
-// const resetEnvFile = () => {
-//   try {
-//     fs.writeFileSync('.env', '', 'utf8'); // Empty the .env file
-//     console.log(' Cleared .env file.');
-//   } catch (error) {
-//     console.error(' Failed to clear .env file:', error.message);
-//   }
-// };
-
-// // Function to write data to the .env file
-// const writeToEnv = (data) => {
-//   const envContent = Object.keys(data)
-//     .map(key => `${key}=${data[key]}`)
-//     .join('\n');
-
-//   fs.writeFileSync('.env', envContent, 'utf8');
-// };
-
-
-// // Function to create the database connection
-// export const getDbConnection = async () => {
-//   resetEnvFile(); // Clear .env file before proceeding
-
-//   dotenv.config(); // Reload the (now empty) .env file
-
-//   // Supported database types
-//   const supportedDbTypes = {
-//     mysql: 'mysql',
-//     my: 'mysql',
-//     postgresql: 'postgresql',
-//     pg: 'postgresql',
-//     mongodb: 'mongodb',
-//     mn: 'mongodb',
-//     sqlite: 'sqlite',
-//     sq: 'sqlite'
-//   };
-
-//   let dbType;
-//   while (true) {
-//     dbType = readlineSync.question('Enter the database type (mysql/my, postgresql/pg, mongodb/mn, sqlite/sq): ').toLowerCase();
-//     if (supportedDbTypes[dbType]) {
-//       dbType = supportedDbTypes[dbType]; // Normalize input
-//       break;
-//     } else {
-//       console.log('❌ Invalid database type. Please enter a valid option.');
-//     }
-//   }
-
-//   // Prompt for database details
-//   const dbName = readlineSync.question('Enter the database name: ').trim();
-//   if (!dbName) {
-//     console.log(' Database name cannot be empty.');
-//     return;
-//   }
-
-//   let dbHost = 'localhost';
-//   let dbUser = '';
-//   let dbPassword = '';
-
-//   if (dbType !== 'sqlite') {
-//     dbHost = readlineSync.question('Enter the database host (default: localhost): ') || 'localhost';
-//     dbUser = readlineSync.question('Enter the database user: ').trim();
-//     dbPassword = readlineSync.question('Enter the database password: ', { hideEchoBack: true }).trim();
-//   }
-
-//   // Save valid details to .env
-//   const envData = {
-//     DB_TYPE: dbType,
-//     DB_NAME: dbName,
-//     DB_HOST: dbHost,
-//     DB_USER: dbUser,
-//     DB_PASSWORD: dbPassword,
-//   };
-
-//   writeToEnv(envData);
-//   console.log(' Database credentials saved to .env file.');
-
-//   let connection;
-
-//   try {
-//     if (dbType === 'mysql') {
-//       const tempConnection = await mysql.createConnection({
-//         host: dbHost,
-//         user: dbUser,
-//         password: dbPassword,
-//       });
-
-//       const [rows] = await tempConnection.query(`SHOW DATABASES LIKE '${dbName}'`);
-//       if (rows.length === 0) {
-//         await tempConnection.query(`CREATE DATABASE \`${dbName}\``);
-//         console.log(` MySQL Database "${dbName}" created successfully.`);
-//       } else {
-//         console.log(` MySQL Database "${dbName}" already exists.`);
-//       }
-
-//       connection = await mysql.createConnection({
-//         host: dbHost,
-//         user: dbUser,
-//         password: dbPassword,
-//         database: dbName,
-//       });
-
-//       await tempConnection.end();
-//     } else if (dbType === 'postgresql') {
-//       const tempClient = new Client({
-//         host: dbHost,
-//         user: dbUser,
-//         password: dbPassword,
-//       });
-
-//       await tempClient.connect();
-
-//       const checkDb = await tempClient.query(`SELECT datname FROM pg_database WHERE datname = '${dbName}'`);
-//       if (checkDb.rows.length === 0) {
-//         await tempClient.query(`CREATE DATABASE ${dbName}`);
-//         console.log(` PostgreSQL Database "${dbName}" created successfully.`);
-//       } else {
-//         console.log(` PostgreSQL Database "${dbName}" already exists.`);
-//       }
-
-//       await tempClient.end();
-
-//       connection = new Client({
-//         host: dbHost,
-//         user: dbUser,
-//         password: dbPassword,
-//         database: dbName,
-//       });
-
-//       await connection.connect();
-//     } else if (dbType === 'mongodb') {
-//       connection = await MongoClient.connect(`mongodb://${dbHost}:27017`);
-//       console.log(` MongoDB connection to "${dbName}" established.`);
-//     } else if (dbType === 'sqlite') {
-//       connection = new sqlite3.Database(`./${dbName}.sqlite`);
-//       console.log(` SQLite Database "${dbName}.sqlite" is ready.`);
-//     } else {
-//       throw new Error(` Unsupported DB type: ${dbType}`);
-//     }
-//   } catch (error) {
-//     console.error(` Failed to create database: ${error.message}`);
-//     return;
-//   }
-
-//   return connection;
-// };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mwalajs",
-  "version": "1.0.7",
+  "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

@@ -0,0 +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 readlineSync from 'readline-sync';
+
+dotenv.config();
+
+const { DB_TYPE, DB_HOST = 'localhost', DB_USER, DB_PASSWORD, DB_NAME } = process.env;
+
+let conn = null;
+
+const getConn = async () => {
+  if (conn) return conn;
+
+  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
+      });
+      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 conn;
+};
+
+export const listTables = async () => {
+  const connection = await getConn();
+  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'));
+    });
+  }
+};
+
+export const describeTable = async (table) => {
+  const connection = await getConn();
+  if (DB_TYPE === 'mysql') {
+    const [rows] = await connection.query(`DESCRIBE \`${table}\``);
+    console.table(rows);
+  } else if (DB_TYPE === 'postgresql') {
+    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 connection = await getConn();
+  await connection.query(`TRUNCATE TABLE \`${table}\` RESTART IDENTITY CASCADE`);
+  console.log(`✅ ${table} truncated`);
+};
+
+export const renameTable = async (oldName, 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().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);
+  }
+};
+
+export const restoreDatabase = (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);
+  }
+};
+
+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');
+    });
+  } else {
+    console.error('Seed file not found');
+  }
+};
+export const checkTableExists = () => console.log('Check exists not implemented');