@studious-lms/server 1.0.4 → 1.0.7

package/dist/routers/event.d.ts

@@ -5,6 +5,7 @@ export declare const eventRouter: import("@trpc/server").TRPCBuiltRouter<{
     errorShape: {
         data: {
             zodError: z.typeToFlattenedError<any, string> | null;
+            prismaError: import("../utils/prismaErrorHandler").PrismaErrorInfo | null;
             code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
             httpStatus: number;
             path?: string;
@@ -27,14 +28,18 @@ export declare const eventRouter: import("@trpc/server").TRPCBuiltRouter<{
                     email: string;
                     password: string;
                     verified: boolean;
+                    role: import(".prisma/client").$Enums.UserRole;
                     profileId: string | null;
+                    schoolId: string | null;
                 } | null;
                 class: {
                     id: string;
+                    schoolId: string | null;
                     name: string;
                     subject: string;
                     color: string | null;
                     section: string;
+                    syllabus: string | null;
                 } | null;
                 assignmentsAttached: {
                     type: import(".prisma/client").$Enums.AssignmentType;
@@ -43,16 +48,16 @@ export declare const eventRouter: import("@trpc/server").TRPCBuiltRouter<{
                         id: string;
                         name: string;
                     } | null;
+                    title: string;
+                    dueDate: Date;
+                    maxGrade: number | null;
                     teacher: {
                         id: string;
                         username: string;
                     };
-                    title: string;
                     instructions: string;
-                    dueDate: Date;
-                    graded: boolean;
-                    maxGrade: number | null;
                     weight: number;
+                    graded: boolean;
                     attachments: {
                         type: string;
                         id: string;
@@ -63,12 +68,12 @@ export declare const eventRouter: import("@trpc/server").TRPCBuiltRouter<{
                 id: string;
                 name: string | null;
                 color: string | null;
-                classId: string | null;
-                userId: string | null;
-                remarks: string | null;
+                location: string | null;
                 startTime: Date;
                 endTime: Date;
-                location: string | null;
+                remarks: string | null;
+                classId: string | null;
+                userId: string | null;
             };
         };
         meta: object;
@@ -79,9 +84,9 @@ export declare const eventRouter: import("@trpc/server").TRPCBuiltRouter<{
             endTime: string;
             name?: string | undefined;
             color?: string | undefined;
-            classId?: string | undefined;
-            remarks?: string | undefined;
             location?: string | undefined;
+            remarks?: string | undefined;
+            classId?: string | undefined;
         };
         output: {
             event: {
@@ -92,12 +97,12 @@ export declare const eventRouter: import("@trpc/server").TRPCBuiltRouter<{
                     name: string;
                 } | null;
                 color: string | null;
-                classId: string | null;
-                userId: string | null;
-                remarks: string | null;
+                location: string | null;
                 startTime: Date;
                 endTime: Date;
-                location: string | null;
+                remarks: string | null;
+                classId: string | null;
+                userId: string | null;
             };
         };
         meta: object;
@@ -110,9 +115,9 @@ export declare const eventRouter: import("@trpc/server").TRPCBuiltRouter<{
                 endTime: string;
                 name?: string | undefined;
                 color?: string | undefined;
-                classId?: string | undefined;
-                remarks?: string | undefined;
                 location?: string | undefined;
+                remarks?: string | undefined;
+                classId?: string | undefined;
             };
         };
         output: {
@@ -120,12 +125,12 @@ export declare const eventRouter: import("@trpc/server").TRPCBuiltRouter<{
                 id: string;
                 name: string | null;
                 color: string | null;
-                classId: string | null;
-                userId: string | null;
-                remarks: string | null;
+                location: string | null;
                 startTime: Date;
                 endTime: Date;
-                location: string | null;
+                remarks: string | null;
+                classId: string | null;
+                userId: string | null;
             };
         };
         meta: object;
@@ -162,20 +167,22 @@ export declare const eventRouter: import("@trpc/server").TRPCBuiltRouter<{
             } & {
                 type: import(".prisma/client").$Enums.AssignmentType;
                 id: string;
+                title: string;
+                dueDate: Date;
+                maxGrade: number | null;
                 classId: string;
+                eventId: string | null;
                 markSchemeId: string | null;
                 gradingBoundaryId: string | null;
-                title: string;
                 instructions: string;
-                dueDate: Date;
+                weight: number;
+                graded: boolean;
+                sectionId: string | null;
+                template: boolean;
                 createdAt: Date | null;
                 modifiedAt: Date | null;
                 teacherId: string;
-                sectionId: string | null;
-                graded: boolean;
-                maxGrade: number | null;
-                weight: number;
-                eventId: string | null;
+                inProgress: boolean;
             };
         };
         meta: object;
@@ -203,20 +210,22 @@ export declare const eventRouter: import("@trpc/server").TRPCBuiltRouter<{
             } & {
                 type: import(".prisma/client").$Enums.AssignmentType;
                 id: string;
+                title: string;
+                dueDate: Date;
+                maxGrade: number | null;
                 classId: string;
+                eventId: string | null;
                 markSchemeId: string | null;
                 gradingBoundaryId: string | null;
-                title: string;
                 instructions: string;
-                dueDate: Date;
+                weight: number;
+                graded: boolean;
+                sectionId: string | null;
+                template: boolean;
                 createdAt: Date | null;
                 modifiedAt: Date | null;
                 teacherId: string;
-                sectionId: string | null;
-                graded: boolean;
-                maxGrade: number | null;
-                weight: number;
-                eventId: string | null;
+                inProgress: boolean;
             };
         };
         meta: object;
@@ -233,16 +242,16 @@ export declare const eventRouter: import("@trpc/server").TRPCBuiltRouter<{
                     id: string;
                     name: string;
                 } | null;
+                title: string;
+                dueDate: Date;
+                maxGrade: number | null;
                 teacher: {
                     id: string;
                     username: string;
                 };
-                title: string;
                 instructions: string;
-                dueDate: Date;
-                graded: boolean;
-                maxGrade: number | null;
                 weight: number;
+                graded: boolean;
                 attachments: {
                     type: string;
                     id: string;

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

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

package/dist/routers/event.js

@@ -1,33 +1,30 @@
-"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(),
+import { z } from "zod";
+import { createTRPCRouter, protectedProcedure } from "../trpc";
+import { TRPCError } from "@trpc/server";
+import { prisma } from "../lib/prisma";
+import { parseISO } from "date-fns";
+const eventSchema = z.object({
+    name: z.string().optional(),
+    location: z.string().optional(),
+    remarks: z.string().optional(),
+    startTime: z.string(),
+    endTime: z.string(),
+    classId: z.string().optional(),
+    color: z.string().optional(),
 });
-exports.eventRouter = (0, trpc_1.createTRPCRouter)({
-    get: trpc_1.protectedProcedure
-        .input(zod_1.z.object({
-        id: zod_1.z.string(),
+export const eventRouter = createTRPCRouter({
+    get: protectedProcedure
+        .input(z.object({
+        id: z.string(),
     }))
         .query(async ({ ctx, input }) => {
         if (!ctx.user) {
-            throw new server_1.TRPCError({
+            throw new TRPCError({
                 code: "UNAUTHORIZED",
                 message: "You must be logged in to get an event",
             });
         }
-        const event = await prisma_1.prisma.event.findUnique({
+        const event = await prisma.event.findUnique({
             where: { id: input.id },
             include: {
                 class: true,
@@ -66,31 +63,31 @@ exports.eventRouter = (0, trpc_1.createTRPCRouter)({
             },
         });
         if (!event) {
-            throw new server_1.TRPCError({
+            throw new TRPCError({
                 code: "NOT_FOUND",
                 message: "Event not found",
             });
         }
         if (event.userId !== ctx.user.id) {
-            throw new server_1.TRPCError({
+            throw new TRPCError({
                 code: "UNAUTHORIZED",
                 message: "You are not authorized to view this event",
             });
         }
         return { event };
     }),
-    create: trpc_1.protectedProcedure
+    create: protectedProcedure
         .input(eventSchema)
         .mutation(async ({ ctx, input }) => {
         if (!ctx.user) {
-            throw new server_1.TRPCError({
+            throw new 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({
+            const classData = await prisma.class.findUnique({
                 where: {
                     id: input.classId,
                     teachers: {
@@ -101,19 +98,19 @@ exports.eventRouter = (0, trpc_1.createTRPCRouter)({
                 },
             });
             if (!classData) {
-                throw new server_1.TRPCError({
+                throw new TRPCError({
                     code: "UNAUTHORIZED",
                     message: "You are not authorized to create events for this class",
                 });
             }
         }
-        const event = await prisma_1.prisma.event.create({
+        const event = await 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),
+                startTime: parseISO(input.startTime),
+                endTime: parseISO(input.endTime),
                 userId: ctx.user.id,
                 color: input.color,
                 ...(input.classId ? { classId: input.classId } : {}),
@@ -138,92 +135,92 @@ exports.eventRouter = (0, trpc_1.createTRPCRouter)({
         });
         return { event };
     }),
-    update: trpc_1.protectedProcedure
-        .input(zod_1.z.object({
-        id: zod_1.z.string(),
+    update: protectedProcedure
+        .input(z.object({
+        id: z.string(),
         data: eventSchema,
     }))
         .mutation(async ({ ctx, input }) => {
         if (!ctx.user) {
-            throw new server_1.TRPCError({
+            throw new TRPCError({
                 code: "UNAUTHORIZED",
                 message: "You must be logged in to update an event",
             });
         }
-        const event = await prisma_1.prisma.event.findUnique({
+        const event = await prisma.event.findUnique({
             where: { id: input.id },
         });
         if (!event) {
-            throw new server_1.TRPCError({
+            throw new TRPCError({
                 code: "NOT_FOUND",
                 message: "Event not found",
             });
         }
         if (event.userId !== ctx.user.id) {
-            throw new server_1.TRPCError({
+            throw new TRPCError({
                 code: "UNAUTHORIZED",
                 message: "You are not authorized to update this event",
             });
         }
-        const updatedEvent = await prisma_1.prisma.event.update({
+        const updatedEvent = await 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),
+                startTime: parseISO(input.data.startTime),
+                endTime: 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(),
+    delete: protectedProcedure
+        .input(z.object({
+        id: z.string(),
     }))
         .mutation(async ({ ctx, input }) => {
         if (!ctx.user) {
-            throw new server_1.TRPCError({
+            throw new TRPCError({
                 code: "UNAUTHORIZED",
                 message: "You must be logged in to delete an event",
             });
         }
-        const event = await prisma_1.prisma.event.findUnique({
+        const event = await prisma.event.findUnique({
             where: { id: input.id },
         });
         if (!event) {
-            throw new server_1.TRPCError({
+            throw new TRPCError({
                 code: "NOT_FOUND",
                 message: "Event not found",
             });
         }
         if (event.userId !== ctx.user.id) {
-            throw new server_1.TRPCError({
+            throw new TRPCError({
                 code: "UNAUTHORIZED",
                 message: "You are not authorized to delete this event",
             });
         }
-        await prisma_1.prisma.event.delete({
+        await 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(),
+    attachAssignment: protectedProcedure
+        .input(z.object({
+        eventId: z.string(),
+        assignmentId: z.string(),
     }))
         .mutation(async ({ ctx, input }) => {
         if (!ctx.user || !ctx.user.id) {
-            throw new server_1.TRPCError({
+            throw new 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({
+        const event = await prisma.event.findUnique({
             where: { id: input.eventId },
             include: {
                 class: {
@@ -236,7 +233,7 @@ exports.eventRouter = (0, trpc_1.createTRPCRouter)({
             }
         });
         if (!event) {
-            throw new server_1.TRPCError({
+            throw new TRPCError({
                 code: "NOT_FOUND",
                 message: "Event not found",
             });
@@ -244,13 +241,13 @@ exports.eventRouter = (0, trpc_1.createTRPCRouter)({
         // 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({
+            throw new 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({
+        const assignment = await prisma.assignment.findUnique({
             where: { id: input.assignmentId },
             include: {
                 class: {
@@ -263,27 +260,27 @@ exports.eventRouter = (0, trpc_1.createTRPCRouter)({
             }
         });
         if (!assignment) {
-            throw new server_1.TRPCError({
+            throw new 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({
+            throw new 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({
+            throw new 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({
+        const updatedAssignment = await prisma.assignment.update({
             where: { id: input.assignmentId },
             data: {
                 eventAttached: {
@@ -314,20 +311,20 @@ exports.eventRouter = (0, trpc_1.createTRPCRouter)({
         });
         return { assignment: updatedAssignment };
     }),
-    detachAssignment: trpc_1.protectedProcedure
-        .input(zod_1.z.object({
-        eventId: zod_1.z.string(),
-        assignmentId: zod_1.z.string(),
+    detachAssignment: protectedProcedure
+        .input(z.object({
+        eventId: z.string(),
+        assignmentId: z.string(),
     }))
         .mutation(async ({ ctx, input }) => {
         if (!ctx.user) {
-            throw new server_1.TRPCError({
+            throw new 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({
+        const event = await prisma.event.findUnique({
             where: { id: input.eventId },
             include: {
                 class: {
@@ -340,7 +337,7 @@ exports.eventRouter = (0, trpc_1.createTRPCRouter)({
             }
         });
         if (!event) {
-            throw new server_1.TRPCError({
+            throw new TRPCError({
                 code: "NOT_FOUND",
                 message: "Event not found",
             });
@@ -348,13 +345,13 @@ exports.eventRouter = (0, trpc_1.createTRPCRouter)({
         // 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({
+            throw new TRPCError({
                 code: "UNAUTHORIZED",
                 message: "You are not authorized to modify this event",
             });
         }
         // Detach assignment from event
-        const updatedAssignment = await prisma_1.prisma.assignment.update({
+        const updatedAssignment = await prisma.assignment.update({
             where: { id: input.assignmentId },
             data: {
                 eventAttached: {
@@ -385,19 +382,19 @@ exports.eventRouter = (0, trpc_1.createTRPCRouter)({
         });
         return { assignment: updatedAssignment };
     }),
-    getAvailableAssignments: trpc_1.protectedProcedure
-        .input(zod_1.z.object({
-        eventId: zod_1.z.string(),
+    getAvailableAssignments: protectedProcedure
+        .input(z.object({
+        eventId: z.string(),
     }))
         .query(async ({ ctx, input }) => {
         if (!ctx.user) {
-            throw new server_1.TRPCError({
+            throw new 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({
+        const event = await prisma.event.findUnique({
             where: { id: input.eventId },
             include: {
                 class: {
@@ -410,7 +407,7 @@ exports.eventRouter = (0, trpc_1.createTRPCRouter)({
             }
         });
         if (!event || !event.classId) {
-            throw new server_1.TRPCError({
+            throw new TRPCError({
                 code: "NOT_FOUND",
                 message: "Event not found",
             });
@@ -418,13 +415,13 @@ exports.eventRouter = (0, trpc_1.createTRPCRouter)({
         // 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({
+            throw new 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({
+        const assignments = await prisma.assignment.findMany({
             where: {
                 classId: event.classId,
                 eventId: null, // Not already attached to any event

package/dist/routers/file.d.ts

@@ -5,6 +5,7 @@ export declare const fileRouter: import("@trpc/server").TRPCBuiltRouter<{
     errorShape: {
         data: {
             zodError: z.typeToFlattenedError<any, string> | null;
+            prismaError: import("../utils/prismaErrorHandler").PrismaErrorInfo | null;
             code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
             httpStatus: number;
             path?: string;
@@ -20,7 +21,76 @@ export declare const fileRouter: import("@trpc/server").TRPCBuiltRouter<{
             fileId: string;
         };
         output: {
-            signedUrl: string;
+            url: string;
+        };
+        meta: object;
+    }>;
+    move: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            [x: string]: unknown;
+            classId: string;
+            fileId: string;
+            targetFolderId: string;
+        };
+        output: {
+            user: {
+                id: string;
+                username: string;
+            } | null;
+        } & {
+            path: string;
+            type: string;
+            id: string;
+            name: string;
+            size: number | null;
+            uploadedAt: Date | null;
+            assignmentId: string | null;
+            submissionId: string | null;
+            userId: string | null;
+            thumbnailId: string | null;
+            annotationId: string | null;
+            classDraftId: string | null;
+            folderId: string | null;
+        };
+        meta: object;
+    }>;
+    rename: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            [x: string]: unknown;
+            classId: string;
+            fileId: string;
+            newName: string;
+        };
+        output: {
+            user: {
+                id: string;
+                username: string;
+            } | null;
+        } & {
+            path: string;
+            type: string;
+            id: string;
+            name: string;
+            size: number | null;
+            uploadedAt: Date | null;
+            assignmentId: string | null;
+            submissionId: string | null;
+            userId: string | null;
+            thumbnailId: string | null;
+            annotationId: string | null;
+            classDraftId: string | null;
+            folderId: string | null;
+        };
+        meta: object;
+    }>;
+    delete: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            [x: string]: unknown;
+            classId: string;
+            fileId: string;
+        };
+        output: {
+            success: boolean;
         };
         meta: object;
     }>;

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

@@ -1 +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"}
+{"version":3,"file":"file.d.ts","sourceRoot":"","sources":["../../src/routers/file.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8VrB,CAAC"}