mwalajs 1.0.5 → 1.0.7

package/bin/mwala.mjs

@@ -55,7 +55,7 @@ switch (command) {
   case '-v':
   case 'v':
   case '--version':
-    console.log('MwalaJS Version: 1.0.5');
+    console.log('MwalaJS Version: 1.0.6');
     process.exit(0);
 
   case 'create-project':

package/config/createdatabase.mjs

@@ -8,17 +8,45 @@ import dotenv from 'dotenv';
 
 const { Client } = pkg;
 
-// Function to reset the .env file before processing
+/* -----------------------------------------------------------
+   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'); // Empty the .env file
-    console.log(' Cleared .env file.');
+    fs.writeFileSync('.env', '', 'utf8');
+    console.log(' 🧹 Cleared .env file.');
   } catch (error) {
-    console.error(' Failed to clear .env file:', error.message);
+    console.error(' ❌ Failed to clear .env file:', error.message);
   }
 };
 
-// Function to write data to the .env file
+/* -----------------------------------------------------------
+   WRITE DATA TO .ENV
+----------------------------------------------------------- */
 const writeToEnv = (data) => {
   const envContent = Object.keys(data)
     .map(key => `${key}=${data[key]}`)
@@ -27,14 +55,20 @@ const writeToEnv = (data) => {
   fs.writeFileSync('.env', envContent, 'utf8');
 };
 
-
-// Function to create the database connection
+/* -----------------------------------------------------------
+   MAIN FUNCTION: CREATE/CONNECT DATABASE
+----------------------------------------------------------- */
 export const getDbConnection = async () => {
-  resetEnvFile(); // Clear .env file before proceeding
 
-  dotenv.config(); // Reload the (now empty) .env file
+  // 🔥 FIRST CREATE BACKUP
+  backupEnvFile();
+
+  // 🔥 THEN CLEAR OLD ENV
+  resetEnvFile();
+
+  // Reload environment
+  dotenv.config();
 
-  // Supported database types
   const supportedDbTypes = {
     mysql: 'mysql',
     my: 'mysql',
@@ -48,19 +82,21 @@ export const getDbConnection = async () => {
 
   let dbType;
   while (true) {
-    dbType = readlineSync.question('Enter the database type (mysql/my, postgresql/pg, mongodb/mn, sqlite/sq): ').toLowerCase();
+    dbType = readlineSync.question(
+      'Enter DB type (mysql/my, postgresql/pg, mongodb/mn, sqlite/sq): '
+    ).toLowerCase();
+
     if (supportedDbTypes[dbType]) {
-      dbType = supportedDbTypes[dbType]; // Normalize input
+      dbType = supportedDbTypes[dbType];
       break;
     } else {
-      console.log('❌ Invalid database type. Please enter a valid option.');
+      console.log(' ❌ Invalid database type. Try again.');
     }
   }
 
-  // Prompt for database details
   const dbName = readlineSync.question('Enter the database name: ').trim();
   if (!dbName) {
-    console.log(' Database name cannot be empty.');
+    console.log(' ❌ Database name cannot be empty.');
     return;
   }
 
@@ -69,64 +105,70 @@ export const getDbConnection = async () => {
   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();
+    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();
   }
 
-  // Save valid details to .env
   const envData = {
     DB_TYPE: dbType,
     DB_NAME: dbName,
     DB_HOST: dbHost,
     DB_USER: dbUser,
-    DB_PASSWORD: dbPassword,
+    DB_PASSWORD: dbPassword
   };
 
   writeToEnv(envData);
-  console.log(' Database credentials saved to .env file.');
+  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,
+        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.`);
+        console.log(`  MySQL database "${dbName}" created.`);
       } else {
-        console.log(` MySQL Database "${dbName}" already exists.`);
+        console.log(`  MySQL database "${dbName}" already exists.`);
       }
 
       connection = await mysql.createConnection({
         host: dbHost,
         user: dbUser,
         password: dbPassword,
-        database: dbName,
+        database: dbName
       });
 
       await tempConnection.end();
-    } else if (dbType === 'postgresql') {
+    }
+
+    /* -------------------- POSTGRESQL -------------------- */
+    else if (dbType === 'postgresql') {
       const tempClient = new Client({
         host: dbHost,
         user: dbUser,
-        password: dbPassword,
+        password: dbPassword
       });
 
       await tempClient.connect();
 
-      const checkDb = await tempClient.query(`SELECT datname FROM pg_database WHERE datname = '${dbName}'`);
+      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.`);
+        console.log(`  PostgreSQL database "${dbName}" created.`);
       } else {
-        console.log(` PostgreSQL Database "${dbName}" already exists.`);
+        console.log(`  PostgreSQL database "${dbName}" already exists.`);
       }
 
       await tempClient.end();
@@ -135,23 +177,186 @@ export const getDbConnection = async () => {
         host: dbHost,
         user: dbUser,
         password: dbPassword,
-        database: dbName,
+        database: dbName
       });
 
       await connection.connect();
-    } else if (dbType === 'mongodb') {
+    }
+
+    /* -------------------- MONGODB -------------------- */
+    else if (dbType === 'mongodb') {
       connection = await MongoClient.connect(`mongodb://${dbHost}:27017`);
-      console.log(` MongoDB connection to "${dbName}" established.`);
-    } else if (dbType === 'sqlite') {
+      console.log(`  MongoDB connected.`);
+    }
+
+    /* -------------------- SQLITE -------------------- */
+    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}`);
+      console.log(`  SQLite database "${dbName}.sqlite" ready.`);
     }
+
   } catch (error) {
-    console.error(` Failed to create database: ${error.message}`);
+    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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mwalajs",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "MwalaJS Framework CLI Tool and Web Framework for Backend and Frontend Development.",
   "type": "module",
   "main": "app.mjs",
@@ -26,6 +26,7 @@
     "mongoose": "^8.12.1",
     "mpath": "^0.9.0",
     "multer": "^1.4.2",
+    "mwalajs": "^1.0.6",
     "mysql2": "^3.13.0",
     "pg": "^8.13.3",
     "pg-hstore": "^2.3.4",

package/setupMwalajs.mjs

@@ -1,58 +1,75 @@
-import { execSync } from 'child_process';
-import fs from 'fs-extra';
+import fs from 'fs';
 import path from 'path';
 import os from 'os';
+import readline from 'readline';
+import { execSync } from 'child_process';
 import { fileURLToPath } from 'url';
 
+// Convert __dirname and __filename for ES module
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Create readline interface
+const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+});
+
+async function prompt(question) {
+    return new Promise((resolve) => rl.question(question, resolve));
+}
+
 /**
- * Function to install express in mwalajs and copy the folder into node_modules.
+ * Function to install mwalajs.
+ * - If package.json exists, it proceeds to install.
+ * - If not, it prompts user to auto-create or manually create.
+ * - When auto-creating, it sets "type": "module" and "main": "app.mjs" by default.
  */
 async function setupMwalajs() {
-    const projectDir = process.cwd(); // Get project root directory
-    const mwalajsDir = path.join(projectDir, 'mwalajs'); // mwalajs folder
-    const nodeModulesDir = path.join(projectDir, 'node_modules'); // node_modules
-    const targetMwalajs = path.join(nodeModulesDir, 'mwalajs'); // Destination folder inside node_modules
+    const projectDir = process.cwd();
+    const packageJsonPath = path.join(projectDir, 'package.json');
 
     try {
-        console.log(" Detecting Operating System...");
-        const userOS = os.platform(); // Get user OS (win32, linux, darwin)
-        console.log(` Running on: ${userOS === "win32" ? "Windows" : userOS === "darwin" ? "MacOS" : "Linux"}`);
-
-        // Check if mwalajs exists
-        if (!fs.existsSync(mwalajsDir)) {
-            console.error(" Error: 'mwalajs' folder not found! Please ensure it exists.");
-            return;
-        }
+        console.log("Detecting Operating System...");
+        const userOS = os.platform();
+        console.log(`Running on: ${userOS === "win32" ? "Windows" : userOS === "darwin" ? "MacOS" : "Linux"}`);
 
-        console.log(" Installing 'dependencies' inside 'mwalajs'...");
-        execSync('npm install express --prefix mwalajs', { stdio: 'inherit' });
+        if (!fs.existsSync(packageJsonPath)) {
+            console.log("No package.json found in the current directory.");
+            const choice = await prompt("Do you want to create one now? (y/n): ");
 
-        // Ensure node_modules exists
-        if (!fs.existsSync(nodeModulesDir)) {
-            fs.mkdirSync(nodeModulesDir);
-        }
+            if (choice.toLowerCase() === 'y') {
+                console.log("Initializing package.json...");
+                execSync('npm init -y', { stdio: 'inherit' });
 
-        // Delete existing mwalajs in node_modules if present
-        if (fs.existsSync(targetMwalajs)) {
-            console.log(" Removing old 'mwalajs' from node_modules...");
-            fs.removeSync(targetMwalajs);
+                // Modify package.json with defaults
+                const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+                pkg.type = "module";
+                pkg.main = "app.mjs";
+                fs.writeFileSync(packageJsonPath, JSON.stringify(pkg, null, 2));
+                console.log('package.json created with type: "module" and main: "app.mjs"');
+            } else {
+                console.log("Please create a package.json file manually using `npm init`.");
+                rl.close();
+                return;
+            }
         }
 
-        console.log(" Copying 'mwalajs' to 'node_modules'...");
-        fs.copySync(mwalajsDir, targetMwalajs, { overwrite: true });
-
-        console.log(` Successfully installed 'dependencies' and moved 'mwalajs' to:`);
-        console.log(` ${targetMwalajs}`);
+        console.log("Installing mwalajs in current directory...");
+        execSync('npm install mwalajs', { stdio: 'inherit' });
+        console.log("mwalajs installed successfully.");
 
     } catch (error) {
-        console.error(" Error:", error.message);
+        console.error("Error:", error.message);
+    } finally {
+        rl.close();
     }
 }
 
-// Export the function so it can be used anywhere
+// Export the function
 export { setupMwalajs };
 
-// Prevent auto-execution unless explicitly called (ES Module Fix)
+// Only execute if run directly
 if (import.meta.url === `file://${process.argv[1]}`) {
     setupMwalajs();
 }