@imksh/create 1.0.0

package/templates/node/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "node-template",
+  "version": "1.0.0",
+  "main": "src/index.js",
+  "type": "module",
+  "scripts": {
+    "start": "node src/index.js",
+    "dev": "nodemon src/index.js",
+    "generate:vapid": "node ./src/utils/generateVapidKeys.js"
+  },
+  "dependencies": {
+    "bcrypt": "^5.1.1",
+    "compression": "^1.7.4",
+    "cookie-parser": "^1.4.6",
+    "cors": "^2.8.5",
+    "dotenv": "^16.3.1",
+    "express": "^4.18.2",
+    "express-rate-limit": "^7.1.4",
+    "helmet": "^7.1.0",
+    "jsonwebtoken": "^9.0.2",
+    "morgan": "^1.10.0",
+    "multer": "^1.4.5-lts.1",
+    "mongoose": "^8.0.0",
+    "cloudinary": "^2.0.0",
+    "nodemailer": "^6.9.7",
+    "socket.io": "^4.7.2",
+    "web-push": "^3.6.6"
+  },
+  "devDependencies": {
+    "nodemon": "^3.0.1"
+  }
+}

package/templates/node/src/app.js

@@ -0,0 +1,42 @@
+import express from "express";
+import helmet from "helmet";
+import cors from "cors";
+import compression from "compression";
+import cookieParser from "cookie-parser";
+import morgan from "morgan";
+import apiRoutes from "./routes/index.js";
+import { notFound, errorHandler } from "./middleware/errorHandler.js";
+import { apiLimiter } from "./middleware/rateLimiter.js";
+
+const app = express();
+
+// Security and utility middlewares
+app.use(helmet());
+app.use(
+  cors({
+    origin: process.env.CLIENT_URL || "http://localhost:5173",
+    credentials: true,
+  })
+);
+app.use(compression());
+app.use(express.json());
+app.use(express.urlencoded({ extended: true }));
+app.use(cookieParser());
+app.use(morgan("dev"));
+
+// Rate limiting
+app.use(apiLimiter);
+
+// API Routes
+app.use("/api", apiRoutes);
+
+// Example health route
+app.get("/api/health", (req, res) => {
+  res.status(200).json({ success: true, message: "API is running" });
+});
+
+// Error handling middlewares
+app.use(notFound);
+app.use(errorHandler);
+
+export default app;

package/templates/node/src/config/cloudinary.js

@@ -0,0 +1,9 @@
+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 default cloudinary;

package/templates/node/src/config/db.js

@@ -0,0 +1,14 @@
+import mongoose from "mongoose";
+import logger from "../utils/logger.js";
+
+const connectDB = async () => {
+  try {
+    const conn = await mongoose.connect(process.env.MONGO_URI);
+    logger.success(`MongoDB connected: ${conn.connection.host}`);
+  } catch (error) {
+    logger.error(`MongoDB connection error: ${error.message}`, error);
+    process.exit(1);
+  }
+};
+
+export default connectDB;

package/templates/node/src/config/dotenv.js

@@ -0,0 +1,2 @@
+import dotenv from "dotenv";
+dotenv.config();

package/templates/node/src/config/email.js

@@ -0,0 +1,30 @@
+// import dotenv from "dotenv";
+// dotenv.config();
+import nodemailer from "nodemailer";
+import logger from "../utils/logger.js";
+
+const sendEmail = async (to, subject, message) => {
+  try {
+    const transporter = nodemailer.createTransport({
+      service: "gmail",
+      auth: {
+        user: process.env.GMAIL_USER,
+        pass: process.env.GMAIL_PASSCODE,
+      },
+    });
+
+    const mailOptions = {
+      from: process.env.GMAIL_USER,
+      to: to,
+      subject: subject,
+      html: message,
+    };
+
+    const res = await transporter.sendMail(mailOptions);
+    logger.success(`Email sent to ${to}: ${res.messageId}`);
+  } catch (error) {
+    logger.error("Failed to send email", error);
+  }
+};
+
+export default sendEmail;

package/templates/node/src/config/socket.js

