tss-stack 1.0.0

package/bin/cli.js

@@ -0,0 +1,467 @@
+#!/usr/bin/env node
+"use strict";
+
+const ora = require("ora");
+const path = require("path");
+const fs = require("fs-extra");
+const inquirer = require("inquirer");
+const { spawn, execSync } = require("child_process");
+
+const { generateBackend } = require("../src/generators/backend");
+const { generateFrontend } = require("../src/generators/frontend");
+const { generateDatabase } = require("../src/generators/database");
+const { toPascal } = require("../src/generators/utils");
+
+const CONSTANTS = {
+    MIN_PORT: 1,
+    MAX_PORT: 65535,
+    MAX_TABLES: 50,
+    MIN_TABLES: 1,
+    DELAY_PER_LINE: 20,
+    INTRO_DELAY: 300,
+    BACKEND_PORT_DEFAULT: "5000",
+    FRONTEND_PORT_DEFAULT: 5173,
+};
+
+const COLORS = {
+    red: "\x1b[31m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    blue: "\x1b[34m",
+    cyan: "\x1b[36m",
+    bold: "\x1b[1m",
+    underline: "\x1b[4m",
+    reset: "\x1b[0m",
+};
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+const logger = {
+    info(message = "") {
+        console.log(message);
+    },
+    success(message) {
+        console.log(`${COLORS.green}[✓]${COLORS.reset} ${message}`);
+    },
+    warn(message) {
+        console.log(`${COLORS.yellow}[!]${COLORS.reset} ${message}`);
+    },
+    error(message) {
+        console.error(`${COLORS.red}[ERROR]${COLORS.reset} ${message}`);
+    },
+    fatal(message, err = null) {
+        console.error(`${COLORS.red}[FATAL]${COLORS.reset} ${message}`);
+        if (err) console.error(err);
+        process.exit(1);
+    },
+};
+
+function validateFolderName(value) {
+    if (!value || value.trim() === "") return "Folder name cannot be empty.";
+    if (value.includes("..") || value.includes("/") || value.includes("\\")) {
+        return "Folder name cannot contain path separators or '..'.";
+    }
+    if (!/^[a-zA-Z0-9][a-zA-Z0-9-_]*$/.test(value)) {
+        return "Folder name can only contain letters, numbers, dashes, and underscores, and must start with a letter or number.";
+    }
+    return true;
+}
+
+function validateDatabaseName(value) {
+    if (!/^[a-zA-Z][a-zA-Z0-9_]*$/.test(value)) {
+        return "Database name must start with a letter and contain only letters, numbers, and underscores.";
+    }
+    if (value.length > 64) return "Database name cannot exceed 64 characters.";
+    return true;
+}
+
+function validateTableName(value) {
+    if (!/^[a-z][a-z0-9_]*$/.test(value)) {
+        return "Table name must start with a lowercase letter and use snake_case (e.g., spare_parts).";
+    }
+    const reservedWords = [
+        "select", "insert", "update", "delete", "create", "drop",
+        "table", "index", "key", "primary", "foreign", "user", "order",
+        "group", "having", "where", "from", "into", "values", "set"
+    ];
+    if (reservedWords.includes(value.toLowerCase())) {
+        return `"${value}" is a reserved SQL keyword. Please use a different name.`;
+    }
+    return true;
+}
+
+function validatePort(value) {
+    const port = Number(value);
+    if (!Number.isInteger(port)) return "Port must be an integer.";
+    if (port < CONSTANTS.MIN_PORT || port > CONSTANTS.MAX_PORT) {
+        return `Port must be between ${CONSTANTS.MIN_PORT} and ${CONSTANTS.MAX_PORT}.`;
+    }
+    if (port < 1024) logger.warn("Warning: Ports below 1024 require root/admin privileges.");
+    return true;
+}
+
+function validateFields(fields) {
+    if (!fields || fields.trim() === "") return "At least one field is required.";
+    const parsed = fields.split(",").map((f) => f.trim()).filter(Boolean);
+    if (parsed.length === 0) return "At least one field is required.";
+    if (parsed.length > 50) return "Maximum 50 fields per table allowed.";
+    const invalid = parsed.find((field) => {
+        if (!/^[a-z][a-z0-9_]*$/.test(field)) return true;
+        const reserved = ["id", "created_at", "updated_at"];
+        return reserved.includes(field.toLowerCase());
+    });
+    if (invalid) {
+        return `Invalid field name "${invalid}". Use lowercase snake_case starting with a letter.`;
+    }
+    return true;
+}
+
+function validateTableCount(value) {
+    const count = Number(value);
+    if (!Number.isInteger(count)) return "Enter a whole number.";
+    if (count < CONSTANTS.MIN_TABLES) return `Minimum ${CONSTANTS.MIN_TABLES} table required.`;
+    if (count > CONSTANTS.MAX_TABLES) return `Maximum ${CONSTANTS.MAX_TABLES} tables allowed for stability.`;
+    return true;
+}
+
+async function printTree(lines) {
+    for (const line of lines) {
+        console.log(line);
+        await sleep(CONSTANTS.DELAY_PER_LINE);
+    }
+}
+
+function formatTree(lines) {
+    if (lines.length === 0) return [];
+    return lines.map((line, index) => (index === lines.length - 1 ? line.replace("├──", "└──") : line));
+}
+
+function sanitizePackageName(name) {
+    return name.toLowerCase().replace(/[^a-z0-9-_]/g, "-").replace(/^-+|-+$/g, "");
+}
+
+function isMySQLInstalled() {
+    try {
+        execSync("mysql --version", { stdio: "ignore" });
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+function checkNodeVersion() {
+    const [major] = process.versions.node.split(".").map(Number);
+    const MIN_NODE = 16;
+    if (major < MIN_NODE) {
+        logger.warn(`Warning: Node.js ${MIN_NODE}+ recommended. Current: ${process.versions.node}`);
+        return false;
+    }
+    return true;
+}
+
+function runCommand(command, args, cwd, spinner, failMessage) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, { cwd, shell: false, stdio: ["ignore", "pipe", "pipe"] });
+
+        child.stdout.on("data", (data) => process.stdout.write(data));
+        child.stderr.on("data", (data) => process.stderr.write(data));
+
+        child.on("close", (code) => {
+            if (code === 0) {
+                spinner.succeed();
+                resolve();
+            } else {
+                spinner.fail(failMessage);
+                reject(new Error(`${command} exited with code ${code}`));
+            }
+        });
+
+        child.on("error", (err) => {
+            spinner.fail(failMessage);
+            reject(err);
+        });
+    });
+}
+
+async function cleanupProject(targetDir) {
+    try {
+        if (await fs.pathExists(targetDir)) {
+            await fs.remove(targetDir);
+            logger.warn(`Cleaned up partially generated project: ${targetDir}`);
+        }
+    } catch (err) {
+        logger.error(`Failed to clean up project directory: ${err.message}`);
+    }
+}
+
+async function generateGitIgnore(targetDir) {
+    const gitIgnoreContent = `node_modules/
+.env
+*.log
+.DS_Store
+.idea/
+.vscode/
+`;
+    const gitIgnorePath = path.join(targetDir, ".gitignore");
+    if (!(await fs.pathExists(gitIgnorePath))) {
+        await fs.outputFile(gitIgnorePath, gitIgnoreContent);
+    }
+}
+
+async function promptBasics(targetDir) {
+    return inquirer.prompt([
+        {
+            name: "projectName",
+            message: "[1] Project display name:",
+            default: targetDir,
+            validate: (value) => (!value || value.trim() === "" ? "Project name cannot be empty." : true),
+        },
+        {
+            name: "dbName",
+            message: "[2] MySQL database name:",
+            default: targetDir.toLowerCase().replace(/-/g, "_") + "_db",
+            validate: validateDatabaseName,
+        },
+        {
+            name: "port",
+            message: "[3] Backend port number:",
+            default: CONSTANTS.BACKEND_PORT_DEFAULT,
+            validate: validatePort,
+        },
+    ]);
+}
+
+async function promptTableCount() {
+    return inquirer.prompt([
+        {
+            name: "tableCount",
+            message: `[4] How many tables does your database need? (1-${CONSTANTS.MAX_TABLES}):`,
+            validate: validateTableCount,
+        },
+    ]);
+}
+
+async function promptTable(index) {
+    return inquirer.prompt([
+        {
+            name: "name",
+            message: `Table ${index + 1} name (snake_case, e.g. spare_parts):`,
+            validate: validateTableName,
+        },
+        {
+            name: "fields",
+            message: "Fields for this table (comma separated, lowercase snake_case):",
+            validate: validateFields,
+            filter: (value) => value.split(",").map((f) => f.trim()).filter(Boolean),
+        },
+        {
+            name: "operations",
+            type: "checkbox",
+            message: "Which operations does this table need?",
+            choices: [
+                { name: "INSERT (create)", value: "insert", checked: true },
+                { name: "SELECT (read/list)", value: "select", checked: true },
+                { name: "UPDATE (edit)", value: "update" },
+                { name: "DELETE (remove)", value: "delete" },
+            ],
+            validate: (value) => (value.length > 0 ? true : "Select at least one operation."),
+        },
+    ]);
+}
+
+async function promptFeatures() {
+    return inquirer.prompt([
+        {
+            name: "needsAuth",
+            type: "confirm",
+            message: "[5] Add session-based login/register system?",
+            default: true,
+        },
+        {
+            name: "needsReports",
+            type: "confirm",
+            message: "[6] Add a Reports page?",
+            default: true,
+        },
+    ]);
+}
+
+process.stdout.write("\x1Bc");
+
+async function showProjectTree(config) {
+    const backendRouteFiles = [
+        config.needsAuth ? "│   ├── auth.js" : null,
+        ...config.tables.map((t) => `│   ├── ${t.name}.js`),
+    ].filter(Boolean);
+
+    const frontendPageFiles = [
+        config.needsAuth ? "│   ├── Login.jsx" : null,
+        ...config.tables.map((t) => `│   ├── ${toPascal(t.name)}.jsx`),
+        config.needsReports ? "│   └── Reports.jsx" : null,
+    ].filter(Boolean);
+
+    const tree = [
+        `${COLORS.yellow}${path.basename(config.targetDir)}/${COLORS.reset}`,
+        "",
+        `├── ${COLORS.blue}backend-project/${COLORS.reset}`,
+        "│   ├── config/",
+        "│   │   ├── db.js",
+        "│   │   └── database.sql",
+        "│   ├── middleware/",
+        config.needsAuth ? "│   │   └── auth.js" : null,
+        "│   ├── routes/",
+        ...formatTree(backendRouteFiles).map((line) => `│   ${line}`),
+        "│   ├── server.js",
+        "│   ├── .env.example",
+        "│   └── package.json",
+        "",
+        `└── ${COLORS.blue}frontend-project/${COLORS.reset}`,
+        "    ├── src/",
+        "    │   ├── api/",
+        "    │   │   └── axios.js",
+        "    │   ├── pages/",
+        ...formatTree(frontendPageFiles).map((line) => `    │   ${line}`),
+        "    │   ├── App.jsx",
+        "    │   └── main.jsx",
+        "    └── package.json",
+    ].filter(Boolean);
+
+    await printTree(tree);
+}
+
+async function run() {
+    checkNodeVersion();
+
+    const targetDir = process.argv[2];
+    if (!targetDir) logger.fatal("Usage: npx project-folder <folder-name>");
+
+    const folderValidation = validateFolderName(targetDir);
+    if (folderValidation !== true) logger.fatal(folderValidation);
+
+    const absoluteTargetDir = path.resolve(process.cwd(), targetDir);
+    if (await fs.pathExists(absoluteTargetDir)) {
+        logger.fatal(`Folder "${targetDir}" already exists.`);
+    }
+
+    logger.info(`\n${COLORS.bold}[✓] Full Project Folder Structure Generator${COLORS.reset}\n`);
+
+    const basics = await promptBasics(targetDir);
+    const { tableCount } = await promptTableCount();
+
+    const tables = [];
+    for (let i = 0; i < Number(tableCount); i++) {
+        tables.push(await promptTable(i));
+    }
+
+    const features = await promptFeatures();
+
+    const config = {
+        projectName: basics.projectName,
+        dbName: basics.dbName,
+        port: basics.port,
+        tables,
+        needsAuth: features.needsAuth,
+        needsReports: features.needsReports,
+        targetDir: absoluteTargetDir,
+        packageName: sanitizePackageName(basics.projectName),
+    };
+
+    logger.info(`\n[⁂] TSS Stack — generating ${COLORS.cyan}${config.projectName}${COLORS.reset}\n`);
+    await sleep(CONSTANTS.INTRO_DELAY);
+
+    try {
+        await generateDatabase(config);
+        await generateBackend(config);
+        await generateFrontend(config);
+    } catch (err) {
+        await cleanupProject(absoluteTargetDir);
+        logger.fatal("Project generation failed.", err.message || err);
+    }
+
+    const backendPath = path.join(absoluteTargetDir, "backend-project");
+    const frontendPath = path.join(absoluteTargetDir, "frontend-project");
+
+    if (!(await fs.pathExists(backendPath))) {
+        await cleanupProject(absoluteTargetDir);
+        logger.fatal(`Missing backend directory:\n${backendPath}`);
+    }
+
+    if (!(await fs.pathExists(frontendPath))) {
+        await cleanupProject(absoluteTargetDir);
+        logger.fatal(`Missing frontend directory:\n${frontendPath}`);
+    }
+
+    await generateGitIgnore(absoluteTargetDir);
+    await showProjectTree(config);
+    logger.info("");
+
+    const backendSpinner = ora({ text: "Installing backend dependencies...", color: "cyan" }).start();
+    try {
+        await runCommand(process.platform === "win32" ? "npm.cmd" : "npm", ["install"], backendPath, backendSpinner, "Backend dependency installation failed");
+    } catch (err) {
+        await cleanupProject(absoluteTargetDir);
+        logger.fatal(err.message);
+    }
+
+    const frontendSpinner = ora({ text: "Installing frontend dependencies...", color: "magenta" }).start();
+    try {
+        await runCommand(process.platform === "win32" ? "npm.cmd" : "npm", ["install"], frontendPath, frontendSpinner, "Frontend dependency installation failed");
+    } catch (err) {
+        await cleanupProject(absoluteTargetDir);
+        logger.fatal(err.message);
+    }
+
+    if (!isMySQLInstalled()) {
+        logger.warn("MySQL not detected. Install MySQL to import the database.");
+    }
+
+    const relativePath = path.relative(process.cwd(), absoluteTargetDir);
+    logger.info(`
+${COLORS.green}[✓] Done! ${config.projectName} is ready.${COLORS.reset}
+
+${COLORS.bold}Next steps:${COLORS.reset}
+
+1. Import your database:
+   ${COLORS.cyan}mysql -u root -p < ${relativePath}/backend-project/config/database.sql${COLORS.reset}
+
+2. Start backend:
+   ${COLORS.cyan}cd ${relativePath}/backend-project${COLORS.reset}
+   ${COLORS.cyan}cp .env.example .env${COLORS.reset}
+   Fill in your MySQL credentials in .env
+   ${COLORS.cyan}npm run dev${COLORS.reset}
+
+3. Start frontend:
+   ${COLORS.cyan}cd ${relativePath}/frontend-project${COLORS.reset}
+   ${COLORS.cyan}npm run dev${COLORS.reset}
+
+4. Open in browser:
+   ${COLORS.underline}http://localhost:${CONSTANTS.FRONTEND_PORT_DEFAULT}${COLORS.reset}
+
+${COLORS.yellow}Tip:${COLORS.reset} Check ${COLORS.cyan}.gitignore${COLORS.reset} to exclude node_modules and .env from version control.
+`);
+}
+
+process.on("SIGINT", async () => {
+    const targetDir = process.argv[2];
+    if (targetDir) await cleanupProject(path.resolve(process.cwd(), targetDir));
+    console.log(`\n${COLORS.red}[ABORTED]${COLORS.reset} Process cancelled by user.`);
+    process.exit(130);
+});
+
+process.on("SIGTERM", async () => {
+    const targetDir = process.argv[2];
+    if (targetDir) await cleanupProject(path.resolve(process.cwd(), targetDir));
+    process.exit(143);
+});
+
+process.on("unhandledRejection", (reason) => {
+    logger.fatal("Unhandled Promise Rejection", reason);
+});
+
+process.on("uncaughtException", (err) => {
+    logger.fatal("Uncaught Exception", err);
+});
+
+run().catch((err) => {
+    logger.fatal("Unexpected fatal error.", err.message || err);
+});

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "tss-stack",
+  "version": "1.0.0",
+  "description": "Interactive full-stack Node.js + React + MySQL project generator",
+  "bin": {
+    "tss-stack": "bin/cli.js"
+  },
+  "files": [
+    "bin/",
+    "src/"
+  ],
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "dependencies": {
+    "fs-extra": "^11.2.0",
+    "inquirer": "^8.2.6",
+    "ora": "^5.4.1"
+  },
+  "keywords": [
+    "cli",
+    "fullstack",
+    "nodejs",
+    "react",
+    "mysql",
+    "scaffold"
+  ],
+  "author": "Mugisha Brian",
+  "license": "ISC",
+  "type": "commonjs"
+}

