create-stackflow 1.0.4 → 1.0.7

package/src/generators/backend.js

@@ -1,8 +1,12 @@
 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";
+import {
+  chatBackendFiles,
+  chatServerSocketBlock,
+  patchMainRouteForChat,
+} from "./chat.js";
 
 export async function createBackend(context) {
   const spinner = ora("Generating backend API").start();
@@ -15,26 +19,16 @@ export async function createBackend(context) {
     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 esm = isTs || context.backendModule !== "cjs";
   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",
@@ -54,7 +48,6 @@ async function writeBackendFiles(context) {
   const devDeps = isTs
     ? {
         "@types/bcryptjs": "latest",
-        "@types/cookie-parser": "latest",
         "@types/cors": "latest",
         "@types/express": "latest",
         "@types/jsonwebtoken": "latest",
@@ -70,7 +63,7 @@ async function writeBackendFiles(context) {
   await writeTemplate(path.join(context.backendDir, "package.json"), JSON.stringify({
     name: path.basename(context.backendDir),
     version: "1.0.0",
-    type: "module",
+    ...(esm ? { type: "module" } : {}),
     private: true,
     scripts: {
       dev: isTs ? "tsx watch src/server.ts" : "nodemon src/server.js",
@@ -85,8 +78,8 @@ async function writeBackendFiles(context) {
     await writeTemplate(path.join(context.backendDir, "tsconfig.json"), `{
   "compilerOptions": {
     "target": "ES2022",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
+    "module": "${context.backendModule === "cjs" ? "CommonJS" : "NodeNext"}",
+    "moduleResolution": "${context.backendModule === "cjs" ? "Node" : "NodeNext"}",
     "strict": false,
     "noImplicitAny": false,
     "noCheck": true,
@@ -106,7 +99,6 @@ 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=" : "" });
 
@@ -116,15 +108,19 @@ COOKIE_NAME=stackflow_token
     "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);
+  const files = backendTemplates({ ...context, language: backendContext.language, clientUrl, esm }, e);
+
+  if (!context.cloudinary) delete files[`src/config/cloudinary.${e}`];
+  if (!context.multer) delete files[`src/middleware/uploadMiddleware.${e}`];
+  if (!context.winston) delete files[`src/utils/logger.${e}`];
+  if (!context.swagger) delete files[`src/config/swagger.${e}`];
+
   await Promise.all(Object.entries(files).map(([file, content]) =>
     writeTemplate(path.join(context.backendDir, file), content, context)
   ));
@@ -136,61 +132,65 @@ function compact(object) {
 
 function backendTemplates(context, e) {
   const isTs = context.language === "typescript";
+  const esm = context.esm !== false;
+  const rel = (p) => (esm ? `${p}.js` : p);
+  const im = (binding, from, relative = false) => {
+    const src = relative ? rel(from) : from;
+    return esm
+      ? `import ${binding} from "${src}";`
+      : `const ${binding} = require("${src}");`;
+  };
+  const imDefault = (binding, from, relative = false) => im(binding, from, relative);
+  const imn = (names, from, relative = false) => {
+    const src = relative ? rel(from) : from;
+    return esm
+      ? `import { ${names} } from "${src}";`
+      : `const { ${names} } = require("${src}");`;
+  };
   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\";" : ""
+    logger: context.winston ? (esm ? imn("logger", "./utils/logger", true) : imn("logger", "./utils/logger", true)) : "",
+    morgan: context.morgan ? im("morgan", "morgan") : "",
+    swagger: context.swagger ? (esm ? imn("setupSwagger", "./config/swagger", true) : imn("setupSwagger", "./config/swagger", true)) : "",
+    socket: context.socketio ? imn("Server", "socket.io") : "",
   };
 
-  return {
-    [`src/server.${e}`]: `import http from "node:http";
-import app from "./app.js";
-import { connectDB } from "./config/db.js";
+  const templates = {
+    [`src/server.${e}`]: `${im("http", "node:http")}
+${imDefault("app", "./app", true)}
+${imn("connectDB", "./config/db", true)}
 ${imports.socket}
 ${imports.logger}
 
 const PORT = Number(process.env.PORT) || 5000;
 
-async function bootstrap() {
+async function startServer() {
   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" });
-  });
-` : ""}
+${chatServerSocketBlock(context, context.clientUrl, { imn })}
   server.listen(PORT, () => {
     ${context.winston ? "logger.info(`API running on http://localhost:${PORT}`);" : "console.log(`API running on http://localhost:${PORT}`);"}
   });
 }
 
-bootstrap().catch((error) => {
+startServer().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";
+${context.multer ? "import { uploadsStatic } from \"./middleware/uploadMiddleware.js\";" : ""}
+import apiRoutes from "./routes/mainRoute.js";
+import { errorHandler } from "./middleware/errorMiddleware.js";
+import { notFound } from "./middleware/notFoundMiddleware.js";
 
 const app = express();
 
@@ -201,17 +201,12 @@ ${context.cors === false ? "" : `app.use(cors({
   credentials: true
 }));`}
 ${context.rateLimit === false ? "" : "app.use(rateLimit({ windowMs: 15 * 60 * 1000, limit: 300 }));"}
-app.use("/uploads", express.static("uploads"));
+${context.multer ? 'app.use("/uploads", uploadsStatic);' : ""}
 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);
@@ -228,7 +223,7 @@ export async function connectDB() {
   ${context.winston ? "logger.info(\"MongoDB connected\");" : "console.log(\"MongoDB connected\");"}
 }
 `,
-    [`src/models/user.model.${e}`]: `import mongoose from "mongoose";
+    [`src/models/userModel.${e}`]: `import mongoose from "mongoose";
 import bcrypt from "bcryptjs";
 
 const userSchema = new mongoose.Schema({
@@ -248,9 +243,9 @@ userSchema.methods.comparePassword = function(candidatePassword) {
 
 export const User = mongoose.model("User", userSchema);
 `,
-    [`src/models/task.model.${e}`]: `import mongoose from "mongoose";
+    [`src/models/todoModel.${e}`]: `import mongoose from "mongoose";
 
-const taskSchema = new mongoose.Schema({
+const todoSchema = new mongoose.Schema({
   title: { type: String, required: true, trim: true },
   description: { type: String, default: "" },
   imageUrl: { type: String, default: "" },
@@ -258,7 +253,7 @@ const taskSchema = new mongoose.Schema({
   owner: { type: mongoose.Schema.Types.ObjectId, ref: "User", required: true }
 }, { timestamps: true });
 
-export const Task = mongoose.model("Task", taskSchema);
+export const Todo = mongoose.model("Todo", todoSchema);
 `,
     [`src/utils/jwt.${e}`]: `import jwt from "jsonwebtoken";
 
@@ -267,41 +262,34 @@ export function signToken(userId) {
     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";
+    [`src/middleware/authMiddleware.${e}`]: `${reqRes}import jwt from "jsonwebtoken";
+import { User } from "../models/userModel.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 ")
+    const token = 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" });
+    if (!token) {
+      return res.status(401).json({ success: false, 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" });
+    if (!user) {
+      return res.status(401).json({ success: false, message: "Invalid authentication" });
+    }
 
     req.user = user;
     next();
   } catch {
-    res.status(401).json({ message: "Invalid or expired token" });
+    res.status(401).json({ success: false, 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")}) {
+    [`src/middleware/errorMiddleware.${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",
@@ -309,169 +297,234 @@ export async function protect(req${type("Request & { user?: unknown }")}, res${t
   });
 }
 `,
-    [`src/middleware/not-found.middleware.${e}`]: `${reqRes}export function notFound(req${type("Request")}, res${type("Response")}) {
+    [`src/middleware/notFoundMiddleware.${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";
+    [`src/controllers/authController.${e}`]: `import { User } from "../models/userModel.js";
+import { signToken } 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);
-  }
-}
+const authController = {
+  // Register
+  register: async (req, res) => {
+    try {
+      const { name, email, password } = req.body;
+      const existing = await User.findOne({ email });
+      if (existing) {
+        return res.status(409).json({ success: false, message: "Email already registered" });
+      }
+      const user = await User.create({ name, email, password });
+      const token = signToken(user._id);
+      res.status(201).json({
+        success: true,
+        message: "Account created successfully",
+        data: { user: publicUser(user), token }
+      });
+    } catch (error) {
+      res.status(500).json({ success: false, message: error.message });
+    }
+  },
 
-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" });
+  // Login
+  login: async (req, res) => {
+    try {
+      const { email, password } = req.body;
+      const user = await User.findOne({ email });
+      if (!user || !(await user.comparePassword(password))) {
+        return res.status(401).json({ success: false, message: "Invalid email or password" });
+      }
+      const token = signToken(user._id);
+      res.status(200).json({
+        success: true,
+        message: "Logged in successfully",
+        data: { user: publicUser(user), token }
+      });
+    } catch (error) {
+      res.status(500).json({ success: false, message: error.message });
     }
-    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) });
-}
+  // Current user
+  me: async (req, res) => {
+    try {
+      res.status(200).json({
+        success: true,
+        message: "Profile fetched successfully",
+        data: { user: publicUser(req.user) }
+      });
+    } catch (error) {
+      res.status(500).json({ success: false, message: error.message });
+    }
+  },
 
-export async function logout(_req, res) {
-  res.clearCookie(process.env.COOKIE_NAME || "stackflow_token");
-  res.json({ message: "Logged out" });
-}
+  // Logout (client clears token)
+  logout: async (_req, res) => {
+    res.status(200).json({
+      success: true,
+      message: "Logged out successfully"
+    });
+  }
+};
+
+export default authController;
 `,
-    [`src/controllers/task.controller.${e}`]: `import { Task } from "../models/task.model.js";
+    [`src/controllers/todoController.${e}`]: `import { Todo } from "../models/todoModel.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);
-  }
-}
+const todoController = {
+  // Get All Todos
+  getTodos: async (req, res) => {
+    try {
+      const todos = await Todo.find({ owner: req.user._id }).sort({ createdAt: -1 });
+      res.status(200).json({
+        success: true,
+        message: "Todos fetched successfully",
+        data: todos
+      });
+    } catch (error) {
+      res.status(500).json({
+        success: false,
+        message: error.message
+      });
+    }
+  },
 
-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);
-  }
-}
+  // Create Todo
+  createTodo: async (req, res) => {
+    try {
+      const imageUrl = req.file ? \`/uploads/\${req.file.filename}\` : "";
+      const newTodo = await Todo.create({ ...req.body, imageUrl, owner: req.user._id });
+      res.status(201).json({
+        success: true,
+        message: "Todo created successfully",
+        data: newTodo
+      });
+    } catch (error) {
+      res.status(500).json({
+        success: false,
+        message: error.message
+      });
+    }
+  },
 
-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);
-  }
-}
+  // Update Todo
+  updateTodo: async (req, res) => {
+    try {
+      const { id } = req.params;
+      const updates = { ...req.body };
+      if (req.file) updates.imageUrl = \`/uploads/\${req.file.filename}\`;
+      const todo = await Todo.findOneAndUpdate(
+        { _id: id, owner: req.user._id },
+        updates,
+        { new: true, runValidators: true }
+      );
+      if (!todo) return res.status(404).json({ success: false, message: "Todo not found" });
+      res.status(200).json({
+        success: true,
+        message: \`Todo \${id} updated successfully\`,
+        data: todo
+      });
+    } catch (error) {
+      res.status(500).json({
+        success: false,
+        message: error.message
+      });
+    }
+  },
 
-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);
+  // Delete Todo
+  deleteTodo: async (req, res) => {
+    try {
+      const { id } = req.params;
+      const todo = await Todo.findOneAndDelete({ _id: id, owner: req.user._id });
+      if (!todo) return res.status(404).json({ success: false, message: "Todo not found" });
+      res.status(200).json({
+        success: true,
+        message: \`Todo \${id} deleted successfully\`
+      });
+    } catch (error) {
+      res.status(500).json({
+        success: false,
+        message: error.message
+      });
+    }
   }
-}
+};
+
+export default todoController;
 `,
-    [`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";
+    [`src/routes/authRoute.${e}`]: `import { Router } from "express";
+import authController from "../controllers/authController.js";
+import { protect } from "../middleware/authMiddleware.js";
 
 const router = Router();
 
-router.post("/register", register);
-router.post("/login", login);
-router.get("/me", protect, me);
-router.post("/logout", logout);
+router.post("/register", authController.register);
+router.post("/login", authController.login);
+router.get("/me", protect, authController.me);
+router.post("/logout", protect, authController.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";
+    [`src/routes/mainRoute.${e}`]: `import { Router } from "express";
+import authRoutes from "./authRoute.js";
+import todoRoutes from "./todoRoute.js";
 
 const router = Router();
 
 router.use("/auth", authRoutes);
-router.use("/tasks", taskRoutes);
+router.use("/todos", todoRoutes);
 
 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\";" : ""}
+    [`src/routes/todoRoute.${e}`]: `import { Router } from "express";
+import todoController from "../controllers/todoController.js";
+import { protect } from "../middleware/authMiddleware.js";
+${context.multer ? "import { upload } from \"../middleware/uploadMiddleware.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);
+
+router.get("/", todoController.getTodos);
+router.post("/", ${context.multer ? "upload.single(\"image\"), " : ""}todoController.createTodo);
+router.put("/:id", ${context.multer ? "upload.single(\"image\"), " : ""}todoController.updateTodo);
+router.delete("/:id", todoController.deleteTodo);
 
 export default router;
 `,
-    [`src/services/upload.service.${e}`]: context.multer ? `import multer from "multer";
-
-const storage = multer.diskStorage({
+    [`src/middleware/uploadMiddleware.${e}`]: context.multer
+      ? `${im("multer", "multer")}
+${im("express", "express")}
+${esm ? "" : "const { diskStorage } = multer;\n"}
+const storage = ${esm ? "multer.diskStorage" : "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";
+${esm ? "export const upload = multer({ storage });" : "const upload = multer({ storage });\n"}
+${esm ? "export const uploadsStatic = express.static(\"uploads\");" : "const uploadsStatic = express.static(\"uploads\");\n"}
+${esm ? "" : "module.exports = { upload, uploadsStatic };"}
+`
+      : undefined,
+    [`src/utils/logger.${e}`]: context.winston
+      ? `${im("winston", "winston")}
 
-export const logger = winston.createLogger({
+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";
+${esm ? "export { logger };" : "module.exports = { logger };"}
+`
+      : undefined,
+    [`src/config/swagger.${e}`]: context.swagger ? `${im("swaggerJSDoc", "swagger-jsdoc")}
+${im("swaggerUi", "swagger-ui-express")}
 
 export function setupSwagger(app) {
   const spec = swaggerJSDoc({
@@ -484,9 +537,11 @@ export function setupSwagger(app) {
 
   app.use("/api/docs", swaggerUi.serve, swaggerUi.setup(spec));
 }
-` : `export function setupSwagger() {}
-`,
-    [`src/config/cloudinary.${e}`]: context.cloudinary ? `import { v2 as cloudinary } from "cloudinary";
+${esm ? "" : "\nmodule.exports = { setupSwagger };"}
+`
+      : undefined,
+    [`src/config/cloudinary.${e}`]: context.cloudinary
+      ? `${esm ? 'import { v2 as cloudinary } from "cloudinary";' : 'const { v2: cloudinary } = require("cloudinary");'}
 
 cloudinary.config({
   cloud_name: process.env.CLOUDINARY_CLOUD_NAME,
@@ -494,8 +549,25 @@ cloudinary.config({
   api_secret: process.env.CLOUDINARY_API_SECRET
 });
 
-export { cloudinary };
-` : `export {};
+${esm ? "export { cloudinary };" : "module.exports = { cloudinary };"}
 `
+      : undefined,
   };
+
+  const merged = {
+    ...templates,
+    ...chatBackendFiles(context, e, { im, imn, esm }),
+  };
+
+  if (merged[`src/routes/mainRoute.${e}`]) {
+    merged[`src/routes/mainRoute.${e}`] = patchMainRouteForChat(
+      merged[`src/routes/mainRoute.${e}`],
+      context,
+      e,
+    );
+  }
+
+  return Object.fromEntries(
+    Object.entries(merged).filter(([, value]) => value !== undefined),
+  );
 }