@studious-lms/server 1.0.0

package/dist/routers/event.js

@@ -0,0 +1,467 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eventRouter = void 0;
+const zod_1 = require("zod");
+const trpc_1 = require("../trpc");
+const server_1 = require("@trpc/server");
+const prisma_1 = require("@lib/prisma");
+const date_fns_1 = require("date-fns");
+const eventSchema = zod_1.z.object({
+    name: zod_1.z.string().optional(),
+    location: zod_1.z.string().optional(),
+    remarks: zod_1.z.string().optional(),
+    startTime: zod_1.z.string(),
+    endTime: zod_1.z.string(),
+    classId: zod_1.z.string().optional(),
+    color: zod_1.z.string().optional(),
+});
+exports.eventRouter = (0, trpc_1.createTRPCRouter)({
+    get: trpc_1.protectedProcedure
+        .input(zod_1.z.object({
+        id: zod_1.z.string(),
+    }))
+        .query(async ({ ctx, input }) => {
+        if (!ctx.user) {
+            throw new server_1.TRPCError({
+                code: "UNAUTHORIZED",
+                message: "You must be logged in to get an event",
+            });
+        }
+        const event = await prisma_1.prisma.event.findUnique({
+            where: { id: input.id },
+            include: {
+                class: true,
+                user: true,
+                assignmentsAttached: {
+                    select: {
+                        id: true,
+                        title: true,
+                        instructions: true,
+                        dueDate: true,
+                        type: true,
+                        graded: true,
+                        maxGrade: true,
+                        weight: true,
+                        attachments: {
+                            select: {
+                                id: true,
+                                name: true,
+                                type: true,
+                            }
+                        },
+                        section: {
+                            select: {
+                                id: true,
+                                name: true
+                            }
+                        },
+                        teacher: {
+                            select: {
+                                id: true,
+                                username: true
+                            }
+                        }
+                    }
+                }
+            },
+        });
+        if (!event) {
+            throw new server_1.TRPCError({
+                code: "NOT_FOUND",
+                message: "Event not found",
+            });
+        }
+        if (event.userId !== ctx.user.id) {
+            throw new server_1.TRPCError({
+                code: "UNAUTHORIZED",
+                message: "You are not authorized to view this event",
+            });
+        }
+        return { event };
+    }),
+    create: trpc_1.protectedProcedure
+        .input(eventSchema)
+        .mutation(async ({ ctx, input }) => {
+        if (!ctx.user) {
+            throw new server_1.TRPCError({
+                code: "UNAUTHORIZED",
+                message: "You must be logged in to create an event",
+            });
+        }
+        // If classId is provided, check if user is a teacher of the class
+        if (input.classId) {
+            const classData = await prisma_1.prisma.class.findUnique({
+                where: {
+                    id: input.classId,
+                    teachers: {
+                        some: {
+                            id: ctx.user.id,
+                        },
+                    },
+                },
+            });
+            if (!classData) {
+                throw new server_1.TRPCError({
+                    code: "UNAUTHORIZED",
+                    message: "You are not authorized to create events for this class",
+                });
+            }
+        }
+        const event = await prisma_1.prisma.event.create({
+            data: {
+                name: input.name,
+                location: input.location,
+                remarks: input.remarks,
+                startTime: (0, date_fns_1.parseISO)(input.startTime),
+                endTime: (0, date_fns_1.parseISO)(input.endTime),
+                userId: ctx.user.id,
+                color: input.color,
+                ...(input.classId ? { classId: input.classId } : {}),
+            },
+            select: {
+                id: true,
+                name: true,
+                location: true,
+                remarks: true,
+                startTime: true,
+                endTime: true,
+                color: true,
+                classId: true,
+                userId: true,
+                class: {
+                    select: {
+                        id: true,
+                        name: true
+                    }
+                },
+            }
+        });
+        return { event };
+    }),
+    update: trpc_1.protectedProcedure
+        .input(zod_1.z.object({
+        id: zod_1.z.string(),
+        data: eventSchema,
+    }))
+        .mutation(async ({ ctx, input }) => {
+        if (!ctx.user) {
+            throw new server_1.TRPCError({
+                code: "UNAUTHORIZED",
+                message: "You must be logged in to update an event",
+            });
+        }
+        const event = await prisma_1.prisma.event.findUnique({
+            where: { id: input.id },
+        });
+        if (!event) {
+            throw new server_1.TRPCError({
+                code: "NOT_FOUND",
+                message: "Event not found",
+            });
+        }
+        if (event.userId !== ctx.user.id) {
+            throw new server_1.TRPCError({
+                code: "UNAUTHORIZED",
+                message: "You are not authorized to update this event",
+            });
+        }
+        const updatedEvent = await prisma_1.prisma.event.update({
+            where: { id: input.id },
+            data: {
+                name: input.data.name,
+                location: input.data.location,
+                remarks: input.data.remarks,
+                startTime: (0, date_fns_1.parseISO)(input.data.startTime),
+                endTime: (0, date_fns_1.parseISO)(input.data.endTime),
+                color: input.data.color,
+                ...(input.data.classId ? { classId: input.data.classId } : {}),
+            },
+        });
+        return { event: updatedEvent };
+    }),
+    delete: trpc_1.protectedProcedure
+        .input(zod_1.z.object({
+        id: zod_1.z.string(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        if (!ctx.user) {
+            throw new server_1.TRPCError({
+                code: "UNAUTHORIZED",
+                message: "You must be logged in to delete an event",
+            });
+        }
+        const event = await prisma_1.prisma.event.findUnique({
+            where: { id: input.id },
+        });
+        if (!event) {
+            throw new server_1.TRPCError({
+                code: "NOT_FOUND",
+                message: "Event not found",
+            });
+        }
+        if (event.userId !== ctx.user.id) {
+            throw new server_1.TRPCError({
+                code: "UNAUTHORIZED",
+                message: "You are not authorized to delete this event",
+            });
+        }
+        await prisma_1.prisma.event.delete({
+            where: { id: input.id },
+        });
+        return { success: true };
+    }),
+    attachAssignment: trpc_1.protectedProcedure
+        .input(zod_1.z.object({
+        eventId: zod_1.z.string(),
+        assignmentId: zod_1.z.string(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        if (!ctx.user || !ctx.user.id) {
+            throw new server_1.TRPCError({
+                code: "UNAUTHORIZED",
+                message: "You must be logged in to attach an assignment",
+            });
+        }
+        // Check if user owns the event
+        const event = await prisma_1.prisma.event.findUnique({
+            where: { id: input.eventId },
+            include: {
+                class: {
+                    include: {
+                        teachers: {
+                            select: { id: true }
+                        }
+                    }
+                }
+            }
+        });
+        if (!event) {
+            throw new server_1.TRPCError({
+                code: "NOT_FOUND",
+                message: "Event not found",
+            });
+        }
+        // Check if user is the event owner or a teacher of the class
+        if (event.userId !== ctx.user.id &&
+            !event.class?.teachers.some(teacher => teacher.id === ctx.user.id)) {
+            throw new server_1.TRPCError({
+                code: "UNAUTHORIZED",
+                message: "You are not authorized to modify this event",
+            });
+        }
+        // Check if assignment exists and belongs to the same class
+        const assignment = await prisma_1.prisma.assignment.findUnique({
+            where: { id: input.assignmentId },
+            include: {
+                class: {
+                    include: {
+                        teachers: {
+                            select: { id: true }
+                        }
+                    }
+                }
+            }
+        });
+        if (!assignment) {
+            throw new server_1.TRPCError({
+                code: "NOT_FOUND",
+                message: "Assignment not found",
+            });
+        }
+        // Check if user is a teacher of the assignment's class
+        if (!assignment.class.teachers.some(teacher => teacher.id === ctx.user.id)) {
+            throw new server_1.TRPCError({
+                code: "UNAUTHORIZED",
+                message: "You are not authorized to modify this assignment",
+            });
+        }
+        // Check if event and assignment belong to the same class
+        if (event.classId !== assignment.classId) {
+            throw new server_1.TRPCError({
+                code: "BAD_REQUEST",
+                message: "Event and assignment must belong to the same class",
+            });
+        }
+        // Attach assignment to event
+        const updatedAssignment = await prisma_1.prisma.assignment.update({
+            where: { id: input.assignmentId },
+            data: {
+                eventAttached: {
+                    connect: { id: input.eventId }
+                }
+            },
+            include: {
+                attachments: {
+                    select: {
+                        id: true,
+                        name: true,
+                        type: true,
+                    }
+                },
+                section: {
+                    select: {
+                        id: true,
+                        name: true
+                    }
+                },
+                teacher: {
+                    select: {
+                        id: true,
+                        username: true
+                    }
+                }
+            }
+        });
+        return { assignment: updatedAssignment };
+    }),
+    detachAssignment: trpc_1.protectedProcedure
+        .input(zod_1.z.object({
+        eventId: zod_1.z.string(),
+        assignmentId: zod_1.z.string(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        if (!ctx.user) {
+            throw new server_1.TRPCError({
+                code: "UNAUTHORIZED",
+                message: "You must be logged in to detach an assignment",
+            });
+        }
+        // Check if user owns the event
+        const event = await prisma_1.prisma.event.findUnique({
+            where: { id: input.eventId },
+            include: {
+                class: {
+                    include: {
+                        teachers: {
+                            select: { id: true }
+                        }
+                    }
+                }
+            }
+        });
+        if (!event) {
+            throw new server_1.TRPCError({
+                code: "NOT_FOUND",
+                message: "Event not found",
+            });
+        }
+        // Check if user is the event owner or a teacher of the class
+        if (event.userId !== ctx.user.id &&
+            !event.class?.teachers.some(teacher => teacher.id === ctx.user.id)) {
+            throw new server_1.TRPCError({
+                code: "UNAUTHORIZED",
+                message: "You are not authorized to modify this event",
+            });
+        }
+        // Detach assignment from event
+        const updatedAssignment = await prisma_1.prisma.assignment.update({
+            where: { id: input.assignmentId },
+            data: {
+                eventAttached: {
+                    disconnect: true
+                }
+            },
+            include: {
+                attachments: {
+                    select: {
+                        id: true,
+                        name: true,
+                        type: true,
+                    }
+                },
+                section: {
+                    select: {
+                        id: true,
+                        name: true
+                    }
+                },
+                teacher: {
+                    select: {
+                        id: true,
+                        username: true
+                    }
+                }
+            }
+        });
+        return { assignment: updatedAssignment };
+    }),
+    getAvailableAssignments: trpc_1.protectedProcedure
+        .input(zod_1.z.object({
+        eventId: zod_1.z.string(),
+    }))
+        .query(async ({ ctx, input }) => {
+        if (!ctx.user) {
+            throw new server_1.TRPCError({
+                code: "UNAUTHORIZED",
+                message: "You must be logged in to get available assignments",
+            });
+        }
+        // Get the event to find the class
+        const event = await prisma_1.prisma.event.findUnique({
+            where: { id: input.eventId },
+            include: {
+                class: {
+                    include: {
+                        teachers: {
+                            select: { id: true }
+                        }
+                    }
+                }
+            }
+        });
+        if (!event || !event.classId) {
+            throw new server_1.TRPCError({
+                code: "NOT_FOUND",
+                message: "Event not found",
+            });
+        }
+        // Check if user is authorized to access this event/class
+        if (event.userId !== ctx.user.id &&
+            !event.class?.teachers.some(teacher => teacher.id === ctx.user.id)) {
+            throw new server_1.TRPCError({
+                code: "UNAUTHORIZED",
+                message: "You are not authorized to access this event",
+            });
+        }
+        // Get all assignments for the class that are not already attached to an event
+        const assignments = await prisma_1.prisma.assignment.findMany({
+            where: {
+                classId: event.classId,
+                eventId: null, // Not already attached to any event
+            },
+            select: {
+                id: true,
+                title: true,
+                instructions: true,
+                dueDate: true,
+                type: true,
+                graded: true,
+                maxGrade: true,
+                weight: true,
+                section: {
+                    select: {
+                        id: true,
+                        name: true
+                    }
+                },
+                attachments: {
+                    select: {
+                        id: true,
+                        name: true,
+                        type: true,
+                    }
+                },
+                teacher: {
+                    select: {
+                        id: true,
+                        username: true
+                    }
+                }
+            },
+            orderBy: {
+                createdAt: 'desc'
+            }
+        });
+        return { assignments };
+    }),
+});

package/dist/routers/file.d.ts

@@ -0,0 +1,27 @@
+import { z } from "zod";
+export declare const fileRouter: import("@trpc/server/dist/unstable-core-do-not-import").BuiltRouter<{
+    ctx: import("../trpc").Context;
+    meta: object;
+    errorShape: {
+        data: {
+            zodError: z.typeToFlattenedError<any, string> | null;
+            code: import("@trpc/server/dist/unstable-core-do-not-import").TRPC_ERROR_CODE_KEY;
+            httpStatus: number;
+            path?: string;
+            stack?: string;
+        };
+        message: string;
+        code: import("@trpc/server/dist/unstable-core-do-not-import").TRPC_ERROR_CODE_NUMBER;
+    };
+    transformer: false;
+}, import("@trpc/server/dist/unstable-core-do-not-import").DecorateCreateRouterOptions<{
+    getSignedUrl: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            fileId: string;
+        };
+        output: {
+            signedUrl: string;
+        };
+    }>;
+}>>;
+//# sourceMappingURL=file.d.ts.map

package/dist/routers/file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file.d.ts","sourceRoot":"","sources":["../../src/routers/file.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;GAwFrB,CAAC"}

package/dist/routers/file.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fileRouter = void 0;
+const zod_1 = require("zod");
+const trpc_1 = require("../trpc");
+const server_1 = require("@trpc/server");
+const googleCloudStorage_1 = require("@/lib/googleCloudStorage");
+const prisma_1 = require("@lib/prisma");
+exports.fileRouter = (0, trpc_1.createTRPCRouter)({
+    getSignedUrl: trpc_1.protectedProcedure
+        .input(zod_1.z.object({
+        fileId: zod_1.z.string(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        const { fileId } = input;
+        const userId = ctx.user?.id;
+        if (!userId) {
+            throw new server_1.TRPCError({
+                code: "UNAUTHORIZED",
+                message: "You must be logged in to access files",
+            });
+        }
+        // Get file metadata from database
+        const file = await prisma_1.prisma.file.findUnique({
+            where: { id: fileId },
+            include: {
+                assignment: {
+                    include: {
+                        class: {
+                            include: {
+                                students: true,
+                                teachers: true
+                            }
+                        }
+                    }
+                },
+                submission: {
+                    include: {
+                        student: true,
+                        assignment: {
+                            include: {
+                                class: {
+                                    include: {
+                                        teachers: true
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        });
+        if (!file) {
+            throw new server_1.TRPCError({
+                code: "NOT_FOUND",
+                message: "File does not exist",
+            });
+        }
+        // Check if user has access to the file
+        const hasAccess = 
+        // File owner
+        file.userId === userId ||
+            // Assignment file - student in class or teacher
+            (file.assignment && (file.assignment.class.students.some((s) => s.id === userId) ||
+                file.assignment.class.teachers.some((t) => t.id === userId))) ||
+            // Submission file - student who submitted or teacher of class
+            (file.submission && (file.submission.student.id === userId ||
+                file.submission.assignment.class.teachers.some((t) => t.id === userId)));
+        if (!hasAccess) {
+            throw new server_1.TRPCError({
+                code: "FORBIDDEN",
+                message: "You do not have access to this file",
+            });
+        }
+        try {
+            // Generate a signed URL with short expiration
+            const signedUrl = await (0, googleCloudStorage_1.getSignedUrl)(file.path);
+            return { signedUrl };
+        }
+        catch (error) {
+            console.error('Error generating signed URL:', error);
+            throw new server_1.TRPCError({
+                code: "INTERNAL_SERVER_ERROR",
+                message: "Failed to generate signed URL",
+            });
+        }
+    }),
+});

package/dist/routers/section.d.ts

@@ -0,0 +1,51 @@
+import { z } from "zod";
+export declare const sectionRouter: import("@trpc/server/dist/unstable-core-do-not-import").BuiltRouter<{
+    ctx: import("../trpc").Context;
+    meta: object;
+    errorShape: {
+        data: {
+            zodError: z.typeToFlattenedError<any, string> | null;
+            code: import("@trpc/server/dist/unstable-core-do-not-import").TRPC_ERROR_CODE_KEY;
+            httpStatus: number;
+            path?: string;
+            stack?: string;
+        };
+        message: string;
+        code: import("@trpc/server/dist/unstable-core-do-not-import").TRPC_ERROR_CODE_NUMBER;
+    };
+    transformer: false;
+}, import("@trpc/server/dist/unstable-core-do-not-import").DecorateCreateRouterOptions<{
+    create: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            name: string;
+            classId: string;
+        };
+        output: {
+            id: string;
+            name: string;
+            classId: string;
+        };
+    }>;
+    update: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            id: string;
+            name: string;
+            classId: string;
+        };
+        output: {
+            id: string;
+            name: string;
+            classId: string;
+        };
+    }>;
+    delete: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            id: string;
+            classId: string;
+        };
+        output: {
+            id: string;
+        };
+    }>;
+}>>;
+//# sourceMappingURL=section.d.ts.map

package/dist/routers/section.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"section.d.ts","sourceRoot":"","sources":["../../src/routers/section.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAqBxB,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoHxB,CAAC"}