package/src/generators/backend.js

@@ -0,0 +1,330 @@
+const fs = require("fs-extra");
+const path = require("path");
+
+const { toPascal, toRoute } = require("./utils");
+
+async function generateBackend(config) {
+    const { dbName, port, tables, needsAuth, targetDir } = config;
+    const root = path.join(targetDir, "backend-project");
+
+    const dependencies = {
+        express: "^4.18.2",
+        mysql2: "^3.6.0",
+        cors: "^2.8.5",
+        dotenv: "^16.3.1",
+        helmet: "^7.1.0",
+        "express-session": "^1.17.3",
+        bcryptjs: "^2.4.3",
+        "express-rate-limit": "^7.1.5",
+    };
+
+    await fs.outputFile(
+        path.join(root, "package.json"),
+        JSON.stringify(
+            {
+                name: "backend-project",
+                version: "1.0.0",
+                scripts: {
+                    dev: "nodemon server.js",
+                    start: "node server.js",
+                },
+                dependencies: needsAuth
+                    ? dependencies
+                    : {
+                        express: dependencies.express,
+                        mysql2: dependencies.mysql2,
+                        cors: dependencies.cors,
+                        dotenv: dependencies.dotenv,
+                        helmet: dependencies.helmet,
+                    },
+                devDependencies: {
+                    nodemon: "^3.0.1",
+                },
+            },
+            null,
+            2
+        )
+    );
+
+    await fs.outputFile(
+        path.join(root, ".env.example"),
+        `DB_HOST=localhost
+DB_USER=root
+DB_PASSWORD=your_password_here
+DB_NAME=${dbName}
+PORT=${port}
+SESSION_SECRET=change_me
+CLIENT_URL=http://localhost:5173
+NODE_ENV=development
+`
+    );
+
+    await fs.outputFile(
+        path.join(root, "config", "db.js"),
+        `const mysql = require("mysql2");
+require("dotenv").config();
+
+const pool = mysql.createPool({
+  host: process.env.DB_HOST,
+  user: process.env.DB_USER,
+  password: process.env.DB_PASSWORD,
+  database: process.env.DB_NAME,
+  waitForConnections: true,
+  connectionLimit: 10,
+});
+
+pool.getConnection((err, connection) => {
+  if (err) {
+    console.error("[ERROR] MySQL connection failed:", err.message);
+    process.exit(1);
+  }
+
+  console.log("[✓] MySQL connected");
+  connection.release();
+});
+
+module.exports = pool.promise();
+`
+    );
+
+    if (needsAuth) {
+        await fs.outputFile(
+            path.join(root, "middleware", "auth.js"),
+            `module.exports = (req, res, next) => {
+  if (req.session && req.session.user) return next();
+  return res.status(401).json({ message: "Unauthorized" });
+};
+`
+        );
+
+        await fs.outputFile(
+            path.join(root, "routes", "auth.js"),
+            `const express = require("express");
+const bcrypt = require("bcryptjs");
+const rateLimit = require("express-rate-limit");
+const router = express.Router();
+const db = require("../config/db");
+
+const authLimiter = rateLimit({
+  windowMs: 15 * 60 * 1000,
+  max: 50,
+});
+
+router.use(authLimiter);
+
+router.post("/register", async (req, res) => {
+  try {
+    const { username, password } = req.body;
+
+    if (!username || !password) {
+      return res.status(400).json({ message: "Username and password required" });
+    }
+
+    if (password.length < 6) {
+      return res.status(400).json({ message: "Password must be at least 6 characters" });
+    }
+
+    const hash = await bcrypt.hash(password, 10);
+
+    await db.query("INSERT INTO users (username, password) VALUES (?, ?)", [username, hash]);
+
+    res.json({ message: "User registered successfully" });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+router.post("/login", async (req, res) => {
+  try {
+    const { username, password } = req.body;
+
+    const [results] = await db.query("SELECT * FROM users WHERE username = ?", [username]);
+
+    if (results.length === 0) {
+      return res.status(401).json({ message: "User not found" });
+    }
+
+    const user = results[0];
+    const passwordMatch = await bcrypt.compare(password, user.password);
+
+    if (!passwordMatch) {
+      return res.status(401).json({ message: "Wrong password" });
+    }
+
+    req.session.user = {
+      id: user.id,
+      username: user.username,
+    };
+
+    res.json({
+      message: "Login successful",
+      user: req.session.user,
+    });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+router.post("/logout", (req, res) => {
+  req.session.destroy(() => {
+    res.json({ message: "Logged out" });
+  });
+});
+
+module.exports = router;
+`
+        );
+    }
+
+    for (const table of tables) {
+        const routeName = toRoute(table.name);
+        const insertFields = table.fields.join(", ");
+        const placeholders = table.fields.map(() => "?").join(", ");
+        const values = table.fields.map((field) => `req.body.${field}`).join(", ");
+        const updateSet = table.fields.map((field) => `${field} = ?`).join(", ");
+        const updateValues = [...table.fields.map((field) => `req.body.${field}`), "req.params.id"].join(", ");
+
+        let route = `const express = require("express");
+const router = express.Router();
+const db = require("../config/db");
+${needsAuth ? 'const isAuthenticated = require("../middleware/auth");' : ""}
+
+`;
+
+        if (table.operations.includes("insert")) {
+            route += `router.post(
+  "/",
+  ${needsAuth ? "isAuthenticated," : ""}
+  async (req, res) => {
+    try {
+      const sql = "INSERT INTO ${table.name} (${insertFields}) VALUES (${placeholders})";
+      await db.query(sql, [${values}]);
+      res.json({ message: "${toPascal(table.name)} created" });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  }
+);
+
+`;
+        }
+
+        if (table.operations.includes("select")) {
+            route += `router.get(
+  "/",
+  ${needsAuth ? "isAuthenticated," : ""}
+  async (req, res) => {
+    try {
+      const [rows] = await db.query("SELECT * FROM ${table.name}");
+      res.json(rows);
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  }
+);
+
+`;
+        }
+
+        if (table.operations.includes("update")) {
+            route += `router.put(
+  "/:id",
+  ${needsAuth ? "isAuthenticated," : ""}
+  async (req, res) => {
+    try {
+      const sql = "UPDATE ${table.name} SET ${updateSet} WHERE id = ?";
+      await db.query(sql, [${updateValues}]);
+      res.json({ message: "${toPascal(table.name)} updated" });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  }
+);
+
+`;
+        }
+
+        if (table.operations.includes("delete")) {
+            route += `router.delete(
+  "/:id",
+  ${needsAuth ? "isAuthenticated," : ""}
+  async (req, res) => {
+    try {
+      await db.query("DELETE FROM ${table.name} WHERE id = ?", [req.params.id]);
+      res.json({ message: "${toPascal(table.name)} deleted" });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  }
+);
+
+`;
+        }
+
+        route += `module.exports = router;
+`;
+
+        await fs.outputFile(path.join(root, "routes", `${routeName}.js`), route);
+    }
+
+    const routeImports = tables
+        .map((t) => `const ${toPascal(t.name)}Route = require("./routes/${toRoute(t.name)}");`)
+        .join("\n");
+
+    const routeMounts = tables
+        .map((t) => `app.use("/${toRoute(t.name)}", ${toPascal(t.name)}Route);`)
+        .join("\n");
+
+    const authImport = needsAuth ? 'const authRoutes = require("./routes/auth");' : "";
+    const authMount = needsAuth ? 'app.use("/auth", authRoutes);' : "";
+    const authMiddleware = needsAuth
+        ? `const session = require("express-session");
+
+app.use(session({
+  secret: process.env.SESSION_SECRET || "change_me",
+  resave: false,
+  saveUninitialized: false,
+  cookie: {
+    httpOnly: true,
+    sameSite: "lax",
+    secure: false,
+  },
+}));
+`
+        : "";
+
+    const server = `const express = require("express");
+const cors = require("cors");
+const helmet = require("helmet");
+require("dotenv").config();
+
+const app = express();
+const db = require("./config/db");
+${authImport}
+${routeImports}
+
+app.use(helmet());
+app.use(cors({
+  origin: process.env.CLIENT_URL || "http://localhost:5173",
+  credentials: true,
+}));
+app.use(express.json());
+${authMiddleware}
+app.get("/health", (req, res) => res.json({ ok: true }));
+${authMount}
+${routeMounts}
+
+const port = process.env.PORT || 5000;
+
+app.listen(port, () => {
+  console.log(\`[✓] Server running on port \${port}\`);
+});
+`;
+
+    await fs.outputFile(path.join(root, "server.js"), server);
+    console.log("  [✓] backend files");
+}
+
+module.exports = {
+    generateBackend,
+};