@@ -0,0 +1,54 @@
+import { Server } from "socket.io";
+import logger from "../utils/logger.js";
+
+let io;
+
+const userSocketMap = {};
+
+const initializeSocket = (server) => {
+  io = new Server(server, {
+    cors: {
+      origin: ["http://localhost:5173"],
+      credentials: true,
+    },
+  });
+
+  io.on("connection", (socket) => {
+    const userId = socket.handshake.auth.userId;
+
+    if (!userId) {
+      logger.warn("No userId, disconnecting socket");
+      socket.disconnect();
+      return;
+    }
+
+    logger.info(`Socket connected: ${socket.id} (User: ${userId})`);
+
+    if (!userSocketMap[userId]) {
+      userSocketMap[userId] = new Set();
+    }
+    userSocketMap[userId].add(socket.id);
+
+    socket.on("disconnect", (reason) => {
+      if (!userId) return;
+      userSocketMap[userId].delete(socket.id);
+      logger.info(`Socket disconnected: ${socket.id} (Reason: ${reason})`);
+    });
+  });
+
+  return io;
+};
+
+export const getIO = () => {
+  if (!io) {
+    throw new Error("Socket.IO has not been initialized yet");
+  }
+  return io;
+};
+
+const getReceiverSocketIds = (userId) =>
+  userSocketMap[userId] ? Array.from(userSocketMap[userId]) : [];
+
+export { io, getReceiverSocketIds, userSocketMap };
+
+export default initializeSocket;

package/templates/node/src/config/webPush.js

@@ -0,0 +1,9 @@
+import webpush from "web-push";
+
+webpush.setVapidDetails(
+  process.env.VAPID_SUBJECT, 
+  process.env.VAPID_PUBLIC_KEY,
+  process.env.VAPID_PRIVATE_KEY
+);
+
+export default webpush;

package/templates/node/src/controllers/auth.controller.js

@@ -0,0 +1,153 @@
+import { authService } from "../services/auth.service.js";
+import { generateToken } from "../utils/jwt.js";
+import genOtpToken from "../utils/genOtpToken.js";
+import logger from "../utils/logger.js";
+
+export const signup = async (req, res, next) => {
+  try {
+    const { name, email, phone, password } = req.body;
+    if (!email || !password || !name) {
+      return next({
+        status: 400,
+        message: "All fields are required.",
+      });
+    }
+
+    const newUser = await authService.signup({ name, email, phone, password });
+    const token = await generateToken(newUser, res);
+    const safeUser = newUser.toObject();
+    delete safeUser.password;
+
+    res
+      .status(201)
+      .json({ message: "Registration Successful", data: safeUser, token });
+  } catch (error) {
+    logger.error("Error in signup controller", error);
+    next(error);
+  }
+};
+
+export const login = async (req, res, next) => {
+  try {
+    const { email, password } = req.body;
+    if (!email || !password) {
+      return next({
+        status: 400,
+        message: "All fields are required.",
+      });
+    }
+
+    const user = await authService.login({ email, password });
+    const token = await generateToken(user, res);
+    const safeUser = user.toObject();
+    delete safeUser.password;
+
+    res
+      .status(200)
+      .json({ message: "Login successfully", data: safeUser, token });
+  } catch (error) {
+    logger.error("Error in login controller", error);
+    next(error);
+  }
+};
+
+export const logout = async (_req, res, next) => {
+  try {
+    res.clearCookie("token", {
+      httpOnly: true,
+      secure: process.env.NODE_ENV === "production",
+      sameSite: "strict",
+      path: "/",
+    });
+
+    res.status(200).json({ message: "Logout Successfully" });
+  } catch (error) {
+    logger.error("Error in logout controller", error);
+    next(error);
+  }
+};
+
+export const getMe = async (req, res, next) => {
+  try {
+    const safeUser = req.user.toObject();
+    delete safeUser.password;
+    res.status(200).json({ message: "User Authenticated", data: safeUser });
+  } catch (error) {
+    logger.error("Error in getMe controller", error);
+    next(error);
+  }
+};
+
+export const genOtp = async (req, res, next) => {
+  try {
+    const { email } = req.body;
+    if (!email) {
+      return next({
+        status: 400,
+        message: "Email is required.",
+      });
+    }
+
+    await authService.generateOtp(email);
+    res.status(200).json({ message: "Otp sent successfully" });
+  } catch (error) {
+    logger.error("Error in genOtp", error);
+    next(error);
+  }
+};
+
+export const verifyOtp = async (req, res, next) => {
+  try {
+    const { email, otp } = req.body;
+    if (!email || !otp) {
+      return next({
+        status: 400,
+        message: "All fields are required.",
+      });
+    }
+
+    const user = await authService.verifyOtp({ email, otp });
+    await genOtpToken(user, res);
+
+    res.status(200).json({ message: "Otp verified successfully" });
+  } catch (error) {
+    logger.error("Error in verifyOtp", error);
+    next(error);
+  }
+};
+
+export const resetPassword = async (req, res, next) => {
+  try {
+    const { newPassword } = req.body;
+    const currentUser = req.user;
+    if (!newPassword) {
+      return next({
+        status: 400,
+        message: "All fields are required.",
+      });
+    }
+
+    await authService.resetPassword(currentUser, newPassword);
+    res.status(200).json({ message: "Password updated successfully" });
+  } catch (error) {
+    logger.error("Error in resetPassword", error);
+    next(error);
+  }
+};
+
+export const updateMe = async (req, res, next) => {
+  try {
+    const { name, phone } = req.body;
+    const user = await authService.updateProfile(req.user._id, {
+      name,
+      phone,
+      file: req.file,
+    });
+    const safeUser = user.toObject();
+    delete safeUser.password;
+    res.status(200).json({ success: true, data: safeUser });
+  } catch (error) {
+    logger.error("Error updating profile", error);
+    next(error);
+  }
+};

