create-fullstack-boilerplate 1.0.0

package/lib/addRoute.js

@@ -0,0 +1,264 @@
+const path = require("path");
+const { ensure } = require("./utils");
+const { routePrompts } = require("./prompts");
+const fs = ensure("fs-extra");
+
+module.exports = async function addRoute() {
+    console.log(`\n➕ Add New Route to Backend\n`);
+
+    const targetDir = process.cwd();
+    const backendDir = path.join(targetDir, "backend");
+    const routesDir = path.join(backendDir, "routes");
+    const servicesDir = path.join(backendDir, "services");
+
+    // Check if we're in a valid project
+    if (!await fs.pathExists(backendDir)) {
+        console.log(`❌ Error: No backend folder found. Are you in a project root directory?`);
+        console.log(`   Run this command from your project root (where backend/ folder exists).`);
+        return;
+    }
+
+    if (!await fs.pathExists(routesDir)) {
+        console.log(`❌ Error: No routes folder found in backend.`);
+        return;
+    }
+
+    try {
+        // Get route info from user
+        const routeInfo = await routePrompts();
+        
+        const routeFileName = `${routeInfo.routeName}Routes.js`;
+        const serviceFileName = `${routeInfo.routeName}Service.js`;
+        const routeFilePath = path.join(routesDir, routeFileName);
+        const serviceFilePath = path.join(servicesDir, serviceFileName);
+
+        // Check if files already exist
+        if (await fs.pathExists(routeFilePath)) {
+            console.log(`⚠️  Route file ${routeFileName} already exists. Aborting.`);
+            return;
+        }
+
+        if (await fs.pathExists(serviceFilePath)) {
+            console.log(`⚠️  Service file ${serviceFileName} already exists. Aborting.`);
+            return;
+        }
+
+        // Create route file
+        const routeContent = generateRouteFile(routeInfo);
+        await fs.writeFile(routeFilePath, routeContent);
+        console.log(`✅ Created route file: routes/${routeFileName}`);
+
+        // Create service file
+        const serviceContent = generateServiceFile(routeInfo);
+        await fs.writeFile(serviceFilePath, serviceContent);
+        console.log(`✅ Created service file: services/${serviceFileName}`);
+
+        // Update routes/index.js
+        await updateRoutesIndex(routesDir, routeInfo);
+        console.log(`✅ Updated routes/index.js`);
+
+        console.log(`\n🎉 Route '${routeInfo.routeName}' added successfully!`);
+        console.log(`\n📝 Next steps:`);
+        console.log(`   1. Implement your business logic in services/${serviceFileName}`);
+        console.log(`   2. Add more endpoints in routes/${routeFileName}`);
+        console.log(`   3. Test your endpoints at ${routeInfo.routePath}`);
+
+    } catch (err) {
+        console.log(`❌ Error adding route:`, err.message);
+    }
+};
+
+function generateRouteFile(routeInfo) {
+    const requireAuth = routeInfo.needsAuth 
+        ? `const { authenticateToken } = require('../middleware/authMiddleware');\n` 
+        : '';
+    
+    const authMiddleware = routeInfo.needsAuth ? 'authenticateToken, ' : '';
+
+    return `const express = require('express');
+const router = express.Router();
+${requireAuth}const ${routeInfo.routeName}Service = require('../services/${routeInfo.routeName}Service');
+
+// GET all ${routeInfo.routeName}
+router.get('/', ${authMiddleware}${routeInfo.routeName}Service.getAll);
+
+// GET single ${routeInfo.routeName} by ID
+router.get('/:id', ${authMiddleware}${routeInfo.routeName}Service.getById);
+
+// POST create new ${routeInfo.routeName}
+router.post('/', ${authMiddleware}${routeInfo.routeName}Service.create);
+
+// PUT update ${routeInfo.routeName}
+router.put('/:id', ${authMiddleware}${routeInfo.routeName}Service.update);
+
+// DELETE ${routeInfo.routeName}
+router.delete('/:id', ${authMiddleware}${routeInfo.routeName}Service.delete);
+
+module.exports = router;
+`;
+}
+
+function generateServiceFile(routeInfo) {
+    const capitalizedName = routeInfo.routeName.charAt(0).toUpperCase() + routeInfo.routeName.slice(1);
+
+    return `// Import your database models here
+// Example: const { YOUR_DB } = require('../Models');
+// const { ${capitalizedName} } = YOUR_DB;
+
+/**
+ * Get all ${routeInfo.routeName}
+ */
+exports.getAll = async (req, res) => {
+    try {
+        // TODO: Implement your logic to fetch all ${routeInfo.routeName}
+        // Example:
+        // const items = await ${capitalizedName}.findAll();
+        // res.json(items);
+
+        res.json({
+            message: 'Get all ${routeInfo.routeName} - To be implemented',
+            data: []
+        });
+    } catch (error) {
+        console.error('Error fetching ${routeInfo.routeName}:', error);
+        res.status(500).json({ message: 'Error fetching ${routeInfo.routeName}', error: error.message });
+    }
+};
+
+/**
+ * Get ${routeInfo.routeName} by ID
+ */
+exports.getById = async (req, res) => {
+    try {
+        const { id } = req.params;
+        
+        // TODO: Implement your logic to fetch ${routeInfo.routeName} by ID
+        // Example:
+        // const item = await ${capitalizedName}.findByPk(id);
+        // if (!item) {
+        //     return res.status(404).json({ message: '${capitalizedName} not found' });
+        // }
+        // res.json(item);
+
+        res.json({
+            message: \`Get ${routeInfo.routeName} with ID \${id} - To be implemented\`,
+            data: { id }
+        });
+    } catch (error) {
+        console.error('Error fetching ${routeInfo.routeName}:', error);
+        res.status(500).json({ message: 'Error fetching ${routeInfo.routeName}', error: error.message });
+    }
+};
+
+/**
+ * Create new ${routeInfo.routeName}
+ */
+exports.create = async (req, res) => {
+    try {
+        const data = req.body;
+        
+        // TODO: Implement your logic to create ${routeInfo.routeName}
+        // Example:
+        // const newItem = await ${capitalizedName}.create(data);
+        // res.status(201).json(newItem);
+
+        res.status(201).json({
+            message: 'Create ${routeInfo.routeName} - To be implemented',
+            data: data
+        });
+    } catch (error) {
+        console.error('Error creating ${routeInfo.routeName}:', error);
+        res.status(500).json({ message: 'Error creating ${routeInfo.routeName}', error: error.message });
+    }
+};
+
+/**
+ * Update ${routeInfo.routeName}
+ */
+exports.update = async (req, res) => {
+    try {
+        const { id } = req.params;
+        const data = req.body;
+        
+        // TODO: Implement your logic to update ${routeInfo.routeName}
+        // Example:
+        // const item = await ${capitalizedName}.findByPk(id);
+        // if (!item) {
+        //     return res.status(404).json({ message: '${capitalizedName} not found' });
+        // }
+        // await item.update(data);
+        // res.json(item);
+
+        res.json({
+            message: \`Update ${routeInfo.routeName} with ID \${id} - To be implemented\`,
+            data: { id, ...data }
+        });
+    } catch (error) {
+        console.error('Error updating ${routeInfo.routeName}:', error);
+        res.status(500).json({ message: 'Error updating ${routeInfo.routeName}', error: error.message });
+    }
+};
+
+/**
+ * Delete ${routeInfo.routeName}
+ */
+exports.delete = async (req, res) => {
+    try {
+        const { id } = req.params;
+        
+        // TODO: Implement your logic to delete ${routeInfo.routeName}
+        // Example:
+        // const item = await ${capitalizedName}.findByPk(id);
+        // if (!item) {
+        //     return res.status(404).json({ message: '${capitalizedName} not found' });
+        // }
+        // await item.destroy();
+        // res.json({ message: '${capitalizedName} deleted successfully' });
+
+        res.json({
+            message: \`Delete ${routeInfo.routeName} with ID \${id} - To be implemented\`,
+            data: { id }
+        });
+    } catch (error) {
+        console.error('Error deleting ${routeInfo.routeName}:', error);
+        res.status(500).json({ message: 'Error deleting ${routeInfo.routeName}', error: error.message });
+    }
+};
+`;
+}
+
+async function updateRoutesIndex(routesDir, routeInfo) {
+    const indexPath = path.join(routesDir, "index.js");
+    let content = await fs.readFile(indexPath, "utf8");
+
+    const requireStatement = `const ${routeInfo.routeName}Routes = require('./${routeInfo.routeName}Routes');\n`;
+    const authMiddleware = routeInfo.needsAuth ? 'authenticateToken, ' : '';
+    const useStatement = `router.use('${routeInfo.routePath}', ${authMiddleware}${routeInfo.routeName}Routes);\n`;
+
+    // Find where to insert require statement (after last require or at top)
+    const lastRequireMatch = content.match(/const.*require\(.*\);/g);
+    if (lastRequireMatch) {
+        const lastRequire = lastRequireMatch[lastRequireMatch.length - 1];
+        const requireIndex = content.lastIndexOf(lastRequire) + lastRequire.length;
+        content = content.slice(0, requireIndex) + '\n' + requireStatement + content.slice(requireIndex);
+    } else {
+        // Insert after the router definition
+        const routerMatch = content.match(/const router = express\.Router\(\);/);
+        if (routerMatch) {
+            const routerIndex = content.indexOf(routerMatch[0]) + routerMatch[0].length;
+            content = content.slice(0, routerIndex) + '\n\n' + requireStatement + content.slice(routerIndex);
+        }
+    }
+
+    // Find where to insert use statement (before module.exports)
+    const exportsMatch = content.match(/module\.exports = router;/);
+    if (exportsMatch) {
+        const exportsIndex = content.indexOf(exportsMatch[0]);
+        content = content.slice(0, exportsIndex) + useStatement + '\n' + content.slice(exportsIndex);
+    } else {
+        // Just append at the end
+        content += '\n' + useStatement;
+    }
+
+    await fs.writeFile(indexPath, content);
+}

