create-stackflow 1.0.0

package/src/generators/backend.js

@@ -0,0 +1,501 @@
+import path from "node:path";
+import fs from "fs-extra";
+import ora from "ora";
+import { execa } from "execa";
+import { ext, writeTemplate } from "../utils/template.js";
+
+export async function createBackend(context) {
+  const spinner = ora("Generating backend API").start();
+  try {
+    await fs.ensureDir(context.backendDir);
+    await writeBackendFiles(context);
+    spinner.succeed("Generating backend API");
+  } catch (error) {
+    spinner.fail("Generating backend API");
+    throw error;
+  }
+
+  if (!context.skipInstall) {
+    const install = ora("Installing backend dependencies").start();
+    try {
+      await execa("npm", ["install"], { cwd: context.backendDir, stdio: "ignore" });
+      install.succeed("Installing backend dependencies");
+    } catch (error) {
+      install.fail("Installing backend dependencies");
+      throw error;
+    }
+  }
+}
+
+async function writeBackendFiles(context) {
+  const backendContext = { ...context, language: context.backendLanguage || context.language };
+  const e = ext(backendContext);
+  const isTs = backendContext.language === "typescript";
+  const clientUrl = context.frontend === "next" ? "http://localhost:3000" : "http://localhost:5173";
+  const deps = {
+    bcryptjs: "latest",
+    "cookie-parser": context.cookieParser === false ? undefined : "latest",
+    cors: context.cors === false ? undefined : "latest",
+    dotenv: "latest",
+    express: "latest",
+    "express-rate-limit": context.rateLimit === false ? undefined : "latest",
+    helmet: context.helmet === false ? undefined : "latest",
+    hpp: context.hpp ? "latest" : undefined,
+    jsonwebtoken: "latest",
+    mongoose: "latest",
+    multer: context.multer ? "latest" : undefined,
+    morgan: context.morgan ? "latest" : undefined,
+    winston: context.winston ? "latest" : undefined,
+    "swagger-jsdoc": context.swagger ? "latest" : undefined,
+    "swagger-ui-express": context.swagger ? "latest" : undefined,
+    "socket.io": context.socketio ? "latest" : undefined,
+    cloudinary: context.cloudinary ? "latest" : undefined
+  };
+  const devDeps = isTs
+    ? {
+        "@types/bcryptjs": "latest",
+        "@types/cookie-parser": "latest",
+        "@types/cors": "latest",
+        "@types/express": "latest",
+        "@types/jsonwebtoken": "latest",
+        "@types/morgan": context.morgan ? "latest" : undefined,
+        "@types/multer": context.multer ? "latest" : undefined,
+        "@types/node": "latest",
+        nodemon: "latest",
+        tsx: "latest",
+        typescript: "latest"
+      }
+    : { nodemon: "latest" };
+
+  await writeTemplate(path.join(context.backendDir, "package.json"), JSON.stringify({
+    name: path.basename(context.backendDir),
+    version: "1.0.0",
+    type: "module",
+    private: true,
+    scripts: {
+      dev: isTs ? "tsx watch src/server.ts" : "nodemon src/server.js",
+      start: isTs ? "node dist/server.js" : "node src/server.js",
+      build: isTs ? "tsc" : "echo \"No build step for JavaScript backend\""
+    },
+    dependencies: compact(deps),
+    devDependencies: compact(devDeps)
+  }, null, 2) + "\n");
+
+  if (isTs) {
+    await writeTemplate(path.join(context.backendDir, "tsconfig.json"), `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": false,
+    "noImplicitAny": false,
+    "noCheck": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src"]
+}
+`);
+  }
+
+  await writeTemplate(path.join(context.backendDir, ".env"), `PORT=5000
+NODE_ENV=development
+CLIENT_URL={{clientUrl}}
+MONGODB_URI=mongodb://127.0.0.1:27017/{{databaseName}}
+JWT_SECRET=change_this_super_secret_value
+JWT_EXPIRES_IN=7d
+COOKIE_NAME=stackflow_token
+{{cloudinaryEnv}}
+`, { ...context, clientUrl, cloudinaryEnv: context.cloudinary ? "CLOUDINARY_CLOUD_NAME=\nCLOUDINARY_API_KEY=\nCLOUDINARY_API_SECRET=" : "" });
+
+  const dirs = [
+    "src/config",
+    "src/controllers",
+    "src/middleware",
+    "src/models",
+    "src/routes",
+    "src/services",
+    "src/utils",
+    "src/validations"
+  ];
+  if (context.multer) dirs.push("uploads");
+  await Promise.all(dirs.map((dir) => fs.ensureDir(path.join(context.backendDir, dir))));
+  if (context.multer) await fs.outputFile(path.join(context.backendDir, "uploads", ".gitkeep"), "");
+
+  const files = backendTemplates({ ...context, language: backendContext.language, clientUrl }, e);
+  await Promise.all(Object.entries(files).map(([file, content]) =>
+    writeTemplate(path.join(context.backendDir, file), content, context)
+  ));
+}
+
+function compact(object) {
+  return Object.fromEntries(Object.entries(object).filter(([, value]) => value));
+}
+
+function backendTemplates(context, e) {
+  const isTs = context.language === "typescript";
+  const type = (name) => isTs ? `: ${name}` : "";
+  const reqRes = isTs ? "import type { Request, Response, NextFunction } from \"express\";\n" : "";
+  const imports = {
+    logger: context.winston ? "import { logger } from \"./utils/logger.js\";" : "",
+    morgan: context.morgan ? "import morgan from \"morgan\";" : "",
+    swagger: context.swagger ? "import { setupSwagger } from \"./config/swagger.js\";" : "",
+    socket: context.socketio ? "import { Server } from \"socket.io\";" : ""
+  };
+
+  return {
+    [`src/server.${e}`]: `import http from "node:http";
+import app from "./app.js";
+import { connectDB } from "./config/db.js";
+${imports.socket}
+${imports.logger}
+
+const PORT = Number(process.env.PORT) || 5000;
+
+async function bootstrap() {
+  await connectDB();
+  const server = http.createServer(app);
+${context.socketio ? `
+  const io = new Server(server, {
+    cors: {
+      origin: process.env.CLIENT_URL || "${context.clientUrl}",
+      credentials: true
+    }
+  });
+
+  io.on("connection", (socket) => {
+    socket.emit("connected", { message: "Socket.IO connected" });
+  });
+` : ""}
+  server.listen(PORT, () => {
+    ${context.winston ? "logger.info(`API running on http://localhost:${PORT}`);" : "console.log(`API running on http://localhost:${PORT}`);"}
+  });
+}
+
+bootstrap().catch((error) => {
+  ${context.winston ? "logger.error(error);" : "console.error(error);"}
+  process.exit(1);
+});
+`,
+    [`src/app.${e}`]: `import "dotenv/config";
+import express from "express";
+${context.cookieParser === false ? "" : "import cookieParser from \"cookie-parser\";"}
+${context.cors === false ? "" : "import cors from \"cors\";"}
+${context.helmet === false ? "" : "import helmet from \"helmet\";"}
+${context.rateLimit === false ? "" : "import rateLimit from \"express-rate-limit\";"}
+${context.hpp ? "import hpp from \"hpp\";" : ""}
+${imports.morgan}
+${imports.swagger}
+import apiRoutes from "./routes/index.routes.js";
+import { errorHandler } from "./middleware/error.middleware.js";
+import { notFound } from "./middleware/not-found.middleware.js";
+
+const app = express();
+
+${context.helmet === false ? "" : "app.use(helmet());"}
+${context.hpp ? "app.use(hpp());" : ""}
+${context.cors === false ? "" : `app.use(cors({
+  origin: process.env.CLIENT_URL || "${context.clientUrl}",
+  credentials: true
+}));`}
+${context.rateLimit === false ? "" : "app.use(rateLimit({ windowMs: 15 * 60 * 1000, limit: 300 }));"}
+app.use("/uploads", express.static("uploads"));
+app.use(express.json({ limit: "1mb" }));
+app.use(express.urlencoded({ extended: true }));
+${context.cookieParser === false ? "" : "app.use(cookieParser());"}
+${context.morgan ? "app.use(morgan(\"dev\"));" : ""}
+${context.swagger ? "setupSwagger(app);" : ""}
+
+app.get("/api/health", (_req, res) => {
+  res.json({ status: "ok", service: "stackflow-api" });
+});
+
+app.use("/api", apiRoutes);
+app.use(notFound);
+app.use(errorHandler);
+
+export default app;
+`,
+    [`src/config/db.${e}`]: `import mongoose from "mongoose";
+${context.winston ? "import { logger } from \"../utils/logger.js\";" : ""}
+
+export async function connectDB() {
+  const uri = process.env.MONGODB_URI;
+  if (!uri) throw new Error("MONGODB_URI is required");
+  await mongoose.connect(uri);
+  ${context.winston ? "logger.info(\"MongoDB connected\");" : "console.log(\"MongoDB connected\");"}
+}
+`,
+    [`src/models/user.model.${e}`]: `import mongoose from "mongoose";
+import bcrypt from "bcryptjs";
+
+const userSchema = new mongoose.Schema({
+  name: { type: String, required: true, trim: true },
+  email: { type: String, required: true, unique: true, lowercase: true, trim: true },
+  password: { type: String, required: true, minlength: 6 }
+}, { timestamps: true });
+
+userSchema.pre("save", async function() {
+  if (!this.isModified("password")) return;
+  this.password = await bcrypt.hash(this.password, 12);
+});
+
+userSchema.methods.comparePassword = function(candidatePassword) {
+  return bcrypt.compare(candidatePassword, this.password);
+};
+
+export const User = mongoose.model("User", userSchema);
+`,
+    [`src/models/task.model.${e}`]: `import mongoose from "mongoose";
+
+const taskSchema = new mongoose.Schema({
+  title: { type: String, required: true, trim: true },
+  description: { type: String, default: "" },
+  imageUrl: { type: String, default: "" },
+  status: { type: String, enum: ["todo", "in-progress", "done"], default: "todo" },
+  owner: { type: mongoose.Schema.Types.ObjectId, ref: "User", required: true }
+}, { timestamps: true });
+
+export const Task = mongoose.model("Task", taskSchema);
+`,
+    [`src/utils/jwt.${e}`]: `import jwt from "jsonwebtoken";
+
+export function signToken(userId) {
+  return jwt.sign({ userId }, process.env.JWT_SECRET || "dev_secret", {
+    expiresIn: process.env.JWT_EXPIRES_IN || "7d"
+  });
+}
+
+export function setAuthCookie(res, token) {
+  res.cookie(process.env.COOKIE_NAME || "stackflow_token", token, {
+    httpOnly: true,
+    sameSite: "lax",
+    secure: process.env.NODE_ENV === "production",
+    maxAge: 7 * 24 * 60 * 60 * 1000
+  });
+}
+`,
+    [`src/middleware/auth.middleware.${e}`]: `${reqRes}import jwt from "jsonwebtoken";
+import { User } from "../models/user.model.js";
+
+export async function protect(req${type("Request & { user?: unknown }")}, res${type("Response")}, next${type("NextFunction")}) {
+  try {
+    const cookieToken = req.cookies?.[process.env.COOKIE_NAME || "stackflow_token"];
+    const headerToken = req.headers.authorization?.startsWith("Bearer ")
+      ? req.headers.authorization.split(" ")[1]
+      : undefined;
+    const token = cookieToken || headerToken;
+    if (!token) return res.status(401).json({ message: "Authentication required" });
+
+    const decoded = jwt.verify(token, process.env.JWT_SECRET || "dev_secret");
+    const userId = typeof decoded === "object" && "userId" in decoded ? decoded.userId : null;
+    const user = await User.findById(userId).select("-password");
+    if (!user) return res.status(401).json({ message: "Invalid authentication" });
+
+    req.user = user;
+    next();
+  } catch {
+    res.status(401).json({ message: "Invalid or expired token" });
+  }
+}
+`,
+    [`src/middleware/error.middleware.${e}`]: `${reqRes}export function errorHandler(error${type("Error & { statusCode?: number }")}, _req${type("Request")}, res${type("Response")}, _next${type("NextFunction")}) {
+  const status = error.statusCode || 500;
+  res.status(status).json({
+    message: error.message || "Server error",
+    stack: process.env.NODE_ENV === "production" ? undefined : error.stack
+  });
+}
+`,
+    [`src/middleware/not-found.middleware.${e}`]: `${reqRes}export function notFound(req${type("Request")}, res${type("Response")}) {
+  res.status(404).json({ message: \`Route not found: \${req.originalUrl}\` });
+}
+`,
+    [`src/controllers/auth.controller.${e}`]: `import { User } from "../models/user.model.js";
+import { signToken, setAuthCookie } from "../utils/jwt.js";
+
+function publicUser(user) {
+  return { id: user._id, name: user.name, email: user.email };
+}
+
+export async function register(req, res, next) {
+  try {
+    const { name, email, password } = req.body;
+    const existing = await User.findOne({ email });
+    if (existing) return res.status(409).json({ message: "Email already registered" });
+    const user = await User.create({ name, email, password });
+    const token = signToken(user._id);
+    setAuthCookie(res, token);
+    res.status(201).json({ user: publicUser(user), token });
+  } catch (error) {
+    next(error);
+  }
+}
+
+export async function login(req, res, next) {
+  try {
+    const { email, password } = req.body;
+    const user = await User.findOne({ email });
+    if (!user || !(await user.comparePassword(password))) {
+      return res.status(401).json({ message: "Invalid email or password" });
+    }
+    const token = signToken(user._id);
+    setAuthCookie(res, token);
+    res.json({ user: publicUser(user), token });
+  } catch (error) {
+    next(error);
+  }
+}
+
+export async function me(req, res) {
+  res.json({ user: publicUser(req.user) });
+}
+
+export async function logout(_req, res) {
+  res.clearCookie(process.env.COOKIE_NAME || "stackflow_token");
+  res.json({ message: "Logged out" });
+}
+`,
+    [`src/controllers/task.controller.${e}`]: `import { Task } from "../models/task.model.js";
+
+export async function listTasks(req, res, next) {
+  try {
+    const tasks = await Task.find({ owner: req.user._id }).sort({ createdAt: -1 });
+    res.json({ tasks });
+  } catch (error) {
+    next(error);
+  }
+}
+
+export async function createTask(req, res, next) {
+  try {
+    const imageUrl = req.file ? \`/uploads/\${req.file.filename}\` : "";
+    const task = await Task.create({ ...req.body, imageUrl, owner: req.user._id });
+    res.status(201).json({ task });
+  } catch (error) {
+    next(error);
+  }
+}
+
+export async function updateTask(req, res, next) {
+  try {
+    const updates = { ...req.body };
+    if (req.file) updates.imageUrl = \`/uploads/\${req.file.filename}\`;
+    const task = await Task.findOneAndUpdate(
+      { _id: req.params.id, owner: req.user._id },
+      updates,
+      { new: true, runValidators: true }
+    );
+    if (!task) return res.status(404).json({ message: "Task not found" });
+    res.json({ task });
+  } catch (error) {
+    next(error);
+  }
+}
+
+export async function deleteTask(req, res, next) {
+  try {
+    const task = await Task.findOneAndDelete({ _id: req.params.id, owner: req.user._id });
+    if (!task) return res.status(404).json({ message: "Task not found" });
+    res.json({ message: "Task deleted" });
+  } catch (error) {
+    next(error);
+  }
+}
+`,
+    [`src/routes/auth.routes.${e}`]: `import { Router } from "express";
+import { login, logout, me, register } from "../controllers/auth.controller.js";
+import { protect } from "../middleware/auth.middleware.js";
+
+const router = Router();
+
+router.post("/register", register);
+router.post("/login", login);
+router.get("/me", protect, me);
+router.post("/logout", logout);
+
+export default router;
+`,
+    [`src/routes/index.routes.${e}`]: `import { Router } from "express";
+import authRoutes from "./auth.routes.js";
+import taskRoutes from "./task.routes.js";
+
+const router = Router();
+
+router.use("/auth", authRoutes);
+router.use("/tasks", taskRoutes);
+
+export default router;
+`,
+    [`src/routes/task.routes.${e}`]: `import { Router } from "express";
+import { createTask, deleteTask, listTasks, updateTask } from "../controllers/task.controller.js";
+import { protect } from "../middleware/auth.middleware.js";
+${context.multer ? "import { upload } from \"../services/upload.service.js\";" : ""}
+
+const router = Router();
+
+router.use(protect);
+router.get("/", listTasks);
+router.post("/", ${context.multer ? "upload.single(\"image\"), " : ""}createTask);
+router.patch("/:id", ${context.multer ? "upload.single(\"image\"), " : ""}updateTask);
+router.delete("/:id", deleteTask);
+
+export default router;
+`,
+    [`src/services/upload.service.${e}`]: context.multer ? `import multer from "multer";
+
+const storage = multer.diskStorage({
+  destination: "uploads/",
+  filename: (_req, file, callback) => {
+    callback(null, \`\${Date.now()}-\${file.originalname}\`);
+  }
+});
+
+export const upload = multer({ storage });
+` : `export {};
+`,
+    [`src/validations/auth.validation.${e}`]: `export const authValidation = {
+  register: ["name", "email", "password"],
+  login: ["email", "password"]
+};
+`,
+    [`src/utils/logger.${e}`]: context.winston ? `import winston from "winston";
+
+export const logger = winston.createLogger({
+  level: "info",
+  format: winston.format.combine(winston.format.timestamp(), winston.format.json()),
+  transports: [new winston.transports.Console()]
+});
+` : `export const logger = console;
+`,
+    [`src/config/swagger.${e}`]: context.swagger ? `import swaggerJSDoc from "swagger-jsdoc";
+import swaggerUi from "swagger-ui-express";
+
+export function setupSwagger(app) {
+  const spec = swaggerJSDoc({
+    definition: {
+      openapi: "3.0.0",
+      info: { title: "StackFlow API", version: "1.0.0" }
+    },
+    apis: ["./src/routes/*.js", "./src/routes/*.ts"]
+  });
+
+  app.use("/api/docs", swaggerUi.serve, swaggerUi.setup(spec));
+}
+` : `export function setupSwagger() {}
+`,
+    [`src/config/cloudinary.${e}`]: context.cloudinary ? `import { v2 as cloudinary } from "cloudinary";
+
+cloudinary.config({
+  cloud_name: process.env.CLOUDINARY_CLOUD_NAME,
+  api_key: process.env.CLOUDINARY_API_KEY,
+  api_secret: process.env.CLOUDINARY_API_SECRET
+});
+
+export { cloudinary };
+` : `export {};
+`
+  };
+}