@studious-lms/server 1.0.7 → 1.1.0

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

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

package/dist/routers/class.js

@@ -1,8 +1,8 @@
 import { z } from "zod";
-import { createTRPCRouter, protectedProcedure, protectedTeacherProcedure, protectedClassMemberProcedure } from "../trpc";
-import { prisma } from "../lib/prisma";
+import { createTRPCRouter, protectedProcedure, protectedTeacherProcedure, protectedClassMemberProcedure } from "../trpc.js";
+import { prisma } from "../lib/prisma.js";
 import { TRPCError } from "@trpc/server";
-import { generateInviteCode } from "../utils/generateInviteCode";
+import { generateInviteCode } from "../utils/generateInviteCode.js";
 export const classRouter = createTRPCRouter({
     getAll: protectedProcedure
         .query(async ({ ctx }) => {
@@ -163,23 +163,26 @@ export const classRouter = createTRPCRouter({
                 },
             },
         });
+        if (!classData) {
+            throw new Error('Class not found');
+        }
+        const formattedClassData = {
+            ...classData,
+            assignments: classData.assignments.map(assignment => ({
+                ...assignment,
+                late: assignment.dueDate < new Date(),
+                submitted: assignment.submissions.some(submission => submission.studentId === ctx.user?.id),
+                returned: assignment.submissions.some(submission => submission.studentId === ctx.user?.id && submission.returned),
+            })),
+        };
         const sections = await prisma.section.findMany({
             where: {
                 classId: classId,
             },
         });
-        if (!classData) {
-            throw new Error('Class not found');
-        }
         return {
             class: {
-                ...classData,
-                assignments: classData.assignments.map(assignment => ({
-                    ...assignment,
-                    late: assignment.dueDate < new Date(),
-                    submitted: assignment.submissions.some(submission => submission.studentId === ctx.user?.id),
-                    returned: assignment.submissions.some(submission => submission.studentId === ctx.user?.id && submission.returned),
-                })),
+                ...formattedClassData,
                 sections,
             },
         };
@@ -448,6 +451,11 @@ export const classRouter = createTRPCRouter({
     }))
         .mutation(async ({ ctx, input }) => {
         const { classId } = input;
+        await prisma.session.deleteMany({
+            where: {
+                classId,
+            },
+        });
         // Create a new session for the invite code
         const session = await prisma.session.create({
             data: {

package/dist/routers/event.d.ts

@@ -1,11 +1,11 @@
 import { z } from "zod";
 export declare const eventRouter: import("@trpc/server").TRPCBuiltRouter<{
-    ctx: import("../trpc").Context;
+    ctx: import("../trpc.js").Context;
     meta: object;
     errorShape: {
         data: {
             zodError: z.typeToFlattenedError<any, string> | null;
-            prismaError: import("../utils/prismaErrorHandler").PrismaErrorInfo | null;
+            prismaError: import("../utils/prismaErrorHandler.js").PrismaErrorInfo | null;
             code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
             httpStatus: number;
             path?: string;

package/dist/routers/event.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
-import { createTRPCRouter, protectedProcedure } from "../trpc";
+import { createTRPCRouter, protectedProcedure } from "../trpc.js";
 import { TRPCError } from "@trpc/server";
-import { prisma } from "../lib/prisma";
+import { prisma } from "../lib/prisma.js";
 import { parseISO } from "date-fns";
 const eventSchema = z.object({
     name: z.string().optional(),

package/dist/routers/file.d.ts

@@ -1,11 +1,11 @@
 import { z } from "zod";
 export declare const fileRouter: import("@trpc/server").TRPCBuiltRouter<{
-    ctx: import("../trpc").Context;
+    ctx: import("../trpc.js").Context;
     meta: object;
     errorShape: {
         data: {
             zodError: z.typeToFlattenedError<any, string> | null;
-            prismaError: import("../utils/prismaErrorHandler").PrismaErrorInfo | null;
+            prismaError: import("../utils/prismaErrorHandler.js").PrismaErrorInfo | null;
             code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
             httpStatus: number;
             path?: string;

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;AAQxB,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8VrB,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsVrB,CAAC"}

package/dist/routers/file.js

@@ -1,9 +1,9 @@
 import { z } from "zod";
-import { createTRPCRouter, protectedProcedure, protectedTeacherProcedure } from "../trpc";
+import { createTRPCRouter, protectedProcedure, protectedTeacherProcedure } from "../trpc.js";
 import { TRPCError } from "@trpc/server";
-import { getSignedUrl, deleteFile } from "../lib/googleCloudStorage";
-import { prisma } from "../lib/prisma";
-import { logger } from "../utils/logger";
+import { getSignedUrl, deleteFile } from "../lib/googleCloudStorage.js";
+import { prisma } from "../lib/prisma.js";
+import { logger } from "../utils/logger.js";
 export const fileRouter = createTRPCRouter({
     getSignedUrl: protectedProcedure
         .input(z.object({
@@ -222,13 +222,6 @@ export const fileRouter = createTRPCRouter({
                 message: "File not found",
             });
         }
-        // Verify the file belongs to this class
-        if (file.folder?.classId !== classId) {
-            throw new TRPCError({
-                code: "FORBIDDEN",
-                message: "File does not belong to this class",
-            });
-        }
         // Validate new name
         if (!newName.trim()) {
             throw new TRPCError({

package/dist/routers/folder.d.ts

@@ -1,11 +1,11 @@
 import { z } from "zod";
 export declare const folderRouter: import("@trpc/server").TRPCBuiltRouter<{
-    ctx: import("../trpc").Context;
+    ctx: import("../trpc.js").Context;
     meta: object;
     errorShape: {
         data: {
             zodError: z.typeToFlattenedError<any, string> | null;
-            prismaError: import("../utils/prismaErrorHandler").PrismaErrorInfo | null;
+            prismaError: import("../utils/prismaErrorHandler.js").PrismaErrorInfo | null;
             code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
             httpStatus: number;
             path?: string;
@@ -227,7 +227,7 @@ export declare const folderRouter: import("@trpc/server").TRPCBuiltRouter<{
             [x: string]: unknown;
             classId: string;
             folderId: string;
-            targetParentFolderId?: string | undefined;
+            targetParentFolderId: string;
         };
         output: {
             files: {

package/dist/routers/folder.js

@@ -1,8 +1,8 @@
 import { z } from "zod";
-import { createTRPCRouter, protectedClassMemberProcedure, protectedTeacherProcedure } from "../trpc";
+import { createTRPCRouter, protectedClassMemberProcedure, protectedTeacherProcedure } from "../trpc.js";
 import { TRPCError } from "@trpc/server";
-import { prisma } from "../lib/prisma";
-import { uploadFiles } from "../lib/fileUpload";
+import { prisma } from "../lib/prisma.js";
+import { uploadFiles } from "../lib/fileUpload.js";
 const fileSchema = z.object({
     name: z.string(),
     type: z.string(),
@@ -501,7 +501,7 @@ export const folderRouter = createTRPCRouter({
     move: protectedTeacherProcedure
         .input(z.object({
         folderId: z.string(),
-        targetParentFolderId: z.string().optional(),
+        targetParentFolderId: z.string(),
         classId: z.string(),
     }))
         .mutation(async ({ ctx, input }) => {
@@ -591,7 +591,7 @@ export const folderRouter = createTRPCRouter({
         const updatedFolder = await prisma.folder.update({
             where: { id: folderId },
             data: {
-                parentFolderId: targetParentFolderId || null,
+                parentFolderId: targetParentFolderId,
             },
             include: {
                 files: {

package/dist/routers/notifications.d.ts

@@ -1,11 +1,11 @@
 import { z } from "zod";
 export declare const notificationRouter: import("@trpc/server").TRPCBuiltRouter<{
-    ctx: import("../trpc").Context;
+    ctx: import("../trpc.js").Context;
     meta: object;
     errorShape: {
         data: {
             zodError: z.typeToFlattenedError<any, string> | null;
-            prismaError: import("../utils/prismaErrorHandler").PrismaErrorInfo | null;
+            prismaError: import("../utils/prismaErrorHandler.js").PrismaErrorInfo | null;
             code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
             httpStatus: number;
             path?: string;

package/dist/routers/notifications.js

@@ -1,5 +1,5 @@
-import { createTRPCRouter, protectedProcedure } from "../trpc";
-import { prisma } from "../lib/prisma";
+import { createTRPCRouter, protectedProcedure } from "../trpc.js";
+import { prisma } from "../lib/prisma.js";
 import { z } from "zod";
 export const notificationRouter = createTRPCRouter({
     list: protectedProcedure.query(async ({ ctx }) => {

package/dist/routers/section.d.ts

@@ -1,11 +1,11 @@
 import { z } from "zod";
 export declare const sectionRouter: import("@trpc/server").TRPCBuiltRouter<{
-    ctx: import("../trpc").Context;
+    ctx: import("../trpc.js").Context;
     meta: object;
     errorShape: {
         data: {
             zodError: z.typeToFlattenedError<any, string> | null;
-            prismaError: import("../utils/prismaErrorHandler").PrismaErrorInfo | null;
+            prismaError: import("../utils/prismaErrorHandler.js").PrismaErrorInfo | null;
             code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
             httpStatus: number;
             path?: string;

package/dist/routers/section.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
-import { createTRPCRouter, protectedProcedure } from "../trpc";
+import { createTRPCRouter, protectedProcedure } from "../trpc.js";
 import { TRPCError } from "@trpc/server";
-import { prisma } from "../lib/prisma";
+import { prisma } from "../lib/prisma.js";
 const createSectionSchema = z.object({
     classId: z.string(),
     name: z.string(),

package/dist/routers/user.d.ts

@@ -1,11 +1,11 @@
 import { z } from "zod";
 export declare const userRouter: import("@trpc/server").TRPCBuiltRouter<{
-    ctx: import("../trpc").Context;
+    ctx: import("../trpc.js").Context;
     meta: object;
     errorShape: {
         data: {
             zodError: z.typeToFlattenedError<any, string> | null;
-            prismaError: import("../utils/prismaErrorHandler").PrismaErrorInfo | null;
+            prismaError: import("../utils/prismaErrorHandler.js").PrismaErrorInfo | null;
             code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
             httpStatus: number;
             path?: string;

package/dist/routers/user.js

@@ -1,8 +1,8 @@
 import { z } from "zod";
-import { createTRPCRouter, protectedProcedure } from "../trpc";
+import { createTRPCRouter, protectedProcedure } from "../trpc.js";
 import { TRPCError } from "@trpc/server";
-import { prisma } from "../lib/prisma";
-import { uploadFiles } from "../lib/fileUpload";
+import { prisma } from "../lib/prisma.js";
+import { uploadFiles } from "../lib/fileUpload.js";
 const fileSchema = z.object({
     name: z.string(),
     type: z.string(),

package/dist/seedDatabase.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"seedDatabase.d.ts","sourceRoot":"","sources":["../src/seedDatabase.ts"],"names":[],"mappings":"AAIA,wBAAsB,aAAa,kBAKlC;AAED,wBAAsB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;;;;;;;;;GAOjF;AAED,wBAAsB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;;;;;;;;GAQnF;AAED,eAAO,MAAM,YAAY,qBA6BxB,CAAC"}
+{"version":3,"file":"seedDatabase.d.ts","sourceRoot":"","sources":["../src/seedDatabase.ts"],"names":[],"mappings":"AAIA,wBAAsB,aAAa,kBA2BlC;AAED,wBAAsB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;;;;;;;;;GAOjF;AAED,wBAAsB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;;;;;;;;GAQnF;AAED,eAAO,MAAM,YAAY,qBA6BxB,CAAC"}

package/dist/seedDatabase.js

@@ -1,11 +1,29 @@
-import { prisma } from "./lib/prisma";
+import { prisma } from "./lib/prisma.js";
 import { hash } from "bcryptjs";
-import { logger } from "./utils/logger";
+import { logger } from "./utils/logger.js";
 export async function clearDatabase() {
+    // Delete in order to respect foreign key constraints
+    // Delete notifications first (they reference users)
+    await prisma.notification.deleteMany();
+    // Delete other records that reference users
+    await prisma.submission.deleteMany();
+    await prisma.assignment.deleteMany();
+    await prisma.announcement.deleteMany();
+    await prisma.event.deleteMany();
+    await prisma.attendance.deleteMany();
+    await prisma.file.deleteMany();
+    // Delete class-related records
+    await prisma.section.deleteMany();
+    await prisma.markScheme.deleteMany();
+    await prisma.gradingBoundary.deleteMany();
+    await prisma.folder.deleteMany();
     await prisma.class.deleteMany();
-    await prisma.userProfile.deleteMany();
+    // Delete user-related records
     await prisma.session.deleteMany();
+    await prisma.userProfile.deleteMany();
+    // Finally delete users and schools
     await prisma.user.deleteMany();
+    await prisma.school.deleteMany();
 }
 export async function createUser(email, password, username) {
     logger.debug("Creating user", { email, username, password });

package/dist/socket/handlers.js

@@ -1,4 +1,4 @@
-import { logger } from '../utils/logger';
+import { logger } from '../utils/logger.js';
 export const setupSocketHandlers = (io) => {
     io.on('connection', (socket) => {
         logger.info('Client connected', { socketId: socket.id });

package/dist/trpc.d.ts

@@ -1,7 +1,7 @@
 import { TRPCError } from '@trpc/server';
 import { Request, Response } from 'express';
 import { z } from 'zod';
-import { PrismaErrorInfo } from './utils/prismaErrorHandler';
+import { PrismaErrorInfo } from './utils/prismaErrorHandler.js';
 interface CreateContextOptions {
     req: Request;
     res: Response;

package/dist/trpc.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"trpc.d.ts","sourceRoot":"","sources":["../src/trpc.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,SAAS,EAAE,MAAM,cAAc,CAAC;AAMnD,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAC5C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAqB,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAEhF,UAAU,oBAAoB;IAC5B,GAAG,EAAE,OAAO,CAAC;IACb,GAAG,EAAE,QAAQ,CAAC;CACf;AAED,MAAM,MAAM,OAAO,GAAG;IACpB,GAAG,EAAE,OAAO,CAAC;IACb,GAAG,EAAE,QAAQ,CAAC;IACd,IAAI,EAAE;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IAC5B,IAAI,CAAC,EAAE;QACL,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,aAAa,CAAC,EAAE,MAAM,CAAC;KACxB,CAAC;CACH,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAU,MAAM,oBAAoB,KAAG,OAAO,CAAC,OAAO,CAwBnF,CAAC;AAEF,eAAO,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8BZ,CAAC;AAOH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;EAAW,CAAC;AACzC,eAAO,MAAM,eAAe,yOAAqC,CAAC;AAGlE,eAAO,MAAM,kBAAkB,yOAAgC,CAAC;AAChE,eAAO,MAAM,6BAA6B;;;;uHAEnB,CAAC;AACxB,eAAO,MAAM,yBAAyB;;;;uHAEd,CAAC;AAIzB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;EAAwB,CAAC"}
+{"version":3,"file":"trpc.d.ts","sourceRoot":"","sources":["../src/trpc.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,SAAS,EAAE,MAAM,cAAc,CAAC;AAMnD,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAC5C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAqB,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAEnF,UAAU,oBAAoB;IAC5B,GAAG,EAAE,OAAO,CAAC;IACb,GAAG,EAAE,QAAQ,CAAC;CACf;AAED,MAAM,MAAM,OAAO,GAAG;IACpB,GAAG,EAAE,OAAO,CAAC;IACb,GAAG,EAAE,QAAQ,CAAC;IACd,IAAI,EAAE;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IAC5B,IAAI,CAAC,EAAE;QACL,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,aAAa,CAAC,EAAE,MAAM,CAAC;KACxB,CAAC;CACH,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAU,MAAM,oBAAoB,KAAG,OAAO,CAAC,OAAO,CAwBnF,CAAC;AAEF,eAAO,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8BZ,CAAC;AAOH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;EAAW,CAAC;AACzC,eAAO,MAAM,eAAe,yOAAqC,CAAC;AAGlE,eAAO,MAAM,kBAAkB,yOAAgC,CAAC;AAChE,eAAO,MAAM,6BAA6B;;;;uHAEnB,CAAC;AACxB,eAAO,MAAM,yBAAyB;;;;uHAEd,CAAC;AAIzB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;EAAwB,CAAC"}

package/dist/trpc.js

@@ -1,11 +1,11 @@
 import { initTRPC } from '@trpc/server';
 import { ZodError } from 'zod';
-import { logger } from './utils/logger';
-import { prisma } from './lib/prisma';
-import { createLoggingMiddleware } from './middleware/logging';
-import { createAuthMiddleware } from './middleware/auth';
+import { logger } from './utils/logger.js';
+import { prisma } from './lib/prisma.js';
+import { createLoggingMiddleware } from './middleware/logging.js';
+import { createAuthMiddleware } from './middleware/auth.js';
 import { z } from 'zod';
-import { handlePrismaError } from './utils/prismaErrorHandler';
+import { handlePrismaError } from './utils/prismaErrorHandler.js';
 export const createTRPCContext = async (opts) => {
     const { req, res } = opts;
     // Get user from session/token

package/dist/types/trpc.d.ts

@@ -1,5 +1,5 @@
 import { inferAsyncReturnType } from '@trpc/server';
-import { createTRPCContext } from '../trpc';
+import { createTRPCContext } from '../trpc.js';
 export type Context = inferAsyncReturnType<typeof createTRPCContext> & {
     isTeacher?: boolean;
     teacherClassIds?: string[];

package/dist/types/trpc.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"trpc.d.ts","sourceRoot":"","sources":["../../src/types/trpc.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAE5C,MAAM,MAAM,OAAO,GAAG,oBAAoB,CAAC,OAAO,iBAAiB,CAAC,GAAG;IACrE,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;CAC5B,CAAC;AAEF,MAAM,WAAW,iBAAiB;IAChC,GAAG,EAAE,OAAO,CAAC;IACb,IAAI,EAAE,CAAC,IAAI,CAAC,EAAE;QAAE,GAAG,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;KAAE,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;IACzD,KAAK,CAAC,EAAE,GAAG,CAAC;IACZ,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;CACf"}
+{"version":3,"file":"trpc.d.ts","sourceRoot":"","sources":["../../src/types/trpc.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAE/C,MAAM,MAAM,OAAO,GAAG,oBAAoB,CAAC,OAAO,iBAAiB,CAAC,GAAG;IACrE,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;CAC5B,CAAC;AAEF,MAAM,WAAW,iBAAiB;IAChC,GAAG,EAAE,OAAO,CAAC;IACb,IAAI,EAAE,CAAC,IAAI,CAAC,EAAE;QAAE,GAAG,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;KAAE,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;IACzD,KAAK,CAAC,EAAE,GAAG,CAAC;IACZ,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;CACf"}

package/dist/utils/prismaWrapper.js

@@ -1,5 +1,5 @@
 import { TRPCError } from '@trpc/server';
-import { handlePrismaError } from './prismaErrorHandler';
+import { handlePrismaError } from './prismaErrorHandler.js';
 export async function withPrismaErrorHandling(operation, context = 'database operation') {
     try {
         return await operation();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@studious-lms/server",
-  "version": "1.0.7",
+  "version": "1.1.0",
   "description": "Backend server for Studious application",
   "main": "dist/exportType.js",
   "types": "dist/exportType.d.ts",
@@ -12,13 +12,13 @@
     }
   },
   "scripts": {
-    "dev": "ts-node-dev --respawn --transpile-only --loader ts-node/esm src/index.ts",
+    "dev": "tsx watch src/index.ts",
     "build": "tsc",
     "start": "node dist/index.js",
     "generate": "npx prisma generate",
     "prepublishOnly": "npm run generate && npm run build",
     "test": "vitest",
-    "seed": "ts-node src/seedDatabase.ts"
+    "seed": "node dist/seedDatabase.js"
   },
   "dependencies": {
     "@google-cloud/storage": "^7.16.0",
@@ -48,6 +48,7 @@
     "ts-node": "^10.9.2",
     "ts-node-dev": "^2.0.0",
     "tsconfig-paths": "^4.2.0",
+    "tsx": "^4.20.5",
     "typescript": "^5.3.3",
     "vitest": "^3.2.4"
   }

package/prisma/schema.prisma

@@ -81,7 +81,7 @@ model User {
 model UserProfile {
   id String @id @default(uuid())
   userId String @unique
-  user User? @relation(fields: [userId], references: [id])
+  user User? @relation(fields: [userId], references: [id], onDelete: Cascade)
 
 } 
 
@@ -291,5 +291,5 @@ model Notification {
   receiverId String
   read Boolean @default(false)
   sender User? @relation("SentNotifications", fields: [senderId], references: [id])
-  receiver User @relation("ReceivedNotifications", fields: [receiverId], references: [id])
+  receiver User @relation("ReceivedNotifications", fields: [receiverId], references: [id], onDelete: Cascade)
 }

package/src/exportType.ts

@@ -4,6 +4,6 @@
  * to the client via npmjs
  */
 
-export type { AppRouter } from "./routers/_app";
-export type { RouterInputs } from "./routers/_app";
-export type { RouterOutputs } from "./routers/_app";
+export type { AppRouter } from "./routers/_app.js";
+export type { RouterInputs } from "./routers/_app.js";
+export type { RouterOutputs } from "./routers/_app.js";

package/src/index.ts

@@ -5,10 +5,10 @@ import { Server } from 'socket.io';
 import cors from 'cors';
 import dotenv from 'dotenv';
 import { createExpressMiddleware } from '@trpc/server/adapters/express';
-import { appRouter } from './routers/_app';
-import { createTRPCContext, createCallerFactory } from './trpc';
-import { logger } from './utils/logger';
-import { setupSocketHandlers } from './socket/handlers';
+import { appRouter } from './routers/_app.js';
+import { createTRPCContext, createCallerFactory } from './trpc.js';
+import { logger } from './utils/logger.js';
+import { setupSocketHandlers } from './socket/handlers.js';
 
 dotenv.config();
 

package/src/lib/fileUpload.ts

@@ -1,8 +1,8 @@
 import { TRPCError } from "@trpc/server";
 import { v4 as uuidv4 } from "uuid";
-import { uploadFile as uploadToGCS, getSignedUrl } from "./googleCloudStorage";
-import { generateThumbnail, storeThumbnail, generateMediaThumbnail } from "./thumbnailGenerator";
-import { prisma } from "./prisma";
+import { uploadFile as uploadToGCS, getSignedUrl } from "./googleCloudStorage.js";
+import { generateThumbnail, storeThumbnail, generateMediaThumbnail } from "./thumbnailGenerator.js";
+import { prisma } from "./prisma.js";
 
 export interface FileData {
   name: string;

package/src/lib/thumbnailGenerator.ts

@@ -1,6 +1,6 @@
 import sharp from 'sharp';
-import { prisma } from './prisma';
-import { uploadFile, deleteFile, getSignedUrl } from './googleCloudStorage';
+import { prisma } from './prisma.js';
+import { uploadFile, deleteFile, getSignedUrl } from './googleCloudStorage.js';
 
 // Thumbnail size configuration
 const THUMBNAIL_WIDTH = 200;

package/src/middleware/auth.ts

@@ -1,6 +1,6 @@
 import { TRPCError } from '@trpc/server';
-import { prisma } from '../lib/prisma';
-import type { MiddlewareContext } from '../types/trpc';
+import { prisma } from '../lib/prisma.js';
+import type { MiddlewareContext } from '../types/trpc.js';
 
 export const createAuthMiddleware = (t: any) => {
 

package/src/middleware/logging.ts

@@ -1,5 +1,5 @@
-import type { MiddlewareContext } from '../types/trpc';
-import { logger } from '../utils/logger';
+import type { MiddlewareContext } from '../types/trpc.js';
+import { logger } from '../utils/logger.js';
 
 export const createLoggingMiddleware = (t: any) => {
   return t.middleware(async ({ path, type, next, ctx }: MiddlewareContext) => {

package/src/routers/_app.ts

@@ -1,18 +1,18 @@
-import { createTRPCRouter } from "../trpc";
-import { classRouter } from "./class";
-import { announcementRouter } from "./announcement";
-import { assignmentRouter } from "./assignment";
-import { userRouter } from "./user";
-import { createCallerFactory } from "../trpc";
+import { createTRPCRouter } from "../trpc.js";
+import { classRouter } from "./class.js";
+import { announcementRouter } from "./announcement.js";
+import { assignmentRouter } from "./assignment.js";
+import { userRouter } from "./user.js";
+import { createCallerFactory } from "../trpc.js";
 import type { inferRouterInputs, inferRouterOutputs } from "@trpc/server";
-import { sectionRouter } from "./section";
-import { attendanceRouter } from "./attendance";
-import { eventRouter } from "./event";
-import { authRouter } from "./auth";
-import { agendaRouter } from "./agenda";
-import { fileRouter } from "./file";
-import { folderRouter } from "./folder";
-import { notificationRouter } from "./notifications";
+import { sectionRouter } from "./section.js";
+import { attendanceRouter } from "./attendance.js";
+import { eventRouter } from "./event.js";
+import { authRouter } from "./auth.js";
+import { agendaRouter } from "./agenda.js";
+import { fileRouter } from "./file.js";
+import { folderRouter } from "./folder.js";
+import { notificationRouter } from "./notifications.js";
 
 export const appRouter = createTRPCRouter({
   class: classRouter,

package/src/routers/agenda.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
-import { createTRPCRouter, protectedProcedure } from "../trpc";
-import { prisma } from "../lib/prisma";
+import { createTRPCRouter, protectedProcedure } from "../trpc.js";
+import { prisma } from "../lib/prisma.js";
 import { TRPCError } from "@trpc/server";
 import { addDays, startOfDay, endOfDay } from "date-fns";
 

package/src/routers/announcement.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
-import { createTRPCRouter, protectedClassMemberProcedure, protectedTeacherProcedure, protectedProcedure } from "../trpc";
-import { prisma } from "../lib/prisma";
+import { createTRPCRouter, protectedClassMemberProcedure, protectedTeacherProcedure, protectedProcedure } from "../trpc.js";
+import { prisma } from "../lib/prisma.js";
 import { TRPCError } from "@trpc/server";
 
 const AnnouncementSelect = {

package/src/routers/assignment.ts

@@ -1,9 +1,9 @@
 import { z } from "zod";
-import { createTRPCRouter, protectedProcedure, protectedClassMemberProcedure, protectedTeacherProcedure } from "../trpc";
+import { createTRPCRouter, protectedProcedure, protectedClassMemberProcedure, protectedTeacherProcedure } from "../trpc.js";
 import { TRPCError } from "@trpc/server";
-import { prisma } from "../lib/prisma";
-import { uploadFiles, type UploadedFile } from "../lib/fileUpload";
-import { deleteFile } from "../lib/googleCloudStorage";
+import { prisma } from "../lib/prisma.js";
+import { uploadFiles, type UploadedFile } from "../lib/fileUpload.js";
+import { deleteFile } from "../lib/googleCloudStorage.js";
 
 const fileSchema = z.object({
   name: z.string(),

package/src/routers/attendance.ts

@@ -1,7 +1,7 @@
 import { z } from "zod";
-import { createTRPCRouter, protectedProcedure } from "../trpc";
+import { createTRPCRouter, protectedProcedure } from "../trpc.js";
 import { TRPCError } from "@trpc/server";
-import { prisma } from "../lib/prisma";
+import { prisma } from "../lib/prisma.js";
 
 const attendanceSchema = z.object({
   eventId: z.string().optional(),

package/src/routers/auth.ts

@@ -1,11 +1,11 @@
 import { z } from "zod";
-import { createTRPCRouter, protectedProcedure, publicProcedure } from "../trpc";
+import { createTRPCRouter, protectedProcedure, publicProcedure } from "../trpc.js";
 import { TRPCError } from "@trpc/server";
-import { prisma } from "../lib/prisma";
+import { prisma } from "../lib/prisma.js";
 import { v4 as uuidv4 } from 'uuid';
 import { compare, hash } from "bcryptjs";
-import { transport } from "../utils/email";
-import { prismaWrapper } from "../utils/prismaWrapper";
+import { transport } from "../utils/email.js";
+import { prismaWrapper } from "../utils/prismaWrapper.js";
 
 const loginSchema = z.object({
   username: z.string(),