@imksh/create 1.0.25 → 1.0.26

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}`;

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

@@ -0,0 +1,32 @@
+import { SocketEvents } from "./events.js";
+
+// Basic user info injected into socket.data by the auth middleware
+export interface SocketUser {
+  id: string;
+  roles?: { role: { name: string } }[] | unknown;
+  institutionId?: string | null;
+}
+
+export interface SocketData {
+  user: SocketUser;
+}
+
+export interface ServerToClientEvents {
+  [SocketEvents.NOTIFICATION_NEW]: (payload: unknown) => void;
+  [SocketEvents.CHAT_NEW_MESSAGE]: (payload: unknown) => void;
+  [SocketEvents.LMS_ASSIGNMENT_CREATED]: (payload: unknown) => void;
+  [SocketEvents.ATTENDANCE_MARKED]: (payload: unknown) => void;
+}
+
+export interface ClientToServerEvents {
+  [SocketEvents.SUBSCRIBE]: (payload: { topic: string }) => void;
+  [SocketEvents.UNSUBSCRIBE]: (payload: { topic: string }) => void;
+  [SocketEvents.NOTIFICATION_MARK_AS_READ]: (
+    payload: { notificationId: string },
+    callback: (response: { success: boolean; notificationId?: string; error?: string }) => void
+  ) => void;
+}
+
+export interface InterServerEvents {
+  ping: () => void;
+}

package/templates/production-fullstack/server/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"]
+}

package/templates/react-native/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "mobile",
+  "name": "shivAi",
   "main": "expo-router/entry",
   "version": "1.0.0",
   "dependencies": {
@@ -19,6 +19,7 @@
     "expo-font": "~57.0.1",
     "expo-glass-effect": "~57.0.1",
     "expo-image": "~57.0.1",
+    "expo-image-picker": "^57.0.6",
     "expo-linear-gradient": "^57.0.1",
     "expo-linking": "~57.0.3",
     "expo-notifications": "~57.0.6",

package/templates/react-native/src/app/(auth)/edit-profile.tsx

@@ -3,8 +3,8 @@ import { View, TouchableOpacity } from "react-native";
 import { useAuthStore } from "../../store/useAuthStore";
 import { Txt } from "../../components/common/Typography";
 import { router, useFocusEffect } from "expo-router";
-import * as ImagePicker from "expo-image-picker";
 import { Ionicons } from "@expo/vector-icons";
+import ImagePickerModal from "../../components/ui/inputs/ImagePickerModal";
 import Avatar from "../../components/ui/data-display/Avatar";
 
 import ScrollContainer from "../../components/ui/layout/ScrollContainer";
@@ -27,19 +27,7 @@ export default function EditProfileScreen() {
   const [name, setName] = useState(user?.name || "");
   const [phone, setPhone] = useState(user?.phone || "");
   const [avatarUri, setAvatarUri] = useState<string | null>(null);
-
-  const pickImage = async () => {
-    const result = await ImagePicker.launchImageLibraryAsync({
-      mediaTypes: ImagePicker.MediaTypeOptions.Images,
-      allowsEditing: true,
-      aspect: [1, 1],
-      quality: 0.8,
-    });
-
-    if (!result.canceled && result.assets[0]) {
-      setAvatarUri(result.assets[0].uri);
-    }
-  };
+  const [isImagePickerOpen, setIsImagePickerOpen] = useState(false);
 
   const handleSave = async () => {
     const formData = new FormData();
@@ -112,7 +100,7 @@ export default function EditProfileScreen() {
               )}
             </View>
             <TouchableOpacity
-              onPress={pickImage}
+              onPress={() => setIsImagePickerOpen(true)}
               className="absolute bottom-0 right-0 bg-primary p-2 rounded-full border-2 border-base-100"
             >
               <Ionicons name="camera" size={18} color="#fff" />
@@ -155,6 +143,14 @@ export default function EditProfileScreen() {
           </View>
         </View>
       </ScrollContainer>
+      <ImagePickerModal
+        isOpen={isImagePickerOpen}
+        onClose={() => setIsImagePickerOpen(false)}
+        onImageSelected={(image) => setAvatarUri(image.uri)}
+        allowsEditing
+        title="Profile Picture"
+        subtitle="Choose a new profile picture"
+      />
     </>
   );
 }

package/templates/react-native/src/app/(tabs)/dashboard.tsx

@@ -1,11 +1,11 @@
 import { View } from "react-native";
 import React from "react";
-import HomeHeader from "@/components/common/HomeHeader";
+import TabHeader from "@/components/common/TabHeader";
 
 const dashboard = () => {
   return (
     <View>
-      <HomeHeader title="Dashboard" icon="apps-outline" />
+      <TabHeader title="Dashboard" showMenuButton={false} />
     </View>
   );
 };