@imksh/create 1.0.25 → 1.0.27

package/templates/production-fullstack/server/src/features/auth/auth.controller.ts

@@ -0,0 +1,124 @@
+import { Request, Response, NextFunction } from "express";
+import * as authService from "./auth.service.js";
+import { generateToken } from "../../common/utils/jwt.js";
+import genOtpToken from "../../common/utils/genOtpToken.js";
+import logger from "../../config/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 };
+    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 };
+    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 {
+    res.status(200).json({ message: "User Authenticated", data: req.user });
+  } 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 };
+    delete safeUser.password;
+    res.status(200).json({ success: true, data: safeUser });
+  } catch (error) {
+    logger.error("Error updating profile", error);
+    next(error);
+  }
+};

package/templates/production-fullstack/server/src/features/auth/auth.routes.ts

@@ -0,0 +1,22 @@
+import express from "express";
+import {
+  signup,
+  login,
+  getMe,
+  logout,
+  updateMe,
+} from "./auth.controller.js";
+import { protect } from "../../common/middlewares/auth.middleware.js";
+import { apiLimiter } from "../../common/middlewares/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/production-fullstack/server/src/features/auth/auth.service.ts

@@ -0,0 +1,155 @@
+import bcrypt from "bcrypt";
+import { prisma } from "../../config/prisma.js";
+import { sendOtpEmail } from "../../common/utils/emailOtp.js";
+import { uploadSingleToCloudinary, deleteFromCloudinary } from "../../common/utils/cloudinaryUpload.js";
+import logger from "../../config/logger.js";
+export const signup = async ({ name, email, phone, password }: any) => {
+    const existingUser = await prisma.user.findUnique({
+      where: { 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 prisma.user.create({
+      data: {
+        name,
+        email: email.toLowerCase(),
+        phone,
+        password: hashedPassword,
+        avatarUrl: photoURL,
+        avatarPublicId: "",
+      },
+    });
+
+    return newUser;
+  }
+export const login = async ({ email, password }: any) => {
+    const user = await prisma.user.findUnique({
+      where: { 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;
+  }
+export const generateOtp = async (email: string) => {
+    const user = await prisma.user.findUnique({
+      where: { email },
+    });
+    if (!user) {
+      const err: any = new Error("User not found");
+      err.status = 404;
+      throw err;
+    }
+
+    const existingOtp = await prisma.otp.findUnique({
+      where: { email },
+    });
+    if (existingOtp) {
+      await prisma.otp.delete({
+        where: { email },
+      });
+    }
+
+    const otp = Math.floor(100000 + Math.random() * 900000).toString();
+    const hashedOtp = await bcrypt.hash(otp, 10);
+
+    await prisma.otp.create({
+      data: {
+        email,
+        otp: hashedOtp,
+      },
+    });
+
+    await sendOtpEmail(email, otp);
+    return true;
+  }
+export const verifyOtp = async ({ email, otp }: any) => {
+    const user = await prisma.user.findUnique({
+      where: { email },
+    });
+    if (!user) {
+      const err: any = new Error("User not found");
+      err.status = 404;
+      throw err;
+    }
+
+    const existingOtp = await prisma.otp.findUnique({
+      where: { 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;
+  }
+export const resetPassword = async (user: any, newPassword: any) => {
+    const hashedPassword = await bcrypt.hash(newPassword, 10);
+    await prisma.user.update({
+      where: { id: user.id },
+      data: { password: hashedPassword },
+    });
+    return true;
+  }
+export const updateProfile = async (userId: any, { name, phone, file }: any) => {
+    const user = await prisma.user.findUnique({
+      where: { id: userId },
+    });
+    if (!user) {
+      const err: any = new Error("User not found");
+      err.status = 404;
+      throw err;
+    }
+
+    const updateData: any = {};
+    if (name) updateData.name = name;
+    if (phone) updateData.phone = phone;
+
+    if (file) {
+      const uploadResult = await uploadSingleToCloudinary(file, {
+        folder: "codelab/avatars",
+      });
+
+      if (user.avatarPublicId) {
+        await deleteFromCloudinary(user.avatarPublicId).catch((err) =>
+          logger.error("Old avatar delete error", err)
+        );
+      }
+
+      updateData.avatarUrl = uploadResult.url;
+      updateData.avatarPublicId = uploadResult.publicId;
+    }
+
+    const updatedUser = await prisma.user.update({
+      where: { id: userId },
+      data: updateData,
+    });
+
+    return updatedUser;
+  }

package/templates/production-fullstack/server/src/features/notifications/push.controller.ts

@@ -0,0 +1,55 @@
+import { Request, Response, NextFunction } from "express";
+import { prisma } from "../../config/prisma.js";
+import logger from "../../config/logger.js";
+
+export const subscribe = async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const subscription = req.body;
+    const userId = req.user?._id || req.user?.id; // supports both mongoose and prisma IDs
+    
+    if (!subscription || !subscription.endpoint) {
+      return next({ status: 400, message: "Invalid subscription payload" });
+    }
+
+    const existingSub = await prisma.pushSubscription.findUnique({ where: { endpoint: subscription.endpoint } });
+
+    if (existingSub) {
+      if (userId) {
+        await prisma.pushSubscription.update({ where: { endpoint: subscription.endpoint }, data: { userId } })
+      }
+      return res.status(200).json({ success: true, message: "Already subscribed." });
+    }
+
+    
+    await prisma.pushSubscription.create({
+      data: {
+        endpoint: subscription.endpoint,
+        p256dh: subscription.keys.p256dh,
+        auth: subscription.keys.auth,
+        userId: userId || null
+      }
+    });
+    
+
+    res.status(201).json({ success: true, message: "Subscription created." });
+  } catch (error) {
+    logger.error("Error in push subscribe controller", error);
+    next(error);
+  }
+};
+
+export const unsubscribe = async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const { endpoint } = req.body;
+    if (!endpoint) {
+      return next({ status: 400, message: "Endpoint required" });
+    }
+
+    await prisma.pushSubscription.delete({ where: { endpoint } }).catch(() => {})
+
+    res.status(200).json({ success: true, message: "Unsubscribed." });
+  } catch (error) {
+    logger.error("Error in push unsubscribe controller", error);
+    next(error);
+  }
+};

package/templates/production-fullstack/server/src/features/notifications/push.routes.ts

@@ -0,0 +1,11 @@
+import express from "express";
+import { subscribe, unsubscribe } from "./push.controller.js";
+import { protect } from "../../common/middlewares/auth.middleware.js";
+
+const router = express.Router();
+
+// You can remove protect if you want anonymous users to be able to subscribe
+router.post("/subscribe", protect, subscribe);
+router.post("/unsubscribe", unsubscribe);
+
+export default router;

package/templates/production-fullstack/server/src/index.ts

@@ -0,0 +1,17 @@
+import dotenv from "dotenv";
+import http from "http";
+import app from "./app.js";
+import connectDB from "./config/prisma.js";
+import logger from "./config/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/production-fullstack/server/src/routes/index.ts

@@ -0,0 +1,12 @@
+import express from "express";
+import authRoutes from "../features/auth/auth.routes.js";
+import uploadRoutes from "../features/attachments/upload.routes.js";
+import pushRoutes from "../features/notifications/push.routes.js";
+
+const router = express.Router();
+
+router.use("/auth", authRoutes);
+router.use("/upload", uploadRoutes);
+router.use("/push", pushRoutes);
+
+export default router;

package/templates/production-fullstack/server/src/sockets/connection.ts

@@ -0,0 +1,31 @@
+import { Socket, Server } from "socket.io";
+import logger from "../config/logger.js";
+import { registerHandlers } from "./handlers/index.js";
+import { getUserRoom, getInstitutionRoom } from "./rooms.js";
+import { SocketEvents } from "./events.js";
+import { SocketData, ServerToClientEvents, ClientToServerEvents, InterServerEvents } from "./types.js";
+
+type AppSocket = Socket<ClientToServerEvents, ServerToClientEvents, InterServerEvents, SocketData>;
+type AppServer = Server<ClientToServerEvents, ServerToClientEvents, InterServerEvents, SocketData>;
+
+export const onConnection = (io: AppServer, socket: AppSocket) => {
+  const user = socket.data.user;
+
+  logger.info(`Socket connected: ${socket.id} (User: ${user.id})`);
+
+  // Auto-join user-specific room
+  socket.join(getUserRoom(user.id));
+
+  // Auto-join institution room if applicable
+  if (user.institutionId) {
+    socket.join(getInstitutionRoom(user.institutionId));
+  }
+
+  // Register all event handlers
+  registerHandlers(io, socket);
+
+  // Handle disconnect
+  socket.on(SocketEvents.DISCONNECT, (reason) => {
+    logger.info(`Socket disconnected: ${socket.id} (User: ${user.id}, Reason: ${reason})`);
+  });
+};

package/templates/production-fullstack/server/src/sockets/emitters/notification.emitter.ts

@@ -0,0 +1,17 @@
+import { getIO } from "../index.js";
+import { getUserRoom } from "../rooms.js";
+import { SocketEvents } from "../events.js";
+import logger from "../../config/logger.js";
+
+/**
+ * Emits a new notification to a specific user.
+ * This is meant to be called from business logic services.
+ */
+export const emitNewNotification = (userId: string, payload: unknown) => {
+  try {
+    const io = getIO();
+    io.to(getUserRoom(userId)).emit(SocketEvents.NOTIFICATION_NEW, payload);
+  } catch (error) {
+    logger.error(`Failed to emit notification to user ${userId}`, error);
+  }
+};

package/templates/production-fullstack/server/src/sockets/events.ts

@@ -0,0 +1,27 @@
+export const SocketEvents = {
+  // Connection Events
+  DISCONNECT: "disconnect",
+  CONNECT_ERROR: "connect_error",
+
+  // Room Events
+  SUBSCRIBE: "room:subscribe",
+  UNSUBSCRIBE: "room:unsubscribe",
+
+  // Notification Events
+  NOTIFICATION_NEW: "notification:new",
+  NOTIFICATION_MARK_AS_READ: "notification:markAsRead",
+
+  // Chat Events
+  CHAT_NEW_MESSAGE: "chat:newMessage",
+  CHAT_TYPING: "chat:typing",
+  CHAT_STOP_TYPING: "chat:stopTyping",
+
+  // LMS Events
+  LMS_ASSIGNMENT_CREATED: "lms:assignmentCreated",
+  LMS_GRADE_PUBLISHED: "lms:gradePublished",
+
+  // Attendance Events
+  ATTENDANCE_MARKED: "attendance:marked",
+} as const;
+
+export type SocketEvent = (typeof SocketEvents)[keyof typeof SocketEvents];

package/templates/production-fullstack/server/src/sockets/handlers/index.ts

@@ -0,0 +1,15 @@
+import { Socket, Server } from "socket.io";
+import { registerNotificationHandlers } from "./notification.handler.js";
+import { SocketData, ServerToClientEvents, ClientToServerEvents, InterServerEvents } from "../types.js";
+
+type AppSocket = Socket<ClientToServerEvents, ServerToClientEvents, InterServerEvents, SocketData>;
+type AppServer = Server<ClientToServerEvents, ServerToClientEvents, InterServerEvents, SocketData>;
+
+export const registerHandlers = (io: AppServer, socket: AppSocket) => {
+  // Register domain specific handlers
+  registerNotificationHandlers(io, socket);
+  
+  // Future handlers:
+  // registerChatHandlers(io, socket);
+  // registerLmsHandlers(io, socket);
+};

package/templates/production-fullstack/server/src/sockets/handlers/notification.handler.ts

@@ -0,0 +1,39 @@
+import { Socket, Server } from "socket.io";
+import logger from "../../config/logger.js";
+import { SocketEvents } from "../events.js";
+import { SocketData, ServerToClientEvents, ClientToServerEvents, InterServerEvents } from "../types.js";
+
+type AppSocket = Socket<ClientToServerEvents, ServerToClientEvents, InterServerEvents, SocketData>;
+type AppServer = Server<ClientToServerEvents, ServerToClientEvents, InterServerEvents, SocketData>;
+
+export const registerNotificationHandlers = (_io: AppServer, socket: AppSocket) => {
+  socket.on(SocketEvents.NOTIFICATION_MARK_AS_READ, (payload, callback) => {
+    try {
+      const { notificationId } = payload;
+      logger.info(`Notification marked as read: ${notificationId} by user ${socket.data.user.id}`);
+      
+      if (typeof callback === "function") {
+        callback({ success: true, notificationId });
+      }
+    } catch (error) {
+      logger.error("Error in notification:markAsRead handler", error);
+      if (typeof callback === "function") {
+        callback({ success: false, error: "Failed to mark as read" });
+      }
+    }
+  });
+
+  socket.on(SocketEvents.SUBSCRIBE, (payload) => {
+    if (payload?.topic) {
+      socket.join(`topic:${payload.topic}`);
+      logger.info(`User ${socket.data.user.id} subscribed to topic: ${payload.topic}`);
+    }
+  });
+
+  socket.on(SocketEvents.UNSUBSCRIBE, (payload) => {
+    if (payload?.topic) {
+      socket.leave(`topic:${payload.topic}`);
+      logger.info(`User ${socket.data.user.id} unsubscribed from topic: ${payload.topic}`);
+    }
+  });
+};

package/templates/production-fullstack/server/src/sockets/index.ts

@@ -0,0 +1,39 @@
+import { Server } from "socket.io";
+import { socketAuthMiddleware } from "./middleware.js";
+import { onConnection } from "./connection.js";
+import { SocketData, ServerToClientEvents, ClientToServerEvents, InterServerEvents } from "./types.js";
+
+type AppServer = Server<ClientToServerEvents, ServerToClientEvents, InterServerEvents, SocketData>;
+
+let io: AppServer;
+
+const initializeSocket = (server: import("http").Server) => {
+  io = new Server(server, {
+    cors: {
+      origin: ["http://localhost:5173"],
+      credentials: true,
+    },
+    // To support Redis in the future, you would add the adapter here:
+    // adapter: createAdapter(pubClient, subClient)
+  });
+
+  // Apply Authentication Middleware
+  io.use(socketAuthMiddleware);
+
+  // Handle Connections
+  io.on("connection", (socket) => {
+    onConnection(io, socket);
+  });
+
+  return io;
+};
+
+export const getIO = (): AppServer => {
+  if (!io) {
+    throw new Error("Socket.IO has not been initialized yet");
+  }
+  return io;
+};
+
+export { io };
+export default initializeSocket;

package/templates/production-fullstack/server/src/sockets/middleware.ts

@@ -0,0 +1,54 @@
+import { Socket } from "socket.io";
+import { verifyToken } from "../common/utils/jwt.js";
+import { SocketData, ServerToClientEvents, ClientToServerEvents, InterServerEvents } from "./types.js";
+import { prisma } from "../config/prisma.js";
+
+type AppSocket = Socket<ClientToServerEvents, ServerToClientEvents, InterServerEvents, SocketData>;
+
+const parseCookie = (cookieString: string, name: string) => {
+  const match = cookieString.match(new RegExp("(^| )" + name + "=([^;]+)"));
+  if (match) return match[2];
+  return null;
+};
+
+export const socketAuthMiddleware = async (socket: AppSocket, next: (err?: Error) => void) => {
+  try {
+    let token = socket.handshake.auth.token;
+
+    // Fallback to cookie if token is not explicitly passed in handshake
+    if (!token && socket.handshake.headers.cookie) {
+      token = parseCookie(socket.handshake.headers.cookie, "token");
+    }
+
+    if (!token) {
+      return next(new Error("Authentication error: No token provided"));
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const decoded: any = verifyToken(token);
+    
+    if (!decoded || !decoded.id) {
+      return next(new Error("Authentication error: Invalid token"));
+    }
+
+    const user = await prisma.user.findUnique({
+      where: { id: decoded.id },
+      select: { id: true, roles: true, institutionId: true },
+    });
+
+    if (!user) {
+      return next(new Error("Authentication error: User not found"));
+    }
+
+    // Attach user to socket data
+    socket.data.user = {
+      id: user.id,
+      roles: user.roles,
+      institutionId: user.institutionId,
+    };
+
+    next();
+  } catch {
+    next(new Error("Authentication error: Token verification failed"));
+  }
+};

package/templates/production-fullstack/server/src/sockets/rooms.ts

@@ -0,0 +1,11 @@
+/**
+ * Room generator functions.
+ * Using a consistent namespace pattern (e.g. user:<id>) ensures
+ * that rooms don't overlap and can be easily managed or targeted.
+ */
+
+export const getUserRoom = (userId: string) => `user:${userId}`;
+export const getInstitutionRoom = (institutionId: string) => `institution:${institutionId}`;
+export const getClassRoom = (classId: string) => `class:${classId}`;
+export const getSectionRoom = (sectionId: string) => `section:${sectionId}`;
+export const getTopicRoom = (topic: string) => `topic:${topic}`;