create-fullstack-boilerplate 2.2.2 → 3.0.0

package/index.js

@@ -13,12 +13,11 @@
         return;
     }
 
-    // ---- Your existing create-project code ----
     const path = require("path");
     const copyProject = require('./lib/copyProject');
-    const { runInstall, installDBDriver, normalizePath } = require("./lib/utils");  // ADD normalizePath HERE
+    const { runInstall, installDBDriver, normalizePath } = require("./lib/utils");
     const setupMainDB = require("./lib/setupMainDB");
-    const setupExtraDB = require("./lib/setupExtraDB");
+    const { setupExtraDB, handleTableCreation } = require("./lib/setupExtraDB");
     const testDBConnection = require("./lib/testDBConnection");
     const { mainPrompts, extraDBPrompts } = require("./lib/prompts");
 
@@ -29,7 +28,7 @@
     let templateDir;
 
     // Try __dirname first (works for local/dev)
-    const localTemplate = normalizePath(path.resolve(__dirname, "template"));  // NORMALIZE
+    const localTemplate = normalizePath(path.resolve(__dirname, "template"));
     console.log("🔍 Checking local template:", localTemplate);
 
     if (fs.existsSync(localTemplate)) {
@@ -39,7 +38,7 @@
         // Fallback for npx (temp folder)
         try {
             const pkg = require.resolve("create-fullstack-boilerplate/package.json");
-            templateDir = normalizePath(path.resolve(path.dirname(pkg), "template"));  // NORMALIZE
+            templateDir = normalizePath(path.resolve(path.dirname(pkg), "template"));
             console.log("✅ Found npm template:", templateDir);
         } catch (err) {
             console.error("❌ Could not resolve package:", err.message);
@@ -68,7 +67,7 @@
         console.log("\n🎛️  Setting Up Full Stack Project...\n");
 
         const answers = await mainPrompts();
-        const targetDir = normalizePath(path.join(process.cwd(), answers.projectName));  // NORMALIZE
+        const targetDir = normalizePath(path.join(process.cwd(), answers.projectName));
 
         console.log("Target directory:", targetDir);
 
@@ -84,23 +83,37 @@
 
         await setupMainDB(targetDir, answers.dbDialect);
         console.log("➡️ Installing backend dependencies...");
-        await runInstall(normalizePath(path.join(targetDir, "Backend")));  // NORMALIZE
+        await runInstall(normalizePath(path.join(targetDir, "Backend")));
 
         console.log("➡️ Installing frontend dependencies...");
-        await runInstall(normalizePath(path.join(targetDir, "Frontend")));  // NORMALIZE
+        await runInstall(normalizePath(path.join(targetDir, "Frontend")));
 
         console.log("➡️ Installing Your Db Dialect: ", answers.dbDialect);
-        await installDBDriver(normalizePath(path.join(targetDir, "Backend")), answers.dbDialect);  // NORMALIZE
-
+        await installDBDriver(normalizePath(path.join(targetDir, "Backend")), answers.dbDialect);
 
         if (answers.addExtraDB) {
             const extraDB = await extraDBPrompts();
             console.log(`\n🔍 Testing connection for ${extraDB.dbKey}...`);
-            await installDBDriver(normalizePath(path.join(targetDir, "Backend")), extraDB.dialect);  // NORMALIZE
+            await installDBDriver(normalizePath(path.join(targetDir, "Backend")), extraDB.dialect);
             const ok = await testDBConnection(targetDir, extraDB);
 
             if (ok) {
+                // Setup the database configuration and first table
                 await setupExtraDB(targetDir, extraDB);
+
+                const firstTable = {
+                    tableName: extraDB.tableName,
+                    attributes: extraDB.attributes
+                };
+
+                await handleTableCreation(
+                    targetDir,
+                    extraDB.dbKey,
+                    firstTable,
+                    extraDB.dialect,
+                    true // isNewDB
+                );
+
                 console.log(`✅ Extra DB '${extraDB.dbKey}' successfully integrated.\n`);
             } else {
                 console.log(`⚠️ Connection failed. Skipping extra DB setup.\n`);

package/lib/addDB.js

@@ -1,9 +1,10 @@
 const path = require("path");
-const { extraDBPrompts } = require("./prompts");
-const testDBConnection = require("./testDBConnection");
-const setupExtraDB = require("./setupExtraDB");
 const fs = require("fs-extra");
-
+const inquirer = require("inquirer");
+const { tablePrompts } = require("./prompts");
+const testDBConnection = require("./testDBConnection");
+const { setupExtraDB, handleTableCreation } = require("./setupExtraDB");
+const { installDBDriver } = require("./utils");
 
 module.exports = async function addDB() {
     console.log(`\n➕ Add New Database to Existing Project\n`);
@@ -31,28 +32,134 @@ module.exports = async function addDB() {
     }
 
     try {
-        // Ask DB info
-        const extraDB = await extraDBPrompts();
-
-        // Check if DB with same key already exists
+        // Get list of existing databases
         const dbConfigsPath = path.join(dbDir, "dbConfigs.js");
+        let existingDBs = [];
+
         if (await fs.pathExists(dbConfigsPath)) {
             const dbConfigsContent = await fs.readFile(dbConfigsPath, "utf8");
-            if (dbConfigsContent.includes(`key: "${extraDB.dbKey}"`)) {
-                console.log(`\n⚠️  Database with key '${extraDB.dbKey}' already exists in the project.`);
-                console.log(`   Please use a different DB identifier.\n`);
-                return;
+            const keyMatches = dbConfigsContent.match(/key:\s*"([^"]+)"/g);
+            if (keyMatches) {
+                existingDBs = keyMatches.map(match => match.match(/"([^"]+)"/)[1]);
             }
         }
 
-        // Check if DB folder already exists
-        const dbFolder = path.join(modelsDir, extraDB.dbKey);
-        if (await fs.pathExists(dbFolder)) {
-            console.log(`\n⚠️  Folder '${extraDB.dbKey}' already exists in Models directory.`);
-            console.log(`   Please use a different DB identifier.\n`);
+        // Show existing databases if any
+        if (existingDBs.length > 0) {
+            console.log(`\n📊 Existing databases in your project:`);
+            existingDBs.forEach(db => console.log(`   - ${db}`));
+            console.log('');
+        }
+
+        // Ask what user wants to do
+        const { action } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'action',
+                message: 'What would you like to do?',
+                choices: [
+                    { name: 'Add a new database', value: 'new' },
+                    ...(existingDBs.length > 0 ? [{ name: 'Add tables to an existing database', value: 'existing' }] : [])
+                ]
+            }
+        ]);
+
+        // If user wants to add to existing DB
+        if (action === 'existing') {
+            const { dbKey } = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'dbKey',
+                    message: 'Select database to add tables to:',
+                    choices: existingDBs
+                }
+            ]);
+
+            console.log(`\n✅ Adding tables to '${dbKey}'...\n`);
+
+            await handleTableCreation(
+                targetDir,
+                dbKey,
+                null, // no first table
+                'mysql', // default dialect
+                false // isNewDB = false
+            );
+
+            console.log(`✅ Successfully updated ${dbKey}.\n`);
+            console.log(`📝 Next steps:`);
+            console.log(`   1. Use the CREATE statements above to create tables in your database`);
+            console.log(`   2. Import and use in your routes: const { ${dbKey} } = require('./Models');\n`);
+
             return;
         }
 
+        // New DB flow
+        console.log(`\n📝 Setting up a new database...\n`);
+
+        // Ask for DB identifier first
+        const { dbKey } = await inquirer.prompt([
+            {
+                name: 'dbKey',
+                message: 'DB Identifier (e.g., REPORTING_DB, myDB, test-db):',
+                validate: (input) => {
+                    if (!input || input.trim().length === 0) {
+                        return 'Cannot be empty';
+                    }
+                    if (/[\s@#$%^&*()+={}[\];:'",.<>?/\\|`~]/.test(input)) {
+                        return 'Special characters and spaces not allowed';
+                    }
+                    return true;
+                }
+            }
+        ]);
+
+        // Collect DB credentials
+        const dbCredentials = await inquirer.prompt([
+            {
+                name: 'database',
+                message: 'DB Name:',
+                validate: (input) => input.trim().length > 0 ? true : 'Cannot be empty'
+            },
+            {
+                name: 'username',
+                message: 'DB Username:',
+                validate: (input) => input.trim().length > 0 ? true : 'Cannot be empty'
+            },
+            {
+                name: 'password',
+                message: 'DB Password:'
+            },
+            {
+                name: 'host',
+                message: 'DB Host:',
+                default: 'localhost'
+            },
+            {
+                name: 'port',
+                message: 'DB Port:',
+                default: '3306',
+                validate: (input) => {
+                    const port = parseInt(input);
+                    if (isNaN(port) || port < 1 || port > 65535) {
+                        return 'Please enter a valid port number (1-65535)';
+                    }
+                    return true;
+                }
+            },
+            {
+                type: 'list',
+                name: 'dialect',
+                message: 'DB Dialect:',
+                choices: ['mysql', 'mariadb', 'postgres']
+            }
+        ]);
+
+        const extraDB = {
+            dbKey: dbKey,
+            ...dbCredentials
+        };
+
+        // Test connection
         console.log(`\n🔍 Testing connection for ${extraDB.dbKey}...\n`);
         const ok = await testDBConnection(targetDir, extraDB);
 
@@ -61,11 +168,36 @@ module.exports = async function addDB() {
             return;
         }
 
+        // Install DB driver
+        await installDBDriver(path.join(targetDir, "Backend"), extraDB.dialect);
+
+        // Collect first table information
+        console.log(`\n📋 Now let's create the first table for ${extraDB.dbKey}...\n`);
+        const firstTableConfig = await tablePrompts();
+
+        // Setup database with first table
+        extraDB.tableName = firstTableConfig.tableName;
+        extraDB.attributes = firstTableConfig.attributes;
         await setupExtraDB(targetDir, extraDB);
-        console.log(`\n✅ Successfully added ${extraDB.dbKey} to project.\n`);
+
+        // Handle additional tables
+        const firstTable = {
+            tableName: firstTableConfig.tableName,
+            attributes: firstTableConfig.attributes
+        };
+
+        await handleTableCreation(
+            targetDir,
+            extraDB.dbKey,
+            firstTable,
+            extraDB.dialect,
+            true // isNewDB
+        );
+
+        console.log(`✅ Successfully added ${extraDB.dbKey} to project.\n`);
         console.log(`📝 Next steps:`);
-        console.log(`   1. Check backend/.env for database credentials`);
-        console.log(`   2. Add more models in backend/Models/${extraDB.dbKey}/`);
+        console.log(`   1. Use the CREATE statements above to create tables in your database`);
+        console.log(`   2. Check backend/.env for database credentials`);
         console.log(`   3. Import and use in your routes: const { ${extraDB.dbKey} } = require('./Models');\n`);
 
     } catch (err) {
@@ -74,4 +206,4 @@ module.exports = async function addDB() {
             console.log(`\nStack trace:`, err.stack);
         }
     }
-};
+};

