@studious-lms/server 1.2.53 → 1.4.0

package/src/middleware/auth.ts

@@ -1,46 +1,33 @@
-import { TRPCError } from '@trpc/server';
-import { prisma } from '../lib/prisma.js';
-import type { MiddlewareContext } from '../types/trpc.js';
+import { TRPCError } from "@trpc/server";
 import * as Sentry from "@sentry/node";
+import type { MiddlewareContext } from "../types/trpc.js";
+import {
+  findUserBySessionToken,
+  findTeacherClassesByUserId,
+  findClassWithMember,
+  findClassWithTeacher,
+} from "../models/auth.js";
 
 export const createAuthMiddleware = (t: any) => {
-
-  // Auth middleware
   const isAuthed = t.middleware(async ({ next, ctx }: MiddlewareContext) => {
-    const startTime = Date.now();
-    // Get user from request headers
-    const userHeader = ctx.req.headers['x-user'];
+    const userHeader = ctx.req.headers["x-user"];
 
     if (!userHeader) {
       throw new TRPCError({
-        code: 'UNAUTHORIZED',
-        message: 'Not authenticated - no token found',
+        code: "UNAUTHORIZED",
+        message: "Not authenticated - no token found",
       });
     }
 
     try {
-      const token = typeof userHeader === 'string' ? userHeader : userHeader[0];
-
-      // Find user by session token
-      const user = await prisma.user.findFirst({
-        where: {
-          sessions: {
-            some: {
-              id: token
-            }
-          }
-        },
-        select: {
-          id: true,
-          username: true,
-          // institutionId: true,
-        }
-      });
+      const token =
+        typeof userHeader === "string" ? userHeader : userHeader[0];
+      const user = await findUserBySessionToken(token);
 
       if (!user) {
         throw new TRPCError({
-          code: 'UNAUTHORIZED',
-          message: 'Invalid or expired session',
+          code: "UNAUTHORIZED",
+          message: "Invalid or expired session",
         });
       }
 
@@ -51,140 +38,96 @@ export const createAuthMiddleware = (t: any) => {
         },
       });
     } catch (error) {
-      // Re-throw TRPCErrors as-is (e.g., UNAUTHORIZED from invalid session)
       if (error instanceof TRPCError) {
         throw error;
       }
       Sentry.captureException(error);
       console.error(error);
       throw new TRPCError({
-        code: 'INTERNAL_SERVER_ERROR',
-        message: 'Internal server error',
+        code: "INTERNAL_SERVER_ERROR",
+        message: "Internal server error",
       });
     }
   });
 