package/lib/copyProject.js

@@ -0,0 +1,25 @@
+const { ensure, log } = require("./utils");
+const fs = ensure("fs-extra");
+const path = require("path");
+
+module.exports = async function copyProject(src, dest) {
+    // Check if destination already exists
+    if (await fs.pathExists(dest)) {
+        throw new Error(`Directory '${path.basename(dest)}' already exists. Please choose a different project name.`);
+    }
+
+    // Check if source template exists
+    if (!await fs.pathExists(src)) {
+        throw new Error(`Template directory not found. Package may be corrupted.`);
+    }
+
+    log("Creating project directory...");
+    try {
+        await fs.copy(src, dest, {
+            filter: (item) => !item.includes("node_modules")
+        });
+        console.log("✅ Files copied successfully.");
+    } catch (err) {
+        throw new Error(`Failed to copy project files: ${err.message}`);
+    }
+};

package/lib/dataTypes.js

@@ -0,0 +1,79 @@
+// Data type mappings for different SQL dialects
+const dataTypesByDialect = {
+    mysql: [
+        { name: 'INTEGER', needsLength: false, description: 'Whole number' },
+        { name: 'BIGINT', needsLength: false, description: 'Large whole number' },
+        { name: 'FLOAT', needsLength: false, description: 'Floating point number' },
+        { name: 'DOUBLE', needsLength: false, description: 'Double precision number' },
+        { name: 'DECIMAL', needsLength: true, description: 'Exact decimal (e.g., 10,2 for currency)' },
+        { name: 'STRING', needsLength: true, description: 'Variable length string (VARCHAR)' },
+        { name: 'TEXT', needsLength: false, description: 'Long text' },
+        { name: 'BOOLEAN', needsLength: false, description: 'True/False' },
+        { name: 'DATE', needsLength: false, description: 'Date only' },
+        { name: 'DATETIME', needsLength: false, description: 'Date and time' },
+        { name: 'TIME', needsLength: false, description: 'Time only' },
+        { name: 'JSON', needsLength: false, description: 'JSON data' },
+        { name: 'BLOB', needsLength: false, description: 'Binary data' },
+        { name: 'ENUM', needsLength: false, description: 'Enumeration (list of values)' }
+    ],
+    mariadb: [
+        { name: 'INTEGER', needsLength: false, description: 'Whole number' },
+        { name: 'BIGINT', needsLength: false, description: 'Large whole number' },
+        { name: 'FLOAT', needsLength: false, description: 'Floating point number' },
+        { name: 'DOUBLE', needsLength: false, description: 'Double precision number' },
+        { name: 'DECIMAL', needsLength: true, description: 'Exact decimal (e.g., 10,2 for currency)' },
+        { name: 'STRING', needsLength: true, description: 'Variable length string (VARCHAR)' },
+        { name: 'TEXT', needsLength: false, description: 'Long text' },
+        { name: 'BOOLEAN', needsLength: false, description: 'True/False' },
+        { name: 'DATE', needsLength: false, description: 'Date only' },
+        { name: 'DATETIME', needsLength: false, description: 'Date and time' },
+        { name: 'TIME', needsLength: false, description: 'Time only' },
+        { name: 'JSON', needsLength: false, description: 'JSON data' },
+        { name: 'BLOB', needsLength: false, description: 'Binary data' },
+        { name: 'ENUM', needsLength: false, description: 'Enumeration (list of values)' }
+    ],
+    postgres: [
+        { name: 'INTEGER', needsLength: false, description: 'Whole number' },
+        { name: 'BIGINT', needsLength: false, description: 'Large whole number' },
+        { name: 'FLOAT', needsLength: false, description: 'Floating point number' },
+        { name: 'DOUBLE', needsLength: false, description: 'Double precision number' },
+        { name: 'DECIMAL', needsLength: true, description: 'Exact decimal (e.g., 10,2 for currency)' },
+        { name: 'STRING', needsLength: true, description: 'Variable length string (VARCHAR)' },
+        { name: 'TEXT', needsLength: false, description: 'Long text' },
+        { name: 'BOOLEAN', needsLength: false, description: 'True/False' },
+        { name: 'DATE', needsLength: false, description: 'Date only' },
+        { name: 'TIMESTAMP', needsLength: false, description: 'Date and time with timezone' },
+        { name: 'TIME', needsLength: false, description: 'Time only' },
+        { name: 'JSONB', needsLength: false, description: 'Binary JSON data (recommended)' },
+        { name: 'JSON', needsLength: false, description: 'JSON data' },
+        { name: 'BYTEA', needsLength: false, description: 'Binary data' },
+        { name: 'UUID', needsLength: false, description: 'Universally unique identifier' },
+        { name: 'ARRAY', needsLength: false, description: 'Array of values' },
+        { name: 'ENUM', needsLength: false, description: 'Enumeration (list of values)' }
+    ]
+};
+
+function getDataTypesForDialect(dialect) {
+    return dataTypesByDialect[dialect] || dataTypesByDialect.mysql;
+}
+
+function getDataTypeChoices(dialect) {
+    const types = getDataTypesForDialect(dialect);
+    return types.map(t => ({
+        name: `${t.name} - ${t.description}`,
+        value: t.name,
+        short: t.name
+    }));
+}
+
+function needsLength(dialect, dataType) {
+    const types = getDataTypesForDialect(dialect);
+    const type = types.find(t => t.name === dataType);
+    return type ? type.needsLength : false;
+}
+
+module.exports = {
+    getDataTypesForDialect,
+    getDataTypeChoices,
+    needsLength
+};

package/lib/installDeps.js

@@ -0,0 +1,11 @@
+const execa = require("execa");
+const path = require("path");
+const { log } = require("./utils");
+
+module.exports = async function installDeps(targetDir) {
+    log("Installing backend dependencies...");
+    await execa("npm", ["install"], { cwd: path.join(targetDir, "backend"), stdio: "inherit" });
+
+    log("Installing frontend dependencies...");
+    await execa("npm", ["install"], { cwd: path.join(targetDir, "frontend"), stdio: "inherit" });
+};

package/lib/prompts.js

@@ -0,0 +1,289 @@
+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
+        }
+    ]);
+};