package/lib/inquirePrompts/extraDBPrompts.js

@@ -0,0 +1,72 @@
+const inquirer = require("inquirer");
+const collectTableAttributes = require('./tableAttributePrompts')
+
+const extraDBPrompts = async () => {
+    const basicInfo = await inquirer.prompt([
+        {
+            name: 'dbKey',
+            message: 'DB Identifier (e.g., REPORTING_DB, myDB, test-db):',
+            validate: (input) => {
+                if (!input || input.trim().length === 0) {
+                    return 'Cannot be empty';
+                }
+                if (/[\s@#$%^&*()+={}[\];:'",.<>?/\\|`~]/.test(input)) {
+                    return 'Special characters and spaces not allowed';
+                }
+                return true;
+            }
+        },
+        { name: 'database', message: 'DB Name:', validate: (input) => input.trim().length > 0 ? true : 'Cannot be empty' },
+        { name: 'username', message: 'DB Username:', validate: (input) => input.trim().length > 0 ? true : 'Cannot be empty' },
+        { name: 'password', message: 'DB Password:' },
+        { name: 'host', message: 'DB Host:', default: 'localhost' },
+        {
+            name: 'port',
+            message: 'DB Port:',
+            default: '3306',
+            validate: (input) => {
+                const port = parseInt(input);
+                if (isNaN(port) || port < 1 || port > 65535) {
+                    return 'Please enter a valid port number (1-65535)';
+                }
+                return true;
+            }
+        },
+        {
+            type: 'list',
+            name: 'dialect',
+            message: 'DB Dialect:',
+            choices: ['mysql', 'mariadb', 'postgres']
+        },
+        {
+            name: 'tableName',
+            message: 'Model / Table Name:',
+            default: 'sample_table',
+            validate: (input) => {
+                if (!input || input.trim().length === 0) {
+                    return 'Cannot be empty';
+                }
+                if (/\s/.test(input)) {
+                    return 'Spaces not allowed - use underscores instead';
+                }
+                return true;
+            }
+
+        },
+        {
+            type: 'confirm',
+            name: 'defineAttributes',
+            message: 'Do you want to define table attributes now?',
+            default: false
+        }
+    ]);
+
+    // If user wants to define attributes, collect them
+    if (basicInfo.defineAttributes) {
+        basicInfo.attributes = await collectTableAttributes(basicInfo.dialect);
+    }
+
+    return basicInfo;
+};
+
+module.exports = extraDBPrompts;

package/lib/inquirePrompts/mainPrompts.js

@@ -0,0 +1,46 @@
+const inquirer = require("inquirer");
+
+const mainPrompts = () => {
+    return inquirer.prompt([
+        {
+            name: 'projectName',
+            message: 'Project name',
+            default: 'my-fullstack-app',
+            validate: (input) => {
+                if (!input || input.trim().length === 0) {
+                    return 'Project name cannot be empty';
+                }
+                if (!/^[a-zA-Z0-9_-]+$/.test(input)) {
+                    return 'Project name can only contain letters, numbers, hyphens, and underscores';
+                }
+                return true;
+            }
+        },
+        {
+            type: 'list',
+            name: 'dbDialect',
+            message: 'Main DB Dialect:',
+            choices: ['mysql', 'mariadb', 'postgres']
+        },
+        {
+            type: 'confirm',
+            name: 'addExtraDB',
+            message: 'Add an extra database connection?',
+            default: false
+        },
+        {
+            type: 'confirm',
+            name: 'initGit',
+            message: 'Initialize Git repository?',
+            default: false
+        },
+        {
+            name: 'remoteRepo',
+            message: 'Enter remote Git repository URL:',
+            when: (answers) => answers.initGit === true,
+            validate: (input) => input.length > 0 ? true : "This field cannot be empty."
+        }
+    ]);
+};
+
+module.exports = mainPrompts;

package/lib/inquirePrompts/routePrompts.js

@@ -0,0 +1,37 @@
+const inquirer = require("inquirer");
+
+const routePrompts = () => {
+    return inquirer.prompt([
+        {
+            name: 'routeName',
+            message: 'Route name (e.g., users, products):',
+            validate: (input) => {
+                if (!input || input.trim().length === 0) {
+                    return 'Route name cannot be empty';
+                }
+                return true;
+            }
+        },
+        {
+            name: 'routePath',
+            message: 'Route path (e.g., /users):',
+            default: (answers) => `/${answers.routeName}`,
+            validate: (input) => {
+                if (!input || input.trim().length === 0) {
+                    return 'Route path cannot be empty';
+                }
+                if (!input.startsWith('/')) {
+                    return 'Route path should start with /';
+                }
+                return true;
+            }
+        },
+        {
+            type: 'confirm',
+            name: 'needsAuth',
+            message: 'Does this route require authentication?',
+            default: true
+        }
+    ]);
+};
+module.exports = routePrompts;

package/lib/inquirePrompts/tableAttributePrompts.js

@@ -0,0 +1,148 @@
+const inquirer = require("inquirer");
+const { getDataTypeChoices, needsLength } = require('../dataTypes');
+
+const collectTableAttributes = async (dialect) => {
+    const attributes = [];
+
+    console.log('\n📋 Define table attributes. Start with the primary key.\n');
+
+    // Primary key first
+    const pkAnswers = await inquirer.prompt([
+        {
+            name: 'name',
+            message: 'Primary key column name:',
+            default: 'id',
+            validate: (input) => {
+                if (!input || input.trim().length === 0) return 'Column name cannot be empty';
+                return true;
+            }
+        },
+        {
+            type: 'list',
+            name: 'type',
+            message: 'Primary key data type:',
+            choices: ['INTEGER', 'BIGINT', 'UUID', 'STRING'],
+            default: 'INTEGER'
+        },
+        {
+            type: 'confirm',
+            name: 'autoIncrement',
+            message: 'Auto-increment?',
+            default: true,
+            when: (answers) => answers.type === 'INTEGER' || answers.type === 'BIGINT'
+        }
+    ]);
+
+    attributes.push({
+        name: pkAnswers.name,
+        type: pkAnswers.type,
+        primaryKey: true,
+        autoIncrement: pkAnswers.autoIncrement || false,
+        allowNull: false
+    });
+
+    console.log('\n✅ Primary key added. Now add other attributes.\n');
+
+    // Collect other attributes
+    let addMore = true;
+    while (addMore) {
+        const attrAnswers = await inquirer.prompt([
+            {
+                name: 'name',
+                message: 'Column name:',
+                validate: (input) => {
+                    if (!input || input.trim().length === 0) {
+                        return 'Cannot be empty';
+                    }
+                    if (/\s/.test(input)) {
+                        return 'Spaces not allowed - use underscores instead';
+                    }
+                    if (attributes.find(a => a.name === input)) return 'Column name already exists';
+
+                    return true;
+                }
+            },
+
+            {
+                type: 'list',
+                name: 'type',
+                message: 'Data type:',
+                choices: getDataTypeChoices(dialect)
+            }
+        ]);
+
+        // Ask for length if needed
+        if (needsLength(dialect, attrAnswers.type)) {
+            const lengthAnswer = await inquirer.prompt([
+                {
+                    name: 'length',
+                    message: `Length/Precision for ${attrAnswers.type}:`,
+                    default: attrAnswers.type === 'STRING' ? '255' : '10,2',
+                    validate: (input) => {
+                        if (!input || input.trim().length === 0) return 'Length cannot be empty';
+                        return true;
+                    }
+                }
+            ]);
+            attrAnswers.length = lengthAnswer.length;
+        }
+
+        // Ask for constraints
+        const constraints = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'allowNull',
+                message: 'Allow NULL values?',
+                default: true
+            },
+            {
+                type: 'confirm',
+                name: 'unique',
+                message: 'Should this be unique?',
+                default: false
+            },
+            {
+                type: 'confirm',
+                name: 'hasDefault',
+                message: 'Set a default value?',
+                default: false
+            }
+        ]);
+
+        if (constraints.hasDefault) {
+            const defaultAnswer = await inquirer.prompt([
+                {
+                    name: 'defaultValue',
+                    message: 'Default value:',
+                    validate: (input) => input !== undefined && input !== '' ? true : 'Provide a default value'
+                }
+            ]);
+            attrAnswers.defaultValue = defaultAnswer.defaultValue;
+        }
+
+        attributes.push({
+            name: attrAnswers.name,
+            type: attrAnswers.type,
+            length: attrAnswers.length,
+            allowNull: constraints.allowNull,
+            unique: constraints.unique,
+            defaultValue: attrAnswers.defaultValue
+        });
+
+        const continueAnswer = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'addMore',
+                message: 'Add another attribute?',
+                default: true
+            }
+        ]);
+
+        addMore = continueAnswer.addMore;
+    }
+
+    console.log(`\n✅ Added ${attributes.length} attributes to the model.\n`);
+    return attributes;
+}
+
+module.exports = collectTableAttributes