-  // Add computed flags middleware
-  const addComputedFlags = t.middleware(async ({ next, ctx }: MiddlewareContext) => {
-    if (!ctx.user) {
-      throw new TRPCError({
-        code: 'UNAUTHORIZED',
-        message: 'Not authenticated',
-      });
-    }
-
-    // Get all classes where user is a teacher
-    const teacherClasses = await prisma.class.findMany({
-      where: {
-        teachers: {
-          some: {
-            id: ctx.user.id
-          }
-        }
-      },
-      select: {
-        id: true
-      }
-    });
-
-    return next({
-      ctx: {
-        ...ctx,
-        isTeacher: teacherClasses.length > 0,
-        teacherClassIds: teacherClasses.map((c: { id: string }) => c.id)
+  const addComputedFlags = t.middleware(
+    async ({ next, ctx }: MiddlewareContext) => {
+      if (!ctx.user) {
+        throw new TRPCError({
+          code: "UNAUTHORIZED",
+          message: "Not authenticated",
+        });
       }
-    });
-  });
-
-  // Student middleware
-  const isMemberInClass = t.middleware(async ({ next, ctx, input }: MiddlewareContext) => {
-    if (!ctx.user) {
-      throw new TRPCError({
-        code: 'UNAUTHORIZED',
-        message: 'Not authenticated',
-      });
-    }
 
-    const classId = (input as { classId: string })?.classId;
+      const teacherClasses = await findTeacherClassesByUserId(ctx.user.id);
 
-    if (!classId) {
-      throw new TRPCError({
-        code: 'BAD_REQUEST',
-        message: 'classId is required',
+      return next({
+        ctx: {
+          ...ctx,
+          isTeacher: teacherClasses.length > 0,
+          teacherClassIds: teacherClasses.map((c) => c.id),
+        },
       });
     }
+  );
 
-    const isMember = await prisma.class.findFirst({
-      where: {
-        id: classId,
-        OR: [
-          {
-            students: {
-              some: {
-                id: ctx.user.id
-              }
-            }
-          },
-          {
-            teachers: {
-              some: {
-                id: ctx.user.id
-              }
-            }
-          }
-        ]
+  const isMemberInClass = t.middleware(
+    async ({ next, ctx, input }: MiddlewareContext) => {
+      if (!ctx.user) {
+        throw new TRPCError({
+          code: "UNAUTHORIZED",
+          message: "Not authenticated",
+        });
       }
-    });
 
-    if (!isMember) {
-      throw new TRPCError({
-        code: 'FORBIDDEN',
-        message: 'Not a member in this class',
-      });
-    }
-
-    return next();
-  });
+      const classId = (input as { classId: string })?.classId;
+      if (!classId) {
+        throw new TRPCError({
+          code: "BAD_REQUEST",
+          message: "classId is required",
+        });
+      }
 
-  // Teacher middleware
-  const isTeacherInClass = t.middleware(async ({ next, ctx, input }: MiddlewareContext) => {
-    if (!ctx.user) {
-      throw new TRPCError({
-        code: 'UNAUTHORIZED',
-        message: 'Not authenticated',
-      });
-    }
+      const isMember = await findClassWithMember(classId, ctx.user.id);
+      if (!isMember) {
+        throw new TRPCError({
+          code: "FORBIDDEN",
+          message: "Not a member in this class",
+        });
+      }
 
-    const classId = input.classId;
-    if (!classId) {
-      throw new TRPCError({
-        code: 'BAD_REQUEST',
-        message: 'classId is required',
-      });
+      return next();
     }
+  );
 
-    const isTeacher = await prisma.class.findFirst({
-      where: {
-        id: classId,
-        teachers: {
-          some: {
-            id: ctx.user.id
-          }
-        }
+  const isTeacherInClass = t.middleware(
+    async ({ next, ctx, input }: MiddlewareContext) => {
+      if (!ctx.user) {
+        throw new TRPCError({
+          code: "UNAUTHORIZED",
+          message: "Not authenticated",
+        });
       }
-    });
 
+      const classId = (input as { classId: string })?.classId;
+      if (!classId) {
+        throw new TRPCError({
+          code: "BAD_REQUEST",
+          message: "classId is required",
+        });
+      }
 
+      const isTeacher = await findClassWithTeacher(classId, ctx.user.id);
+      if (!isTeacher) {
+        throw new TRPCError({
+          code: "FORBIDDEN",
+          message: "Not a teacher in this class",
+        });
+      }
 
-    if (!isTeacher) {
-      throw new TRPCError({
-        code: 'FORBIDDEN',
-        message: 'Not a teacher in this class',
-      });
+      return next();
     }
-
-    return next();
-  });
+  );
 
   return {
     isAuthed,
@@ -192,4 +135,4 @@ export const createAuthMiddleware = (t: any) => {
     isMemberInClass,
     isTeacherInClass,
   };
-}; 
+};

package/src/models/agenda.ts

@@ -0,0 +1,46 @@
+/**
+ * Agenda model – personal and class events for a date range.
+ */
+import { prisma } from "../lib/prisma.js";
+
+/** @returns Personal events (no class) for user in date range. */
+export function findPersonalEvents(
+  userId: string,
+  rangeStart: Date,
+  rangeEnd: Date,
+) {
+  return prisma.event.findMany({
+    where: {
+      userId,
+      startTime: { gte: rangeStart, lte: rangeEnd },
+      class: { is: null },
+    },
+    include: {
+      assignmentsAttached: true,
+      class: true,
+    },
+  });
+}
+
+/** @returns Class events for user's classes in date range. */
+export function findClassEvents(
+  userId: string,
+  rangeStart: Date,
+  rangeEnd: Date,
+) {
+  return prisma.event.findMany({
+    where: {
+      class: {
+        OR: [
+          { teachers: { some: { id: userId } } },
+          { students: { some: { id: userId } } },
+        ],
+      },
+      startTime: { gte: rangeStart, lte: rangeEnd },
+    },
+    include: {
+      assignmentsAttached: true,
+      class: true,
+    },
+  });
+}

package/src/models/announcement.ts

@@ -0,0 +1,134 @@
+/**
+ * Announcement model – announcements, attachments, comments.
+ */
+import { prisma } from "../lib/prisma.js";
+
+export const announcementSelect = {
+  id: true,
+  teacher: {
+    select: {
+      id: true,
+      username: true,
+      profile: {
+        select: {
+          displayName: true,
+          profilePicture: true,
+          profilePictureThumbnail: true,
+        },
+      },
+    },
+  },
+  remarks: true,
+  createdAt: true,
+  modifiedAt: true,
+  attachments: {
+    select: {
+      id: true,
+      name: true,
+      type: true,
+      size: true,
+      path: true,
+      uploadedAt: true,
+      thumbnailId: true,
+    },
+  },
+};
+
+/** @returns Announcements for a class. */
+export function findAnnouncementsByClassId(classId: string) {
+  return prisma.announcement.findMany({
+    where: { classId },
+    select: {
+      ...announcementSelect,
+      _count: {
+        select: { comments: true },
+      },
+    },
+    orderBy: { createdAt: "desc" },
+  });
+}
+
+/** @returns Announcement by ID and class. */
+export function findAnnouncementByIdAndClass(id: string, classId: string) {
+  return prisma.announcement.findFirst({
+    where: { id, classId },
+    select: announcementSelect,
+  });
+}
+
+/** @returns Announcement by ID with class and teachers. */
+export function findAnnouncementWithClass(id: string) {
+  return prisma.announcement.findUnique({
+    where: { id },
+    include: {
+      class: {
+        include: { teachers: true },
+      },
+      attachments: {
+        select: {
+          id: true,
+          name: true,
+          type: true,
+          path: true,
+          size: true,
+          uploadStatus: true,
+          thumbnail: { select: { path: true } },
+        },
+      },
+    },
+  });
+}
+
+/** Create an announcement. */
+export function createAnnouncement(data: {
+  remarks: string;
+  teacherId: string;
+  classId: string;
+}) {
+  return prisma.announcement.create({
+    data: {
+      remarks: data.remarks,
+      teacher: { connect: { id: data.teacherId } },
+      class: { connect: { id: data.classId } },
+    },
+    select: announcementSelect,
+  });
+}
+
+/** Update announcement attachments. */
+export function updateAnnouncementAttachments(
+  id: string,
+  data: {
+    connect?: { id: string }[];
+    deleteMany?: { id: { in: string[] } };
+  }
+) {
+  return prisma.announcement.update({
+    where: { id },
+    data: {
+      ...(data.connect?.length && {
+        attachments: { connect: data.connect },
+      }),
+      ...(data.deleteMany && {
+        attachments: { deleteMany: data.deleteMany },
+      }),
+    },
+    select: announcementSelect,
+  });
+}
+
+/** Update announcement remarks. */
+export function updateAnnouncement(id: string, data: { remarks?: string }) {
+  return prisma.announcement.update({
+    where: { id },
+    data,
+    select: announcementSelect,
+  });
+}
+
+/** Delete an announcement. */
+export function deleteAnnouncement(id: string) {
+  return prisma.announcement.delete({
+    where: { id },
+  });
+}