create-diolo-app 1.0.0

package/index.js

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+
+import path from "path";
+import { fileURLToPath } from "url";
+import fs from "fs-extra";
+import inquirer from "inquirer";
+import chalk from "chalk";
+import ora from "ora";
+import { installDependencies } from "./utils/installDependencies.js";
+import { createEnvFiles } from "./utils/createEnv.js";
+import { replaceVariables } from "./utils/replaceVariables.js";
+import { gitInit } from "./utils/gitInit.js";
+import { generateProjectFiles } from "./utils/generateProjectFiles.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const templates = [
+  { name: "Employee Management System", value: "employee-management" },
+  { name: "Stock Management System", value: "stock-management" },
+  { name: "Car Management System", value: "car-management" },
+  { name: "Slot Car Management System", value: "slot-car-management" },
+  { name: "Inventory Management System", value: "inventory-management" },
+  { name: "Sales Records Management System", value: "sales-management" },
+  { name: "Supply Chain Management System", value: "supply-chain" },
+  { name: "School Management System", value: "school-management" },
+  { name: "Hospital Management System", value: "hospital-management" },
+  { name: "Hotel Management System", value: "hotel-management" },
+  { name: "POS System", value: "pos-system" },
+  { name: "E-Commerce System", value: "ecommerce-system" },
+  { name: "Library Management System", value: "library-management" },
+  { name: "Pharmacy Management System", value: "pharmacy-management" },
+  { name: "Banking Management System", value: "banking-management" },
+  { name: "Express API Starter", value: "express-api" },
+  { name: "React Dashboard Starter", value: "react-dashboard" },
+  { name: "Node.js Bot Starter", value: "bot-starter" }
+];
+
+function slugify(value) {
+  return value
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/(^-|-$)+/g, "");
+}
+
+function databaseName(projectName) {
+  return slugify(projectName).replace(/-/g, "_");
+}
+
+async function main() {
+  console.log(chalk.cyan.bold("\n🚀 Welcome to Create Diolo App\n"));
+
+  const answers = await inquirer.prompt([
+    {
+      type: "input",
+      name: "projectName",
+      message: "Project Name",
+      default: "diolo-business-app",
+      filter: slugify,
+      validate: (value) => (value ? true : "Project name is required.")
+    },
+    {
+      type: "list",
+      name: "template",
+      message: "Choose Template",
+      choices: templates
+    },
+    {
+      type: "list",
+      name: "databaseType",
+      message: "Database Type?",
+      choices: ["MySQL", "PostgreSQL", "MongoDB"]
+    },
+    {
+      type: "list",
+      name: "packageManager",
+      message: "Package Manager?",
+      choices: ["npm", "pnpm", "yarn"]
+    },
+    {
+      type: "input",
+      name: "port",
+      message: "Backend Port",
+      default: "5000",
+      validate: (value) => (/^\d+$/.test(value) ? true : "Port must be a number.")
+    }
+  ]);
+
+  const targetDir = path.resolve(process.cwd(), answers.projectName);
+  const templateDir = path.join(__dirname, "templates", answers.template);
+  const templateConfigPath = path.join(templateDir, "template.config.json");
+
+  if (await fs.pathExists(targetDir)) {
+    const { overwrite } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "overwrite",
+        message: `${answers.projectName} already exists. Overwrite it?`,
+        default: false
+      }
+    ]);
+
+    if (!overwrite) {
+      console.log(chalk.yellow("Project creation cancelled."));
+      return;
+    }
+
+    await fs.remove(targetDir);
+  }
+
+  const spinner = ora("Creating project files...").start();
+
+  try {
+    await fs.ensureDir(targetDir);
+    await fs.copy(templateDir, targetDir);
+
+    const templateConfig = await fs.readJson(templateConfigPath);
+    const variables = {
+      PROJECT_NAME: answers.projectName,
+      DATABASE_NAME: databaseName(answers.projectName),
+      DATABASE_TYPE: answers.databaseType,
+      PORT: answers.port,
+      TEMPLATE_NAME: templateConfig.name
+    };
+
+    await generateProjectFiles(targetDir, {
+      ...answers,
+      databaseName: variables.DATABASE_NAME,
+      templateConfig
+    });
+    await createEnvFiles(targetDir, variables, answers.databaseType);
+    await replaceVariables(targetDir, variables);
+
+    spinner.succeed("Project files created.");
+
+    await installDependencies(targetDir, answers.packageManager);
+    await gitInit(targetDir);
+
+    console.log(chalk.green.bold("\n✅ Project Created Successfully\n"));
+    console.log(chalk.bold("Next Steps:\n"));
+    console.log(`cd ${answers.projectName}`);
+    console.log(`${answers.packageManager} install`);
+    console.log(`${answers.packageManager} run dev\n`);
+  } catch (error) {
+    spinner.fail("Project creation failed.");
+    console.error(chalk.red(error.message));
+    process.exit(1);
+  }
+}
+
+main();

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "create-diolo-app",
+  "version": "1.0.0",
+  "description": "Create production-ready Diolo full-stack business management applications.",
+  "type": "module",
+  "main": "index.js",
+  "bin": {
+    "create-diolo-app": "./index.js"
+  },
+  "files": [
+    "index.js",
+    "utils",
+    "templates"
+  ],
+  "scripts": {
+    "start": "node index.js",
+    "lint": "node --check index.js && node --check utils/*.js"
+  },
+  "keywords": [
+    "create",
+    "cli",
+    "react",
+    "vite",
+    "express",
+    "business",
+    "dashboard"
+  ],
+  "author": "Diolo",
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "fs-extra": "^11.2.0",
+    "inquirer": "^9.2.23",
+    "ora": "^8.1.0"
+  },
+  "engines": {
+    "node": ">=18.18.0"
+  }
+}

package/templates/banking-management/template.config.json

@@ -0,0 +1 @@
+{ "name": "Banking Management System", "slug": "banking-management", "primaryEntity": "Account" }