package/src/generators/database.js

@@ -0,0 +1,54 @@
+const fs = require("fs-extra");
+const path = require("path");
+
+const { toPascal, escapeSqlIdentifier, inferSqlType } = require("./utils");
+
+async function generateDatabase(config) {
+    const { dbName, tables, needsAuth, targetDir } = config;
+
+    let sql = `-- ======================================================
+-- Database: ${dbName}
+-- Generated automatically
+-- ======================================================
+
+CREATE DATABASE IF NOT EXISTS ${escapeSqlIdentifier(dbName)};
+USE ${escapeSqlIdentifier(dbName)};
+
+`;
+
+    if (needsAuth) {
+        sql += `CREATE TABLE IF NOT EXISTS users (
+  id INT AUTO_INCREMENT PRIMARY KEY,
+  username VARCHAR(100) NOT NULL UNIQUE,
+  password VARCHAR(255) NOT NULL,
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+`;
+    }
+
+    for (const table of tables) {
+        sql += `-- ${toPascal(table.name)} table
+CREATE TABLE IF NOT EXISTS ${escapeSqlIdentifier(table.name)} (
+  id INT AUTO_INCREMENT PRIMARY KEY,
+`;
+
+        for (const field of table.fields) {
+            sql += `  ${escapeSqlIdentifier(field)} ${inferSqlType(field)} NOT NULL,
+`;
+        }
+
+        sql += `  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+`;
+    }
+
+    const outputPath = path.join(targetDir, "backend-project", "config", "database.sql");
+    await fs.outputFile(outputPath, sql);
+    console.log("  [✓] database.sql");
+}
+
+module.exports = {
+    generateDatabase,
+};