package/templates/node/src/controllers/upload.controller.js

@@ -0,0 +1,26 @@
+import { uploadSingleToCloudinary } from "../utils/cloudinaryUpload.js";
+import logger from "../utils/logger.js";
+
+/**
+ * Handle single file uploads to Cloudinary
+ */
+export const uploadFile = async (req, res, next) => {
+  try {
+    if (!req.file) {
+      return res.status(400).json({ success: false, message: "No file uploaded" });
+    }
+
+    const result = await uploadSingleToCloudinary(req.file, {
+      folder: req.body.folder || "general_uploads",
+    });
+
+    res.status(200).json({
+      success: true,
+      message: "File uploaded successfully",
+      data: result,
+    });
+  } catch (error) {
+    logger.error("Upload controller error", error);
+    next(error);
+  }
+};

package/templates/node/src/index.js

@@ -0,0 +1,24 @@
+import dotenv from "dotenv";
+import http from "http";
+import app from "./app.js";
+import connectDB from "./config/db.js";
+import logger from "./utils/logger.js";
+// import initializeSocket from "./config/socket.js";
+
+dotenv.config();
+
+const PORT = process.env.PORT || 5000;
+
+// Connect to Database
+connectDB();
+
+// Create HTTP Server
+const server = http.createServer(app);
+
+// Wire Socket.io (Commented out by default)
+// initializeSocket(server);
+
+// Start Server
+server.listen(PORT, () => {
+  logger.success(`Server is running on port ${PORT}`);
+});

package/templates/node/src/middleware/auth.middleware.js

@@ -0,0 +1,43 @@
+import jwt from "jsonwebtoken";
+import User from "../models/user.model.js";
+import { verifyToken } from "../utils/jwt.js";
+import logger from "../utils/logger.js";
+
+export const protect = async (req, res, next) => {
+  let token;
+  if (req.cookies?.token) {
+    token = req.cookies.token;
+  } else if (
+    req.headers.authorization &&
+    req.headers.authorization.startsWith("Bearer")
+  ) {
+    token = req.headers.authorization.split(" ")[1];
+  }
+
+  if (!token) {
+    return res
+      .status(401)
+      .json({ message: "Not authorized, no token provided" });
+  }
+
+  try {
+    const decoded = verifyToken(token);
+    if (!decoded) {
+      return res.status(401).json({ message: "Not authorized, invalid token" });
+    }
+
+    req.user = await User.findById(decoded.id).select("-password");
+    if (!req.user) {
+      return res
+        .status(401)
+        .json({ message: "Not authorized, user not found" });
+    }
+
+    return next();
+  } catch (error) {
+    logger.error("Auth middleware error", error);
+    return res
+      .status(401)
+      .json({ message: "Not authorized, token verification failed" });
+  }
+};

package/templates/node/src/middleware/errorHandler.js

@@ -0,0 +1,22 @@
+/**
+ * Not Found Middleware
+ * Catches all unmatched requests and forwards a 404 error
+ */
+export const notFound = (req, res, next) => {
+  const error = new Error(`Not Found - ${req.originalUrl}`);
+  res.status(404);
+  next(error);
+};
+
+/**
+ * Global Error Handler Middleware
+ * Formats error responses nicely in JSON
+ */
+export const errorHandler = (err, req, res, next) => {
+  const statusCode = err.status || err.statusCode || (res.statusCode === 200 ? 500 : res.statusCode);
+  res.status(statusCode).json({
+    success: false,
+    message: err.message || "An unexpected error occurred",
+    stack: process.env.NODE_ENV === "production" ? undefined : err.stack,
+  });
+};

package/templates/node/src/middleware/multer.js

@@ -0,0 +1,21 @@
+import multer from "multer";
+
+// Configure memory storage to receive file buffers directly
+const storage = multer.memoryStorage();
+
+// Validate file types (only allow common image formats)
+const fileFilter = (req, file, cb) => {
+  if (file.mimetype.startsWith("image/")) {
+    cb(null, true);
+  } else {
+    cb(new Error("Only image files are allowed!"), false);
+  }
+};
+
+export const upload = multer({
+  storage,
+  fileFilter,
+  limits: {
+    fileSize: 5 * 1024 * 1024, // 5MB limit
+  },
+});

package/templates/node/src/middleware/rateLimiter.js

