@imksh/create 1.0.0

package/templates/node-ts/src/config/socket.ts

@@ -0,0 +1,54 @@
+import { Server } from "socket.io";
+import logger from "../utils/logger.js";
+
+let io: Server;
+
+const userSocketMap: { [key: string]: Set<string> } = {};
+
+const initializeSocket = (server: any) => {
+  io = new Server(server, {
+    cors: {
+      origin: ["http://localhost:5173"],
+      credentials: true,
+    },
+  });
+
+  io.on("connection", (socket) => {
+    const userId = socket.handshake.auth.userId as string | undefined;
+
+    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<string>();
+    }
+    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: string) =>
+  userSocketMap[userId] ? Array.from(userSocketMap[userId]) : [];
+
+export { io, getReceiverSocketIds, userSocketMap };
+
+export default initializeSocket;

package/templates/node-ts/src/config/webPush.ts

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

package/templates/node-ts/src/controllers/auth.controller.ts

@@ -0,0 +1,126 @@
+import { Request, Response, NextFunction } from "express";
+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: Request, res: Response, next: NextFunction) => {
+  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: any = 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: Request, res: Response, next: NextFunction) => {
+  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: any = 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: Request, res: Response, next: NextFunction) => {
+  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: Request, res: Response, next: NextFunction) => {
+  try {
+    const safeUser: any = 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: Request, res: Response, next: NextFunction) => {
+  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: Request, res: Response, next: NextFunction) => {
+  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: Request, res: Response, next: NextFunction) => {
+  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: Request, res: Response, next: NextFunction) => {
+  try {
+    const { name, phone } = req.body;
+    const user = await authService.updateProfile(req.user._id, {
+      name,
+      phone,
+      file: req.file,
+    });
+    const safeUser: any = 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-ts/src/controllers/upload.controller.ts

@@ -0,0 +1,22 @@
+import { Request, Response, NextFunction } from "express";
+import { uploadSingleToCloudinary } from "../utils/cloudinaryUpload.js";
+import logger from "../utils/logger.js";
+
+export const uploadFile = async (req: Request, res: Response, next: NextFunction) => {
+  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-ts/src/index.ts

@@ -0,0 +1,17 @@
+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";
+
+dotenv.config();
+
+const PORT = process.env.PORT || 5000;
+
+connectDB();
+
+const server = http.createServer(app);
+
+server.listen(PORT, () => {
+  logger.success(`Server is running on port ${PORT}`);
+});

package/templates/node-ts/src/middleware/auth.middleware.ts

@@ -0,0 +1,38 @@
+import { Request, Response, NextFunction } from "express";
+import User from "../models/user.model.js";
+import { verifyToken } from "../utils/jwt.js";
+import logger from "../utils/logger.js";
+
+export const protect = async (req: Request, res: Response, next: NextFunction) => {
+  let token: string | undefined;
+
+  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: any = 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: any) {
+    logger.error("Auth middleware error", error);
+    return res.status(401).json({ message: "Not authorized, token verification failed" });
+  }
+};

package/templates/node-ts/src/middleware/errorHandler.ts

@@ -0,0 +1,16 @@
+import { Request, Response, NextFunction } from "express";
+
+export const notFound = (req: Request, res: Response, next: NextFunction) => {
+  const error = new Error(`Not Found - ${req.originalUrl}`);
+  res.status(404);
+  next(error);
+};
+
+export const errorHandler = (err: any, req: Request, res: Response, next: NextFunction) => {
+  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-ts/src/middleware/multer.ts

@@ -0,0 +1,20 @@
+import multer, { FileFilterCallback } from "multer";
+import { Request } from "express";
+
+const storage = multer.memoryStorage();
+
+const fileFilter = (req: Request, file: Express.Multer.File, cb: FileFilterCallback) => {
+  if (file.mimetype.startsWith("image/")) {
+    cb(null, true);
+  } else {
+    cb(new Error("Only image files are allowed!"));
+  }
+};
+
+export const upload = multer({
+  storage,
+  fileFilter,
+  limits: {
+    fileSize: 5 * 1024 * 1024, // 5MB limit
+  },
+});

package/templates/node-ts/src/middleware/rateLimiter.ts

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

package/templates/node-ts/src/models/otp.model.ts

@@ -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-ts/src/models/pushSubscription.model.ts

@@ -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-ts/src/models/user.model.ts

@@ -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-ts/src/routes/auth.route.ts

@@ -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-ts/src/routes/index.ts

@@ -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;

package/templates/node-ts/src/routes/upload.route.ts

@@ -0,0 +1,11 @@
+import express from "express";
+import { upload } from "../middleware/multer.js";
+import { uploadFile } from "../controllers/upload.controller.js";
+import { protect } from "../middleware/auth.middleware.js";
+import { uploadLimiter } from "../middleware/rateLimiter.js";
+
+const router = express.Router();
+
+router.post("/", protect, uploadLimiter, upload.single("file"), uploadFile);
+
+export default router;

package/templates/node-ts/src/services/auth.service.ts

@@ -0,0 +1,115 @@
+import User from "../models/user.model.js";
+import Otp from "../models/otp.model.js";
+import bcrypt from "bcrypt";
+import { generateToken } from "../utils/jwt.js";
+import { sendOtpEmail } from "../utils/emailOtp.js";
+import { uploadSingleToCloudinary, deleteFromCloudinary } from "../utils/cloudinaryUpload.js";
+import logger from "../utils/logger.js";
+
+export const authService = {
+  signup: async ({ name, email, phone, password }: any) => {
+    const existingUser = await User.findOne({ email });
+    if (existingUser) {
+      const err: any = new Error("User already exists");
+      err.status = 409;
+      throw err;
+    }
+    const salt = await bcrypt.genSalt(10);
+    const hashedPassword = await bcrypt.hash(password, salt);
+    const photoURL = `https://placehold.co/600x400?text=${name.charAt(0).toUpperCase()}`;
+    const newUser = await User.create({
+      name,
+      email: email.toLowerCase(),
+      phone,
+      role: "user",
+      password: hashedPassword,
+      avatar: { url: photoURL, publicId: "" },
+    });
+    return newUser;
+  },
+
+  login: async ({ email, password }: any) => {
+    const user = await User.findOne({ email });
+    if (!user) {
+      const err: any = new Error("User not found");
+      err.status = 404;
+      throw err;
+    }
+    const isValid = await bcrypt.compare(password, user.password);
+    if (!isValid) {
+      const err: any = new Error("Invalid Credentials");
+      err.status = 401;
+      throw err;
+    }
+    return user;
+  },
+
+  generateOtp: async (email: string) => {
+    const user = await User.findOne({ email });
+    if (!user) {
+      const err: any = new Error("User not found");
+      err.status = 404;
+      throw err;
+    }
+    const existingOtp = await Otp.findOne({ email });
+    if (existingOtp) {
+      await existingOtp.deleteOne();
+    }
+    const otp = Math.floor(100000 + Math.random() * 900000).toString();
+    const hashedOtp = await bcrypt.hash(otp, 10);
+    await Otp.create({ email, otp: hashedOtp });
+    await sendOtpEmail(email, otp);
+    return true;
+  },
+
+  verifyOtp: async ({ email, otp }: any) => {
+    const user = await User.findOne({ email });
+    if (!user) {
+      const err: any = new Error("User not found");
+      err.status = 404;
+      throw err;
+    }
+    const existingOtp = await Otp.findOne({ email });
+    if (!existingOtp) {
+      const err: any = new Error("OTP match failed");
+      err.status = 400;
+      throw err;
+    }
+    const isMatched = await bcrypt.compare(otp, existingOtp.otp);
+    if (!isMatched) {
+      const err: any = new Error("OTP match failed");
+      err.status = 400;
+      throw err;
+    }
+    return user;
+  },
+
+  resetPassword: async (user: any, newPassword: any) => {
+    const hashedPassword = await bcrypt.hash(newPassword, 10);
+    user.password = hashedPassword;
+    await user.save();
+    return true;
+  },
+
+  updateProfile: async (userId: any, { name, phone, file }: any) => {
+    const user = await User.findById(userId);
+    if (!user) {
+      const err: any = new Error("User not found");
+      err.status = 404;
+      throw err;
+    }
+    if (name) user.name = name;
+    if (phone) user.phone = phone;
+    if (file) {
+      const uploadResult = await uploadSingleToCloudinary(file, { folder: "codelab/avatars" });
+      if (user.avatar && user.avatar.publicId) {
+        await deleteFromCloudinary(user.avatar.publicId).catch((err) =>
+          logger.error("Old avatar delete error", err)
+        );
+      }
+      user.avatar = { url: uploadResult.url, publicId: uploadResult.publicId };
+    }
+    await user.save();
+    return user;
+  },
+};

package/templates/node-ts/src/types/express.d.ts

@@ -0,0 +1,10 @@
+import { Express } from "express";
+
+declare global {
+  namespace Express {
+    interface Request {
+      user?: any;
+      file?: any;
+    }
+  }
+}

package/templates/node-ts/src/utils/cloudinaryUpload.ts

@@ -0,0 +1,44 @@
+import cloudinary from "../config/cloudinary.js";
+import logger from "./logger.js";
+
+const uploadToCloudinary = async (file: any, options: any = {}) => {
+  if (!file?.buffer) {
+    throw new Error("Invalid file.");
+  }
+  const dataURI = `data:${file.mimetype};base64,${file.buffer.toString("base64")}`;
+  const result = await cloudinary.uploader.upload(dataURI, {
+    folder: options.folder || "uploads",
+    ...options,
+  });
+  return {
+    url: result.secure_url,
+    publicId: result.public_id,
+  };
+};
+
+export const uploadSingleToCloudinary = async (file: any, options: any = {}) => {
+  try {
+    return await uploadToCloudinary(file, options);
+  } catch (error) {
+    logger.error("Cloudinary Upload Error", error);
+    throw new Error("Failed to upload image.");
+  }
+};
+
+export const uploadMultipleToCloudinary = async (files: any[] = [], options: any = {}) => {
+  try {
+    return await Promise.all(files.map((file) => uploadToCloudinary(file, options)));
+  } catch (error) {
+    logger.error("Cloudinary Upload Error", error);
+    throw new Error("Failed to upload images.");
+  }
+};
+
+export const deleteFromCloudinary = async (publicId: string) => {
+  try {
+    return await cloudinary.uploader.destroy(publicId);
+  } catch (error) {
+    logger.error("Cloudinary Delete Error", error);
+    throw new Error("Failed to delete image.");
+  }
+};