package/lib/inquirePrompts/tablePrompts.js

@@ -0,0 +1,31 @@
+const inquirer = require("inquirer");
+const collectTableAttributes = require('./tableAttributePrompts')
+
+const tablePrompts = async () => {
+    const tableInfo = await inquirer.prompt([
+        {
+            name: 'tableName',
+            message: 'Model / Table Name:',
+            validate: (input) => {
+                if (!input || input.trim().length === 0) {
+                    return 'Table name cannot be empty';
+                }
+                return true;
+            }
+        },
+        {
+            type: 'confirm',
+            name: 'defineAttributes',
+            message: 'Do you want to define table attributes now?',
+            default: true
+        }
+    ]);
+
+    if (tableInfo.defineAttributes) {
+        tableInfo.attributes = await collectTableAttributes('mysql'); // You can pass dialect if needed
+    }
+
+    return tableInfo;
+};
+
+module.exports = tablePrompts

package/lib/prompts.js

@@ -1,289 +1,13 @@
-const inquirer = require("inquirer");
-const { getDataTypeChoices, needsLength } = require('./dataTypes');
-
-module.exports.mainPrompts = () => {
-    return inquirer.prompt([
-        {
-            name: 'projectName',
-            message: 'Project name',
-            default: 'my-fullstack-app',
-            validate: (input) => {
-                if (!input || input.trim().length === 0) {
-                    return 'Project name cannot be empty';
-                }
-                if (!/^[a-zA-Z0-9_-]+$/.test(input)) {
-                    return 'Project name can only contain letters, numbers, hyphens, and underscores';
-                }
-                return true;
-            }
-        },
-        {
-            type: 'list',
-            name: 'dbDialect',
-            message: 'Main DB Dialect:',
-            choices: ['mysql', 'mariadb', 'postgres']
-        },
-        {
-            type: 'confirm',
-            name: 'addExtraDB',
-            message: 'Add an extra database connection?',
-            default: false
-        },
-        {
-            type: 'confirm',
-            name: 'initGit',
-            message: 'Initialize Git repository?',
-            default: false
-        },
-        {
-            name: 'remoteRepo',
-            message: 'Enter remote Git repository URL:',
-            when: (answers) => answers.initGit === true,
-            validate: (input) => input.length > 0 ? true : "This field cannot be empty."
-        }
-    ]);
-};
-
-module.exports.extraDBPrompts = async () => {
-    const basicInfo = await inquirer.prompt([
-        {
-            name: 'dbKey',
-            message: 'DB Identifier (e.g., REPORTING_DB):',
-            validate: (input) => {
-                if (!input || input.trim().length === 0) {
-                    return 'DB identifier cannot be empty';
-                }
-                if (!/^[A-Z][A-Z0-9_]*$/.test(input)) {
-                    return 'DB identifier should be UPPERCASE with underscores (e.g., MY_DB)';
-                }
-                return true;
-            }
-        },
-        { name: 'database', message: 'DB Name:', validate: (input) => input.trim().length > 0 ? true : 'Cannot be empty' },
-        { name: 'username', message: 'DB Username:', validate: (input) => input.trim().length > 0 ? true : 'Cannot be empty' },
-        { name: 'password', message: 'DB Password:' },
-        { name: 'host', message: 'DB Host:', default: 'localhost' },
-        {
-            name: 'port',
-            message: 'DB Port:',
-            default: '3306',
-            validate: (input) => {
-                const port = parseInt(input);
-                if (isNaN(port) || port < 1 || port > 65535) {
-                    return 'Please enter a valid port number (1-65535)';
-                }
-                return true;
-            }
-        },
-        {
-            type: 'list',
-            name: 'dialect',
-            message: 'DB Dialect:',
-            choices: ['mysql', 'mariadb', 'postgres']
-        },
-        {
-            name: 'tableName',
-            message: 'Model / Table Name:',
-            default: 'sample_table',
-            validate: (input) => {
-                if (!input || input.trim().length === 0) {
-                    return 'Table name cannot be empty';
-                }
-                if (!/^[a-z][a-z0-9_]*$/.test(input)) {
-                    return 'Table name should be lowercase with underscores (e.g., user_profiles)';
-                }
-                return true;
-            }
-        },
-        {
-            type: 'confirm',
-            name: 'defineAttributes',
-            message: 'Do you want to define table attributes now?',
-            default: false
-        }
-    ]);
-
-    // If user wants to define attributes, collect them
-    if (basicInfo.defineAttributes) {
-        basicInfo.attributes = await collectTableAttributes(basicInfo.dialect);
-    }
-
-    return basicInfo;
-};
-
-async function collectTableAttributes(dialect) {
-    const attributes = [];
-
-    console.log('\n📋 Define table attributes. Start with the primary key.\n');
-
-    // Primary key first
-    const pkAnswers = await inquirer.prompt([
-        {
-            name: 'name',
-            message: 'Primary key column name:',
-            default: 'id',
-            validate: (input) => {
-                if (!input || input.trim().length === 0) return 'Column name cannot be empty';
-                if (!/^[a-z][a-z0-9_]*$/.test(input)) return 'Use lowercase with underscores';
-                return true;
-            }
-        },
-        {
-            type: 'list',
-            name: 'type',
-            message: 'Primary key data type:',
-            choices: ['INTEGER', 'BIGINT', 'UUID', 'STRING'],
-            default: 'INTEGER'
-        },
-        {
-            type: 'confirm',
-            name: 'autoIncrement',
-            message: 'Auto-increment?',
-            default: true,
-            when: (answers) => answers.type === 'INTEGER' || answers.type === 'BIGINT'
-        }
-    ]);
-
-    attributes.push({
-        name: pkAnswers.name,
-        type: pkAnswers.type,
-        primaryKey: true,
-        autoIncrement: pkAnswers.autoIncrement || false,
-        allowNull: false
-    });
-
-    console.log('\n✅ Primary key added. Now add other attributes.\n');
-
-    // Collect other attributes
-    let addMore = true;
-    while (addMore) {
-        const attrAnswers = await inquirer.prompt([
-            {
-                name: 'name',
-                message: 'Column name:',
-                validate: (input) => {
-                    if (!input || input.trim().length === 0) return 'Column name cannot be empty';
-                    if (!/^[a-z][a-z0-9_]*$/.test(input)) return 'Use lowercase with underscores';
-                    if (attributes.find(a => a.name === input)) return 'Column name already exists';
-                    return true;
-                }
-            },
-            {
-                type: 'list',
-                name: 'type',
-                message: 'Data type:',
-                choices: getDataTypeChoices(dialect)
-            }
-        ]);
-
-        // Ask for length if needed
-        if (needsLength(dialect, attrAnswers.type)) {
-            const lengthAnswer = await inquirer.prompt([
-                {
-                    name: 'length',
-                    message: `Length/Precision for ${attrAnswers.type}:`,
-                    default: attrAnswers.type === 'STRING' ? '255' : '10,2',
-                    validate: (input) => {
-                        if (!input || input.trim().length === 0) return 'Length cannot be empty';
-                        return true;
-                    }
-                }
-            ]);
-            attrAnswers.length = lengthAnswer.length;
-        }
-
-        // Ask for constraints
-        const constraints = await inquirer.prompt([
-            {
-                type: 'confirm',
-                name: 'allowNull',
-                message: 'Allow NULL values?',
-                default: true
-            },
-            {
-                type: 'confirm',
-                name: 'unique',
-                message: 'Should this be unique?',
-                default: false
-            },
-            {
-                type: 'confirm',
-                name: 'hasDefault',
-                message: 'Set a default value?',
-                default: false
-            }
-        ]);
-
-        if (constraints.hasDefault) {
-            const defaultAnswer = await inquirer.prompt([
-                {
-                    name: 'defaultValue',
-                    message: 'Default value:',
-                    validate: (input) => input !== undefined && input !== '' ? true : 'Provide a default value'
-                }
-            ]);
-            attrAnswers.defaultValue = defaultAnswer.defaultValue;
-        }
-
-        attributes.push({
-            name: attrAnswers.name,
-            type: attrAnswers.type,
-            length: attrAnswers.length,
-            allowNull: constraints.allowNull,
-            unique: constraints.unique,
-            defaultValue: attrAnswers.defaultValue
-        });
-
-        const continueAnswer = await inquirer.prompt([
-            {
-                type: 'confirm',
-                name: 'addMore',
-                message: 'Add another attribute?',
-                default: true
-            }
-        ]);
-
-        addMore = continueAnswer.addMore;
-    }
-
-    console.log(`\n✅ Added ${attributes.length} attributes to the model.\n`);
-    return attributes;
-}
-
-module.exports.routePrompts = () => {
-    return inquirer.prompt([
-        {
-            name: 'routeName',
-            message: 'Route name (e.g., users, products):',
-            validate: (input) => {
-                if (!input || input.trim().length === 0) {
-                    return 'Route name cannot be empty';
-                }
-                if (!/^[a-z][a-z0-9_]*$/.test(input)) {
-                    return 'Route name should be lowercase with underscores (e.g., user_profiles)';
-                }
-                return true;
-            }
-        },
-        {
-            name: 'routePath',
-            message: 'Route path (e.g., /users):',
-            default: (answers) => `/${answers.routeName}`,
-            validate: (input) => {
-                if (!input || input.trim().length === 0) {
-                    return 'Route path cannot be empty';
-                }
-                if (!input.startsWith('/')) {
-                    return 'Route path should start with /';
-                }
-                return true;
-            }
-        },
-        {
-            type: 'confirm',
-            name: 'needsAuth',
-            message: 'Does this route require authentication?',
-            default: true
-        }
-    ]);
-};
+const mainPrompts = require("./inquirePrompts/mainPrompts");
+const extraDBPrompts = require("./inquirePrompts/extraDBPrompts");
+const routePrompts = require("./inquirePrompts/routePrompts");
+const tablePrompts = require("./inquirePrompts/tablePrompts");
+const tableAttributePrompts = require("./inquirePrompts/tableAttributePrompts");
+
+module.exports = {
+    mainPrompts,
+    extraDBPrompts,
+    routePrompts,
+    tablePrompts,
+    tableAttributePrompts
+};