@@ -0,0 +1,57 @@
+import rateLimit from "express-rate-limit";
+
+const createLimiter = ({
+  windowMs,
+  max,
+  message,
+  skipSuccessfulRequests = false,
+}) =>
+  rateLimit({
+    windowMs,
+    max,
+    standardHeaders: true,
+    legacyHeaders: false,
+    skipSuccessfulRequests,
+
+    keyGenerator: (req) => {
+      return req.user?.id || req.ip || req.headers["x-forwarded-for"] || req.socket.remoteAddress;
+    },
+
+    handler: (req, res) => {
+      res.status(429).json({
+        success: false,
+        message,
+      });
+    },
+  });
+
+/**
+ * General API Limiter
+ * 100 requests / 15 minutes
+ */
+export const apiLimiter = createLimiter({
+  windowMs: 15 * 60 * 1000,
+  max: 100,
+  message: "Too many requests. Please try again later.",
+});
+
+/**
+ * Authentication Limiter
+ * 10 failed attempts / 15 minutes
+ */
+export const authLimiter = createLimiter({
+  windowMs: 15 * 60 * 1000,
+  max: 10,
+  skipSuccessfulRequests: true,
+  message: "Too many login attempts. Please try again later.",
+});
+
+/**
+ * Upload Limiter
+ * 20 uploads / hour
+ */
+export const uploadLimiter = createLimiter({
+  windowMs: 60 * 60 * 1000,
+  max: 20,
+  message: "Upload limit reached. Please try again in an hour.",
+});

package/templates/node/src/models/otp.model.js

@@ -0,0 +1,21 @@
+import mongoose from "mongoose";
+
+const otpSchema = new mongoose.Schema({
+  email: {
+    type: String,
+    required: true,
+  },
+  otp: {
+    type: String,
+    required: true,
+  },
+  createdAt: {
+    type: Date,
+    default: Date.now(),
+    expires: 300,
+  },
+});
+
+const Otp = mongoose.model("Otp", otpSchema);
+
+export default Otp;

package/templates/node/src/models/pushSubscription.model.js

@@ -0,0 +1,32 @@
+import mongoose from "mongoose";
+
+const pushSubscriptionSchema = new mongoose.Schema(
+  {
+    endpoint: {
+      type: String,
+      required: true,
+      unique: true,
+    },
+    keys: {
+      p256dh: { type: String, required: true },
+      auth: { type: String, required: true },
+    },
+    user: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "User",
+    },
+    role: {
+      type: String,
+      enum: ["admin", "user"],
+      default: "user",
+    },
+    expiresAt: {
+      type: Date,
+      default: () => new Date(Date.now() + 7 * 24 * 60 * 60 * 1000),
+      index: { expires: 0 },
+    },
+  },
+  { timestamps: true },
+);
+
+export default mongoose.model("PushSubscription", pushSubscriptionSchema);

package/templates/node/src/models/user.model.js

@@ -0,0 +1,43 @@
+import mongoose from "mongoose";
+
+const userSchema = new mongoose.Schema(
+  {
+    name: {
+      type: String,
+      required: [true, "Name is required"],
+      trim: true,
+    },
+
+    email: {
+      type: String,
+      required: [true, "Email is required"],
+      unique: true,
+      lowercase: true,
+      trim: true,
+    },
+    phone: {
+      type: String,
+    },
+    avatar: {
+      publicId: {
+        type: String,
+      },
+      url: {
+        type: String,
+      },
+    },
+    password: {
+      type: String,
+      required: [true, "Password is required"],
+    },
+    role: {
+      type: String,
+      enum: ["user", "admin", "other"],
+      default: "user",
+    },
+  },
+  { timestamps: true },
+);
+
+const User = mongoose.model("User", userSchema);
+export default User;

package/templates/node/src/routes/auth.route.js

@@ -0,0 +1,22 @@
+import express from "express";
+import {
+  signup,
+  login,
+  getMe,
+  logout,
+  updateMe,
+} from "../controllers/auth.controller.js";
+import { protect } from "../middleware/auth.middleware.js";
+import { apiLimiter } from "../middleware/rateLimiter.js";
+
+const router = express.Router();
+
+router.use(apiLimiter);
+
+router.post("/signup", signup);
+router.post("/login", login);
+router.post("/logout", logout);
+router.get("/me", protect, getMe);
+router.put("/me", protect, updateMe);
+
+export default router;

package/templates/node/src/routes/index.js

@@ -0,0 +1,10 @@
+import express from "express";
+import authRoutes from "./auth.route.js";
+import uploadRoutes from "./upload.route.js";
+
+const router = express.Router();
+
+router.use("/auth", authRoutes);
+router.use("/upload", uploadRoutes);
+
+export default router;