package/templates/bot-starter/template.config.json

@@ -0,0 +1 @@
+{ "name": "Node.js Bot Starter", "slug": "bot-starter", "primaryEntity": "Task" }

package/templates/car-management/template.config.json

@@ -0,0 +1 @@
+{ "name": "Car Management System", "slug": "car-management", "primaryEntity": "Car" }

package/templates/ecommerce-system/template.config.json

@@ -0,0 +1 @@
+{ "name": "E-Commerce System", "slug": "ecommerce-system", "primaryEntity": "Order" }

package/templates/employee-management/template.config.json

@@ -0,0 +1 @@
+{ "name": "Employee Management System", "slug": "employee-management", "primaryEntity": "Employee" }

package/templates/express-api/template.config.json

@@ -0,0 +1 @@
+{ "name": "Express API Starter", "slug": "express-api", "primaryEntity": "Record" }

package/templates/hospital-management/template.config.json

@@ -0,0 +1 @@
+{ "name": "Hospital Management System", "slug": "hospital-management", "primaryEntity": "Patient" }

package/templates/hotel-management/template.config.json

@@ -0,0 +1 @@
+{ "name": "Hotel Management System", "slug": "hotel-management", "primaryEntity": "Booking" }

package/templates/inventory-management/template.config.json

@@ -0,0 +1 @@
+{ "name": "Inventory Management System", "slug": "inventory-management", "primaryEntity": "Inventory Item" }

package/templates/library-management/template.config.json

@@ -0,0 +1 @@
+{ "name": "Library Management System", "slug": "library-management", "primaryEntity": "Book" }

package/templates/pharmacy-management/template.config.json

@@ -0,0 +1 @@
+{ "name": "Pharmacy Management System", "slug": "pharmacy-management", "primaryEntity": "Medicine" }

package/templates/pos-system/template.config.json

@@ -0,0 +1 @@
+{ "name": "POS System", "slug": "pos-system", "primaryEntity": "Transaction" }

package/templates/react-dashboard/template.config.json

@@ -0,0 +1 @@
+{ "name": "React Dashboard Starter", "slug": "react-dashboard", "primaryEntity": "Dashboard" }

package/templates/sales-management/template.config.json

@@ -0,0 +1 @@
+{ "name": "Sales Records Management System", "slug": "sales-management", "primaryEntity": "Sale" }

package/templates/school-management/template.config.json

@@ -0,0 +1 @@
+{ "name": "School Management System", "slug": "school-management", "primaryEntity": "Student" }

package/templates/slot-car-management/template.config.json

@@ -0,0 +1 @@
+{ "name": "Slot Car Management System", "slug": "slot-car-management", "primaryEntity": "Slot Car" }

package/templates/stock-management/template.config.json

@@ -0,0 +1 @@
+{ "name": "Stock Management System", "slug": "stock-management", "primaryEntity": "Stock Item" }

package/templates/supply-chain/template.config.json

@@ -0,0 +1 @@
+{ "name": "Supply Chain Management System", "slug": "supply-chain", "primaryEntity": "Shipment" }

package/utils/createEnv.js

@@ -0,0 +1,37 @@
+import path from "path";
+import fs from "fs-extra";
+
+function dbDriver(databaseType) {
+  if (databaseType === "PostgreSQL") return "postgres";
+  if (databaseType === "MongoDB") return "mongodb";
+  return "mysql";
+}
+
+export async function createEnvFiles(projectDir, variables, databaseType) {
+  const env = [
+    `PORT=${variables.PORT}`,
+    `DATABASE_NAME=${variables.DATABASE_NAME}`,
+    "DB_HOST=localhost",
+    "DB_USER=root",
+    "DB_PASSWORD=",
+    `DB_DIALECT=${dbDriver(databaseType)}`,
+    `DATABASE_URL=${databaseType === "MongoDB" ? `mongodb://localhost:27017/${variables.DATABASE_NAME}` : ""}`,
+    "JWT_SECRET=change-this-secret-before-production",
+    "JWT_EXPIRES_IN=7d",
+    "CLIENT_URL=http://localhost:5173"
+  ].join("\n");
+
+  const backendDir = path.join(projectDir, "backend");
+  if (await fs.pathExists(backendDir)) {
+    await fs.writeFile(path.join(backendDir, ".env"), `${env}\n`, "utf8");
+  }
+
+  const rootEnv = [
+    `PORT=${variables.PORT}`,
+    `DATABASE_NAME=${variables.DATABASE_NAME}`,
+    `DATABASE_TYPE=${databaseType}`
+  ].join("\n");
+
+  await fs.writeFile(path.join(projectDir, ".env.example"), `${env}\n`, "utf8");
+  await fs.writeFile(path.join(projectDir, ".env"), `${rootEnv}\n`, "utf8");
+}

package/utils/generateProjectFiles.js