package/src/generators/frontend.js

@@ -0,0 +1,314 @@
+const fs = require("fs-extra");
+const path = require("path");
+const { toPascal, toRoute } = require("./utils");
+
+function generateFrontend(config) {
+    const { projectName, tables, needsAuth, needsReports, targetDir } = config;
+    const root = path.join(targetDir, "frontend-project");
+
+    fs.outputFileSync(
+        path.join(root, "package.json"),
+        JSON.stringify(
+            {
+                name: "frontend-project",
+                version: "1.0.0",
+                scripts: { dev: "vite", build: "vite build" },
+                dependencies: {
+                    react: "^18.2.0",
+                    "react-dom": "^18.2.0",
+                    "react-router-dom": "^6.18.0",
+                    axios: "^1.6.0",
+                },
+                devDependencies: {
+                    vite: "^5.0.0",
+                    "@vitejs/plugin-react": "^4.2.0",
+                    tailwindcss: "^3.3.0",
+                    autoprefixer: "^10.4.16",
+                    postcss: "^8.4.31",
+                },
+            },
+            null,
+            2
+        )
+    );
+
+    fs.outputFileSync(
+        path.join(root, "src", "api", "axios.js"),
+        `import axios from "axios";
+
+const API = axios.create({
+  baseURL: "http://localhost:5000",
+  withCredentials: true,
+});
+
+export default API;
+`
+    );
+
+    fs.outputFileSync(
+        path.join(root, "src", "main.jsx"),
+        `import React from "react";
+import ReactDOM from "react-dom/client";
+import App from "./App";
+import "./index.css";
+
+ReactDOM.createRoot(document.getElementById("root")).render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>
+);
+`
+    );
+
+    fs.outputFileSync(
+        path.join(root, "src", "index.css"),
+        `@tailwind base;
+@tailwind components;
+@tailwind utilities;
+`
+    );
+
+    for (const table of tables) {
+        const name = toPascal(table.name);
+        const route = toRoute(table.name);
+        const fields = table.fields;
+        const ops = table.operations;
+
+        const stateFields = fields.map((f) => `    ${f}: ""`).join(",\n");
+        const formReset = fields.map((f) => `${f}: ""`).join(", ");
+        const editSet = fields.map((f) => `${f}: item.${f}`).join(", ");
+        const inputs = fields
+            .map(
+                (f) => `        <input
+          type="text"
+          placeholder="${f}"
+          value={form.${f}}
+          onChange={(e) => setForm({ ...form, ${f}: e.target.value })}
+          className="border p-2 rounded w-full"
+        />`
+            )
+            .join("\n");
+
+        const tableHeaders = ["id", ...fields, "created_at"]
+            .map((f) => `          <th className="border px-4 py-2">${f}</th>`)
+            .join("\n");
+
+        const tableRow = ["id", ...fields, "created_at"]
+            .map((f) => `          <td className="border px-4 py-2">{item.${f}}</td>`)
+            .join("\n");
+
+        let page = `import { useState, useEffect } from "react";
+import API from "../api/axios";
+
+export default function ${name}() {
+  const [items, setItems] = useState([]);
+  const [form, setForm] = useState({
+${stateFields}
+  });
+${ops.includes("update") ? "  const [editId, setEditId] = useState(null);" : ""}
+
+  const fetchAll = async () => {
+    const res = await API.get("/${route}");
+    setItems(res.data);
+  };
+
+  useEffect(() => {
+    fetchAll();
+  }, []);
+
+`;
+
+        if (ops.includes("insert")) {
+            page += `  const handleSubmit = async (e) => {
+    e.preventDefault();
+${ops.includes("update") ? `    if (editId) {
+      await API.put(\`/${route}/\${editId}\`, form);
+      setEditId(null);
+    } else {
+      await API.post("/${route}", form);
+    }` : `    await API.post("/${route}", form);`}
+    setForm({ ${formReset} });
+    fetchAll();
+  };
+
+`;
+        }
+
+        if (ops.includes("delete")) {
+            page += `  const handleDelete = async (id) => {
+    if (!window.confirm("Are you sure you want to delete this?")) return;
+    await API.delete(\`/${route}/\${id}\`);
+    fetchAll();
+  };
+
+`;
+        }
+
+        if (ops.includes("update")) {
+            page += `  const handleEdit = (item) => {
+    setEditId(item.id);
+    setForm({ ${editSet} });
+  };
+
+`;
+        }
+
+        page += `  return (
+    <div className="p-6">
+      <h1 className="text-2xl font-bold mb-4">${name}</h1>
+
+      <form onSubmit={handleSubmit} className="flex flex-col gap-3 mb-6 max-w-md">
+${inputs}
+        <button type="submit" className="bg-blue-600 text-white px-4 py-2 rounded hover:bg-blue-700">
+          ${ops.includes("update") ? 'editId ? "Update" : "Add"' : '"Add"'}
+        </button>
+      </form>
+
+      <table className="w-full border-collapse text-sm">
+        <thead className="bg-gray-100">
+          <tr>
+${tableHeaders}
+${ops.includes("update") || ops.includes("delete") ? '          <th className="border px-4 py-2">Actions</th>' : ""}
+          </tr>
+        </thead>
+        <tbody>
+          {items.map((item) => (
+            <tr key={item.id} className="hover:bg-gray-50">
+${tableRow}
+${ops.includes("update") || ops.includes("delete") ? `          <td className="border px-4 py-2 space-x-2">
+${ops.includes("update") ? '            <button onClick={() => handleEdit(item)} className="text-blue-600 hover:underline">Edit</button>' : ""}
+${ops.includes("delete") ? '            <button onClick={() => handleDelete(item.id)} className="text-red-600 hover:underline">Delete</button>' : ""}
+          </td>` : ""}
+            </tr>
+          ))}
+        </tbody>
+      </table>
+    </div>
+  );
+}
+`;
+
+        fs.outputFileSync(path.join(root, "src", "pages", `${name}.jsx`), page);
+        console.log(`  [✓] pages/${name}.jsx`);
+    }
+
+    if (needsAuth) {
+        fs.outputFileSync(
+            path.join(root, "src", "pages", "Login.jsx"),
+            `import { useState } from "react";
+import { useNavigate } from "react-router-dom";
+import API from "../api/axios";
+
+export default function Login() {
+  const navigate = useNavigate();
+  const [form, setForm] = useState({ username: "", password: "" });
+  const [error, setError] = useState("");
+
+  const handleLogin = async (e) => {
+    e.preventDefault();
+    setError("");
+    try {
+      await API.post("/auth/login", form);
+      navigate("/");
+    } catch (err) {
+      setError(err.response?.data?.message || "Login failed");
+    }
+  };
+
+  return (
+    <div className="p-6 max-w-md">
+      <h1 className="text-2xl font-bold mb-4">Login</h1>
+      <form onSubmit={handleLogin} className="flex flex-col gap-3">
+        <input
+          className="border p-2 rounded"
+          placeholder="Username"
+          value={form.username}
+          onChange={(e) => setForm({ ...form, username: e.target.value })}
+        />
+        <input
+          className="border p-2 rounded"
+          type="password"
+          placeholder="Password"
+          value={form.password}
+          onChange={(e) => setForm({ ...form, password: e.target.value })}
+        />
+        {error ? <p className="text-red-600">{error}</p> : null}
+        <button className="bg-blue-600 text-white px-4 py-2 rounded">Login</button>
+      </form>
+    </div>
+  );
+}
+`
+        );
+    }
+
+    if (needsReports) {
+        fs.outputFileSync(
+            path.join(root, "src", "pages", "Reports.jsx"),
+            `export default function Reports() {
+  return (
+    <div className="p-6">
+      <h1 className="text-2xl font-bold mb-4">Reports</h1>
+      <p>Build your reports dashboard here.</p>
+    </div>
+  );
+}
+`
+        );
+    }
+
+    const imports = tables
+        .map((t) => `import ${toPascal(t.name)} from "./pages/${toPascal(t.name)}";`)
+        .join("\n");
+
+    const routes = tables
+        .map((t) => `          <Route path="/${toRoute(t.name)}" element={<${toPascal(t.name)} />} />`)
+        .join("\n");
+
+    const navLinks = tables
+        .map((t) => `          <Link to="/${toRoute(t.name)}" className="hover:underline">${toPascal(t.name)}</Link>`)
+        .join("\n");
+
+    const app = `import { BrowserRouter, Routes, Route, Link, useNavigate } from "react-router-dom";
+${imports}
+${needsAuth ? 'import Login from "./pages/Login";' : ""}
+${needsReports ? 'import Reports from "./pages/Reports";' : ""}
+import API from "./api/axios";
+
+function Navbar() {
+  const navigate = useNavigate();
+
+  const logout = async () => {
+    await API.post("/auth/logout");
+    navigate("/login");
+  };
+
+  return (
+    <nav className="bg-blue-700 text-white px-6 py-3 flex gap-6 items-center">
+      <span className="font-bold text-lg">${projectName}</span>
+${navLinks}
+${needsReports ? '      <Link to="/reports" className="hover:underline">Reports</Link>' : ""}
+${needsAuth ? '      <button onClick={logout} className="ml-auto hover:underline">Logout</button>' : ""}
+    </nav>
+  );
+}
+
+export default function App() {
+  return (
+    <BrowserRouter>
+      <Navbar />
+      <Routes>
+${needsAuth ? '        <Route path="/login" element={<Login />} />' : ""}
+${routes}
+${needsReports ? '        <Route path="/reports" element={<Reports />} />' : ""}
+      </Routes>
+    </BrowserRouter>
+  );
+}
+`;
+
+    fs.outputFileSync(path.join(root, "src", "App.jsx"), app);
+    console.log("  [✓] App.jsx");
+}
+
+module.exports = { generateFrontend };

package/src/generators/utils.js

@@ -0,0 +1,60 @@
+/**
+ * String and SQL helpers for generator templates.
+ */
+
+const normalizeInput = (value = "") => String(value).trim();
+
+const splitSnakeCase = (value = "") =>
+    normalizeInput(value)
+        .split("_")
+        .map((part) => part.trim())
+        .filter(Boolean);
+
+const capitalize = (value = "") =>
+    value ? value.charAt(0).toUpperCase() + value.slice(1) : "";
+
+const toPascal = (str = "") => splitSnakeCase(str).map(capitalize).join("");
+
+const toCamel = (str = "") => {
+    const pascal = toPascal(str);
+    return pascal ? pascal.charAt(0).toLowerCase() + pascal.slice(1) : "";
+};
+
+const toRoute = (str = "") =>
+    normalizeInput(str)
+        .replace(/_+/g, "-")
+        .replace(/\s+/g, "-")
+        .replace(/-+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .toLowerCase();
+
+const escapeSqlIdentifier = (identifier = "") => {
+    const safe = String(identifier).replace(/`/g, "``");
+    return `\`${safe}\``;
+};
+
+function inferSqlType(field = "") {
+    const lower = String(field).toLowerCase().trim();
+
+    if (!lower) return "VARCHAR(255)";
+    if (lower === "id" || lower.endsWith("_id")) return "INT";
+    if (lower.includes("quantity") || lower.includes("count") || lower.includes("number")) return "INT";
+    if (lower.includes("price") || lower.includes("amount") || lower.includes("total") || lower.includes("cost")) {
+        return "DECIMAL(10,2)";
+    }
+    if (lower.includes("date") || lower.includes("birthday")) return "DATE";
+    if (lower.includes("time")) return "DATETIME";
+    if (lower.includes("email")) return "VARCHAR(255)";
+    if (lower.includes("phone")) return "VARCHAR(30)";
+    if (lower.includes("description") || lower.includes("notes") || lower.includes("message")) return "TEXT";
+
+    return "VARCHAR(255)";
+}
+
+module.exports = {
+    toPascal,
+    toCamel,
+    toRoute,
+    escapeSqlIdentifier,
+    inferSqlType,
+};