@imksh/create 1.0.24 → 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/babel.config.js

@@ -6,6 +6,7 @@ module.exports = function (api) {
       "nativewind/babel",
     ],
     plugins: [
+      ["inline-import", { "extensions": [".sql"] }],
       "react-native-reanimated/plugin" 
     ],
   };

package/templates/react-native/drizzle.config.ts

@@ -0,0 +1,8 @@
+import type { Config } from 'drizzle-kit';
+
+export default {
+  schema: './src/db/schema.ts',
+  out: './drizzle',
+  dialect: 'sqlite',
+  driver: 'expo',
+} satisfies Config;

package/templates/react-native/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "mobile",
+  "name": "shivAi",
   "main": "expo-router/entry",
   "version": "1.0.0",
   "dependencies": {
@@ -11,6 +11,7 @@
     "@react-navigation/bottom-tabs": "^7.18.10",
     "axios": "^1.18.1",
     "babel-preset-expo": "^57.0.3",
+    "drizzle-orm": "^0.45.2",
     "expo": "~57.0.7",
     "expo-blur": "~57.0.2",
     "expo-constants": "~57.0.6",
@@ -18,10 +19,13 @@
     "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",
     "expo-router": "~57.0.7",
     "expo-splash-screen": "~57.0.4",
+    "expo-sqlite": "^57.0.1",
     "expo-status-bar": "~57.0.1",
     "expo-symbols": "~57.0.1",
     "expo-system-ui": "~57.0.1",
@@ -45,11 +49,14 @@
     "react-native-toast-message": "^2.4.0",
     "react-native-web": "~0.21.0",
     "react-native-worklets": "0.10.0",
+    "socket.io-client": "^4.8.3",
     "tailwindcss": "^3.4.19",
     "zustand": "^5.0.14"
   },
   "devDependencies": {
     "@types/react": "~19.2.2",
+    "babel-plugin-inline-import": "^3.0.0",
+    "drizzle-kit": "^0.31.10",
     "eslint": "^9.0.0",
     "eslint-config-expo": "~57.0.0",
     "typescript": "~6.0.3"

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

@@ -0,0 +1,12 @@
+import { Stack } from 'expo-router';
+
+export default function AuthLayout() {
+  return (
+    <Stack screenOptions={{ headerShown: false }}>
+      <Stack.Screen name="login" />
+      <Stack.Screen name="forgot-password" />
+      <Stack.Screen name="edit-profile" options={{ presentation: 'modal' }} />
+      <Stack.Screen name="change-password" options={{ presentation: 'modal' }} />
+    </Stack>
+  );
+}