@@ -0,0 +1,841 @@
+import path from "path";
+import fs from "fs-extra";
+
+const businessCrud = ["Users", "Products", "Customers", "Orders", "Invoices", "Reports"];
+
+function packageScripts(packageManager, stack) {
+  const scoped = {
+    npm: (workspace, script) => `npm run ${script} --workspace ${workspace}`,
+    pnpm: (workspace, script) => `pnpm --filter ${workspace} run ${script}`,
+    yarn: (workspace, script) => `yarn workspace ${workspace} ${script}`
+  }[packageManager];
+
+  if (stack === "backend") return { dev: scoped("backend", "dev"), start: scoped("backend", "start") };
+  if (stack === "frontend") return { dev: scoped("frontend", "dev"), build: scoped("frontend", "build") };
+  if (stack === "bot") return { dev: "node --watch src/index.js", start: "node src/index.js" };
+  return {
+    dev: `concurrently "${scoped("backend", "dev")}" "${scoped("frontend", "dev")}"`,
+    build: scoped("frontend", "build"),
+    start: scoped("backend", "start")
+  };
+}
+
+function stackFor(templateValue) {
+  if (templateValue === "express-api") return "backend";
+  if (templateValue === "react-dashboard") return "frontend";
+  if (templateValue === "bot-starter") return "bot";
+  return "fullstack";
+}
+
+async function write(projectDir, file, content) {
+  const destination = path.join(projectDir, file);
+  await fs.ensureDir(path.dirname(destination));
+  await fs.writeFile(destination, `${content.trim()}\n`, "utf8");
+}
+
+function rootPackage({ projectName, packageManager, stack }) {
+  const workspaces = stack === "fullstack" ? ["backend", "frontend"] : stack === "backend" ? ["backend"] : stack === "frontend" ? ["frontend"] : undefined;
+  return JSON.stringify(
+    {
+      name: projectName,
+      version: "1.0.0",
+      private: true,
+      type: "module",
+      scripts: packageScripts(packageManager, stack),
+      workspaces,
+      dependencies: stack === "fullstack" ? { concurrently: "^8.2.2" } : undefined
+    },
+    null,
+    2
+  ).replace(/\n  "workspaces": undefined,|\n  "dependencies": undefined,/g, "");
+}
+
+function backendPackage() {
+  return JSON.stringify(
+    {
+      name: "backend",
+      version: "1.0.0",
+      private: true,
+      type: "module",
+      scripts: {
+        dev: "nodemon src/server.js",
+        start: "node src/server.js"
+      },
+      dependencies: {
+        bcrypt: "^5.1.1",
+        cors: "^2.8.5",
+        dotenv: "^16.4.5",
+        express: "^4.19.2",
+        "express-validator": "^7.2.0",
+        jsonwebtoken: "^9.0.2",
+        mongoose: "^8.5.2",
+        multer: "^1.4.5-lts.1",
+        mysql2: "^3.11.0",
+        pg: "^8.12.0",
+        "pg-hstore": "^2.3.4",
+        sequelize: "^6.37.3",
+        xlsx: "^0.18.5"
+      },
+      devDependencies: {
+        nodemon: "^3.1.4"
+      }
+    },
+    null,
+    2
+  );
+}
+
+function frontendPackage() {
+  return JSON.stringify(
+    {
+      name: "frontend",
+      version: "1.0.0",
+      private: true,
+      type: "module",
+      scripts: {
+        dev: "vite --host 0.0.0.0",
+        build: "vite build",
+        preview: "vite preview"
+      },
+      dependencies: {
+        "@vitejs/plugin-react": "^4.3.1",
+        axios: "^1.7.4",
+        "framer-motion": "^11.3.24",
+        jspdf: "^2.5.1",
+        "lucide-react": "^0.468.0",
+        react: "^19.0.0",
+        "react-dom": "^19.0.0",
+        "react-icons": "^5.2.1",
+        "react-router-dom": "^6.26.1",
+        recharts: "^2.12.7",
+        vite: "^5.4.0",
+        xlsx: "^0.18.5"
+      },
+      devDependencies: {
+        autoprefixer: "^10.4.20",
+        postcss: "^8.4.41",
+        tailwindcss: "^3.4.10"
+      }
+    },
+    null,
+    2
+  );
+}
+
+function serverJs() {
+  return `
+import http from "http";
+import app from "./app.js";
+import { connectDatabase } from "./config/database.js";
+
+const port = Number(process.env.PORT || 5000);
+
+async function boot() {
+  await connectDatabase();
+  http.createServer(app).listen(port, () => {
+    console.log(\`API running on http://localhost:\${port}\`);
+  });
+}
+
+boot().catch((error) => {
+  console.error("Failed to start server", error);
+  process.exit(1);
+});
+`;
+}
+
+function appJs() {
+  return `
+import "dotenv/config";
+import express from "express";
+import cors from "cors";
+import authRoutes from "./routes/auth.routes.js";
+import crudRoutes from "./routes/crud.routes.js";
+import { errorHandler, notFound } from "./middleware/error.js";
+
+const app = express();
+
+app.use(cors({ origin: process.env.CLIENT_URL || "http://localhost:5173", credentials: true }));
+app.use(express.json({ limit: "10mb" }));
+app.use(express.urlencoded({ extended: true }));
+
+app.get("/api/health", (_req, res) => {
+  res.json({ status: "ok", service: "{{PROJECT_NAME}}", timestamp: new Date().toISOString() });
+});
+
+app.use("/api/auth", authRoutes);
+app.use("/api", crudRoutes);
+app.use(notFound);
+app.use(errorHandler);
+
+export default app;
+`;
+}
+
+function databaseJs() {
+  return `
+import { Sequelize } from "sequelize";
+import mongoose from "mongoose";
+
+const dialect = process.env.DB_DIALECT || "mysql";
+
+export const sequelize =
+  dialect === "mongodb"
+    ? null
+    : new Sequelize(process.env.DATABASE_NAME, process.env.DB_USER, process.env.DB_PASSWORD, {
+        host: process.env.DB_HOST || "localhost",
+        dialect,
+        logging: false,
+        define: { underscored: true, timestamps: true }
+      });
+
+export async function connectDatabase() {
+  if (dialect === "mongodb") {
+    await mongoose.connect(process.env.DATABASE_URL || "mongodb://localhost:27017/{{DATABASE_NAME}}");
+    console.log("MongoDB connected");
+    return;
+  }
+
+  await sequelize.authenticate();
+  await sequelize.sync();
+  console.log(\`\${dialect} database connected\`);
+}
+`;
+}
+
+function authModelJs() {
+  return `
+import bcrypt from "bcrypt";
+import mongoose from "mongoose";
+import { DataTypes } from "sequelize";
+import { sequelize } from "../config/database.js";
+
+const roles = ["Admin", "Manager", "User"];
+
+const userFields = {
+  name: { type: String, required: true },
+  email: { type: String, required: true, unique: true, lowercase: true },
+  password: { type: String, required: true },
+  role: { type: String, enum: roles, default: "User" }
+};
+
+export const MongoUser = mongoose.models.User || mongoose.model("User", new mongoose.Schema(userFields, { timestamps: true }));
+
+export const SqlUser =
+  sequelize &&
+  sequelize.define("User", {
+    name: { type: DataTypes.STRING, allowNull: false },
+    email: { type: DataTypes.STRING, allowNull: false, unique: true, validate: { isEmail: true } },
+    password: { type: DataTypes.STRING, allowNull: false },
+    role: { type: DataTypes.ENUM(...roles), defaultValue: "User" }
+  });
+
+export function activeUserModel() {
+  return process.env.DB_DIALECT === "mongodb" ? MongoUser : SqlUser;
+}
+
+export async function hashPassword(password) {
+  return bcrypt.hash(password, 12);
+}
+
+export async function comparePassword(password, hash) {
+  return bcrypt.compare(password, hash);
+}
+`;
+}
+
+function crudModelJs() {
+  return `
+import mongoose from "mongoose";
+import { DataTypes } from "sequelize";
+import { sequelize } from "../config/database.js";
+
+const mongoSchema = new mongoose.Schema(
+  {
+    resource: { type: String, required: true, index: true },
+    name: { type: String, required: true },
+    status: { type: String, default: "Active" },
+    amount: { type: Number, default: 0 },
+    metadata: { type: Object, default: {} }
+  },
+  { timestamps: true }
+);
+
+export const MongoRecord = mongoose.models.Record || mongoose.model("Record", mongoSchema);
+
+export const SqlRecord =
+  sequelize &&
+  sequelize.define("Record", {
+    resource: { type: DataTypes.STRING, allowNull: false },
+    name: { type: DataTypes.STRING, allowNull: false },
+    status: { type: DataTypes.STRING, defaultValue: "Active" },
+    amount: { type: DataTypes.FLOAT, defaultValue: 0 },
+    metadata: { type: DataTypes.JSON }
+  });
+
+export function activeRecordModel() {
+  return process.env.DB_DIALECT === "mongodb" ? MongoRecord : SqlRecord;
+}
+`;
+}
+
+function authMiddlewareJs() {
+  return `
+import jwt from "jsonwebtoken";
+
+export function requireAuth(req, res, next) {
+  const header = req.headers.authorization || "";
+  const token = header.startsWith("Bearer ") ? header.slice(7) : null;
+
+  if (!token) return res.status(401).json({ message: "Authentication required" });
+
+  try {
+    req.user = jwt.verify(token, process.env.JWT_SECRET);
+    next();
+  } catch {
+    res.status(401).json({ message: "Invalid or expired token" });
+  }
+}
+
+export function allowRoles(...roles) {
+  return (req, res, next) => {
+    if (!roles.includes(req.user?.role)) return res.status(403).json({ message: "Insufficient permissions" });
+    next();
+  };
+}
+`;
+}
+
+function authRoutesJs() {
+  return `
+import express from "express";
+import jwt from "jsonwebtoken";
+import { body, validationResult } from "express-validator";
+import { activeUserModel, comparePassword, hashPassword } from "../models/user.model.js";
+import { requireAuth } from "../middleware/auth.js";
+
+const router = express.Router();
+
+function tokenFor(user) {
+  return jwt.sign({ id: user.id || user._id, email: user.email, role: user.role }, process.env.JWT_SECRET, {
+    expiresIn: process.env.JWT_EXPIRES_IN || "7d"
+  });
+}
+
+function publicUser(user) {
+  return { id: user.id || user._id, name: user.name, email: user.email, role: user.role };
+}
+
+router.post(
+  "/register",
+  body("name").notEmpty(),
+  body("email").isEmail(),
+  body("password").isLength({ min: 8 }),
+  async (req, res, next) => {
+    try {
+      const errors = validationResult(req);
+      if (!errors.isEmpty()) return res.status(422).json({ errors: errors.array() });
+
+      const User = activeUserModel();
+      const payload = { ...req.body, password: await hashPassword(req.body.password), role: req.body.role || "User" };
+      const user = await User.create(payload);
+      res.status(201).json({ user: publicUser(user), token: tokenFor(user) });
+    } catch (error) {
+      next(error);
+    }
+  }
+);
+
+router.post("/login", body("email").isEmail(), body("password").notEmpty(), async (req, res, next) => {
+  try {
+    const User = activeUserModel();
+    const user =
+      process.env.DB_DIALECT === "mongodb"
+        ? await User.findOne({ email: req.body.email })
+        : await User.findOne({ where: { email: req.body.email } });
+    if (!user || !(await comparePassword(req.body.password, user.password))) {
+      return res.status(401).json({ message: "Invalid credentials" });
+    }
+    res.json({ user: publicUser(user), token: tokenFor(user) });
+  } catch (error) {
+    next(error);
+  }
+});
+
+router.post("/forgot-password", body("email").isEmail(), (_req, res) => {
+  res.json({ message: "Password reset instructions will be sent if the account exists." });
+});
+
+router.get("/me", requireAuth, (req, res) => {
+  res.json({ user: req.user });
+});
+
+export default router;
+`;
+}
+
+function crudRoutesJs() {
+  return `
+import express from "express";
+import multer from "multer";
+import { Op } from "sequelize";
+import { requireAuth, allowRoles } from "../middleware/auth.js";
+import { activeRecordModel } from "../models/record.model.js";
+
+const router = express.Router();
+const upload = multer({ storage: multer.memoryStorage() });
+const resources = ${JSON.stringify(businessCrud.map((item) => item.toLowerCase()))};
+
+router.use(requireAuth);
+
+function assertResource(req, res, next) {
+  if (!resources.includes(req.params.resource)) return res.status(404).json({ message: "Unknown resource" });
+  next();
+}
+
+router.get("/:resource", assertResource, async (req, res, next) => {
+  try {
+    const Model = activeRecordModel();
+    const page = Number(req.query.page || 1);
+    const limit = Math.min(Number(req.query.limit || 10), 100);
+    const search = String(req.query.search || "");
+    const offset = (page - 1) * limit;
+
+    if (process.env.DB_DIALECT === "mongodb") {
+      const filter = { resource: req.params.resource, name: new RegExp(search, "i") };
+      const [items, total] = await Promise.all([
+        Model.find(filter).sort({ createdAt: -1 }).skip(offset).limit(limit),
+        Model.countDocuments(filter)
+      ]);
+      return res.json({ items, total, page, pages: Math.ceil(total / limit) });
+    }
+
+    const result = await Model.findAndCountAll({
+      where: { resource: req.params.resource, name: { [Op.like]: \`%\${search}%\` } },
+      order: [["createdAt", "DESC"]],
+      limit,
+      offset
+    });
+    res.json({ items: result.rows, total: result.count, page, pages: Math.ceil(result.count / limit) });
+  } catch (error) {
+    next(error);
+  }
+});
+
+router.post("/:resource", allowRoles("Admin", "Manager"), assertResource, upload.none(), async (req, res, next) => {
+  try {
+    const Model = activeRecordModel();
+    const item = await Model.create({ ...req.body, resource: req.params.resource });
+    res.status(201).json(item);
+  } catch (error) {
+    next(error);
+  }
+});
+
+router.put("/:resource/:id", allowRoles("Admin", "Manager"), assertResource, async (req, res, next) => {
+  try {
+    const Model = activeRecordModel();
+    const item = process.env.DB_DIALECT === "mongodb" ? await Model.findByIdAndUpdate(req.params.id, req.body, { new: true }) : await Model.findByPk(req.params.id);
+    if (!item) return res.status(404).json({ message: "Record not found" });
+    if (process.env.DB_DIALECT !== "mongodb") await item.update(req.body);
+    res.json(item);
+  } catch (error) {
+    next(error);
+  }
+});
+
+router.delete("/:resource/:id", allowRoles("Admin"), assertResource, async (req, res, next) => {
+  try {
+    const Model = activeRecordModel();
+    const item = process.env.DB_DIALECT === "mongodb" ? await Model.findByIdAndDelete(req.params.id) : await Model.findByPk(req.params.id);
+    if (!item) return res.status(404).json({ message: "Record not found" });
+    if (process.env.DB_DIALECT !== "mongodb") await item.destroy();
+    res.status(204).send();
+  } catch (error) {
+    next(error);
+  }
+});
+
+export default router;
+`;
+}
+
+function errorJs() {
+  return `
+export function notFound(req, res) {
+  res.status(404).json({ message: \`Route not found: \${req.originalUrl}\` });
+}
+
+export function errorHandler(error, _req, res, _next) {
+  const status = error.status || 500;
+  res.status(status).json({
+    message: status === 500 ? "Internal server error" : error.message,
+    detail: process.env.NODE_ENV === "production" ? undefined : error.message
+  });
+}
+`;
+}
+
+function frontendFiles(title, projectName) {
+  return {
+    "frontend/package.json": frontendPackage(),
+    "frontend/index.html": `<div id="root"></div><script type="module" src="/src/main.jsx"></script>`,
+    "frontend/vite.config.js": `
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+
+export default defineConfig({
+  plugins: [react()],
+  server: { port: 5173 },
+  preview: { port: 4173 }
+});
+`,
+    "frontend/postcss.config.js": `export default { plugins: { tailwindcss: {}, autoprefixer: {} } };`,
+    "frontend/tailwind.config.js": `
+export default {
+  content: ["./index.html", "./src/**/*.{js,jsx}"],
+  darkMode: "class",
+  theme: { extend: { fontFamily: { sans: ["Inter", "ui-sans-serif", "system-ui"] } } },
+  plugins: []
+};
+`,
+    "frontend/src/main.jsx": `
+import React from "react";
+import { createRoot } from "react-dom/client";
+import { BrowserRouter } from "react-router-dom";
+import App from "./App.jsx";
+import "./styles.css";
+
+createRoot(document.getElementById("root")).render(
+  <React.StrictMode>
+    <BrowserRouter>
+      <App />
+    </BrowserRouter>
+  </React.StrictMode>
+);
+`,
+    "frontend/src/api/client.js": `
+import axios from "axios";
+
+export const api = axios.create({
+  baseURL: import.meta.env.VITE_API_URL || "http://localhost:5000/api"
+});
+
+api.interceptors.request.use((config) => {
+  const token = localStorage.getItem("token");
+  if (token) config.headers.Authorization = \`Bearer \${token}\`;
+  return config;
+});
+`,
+    "frontend/src/App.jsx": `
+import { useMemo, useState } from "react";
+import { Link, Navigate, Route, Routes, useNavigate } from "react-router-dom";
+import { motion } from "framer-motion";
+import { FiBarChart2, FiBox, FiLogOut, FiMoon, FiSearch, FiSun, FiUsers } from "react-icons/fi";
+import { Area, AreaChart, CartesianGrid, ResponsiveContainer, Tooltip, XAxis, YAxis } from "recharts";
+import { jsPDF } from "jspdf";
+import * as XLSX from "xlsx";
+import { api } from "./api/client.js";
+
+const modules = ${JSON.stringify(businessCrud)};
+const chartData = [
+  { month: "Jan", value: 120 },
+  { month: "Feb", value: 180 },
+  { month: "Mar", value: 150 },
+  { month: "Apr", value: 230 },
+  { month: "May", value: 280 },
+  { month: "Jun", value: 320 }
+];
+
+function AuthPage({ mode }) {
+  const navigate = useNavigate();
+  const [form, setForm] = useState({ name: "", email: "admin@diolo.app", password: "password123", role: "Admin" });
+  const [error, setError] = useState("");
+
+  async function submit(event) {
+    event.preventDefault();
+    try {
+      if (mode === "forgot") {
+        await api.post("/auth/forgot-password", { email: form.email });
+        navigate("/login");
+        return;
+      }
+      const endpoint = mode === "register" ? "/auth/register" : "/auth/login";
+      const { data } = await api.post(endpoint, form);
+      localStorage.setItem("token", data.token);
+      localStorage.setItem("user", JSON.stringify(data.user));
+      navigate("/");
+    } catch (err) {
+      setError(err.response?.data?.message || "Please check your details and try again.");
+    }
+  }
+
+  return (
+    <main className="min-h-screen bg-slate-950 px-4 py-10 text-white">
+      <section className="mx-auto grid min-h-[calc(100vh-5rem)] max-w-6xl items-center gap-8 md:grid-cols-[1.1fr_.9fr]">
+        <div>
+          <p className="text-sm font-semibold uppercase tracking-wide text-cyan-300">${title}</p>
+          <h1 className="mt-4 text-4xl font-bold md:text-6xl">{mode === "forgot" ? "Recover access" : "Run business operations with confidence."}</h1>
+          <p className="mt-5 max-w-2xl text-lg text-slate-300">Role-based dashboards, CRUD workflows, charts, exports, search, pagination, and responsive layouts are wired from day one.</p>
+        </div>
+        <form onSubmit={submit} className="rounded-lg border border-slate-800 bg-white p-6 text-slate-950 shadow-2xl">
+          <h2 className="text-2xl font-bold">{mode === "register" ? "Create account" : mode === "forgot" ? "Forgot password" : "Login"}</h2>
+          {mode === "register" && <input className="mt-5 input" placeholder="Full name" value={form.name} onChange={(e) => setForm({ ...form, name: e.target.value })} />}
+          <input className="mt-4 input" placeholder="Email" value={form.email} onChange={(e) => setForm({ ...form, email: e.target.value })} />
+          {mode !== "forgot" && <input className="mt-4 input" type="password" placeholder="Password" value={form.password} onChange={(e) => setForm({ ...form, password: e.target.value })} />}
+          {mode === "register" && (
+            <select className="mt-4 input" value={form.role} onChange={(e) => setForm({ ...form, role: e.target.value })}>
+              <option>Admin</option><option>Manager</option><option>User</option>
+            </select>
+          )}
+          {error && <p className="mt-4 text-sm text-red-600">{error}</p>}
+          <button className="mt-5 w-full rounded-md bg-slate-950 px-4 py-3 font-semibold text-white">{mode === "forgot" ? "Send reset link" : "Continue"}</button>
+          <div className="mt-4 flex justify-between text-sm text-slate-600">
+            <Link to="/login">Login</Link>
+            <Link to="/register">Register</Link>
+            <Link to="/forgot-password">Forgot?</Link>
+          </div>
+        </form>
+      </section>
+    </main>
+  );
+}
+
+function Dashboard() {
+  const [dark, setDark] = useState(false);
+  const [active, setActive] = useState("Users");
+  const [query, setQuery] = useState("");
+  const [page, setPage] = useState(1);
+  const user = JSON.parse(localStorage.getItem("user") || '{"name":"Admin","role":"Admin"}');
+  const rows = useMemo(() => Array.from({ length: 18 }, (_, index) => ({
+    id: index + 1,
+    name: \`\${active.slice(0, -1)} \${index + 1}\`,
+    status: index % 3 === 0 ? "Pending" : "Active",
+    amount: 1200 + index * 135
+  })).filter((row) => row.name.toLowerCase().includes(query.toLowerCase())), [active, query]);
+  const visibleRows = rows.slice((page - 1) * 6, page * 6);
+
+  function logout() {
+    localStorage.clear();
+    window.location.href = "/login";
+  }
+
+  function exportPdf() {
+    const doc = new jsPDF();
+    doc.text(\`\${active} Report\`, 14, 18);
+    visibleRows.forEach((row, index) => doc.text(\`\${row.id}. \${row.name} - \${row.status} - $\${row.amount}\`, 14, 30 + index * 8));
+    doc.save(\`\${active.toLowerCase()}-report.pdf\`);
+  }
+
+  function exportExcel() {
+    const sheet = XLSX.utils.json_to_sheet(visibleRows);
+    const book = XLSX.utils.book_new();
+    XLSX.utils.book_append_sheet(book, sheet, active);
+    XLSX.writeFile(book, \`\${active.toLowerCase()}-report.xlsx\`);
+  }
+
+  return (
+    <div className={dark ? "dark" : ""}>
+      <div className="min-h-screen bg-slate-100 text-slate-950 dark:bg-slate-950 dark:text-white">
+        <aside className="fixed inset-y-0 left-0 hidden w-64 border-r border-slate-200 bg-white p-5 dark:border-slate-800 dark:bg-slate-900 lg:block">
+          <div className="flex items-center gap-3 text-xl font-bold"><FiBox /> ${projectName}</div>
+          <nav className="mt-8 space-y-1">
+            {modules.map((module) => (
+              <button key={module} onClick={() => { setActive(module); setPage(1); }} className={\`nav-item \${active === module ? "nav-active" : ""}\`}>
+                {module === "Users" ? <FiUsers /> : <FiBarChart2 />} {module}
+              </button>
+            ))}
+          </nav>
+        </aside>
+        <main className="lg:pl-64">
+          <header className="sticky top-0 z-10 flex items-center justify-between border-b border-slate-200 bg-white/90 px-5 py-4 backdrop-blur dark:border-slate-800 dark:bg-slate-900/90">
+            <div>
+              <p className="text-sm text-slate-500 dark:text-slate-400">{user.role}</p>
+              <h1 className="text-xl font-bold">${title}</h1>
+            </div>
+            <div className="flex items-center gap-2">
+              <button className="icon-btn" onClick={() => setDark(!dark)} aria-label="Toggle dark mode">{dark ? <FiSun /> : <FiMoon />}</button>
+              <button className="icon-btn" onClick={logout} aria-label="Logout"><FiLogOut /></button>
+            </div>
+          </header>
+          <section className="grid gap-5 p-5 md:grid-cols-3">
+            {["Revenue", "Orders", "Customers"].map((label, index) => (
+              <motion.div initial={{ opacity: 0, y: 12 }} animate={{ opacity: 1, y: 0 }} transition={{ delay: index * 0.05 }} className="metric" key={label}>
+                <p>{label}</p><strong>{index === 0 ? "$84,220" : index === 1 ? "1,284" : "642"}</strong>
+              </motion.div>
+            ))}
+          </section>
+          <section className="grid gap-5 px-5 pb-5 xl:grid-cols-[1fr_1.3fr]">
+            <div className="panel h-80">
+              <h2 className="section-title">Performance</h2>
+              <ResponsiveContainer width="100%" height="85%">
+                <AreaChart data={chartData}><CartesianGrid strokeDasharray="3 3" /><XAxis dataKey="month" /><YAxis /><Tooltip /><Area type="monotone" dataKey="value" stroke="#0891b2" fill="#67e8f9" /></AreaChart>
+              </ResponsiveContainer>
+            </div>
+            <div className="panel">
+              <div className="flex flex-col gap-3 md:flex-row md:items-center md:justify-between">
+                <h2 className="section-title">{active}</h2>
+                <div className="flex flex-wrap gap-2">
+                  <label className="search"><FiSearch /><input value={query} onChange={(e) => setQuery(e.target.value)} placeholder="Search" /></label>
+                  <button className="action-btn" onClick={exportPdf}>Export PDF</button>
+                  <button className="action-btn" onClick={exportExcel}>Export Excel</button>
+                </div>
+              </div>
+              <div className="mt-5 overflow-x-auto">
+                <table className="w-full min-w-[620px] text-left text-sm">
+                  <thead><tr className="border-b border-slate-200 dark:border-slate-800"><th>ID</th><th>Name</th><th>Status</th><th>Amount</th></tr></thead>
+                  <tbody>{visibleRows.map((row) => <tr key={row.id} className="border-b border-slate-100 dark:border-slate-800"><td>{row.id}</td><td>{row.name}</td><td><span className="badge">{row.status}</span></td><td>{\`$\${row.amount.toLocaleString()}\`}</td></tr>)}</tbody>
+                </table>
+              </div>
+              <div className="mt-4 flex items-center justify-between">
+                <button className="action-btn" disabled={page === 1} onClick={() => setPage(page - 1)}>Previous</button>
+                <span className="text-sm text-slate-500">Page {page}</span>
+                <button className="action-btn" disabled={page * 6 >= rows.length} onClick={() => setPage(page + 1)}>Next</button>
+              </div>
+            </div>
+          </section>
+        </main>
+      </div>
+    </div>
+  );
+}
+
+function Protected() {
+  return localStorage.getItem("token") ? <Dashboard /> : <Navigate to="/login" replace />;
+}
+
+export default function App() {
+  return (
+    <Routes>
+      <Route path="/" element={<Protected />} />
+      <Route path="/login" element={<AuthPage mode="login" />} />
+      <Route path="/register" element={<AuthPage mode="register" />} />
+      <Route path="/forgot-password" element={<AuthPage mode="forgot" />} />
+    </Routes>
+  );
+}
+`,
+    "frontend/src/styles.css": `
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+* { box-sizing: border-box; }
+body { margin: 0; font-family: Inter, ui-sans-serif, system-ui, sans-serif; }
+th, td { padding: 0.85rem 0.7rem; }
+.input { width: 100%; border: 1px solid #cbd5e1; border-radius: 0.5rem; padding: 0.8rem 0.9rem; outline: none; }
+.input:focus { border-color: #0891b2; box-shadow: 0 0 0 3px rgb(8 145 178 / 15%); }
+.nav-item { display: flex; width: 100%; align-items: center; gap: 0.75rem; border-radius: 0.5rem; padding: 0.75rem; color: #475569; }
+.nav-active, .nav-item:hover { background: #ecfeff; color: #0e7490; }
+.dark .nav-active, .dark .nav-item:hover { background: #164e63; color: white; }
+.icon-btn { display: grid; place-items: center; width: 2.5rem; height: 2.5rem; border: 1px solid #cbd5e1; border-radius: 0.5rem; }
+.metric, .panel { border: 1px solid #e2e8f0; border-radius: 0.5rem; background: white; padding: 1.25rem; box-shadow: 0 8px 30px rgb(15 23 42 / 5%); }
+.dark .metric, .dark .panel { border-color: #1e293b; background: #0f172a; }
+.metric p { color: #64748b; font-size: 0.9rem; }
+.metric strong { display: block; margin-top: 0.5rem; font-size: 1.8rem; }
+.section-title { font-size: 1.1rem; font-weight: 800; }
+.search { display: flex; align-items: center; gap: 0.5rem; border: 1px solid #cbd5e1; border-radius: 0.5rem; padding: 0.6rem 0.75rem; }
+.search input { min-width: 10rem; border: 0; background: transparent; outline: none; }
+.action-btn { border: 1px solid #cbd5e1; border-radius: 0.5rem; padding: 0.6rem 0.85rem; font-weight: 700; }
+.action-btn:disabled { opacity: 0.45; }
+.badge { border-radius: 999px; background: #dcfce7; color: #166534; padding: 0.25rem 0.55rem; font-size: 0.75rem; font-weight: 700; }
+`
+  };
+}
+
+function readme({ title, databaseType, stack }) {
+  return `
+# {{PROJECT_NAME}}
+
+Generated with create-diolo-app.
+
+## Stack
+
+- ${stack === "frontend" ? "React 19, Vite, Tailwind CSS" : stack === "backend" ? "Node.js, Express, JWT, Sequelize, MongoDB support" : "React 19, Vite, Tailwind CSS, Node.js, Express, JWT"}
+- Database: ${databaseType}
+- Role-based access: Admin, Manager, User
+- Dashboard: sidebar, navbar, dark mode, charts, tables, pagination, search, PDF and Excel exports
+- CRUD modules: ${businessCrud.join(", ")}
+
+## Getting Started
+
+\`\`\`bash
+npm install
+npm run dev
+\`\`\`
+
+Backend runs on http://localhost:{{PORT}} and frontend runs on http://localhost:5173.
+
+## Environment
+
+Update \`backend/.env\` before production. Set a strong \`JWT_SECRET\`, database credentials, and allowed \`CLIENT_URL\`.
+`;
+}
+
+function botFiles({ projectName }) {
+  return {
+    "package.json": JSON.stringify(
+      {
+        name: projectName,
+        version: "1.0.0",
+        private: true,
+        type: "module",
+        scripts: { dev: "node --watch src/index.js", start: "node src/index.js" },
+        dependencies: { dotenv: "^16.4.5" }
+      },
+      null,
+      2
+    ),
+    "src/index.js": `
+import "dotenv/config";
+
+const botName = process.env.BOT_NAME || "{{PROJECT_NAME}}";
+
+async function startBot() {
+  console.log(\`\${botName} is online.\`);
+  console.log("Add your queue, webhook, chat, or automation adapter in src/index.js.");
+}
+
+startBot().catch((error) => {
+  console.error("Bot failed", error);
+  process.exit(1);
+});
+`,
+    ".env": "BOT_NAME={{PROJECT_NAME}}",
+    "README.md": "# {{PROJECT_NAME}}\n\nNode.js bot starter generated with create-diolo-app.\n\n```bash\nnpm install\nnpm run dev\n```"
+  };
+}
+
+export async function generateProjectFiles(projectDir, options) {
+  const stack = stackFor(options.template);
+  const title = options.templateConfig.name;
+
+  if (stack === "bot") {
+    for (const [file, content] of Object.entries(botFiles(options))) await write(projectDir, file, content);
+    return;
+  }
+
+  await write(projectDir, "package.json", rootPackage({ ...options, stack }));
+  await write(projectDir, ".gitignore", "node_modules\n.env\n.DS_Store\ndist\ncoverage\nuploads\n");
+  await write(projectDir, "README.md", readme({ title, databaseType: options.databaseType, stack }));
+
+  if (stack === "fullstack" || stack === "backend") {
+    const backend = {
+      "backend/package.json": backendPackage(),
+      "backend/src/server.js": serverJs(),
+      "backend/src/app.js": appJs(),
+      "backend/src/config/database.js": databaseJs(),
+      "backend/src/models/user.model.js": authModelJs(),
+      "backend/src/models/record.model.js": crudModelJs(),
+      "backend/src/middleware/auth.js": authMiddlewareJs(),
+      "backend/src/middleware/error.js": errorJs(),
+      "backend/src/routes/auth.routes.js": authRoutesJs(),
+      "backend/src/routes/crud.routes.js": crudRoutesJs()
+    };
+    for (const [file, content] of Object.entries(backend)) await write(projectDir, file, content);
+  }
+
+  if (stack === "fullstack" || stack === "frontend") {
+    for (const [file, content] of Object.entries(frontendFiles(title, options.projectName))) await write(projectDir, file, content);
+  }
+}