package/lib/setupExtraDB.js

@@ -1,8 +1,11 @@
 const path = require("path");
 const fs = require("fs-extra");
+const { generateModelContent, addTableToDB } = require('./tableHandlers/dbTableAddition')
+const handleTableCreation = require('./tableHandlers/handleTableCreation')
+const generateCreateStatement = require('./tableHandlers/createStatementGenerator')
 
 
-module.exports = async function setupExtraDB(targetDir, dbConfig) {
+async function setupExtraDB(targetDir, dbConfig) {
   const backendDir = path.join(targetDir, "Backend");
   const modelsDir = path.join(backendDir, "Models");
   const dbDir = path.join(backendDir, "DB");
@@ -96,77 +99,11 @@ $2`
   console.log(`✅ Database '${dbConfig.dbKey}' configured successfully.`);
 };
 
-function generateModelContent(dbConfig) {
-  const modelName = dbConfig.tableName.charAt(0).toUpperCase() + dbConfig.tableName.slice(1);
-
-  // Generate model content based on whether attributes were provided
-  if (dbConfig.attributes && dbConfig.attributes.length > 0) {
-    const attributesStr = dbConfig.attributes.map(attr => {
-      let attrDef = `    ${attr.name}: {\n      type: DataTypes.${attr.type}`;
-
-      if (attr.length) {
-        attrDef += `(${attr.length})`;
-      }
-
-      if (attr.primaryKey) {
-        attrDef += `,\n      primaryKey: true,\n      autoIncrement: true`;
-      }
-
-      if (attr.allowNull === false) {
-        attrDef += `,\n      allowNull: false`;
-      }
-
-      if (attr.unique) {
-        attrDef += `,\n      unique: true`;
-      }
-
-      if (attr.defaultValue !== undefined) {
-        attrDef += `,\n      defaultValue: ${JSON.stringify(attr.defaultValue)}`;
-      }
-
-      attrDef += `\n    }`;
-      return attrDef;
-    }).join(',\n');
-
-    return `'use strict';
-module.exports = (sequelize, DataTypes) => {
-  const ${modelName} = sequelize.define('${modelName}', {
-${attributesStr}
-  }, {
-    tableName: '${dbConfig.tableName}',
-    timestamps: true
-  });
-
-  ${modelName}.associate = function(models) {
-    // Define associations here
-    // Example: ${modelName}.belongsTo(models.OtherModel, { foreignKey: 'otherId' });
-  };
-
-  return ${modelName};
-};
-`;
-  } else {
-    // Simple model with just ID
-    return `'use strict';
-module.exports = (sequelize, DataTypes) => {
-  const ${modelName} = sequelize.define('${modelName}', {
-    id: {
-      type: DataTypes.INTEGER,
-      primaryKey: true,
-      autoIncrement: true
-    }
-  }, {
-    tableName: '${dbConfig.tableName}',
-    timestamps: true
-  });
-
-  ${modelName}.associate = function(models) {
-    // Define associations here
-    // Example: ${modelName}.belongsTo(models.OtherModel, { foreignKey: 'otherId' });
-  };
-
-  return ${modelName};
-};
-`;
-  }
-}
+
+module.exports = {
+  setupExtraDB,
+  addTableToDB,
+  handleTableCreation,
+  generateCreateStatement,
+  generateModelContent
+}

package/lib/tableHandlers/createStatementGenerator.js

@@ -0,0 +1,90 @@
+function generateCreateStatement(tableName, attributes, dialect = 'mysql') {
+    const modelName = tableName.charAt(0).toUpperCase() + tableName.slice(1);
+
+    if (!attributes || attributes.length === 0) {
+        return `CREATE TABLE ${tableName} (
+  id INT PRIMARY KEY AUTO_INCREMENT,
+  createdAt TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  updatedAt TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
+);`;
+    }
+
+    const columns = attributes.map(attr => {
+        let colDef = `  ${attr.name} `;
+
+        // Map Sequelize types to SQL types
+        switch (attr.type) {
+            case 'INTEGER':
+                colDef += 'INT';
+                break;
+            case 'BIGINT':
+                colDef += 'BIGINT';
+                break;
+            case 'STRING':
+                colDef += `VARCHAR(${attr.length || 255})`;
+                break;
+            case 'TEXT':
+                colDef += 'TEXT';
+                break;
+            case 'BOOLEAN':
+                colDef += 'BOOLEAN';
+                break;
+            case 'DATE':
+                colDef += 'DATE';
+                break;
+            case 'DATEONLY':
+                colDef += 'DATE';
+                break;
+            case 'DECIMAL':
+                colDef += `DECIMAL(${attr.length || '10,2'})`;
+                break;
+            case 'FLOAT':
+                colDef += 'FLOAT';
+                break;
+            case 'DOUBLE':
+                colDef += 'DOUBLE';
+                break;
+            case 'UUID':
+                colDef += 'CHAR(36)';
+                break;
+            case 'JSON':
+                colDef += 'JSON';
+                break;
+            default:
+                colDef += attr.type;
+        }
+
+        if (attr.primaryKey) {
+            colDef += ' PRIMARY KEY';
+            if (attr.autoIncrement) {
+                colDef += ' AUTO_INCREMENT';
+            }
+        }
+
+        if (attr.allowNull === false && !attr.primaryKey) {
+            colDef += ' NOT NULL';
+        }
+
+        if (attr.unique && !attr.primaryKey) {
+            colDef += ' UNIQUE';
+        }
+
+        if (attr.defaultValue !== undefined) {
+            if (typeof attr.defaultValue === 'string') {
+                colDef += ` DEFAULT '${attr.defaultValue}'`;
+            } else {
+                colDef += ` DEFAULT ${attr.defaultValue}`;
+            }
+        }
+
+        return colDef;
+    }).join(',\n');
+
+    return `CREATE TABLE ${tableName} (
+${columns},
+  createdAt TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  updatedAt TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
+);`;
+}
+
+module.exports = generateCreateStatement;

package/lib/tableHandlers/dbTableAddition.js

@@ -0,0 +1,98 @@
+const path = require("path");
+const fs = require("fs-extra");
+
+function generateModelContent(dbConfig) {
+    const modelName = dbConfig.tableName.charAt(0).toUpperCase() + dbConfig.tableName.slice(1);
+
+    // Generate model content based on whether attributes were provided
+    if (dbConfig.attributes && dbConfig.attributes.length > 0) {
+        const attributesStr = dbConfig.attributes.map(attr => {
+            let attrDef = `    ${attr.name}: {\n      type: DataTypes.${attr.type}`;
+
+            if (attr.length) {
+                attrDef += `(${attr.length})`;
+            }
+
+            if (attr.primaryKey) {
+                attrDef += `,\n      primaryKey: true,\n      autoIncrement: true`;
+            }
+
+            if (attr.allowNull === false) {
+                attrDef += `,\n      allowNull: false`;
+            }
+
+            if (attr.unique) {
+                attrDef += `,\n      unique: true`;
+            }
+
+            if (attr.defaultValue !== undefined) {
+                attrDef += `,\n      defaultValue: ${JSON.stringify(attr.defaultValue)}`;
+            }
+
+            attrDef += `\n    }`;
+            return attrDef;
+        }).join(',\n');
+
+        return `'use strict';
+module.exports = (sequelize, DataTypes) => {
+  const ${modelName} = sequelize.define('${modelName}', {
+${attributesStr}
+  }, {
+    tableName: '${dbConfig.tableName}',
+    timestamps: true
+  });
+
+  ${modelName}.associate = function(models) {
+    // Define associations here
+    // Example: ${modelName}.belongsTo(models.OtherModel, { foreignKey: 'otherId' });
+  };
+
+  return ${modelName};
+};
+`;
+    } else {
+        // Simple model with just ID
+        return `'use strict';
+module.exports = (sequelize, DataTypes) => {
+  const ${modelName} = sequelize.define('${modelName}', {
+    id: {
+      type: DataTypes.INTEGER,
+      primaryKey: true,
+      autoIncrement: true
+    }
+  }, {
+    tableName: '${dbConfig.tableName}',
+    timestamps: true
+  });
+
+  ${modelName}.associate = function(models) {
+    // Define associations here
+    // Example: ${modelName}.belongsTo(models.OtherModel, { foreignKey: 'otherId' });
+  };
+
+  return ${modelName};
+};
+`;
+    }
+}
+
+// New function to add a table to an existing DB
+async function addTableToDB(targetDir, dbKey, tableConfig) {
+    const backendDir = path.join(targetDir, "Backend");
+    const modelsDir = path.join(backendDir, "Models");
+    const dbModelsFolder = path.join(modelsDir, dbKey);
+
+    // Create the model file
+    const modelContent = generateModelContent(tableConfig);
+    const modelFileName = `${tableConfig.tableName}.js`;
+    const modelPath = path.join(dbModelsFolder, modelFileName);
+
+    await fs.writeFile(modelPath, modelContent);
+    console.log(`✅ Table model '${tableConfig.tableName}' created in ${dbKey}/`);
+};
+
+
+module.exports = {
+    addTableToDB,
+    generateModelContent
+}

package/lib/tableHandlers/handleTableCreation.js

@@ -0,0 +1,77 @@
+const {tablePrompts} = require('../prompts')
+const { addTableToDB } = require('./dbTableAddition')
+const generateCreateStatement = require('./createStatementGenerator')
+const inquirer = require("inquirer");
+
+async function handleTableCreation(
+    targetDir,
+    dbKey,
+    firstTable = null,
+    dialect = 'mysql',
+    isNewDB = true
+) {
+    const createdTables = [];
+
+    // If this is a new DB and we have a first table from initial setup
+    if (isNewDB && firstTable) {
+        createdTables.push(firstTable);
+    }
+
+    // Ask if user wants to add more tables (or start adding if no firstTable)
+    let addMoreTables = true;
+
+    while (addMoreTables) {
+        // If we don't have a first table yet, or we're adding additional tables
+        if (!firstTable || createdTables.length > 0) {
+            // Ask if they want to add a table
+            const { wantToAdd } = await inquirer.prompt([
+                {
+                    type: "confirm",
+                    name: "wantToAdd",
+                    message: createdTables.length === 0
+                        ? "Do you want to create a table for this database?"
+                        : "Do you want to add another table to this database?",
+                    default: createdTables.length === 0 ? true : false
+                }
+            ]);
+
+            if (!wantToAdd) {
+                addMoreTables = false;
+                break;
+            }
+
+            const tableConfig = await tablePrompts();
+
+            // For additional tables (not the first one), use addTableToDB
+            if (isNewDB && createdTables.length === 0) {
+                // First table in new DB - already created by setupExtraDB, just track it
+                createdTables[0] = tableConfig;
+            } else {
+                // Additional tables - need to create them
+                await addTableToDB(targetDir, dbKey, tableConfig);
+                createdTables.push(tableConfig);
+            }
+        } else {
+            // We already have the first table, just break to ask for more
+            addMoreTables = false;
+        }
+    }
+
+    // Print CREATE statements for all tables
+    if (createdTables.length > 0) {
+        console.log(`\n📋 CREATE Statements for your tables:\n`);
+        console.log(`${'='.repeat(60)}\n`);
+
+        createdTables.forEach((table, index) => {
+            console.log(`-- Table ${index + 1}: ${table.tableName}`);
+            console.log(generateCreateStatement(table.tableName, table.attributes, dialect));
+            console.log('');
+        });
+
+        console.log(`${'='.repeat(60)}\n`);
+    }
+
+    return createdTables;
+};
+
+module.exports = handleTableCreation

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-fullstack-boilerplate",
-  "version": "2.2.2",
+  "version": "3.0.0",
   "description": "A powerful CLI tool to generate fully configured full-stack applications with React frontend and Express backend. Includes authentication middleware, database configuration, protected routes, route-based Axios instances, and encryption setup - all ready with a single command.",
   "main": "index.js",
   "types": "index.d.ts",

package/template/Frontend/index.html

@@ -2,9 +2,9 @@
 <html lang="en">
   <head>
     <meta charset="UTF-8" />
-    <link rel="icon" type="image/svg+xml" href="/PMDLogo.png" />
+    <link rel="icon" type="image/svg+xml" href="/pp.jpg" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>PMD - Reports</title>
+    <title>Full Stack Boilerplate</title>
   </head>
   <body>
     <div id="root"></div>

package/template/Frontend/src/components/Loader.jsx

@@ -6,7 +6,7 @@ const SpinningLoader = ({ size = 10 }) => {
     return (
         <div className={`flex flex-col justify-center items-center gap-4 h-full w-full ${isDark ? 'bg-gray-900' : 'bg-white'}`}>
             <img
-                src={'/PMDLogo.png'}
+                src={'/load.webp'}
                 alt="Loading..."
                 style={{ width: "auto", height: size }}
                 className="animate-pulse"

package/template/Frontend/src/pages/Login.jsx

@@ -69,7 +69,7 @@ const Login = () => {
                     {/* Header */}
                     <div className="px-6 pt-6 pb-4 text-center">
                         <div className="relative mb-4">
-                            <img src={'/PMDLogo.png'} alt="PMD Logo" className='w-max h-14 mx-auto' />
+                            <img src={'/pp.jpg'} alt="PMD Logo" className='w-max h-20 rounded-full shadow-md shadow-gray-400 mx-auto' />
                         </div>
 
                         <h1 className="text-2xl font-articulatcf-demibold text-gray-800 mb-1">Welcome Back</h1>