package/utils/gitInit.js

@@ -0,0 +1,23 @@
+import { spawn } from "child_process";
+import ora from "ora";
+
+export async function gitInit(projectDir) {
+  const spinner = ora("Initializing Git repository...").start();
+
+  return new Promise((resolve) => {
+    const child = spawn("git", ["init"], {
+      cwd: projectDir,
+      stdio: "pipe",
+      shell: process.platform === "win32"
+    });
+
+    child.on("close", (code) => {
+      if (code === 0) {
+        spinner.succeed("Git repository initialized.");
+      } else {
+        spinner.warn("Git was not initialized. You can run git init manually.");
+      }
+      resolve();
+    });
+  });
+}

package/utils/installDependencies.js

@@ -0,0 +1,39 @@
+import { spawn } from "child_process";
+import ora from "ora";
+
+const installCommands = {
+  npm: ["install"],
+  pnpm: ["install"],
+  yarn: ["install"]
+};
+
+export async function installDependencies(projectDir, packageManager) {
+  const spinner = ora(`Installing dependencies with ${packageManager}...`).start();
+
+  return new Promise((resolve, reject) => {
+    const child = spawn(packageManager, installCommands[packageManager], {
+      cwd: projectDir,
+      stdio: "pipe",
+      shell: process.platform === "win32"
+    });
+
+    let output = "";
+    child.stdout.on("data", (data) => {
+      output += data.toString();
+    });
+    child.stderr.on("data", (data) => {
+      output += data.toString();
+    });
+
+    child.on("close", (code) => {
+      if (code === 0) {
+        spinner.succeed("Dependencies installed.");
+        resolve();
+        return;
+      }
+
+      spinner.fail("Dependency installation failed.");
+      reject(new Error(output || `${packageManager} install exited with code ${code}`));
+    });
+  });
+}

package/utils/replaceVariables.js

@@ -0,0 +1,38 @@
+import path from "path";
+import fs from "fs-extra";
+
+const textExtensions = new Set([
+  ".js",
+  ".jsx",
+  ".ts",
+  ".tsx",
+  ".json",
+  ".md",
+  ".env",
+  ".txt",
+  ".html",
+  ".css",
+  ".sql"
+]);
+
+export async function replaceVariables(targetDir, variables) {
+  const entries = await fs.readdir(targetDir);
+
+  for (const entry of entries) {
+    const entryPath = path.join(targetDir, entry);
+    const stat = await fs.stat(entryPath);
+
+    if (stat.isDirectory()) {
+      await replaceVariables(entryPath, variables);
+      continue;
+    }
+
+    if (!textExtensions.has(path.extname(entryPath))) continue;
+
+    let content = await fs.readFile(entryPath, "utf8");
+    for (const [key, value] of Object.entries(variables)) {
+      content = content.replaceAll(`{{${key}}}`, String(value));
+    }
+    await fs.writeFile(entryPath, content, "utf8");
+  }
+}