@studious-lms/server 1.0.4 → 1.0.7

package/dist/routers/attendance.d.ts

@@ -5,6 +5,7 @@ export declare const attendanceRouter: 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;
@@ -25,9 +26,9 @@ export declare const attendanceRouter: import("@trpc/server").TRPCBuiltRouter<{
                 id: string;
                 name: string | null;
                 color: string | null;
+                location: string | null;
                 startTime: Date;
                 endTime: Date;
-                location: string | null;
             } | null;
             late: {
                 id: string;
@@ -44,8 +45,8 @@ export declare const attendanceRouter: import("@trpc/server").TRPCBuiltRouter<{
         } & {
             id: string;
             classId: string;
-            date: Date;
             eventId: string | null;
+            date: Date;
         })[];
         meta: object;
     }>;
@@ -73,9 +74,9 @@ export declare const attendanceRouter: import("@trpc/server").TRPCBuiltRouter<{
             event: {
                 id: string;
                 name: string | null;
+                location: string | null;
                 startTime: Date;
                 endTime: Date;
-                location: string | null;
             } | null;
             late: {
                 id: string;
@@ -92,8 +93,8 @@ export declare const attendanceRouter: import("@trpc/server").TRPCBuiltRouter<{
         } & {
             id: string;
             classId: string;
-            date: Date;
             eventId: string | null;
+            date: Date;
         };
         meta: object;
     }>;

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

@@ -1 +1 @@
-{"version":3,"file":"attendance.d.ts","sourceRoot":"","sources":["../../src/routers/attendance.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAYxB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+Q3B,CAAC"}
+{"version":3,"file":"attendance.d.ts","sourceRoot":"","sources":["../../src/routers/attendance.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAYxB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+Q3B,CAAC"}

package/dist/routers/attendance.js

@@ -1,31 +1,28 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.attendanceRouter = 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 attendanceSchema = zod_1.z.object({
-    eventId: zod_1.z.string().optional(),
-    present: zod_1.z.array(zod_1.z.object({ id: zod_1.z.string(), username: zod_1.z.string() })),
-    late: zod_1.z.array(zod_1.z.object({ id: zod_1.z.string(), username: zod_1.z.string() })),
-    absent: zod_1.z.array(zod_1.z.object({ id: zod_1.z.string(), username: zod_1.z.string() })),
+import { z } from "zod";
+import { createTRPCRouter, protectedProcedure } from "../trpc";
+import { TRPCError } from "@trpc/server";
+import { prisma } from "../lib/prisma";
+const attendanceSchema = z.object({
+    eventId: z.string().optional(),
+    present: z.array(z.object({ id: z.string(), username: z.string() })),
+    late: z.array(z.object({ id: z.string(), username: z.string() })),
+    absent: z.array(z.object({ id: z.string(), username: z.string() })),
 });
-exports.attendanceRouter = (0, trpc_1.createTRPCRouter)({
-    get: trpc_1.protectedProcedure
-        .input(zod_1.z.object({
-        classId: zod_1.z.string(),
-        eventId: zod_1.z.string().optional(),
+export const attendanceRouter = createTRPCRouter({
+    get: protectedProcedure
+        .input(z.object({
+        classId: z.string(),
+        eventId: z.string().optional(),
     }))
         .query(async ({ ctx, input }) => {
         if (!ctx.user) {
-            throw new server_1.TRPCError({
+            throw new TRPCError({
                 code: "UNAUTHORIZED",
                 message: "You must be logged in to view attendance",
             });
         }
         // Check if user is a teacher or student of the class
-        const classData = await prisma_1.prisma.class.findUnique({
+        const classData = await prisma.class.findUnique({
             where: {
                 id: input.classId,
                 OR: [
@@ -54,25 +51,25 @@ exports.attendanceRouter = (0, trpc_1.createTRPCRouter)({
             },
         });
         if (!classData) {
-            throw new server_1.TRPCError({
+            throw new TRPCError({
                 code: "UNAUTHORIZED",
                 message: "You are not authorized to view this class's attendance",
             });
         }
         // check each event has an attendance, if not create one
-        const events = await prisma_1.prisma.event.findMany({
+        const events = await prisma.event.findMany({
             where: {
                 classId: input.classId,
             },
         });
         for (const event of events) {
-            const attendance = await prisma_1.prisma.attendance.findFirst({
+            const attendance = await prisma.attendance.findFirst({
                 where: {
                     eventId: event.id,
                 },
             });
             if (!attendance) {
-                await prisma_1.prisma.attendance.create({
+                await prisma.attendance.create({
                     data: {
                         event: {
                             connect: {
@@ -91,7 +88,7 @@ exports.attendanceRouter = (0, trpc_1.createTRPCRouter)({
                 });
             }
         }
-        const attendance = await prisma_1.prisma.attendance.findMany({
+        const attendance = await prisma.attendance.findMany({
             where: {
                 classId: input.classId,
                 ...(input.eventId ? { eventId: input.eventId } : {}),
@@ -132,21 +129,21 @@ exports.attendanceRouter = (0, trpc_1.createTRPCRouter)({
         });
         return attendance;
     }),
-    update: trpc_1.protectedProcedure
-        .input(zod_1.z.object({
-        classId: zod_1.z.string(),
-        eventId: zod_1.z.string().optional(),
+    update: protectedProcedure
+        .input(z.object({
+        classId: z.string(),
+        eventId: z.string().optional(),
         attendance: attendanceSchema,
     }))
         .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 attendance",
             });
         }
         // Check if user is a teacher of the class
-        const classData = await prisma_1.prisma.class.findUnique({
+        const classData = await prisma.class.findUnique({
             where: {
                 id: input.classId,
                 teachers: {
@@ -157,13 +154,13 @@ exports.attendanceRouter = (0, trpc_1.createTRPCRouter)({
             },
         });
         if (!classData) {
-            throw new server_1.TRPCError({
+            throw new TRPCError({
                 code: "UNAUTHORIZED",
                 message: "You are not authorized to update this class's attendance",
             });
         }
         // Check if attendance record exists
-        const existingAttendance = await prisma_1.prisma.attendance.findFirst({
+        const existingAttendance = await prisma.attendance.findFirst({
             where: {
                 classId: input.classId,
                 eventId: input.eventId,
@@ -171,7 +168,7 @@ exports.attendanceRouter = (0, trpc_1.createTRPCRouter)({
         });
         if (!existingAttendance) {
             // Create new attendance record
-            const attendance = await prisma_1.prisma.attendance.create({
+            const attendance = await prisma.attendance.create({
                 data: {
                     classId: input.classId,
                     eventId: input.eventId,
@@ -219,7 +216,7 @@ exports.attendanceRouter = (0, trpc_1.createTRPCRouter)({
             return attendance;
         }
         // Update existing attendance record
-        const attendance = await prisma_1.prisma.attendance.update({
+        const attendance = await prisma.attendance.update({
             where: {
                 id: existingAttendance.id,
             },

package/dist/routers/auth.d.ts

@@ -5,6 +5,7 @@ export declare const authRouter: 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;

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

@@ -1 +1 @@
-{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../src/routers/auth.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAuBxB,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsQrB,CAAC"}
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../src/routers/auth.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAwBxB,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+RrB,CAAC"}

package/dist/routers/auth.js

@@ -1,33 +1,30 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.authRouter = 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 uuid_1 = require("uuid");
-const bcryptjs_1 = require("bcryptjs");
-const email_1 = require("../utils/email");
-const loginSchema = zod_1.z.object({
-    username: zod_1.z.string(),
-    password: zod_1.z.string(),
+import { z } from "zod";
+import { createTRPCRouter, protectedProcedure, publicProcedure } from "../trpc";
+import { TRPCError } from "@trpc/server";
+import { prisma } from "../lib/prisma";
+import { v4 as uuidv4 } from 'uuid';
+import { compare, hash } from "bcryptjs";
+import { prismaWrapper } from "../utils/prismaWrapper";
+const loginSchema = z.object({
+    username: z.string(),
+    password: z.string(),
 });
-const registerSchema = zod_1.z.object({
-    username: zod_1.z.string().min(3, "Username must be at least 3 characters"),
-    email: zod_1.z.string().email("Invalid email address"),
-    password: zod_1.z.string().min(6, "Password must be at least 6 characters"),
-    confirmPassword: zod_1.z.string(),
+const registerSchema = z.object({
+    username: z.string().min(3, "Username must be at least 3 characters"),
+    email: z.string().email("Invalid email address"),
+    password: z.string().min(6, "Password must be at least 6 characters"),
+    confirmPassword: z.string(),
 }).refine((data) => data.password === data.confirmPassword, {
     message: "Passwords don't match",
     path: ["confirmPassword"],
 });
-exports.authRouter = (0, trpc_1.createTRPCRouter)({
-    register: trpc_1.publicProcedure
+export const authRouter = createTRPCRouter({
+    register: publicProcedure
         .input(registerSchema)
         .mutation(async ({ input }) => {
         const { username, email, password } = input;
         // Check if username already exists
-        const existingUser = await prisma_1.prisma.user.findFirst({
+        const existingUser = await prismaWrapper.findFirst(() => prisma.user.findFirst({
             where: {
                 OR: [
                     { username },
@@ -40,56 +37,58 @@ exports.authRouter = (0, trpc_1.createTRPCRouter)({
                 email: true,
                 verified: true,
             }
-        });
+        }), 'checking for existing user during registration');
         if (existingUser && existingUser.verified) {
             if (existingUser.username === username) {
-                throw new server_1.TRPCError({
+                throw new TRPCError({
                     code: "CONFLICT",
                     message: "Username already exists",
                 });
             }
             if (existingUser.email === email) {
-                throw new server_1.TRPCError({
+                throw new TRPCError({
                     code: "CONFLICT",
                     message: "Email already exists",
                 });
             }
         }
         else if (existingUser && !existingUser.verified) {
-            await prisma_1.prisma.session.deleteMany({
+            await prismaWrapper.deleteMany(() => prisma.session.deleteMany({
                 where: { userId: existingUser.id },
-            });
-            await prisma_1.prisma.user.delete({
+            }), 'deleting existing sessions for unverified user');
+            await prismaWrapper.delete(() => prisma.user.delete({
                 where: { id: existingUser.id },
-            });
+            }), 'deleting unverified user');
         }
         // Create new user
-        const user = await prisma_1.prisma.user.create({
+        const user = await prismaWrapper.create(async () => await prisma.user.create({
             data: {
                 username,
                 email,
-                password: await (0, bcryptjs_1.hash)(password, 10),
+                password: await hash(password, 10),
                 profile: {},
+                verified: true, // temporary
             },
             select: {
                 id: true,
                 username: true,
                 email: true,
             }
-        });
-        const verificationToken = await prisma_1.prisma.session.create({
+        }), 'creating new user during registration');
+        const verificationToken = await prismaWrapper.create(() => prisma.session.create({
             data: {
-                id: (0, uuid_1.v4)(),
+                id: uuidv4(),
                 userId: user.id,
                 expiresAt: new Date(Date.now() + 1000 * 60 * 60 * 24 * 30),
             },
-        });
-        await email_1.transport.sendMail({
-            from: 'noreply@studious.sh',
-            to: user.email,
-            subject: 'Verify your email',
-            text: `Click the link to verify your email: ${process.env.NEXT_PUBLIC_APP_URL}/verify/${verificationToken.id}`,
-        });
+        }), 'creating verification token');
+        // await transport.sendMail({
+        //   from: 'noreply@studious.sh',
+        //   to: user.email,
+        //   subject: 'Verify your email',
+        //   text: `Click the link to verify your email: ${process.env.NEXT_PUBLIC_APP_URL}/verify/${verificationToken.id}`,
+        // });
+        console.log(`${process.env.NEXT_PUBLIC_APP_URL}/verify/${verificationToken.id}`);
         return {
             user: {
                 id: user.id,
@@ -97,11 +96,11 @@ exports.authRouter = (0, trpc_1.createTRPCRouter)({
             },
         };
     }),
-    login: trpc_1.publicProcedure
+    login: publicProcedure
         .input(loginSchema)
         .mutation(async ({ input }) => {
         const { username, password } = input;
-        const user = await prisma_1.prisma.user.findFirst({
+        const user = await prisma.user.findFirst({
             where: { username },
             select: {
                 id: true,
@@ -112,13 +111,13 @@ exports.authRouter = (0, trpc_1.createTRPCRouter)({
             }
         });
         if (!user) {
-            throw new server_1.TRPCError({
+            throw new TRPCError({
                 code: "UNAUTHORIZED",
                 message: "Invalid username or password",
             });
         }
-        if (await (0, bcryptjs_1.compare)(password, user.password)) {
-            throw new server_1.TRPCError({
+        if (!(await compare(password, user.password))) {
+            throw new TRPCError({
                 code: "UNAUTHORIZED",
                 message: "Invalid username or password",
             });
@@ -132,9 +131,9 @@ exports.authRouter = (0, trpc_1.createTRPCRouter)({
             };
         }
         // Create a new session
-        const session = await prisma_1.prisma.session.create({
+        const session = await prisma.session.create({
             data: {
-                id: (0, uuid_1.v4)(),
+                id: uuidv4(),
                 userId: user.id,
                 expiresAt: new Date(Date.now() + 1000 * 60 * 60 * 24 * 30),
             },
@@ -147,29 +146,29 @@ exports.authRouter = (0, trpc_1.createTRPCRouter)({
             },
         };
     }),
-    logout: trpc_1.publicProcedure
+    logout: publicProcedure
         .mutation(async ({ ctx }) => {
         if (!ctx.user) {
-            throw new server_1.TRPCError({
+            throw new TRPCError({
                 code: "UNAUTHORIZED",
                 message: "Not authenticated",
             });
         }
         // Delete the current session
-        await prisma_1.prisma.session.deleteMany({
+        await prisma.session.deleteMany({
             where: { userId: ctx.user.id },
         });
         return { success: true };
     }),
-    check: trpc_1.protectedProcedure
+    check: protectedProcedure
         .query(async ({ ctx }) => {
         if (!ctx.user) {
-            throw new server_1.TRPCError({
+            throw new TRPCError({
                 code: "UNAUTHORIZED",
                 message: "Not authenticated",
             });
         }
-        const user = await prisma_1.prisma.user.findUnique({
+        const user = await prisma.user.findUnique({
             where: { id: ctx.user.id },
             select: {
                 id: true,
@@ -177,79 +176,85 @@ exports.authRouter = (0, trpc_1.createTRPCRouter)({
             }
         });
         if (!user) {
-            throw new server_1.TRPCError({
+            throw new TRPCError({
                 code: "NOT_FOUND",
                 message: "User not found",
             });
         }
         return { user };
     }),
-    resendVerificationEmail: trpc_1.publicProcedure
-        .input(zod_1.z.object({
-        email: zod_1.z.string().email(),
+    resendVerificationEmail: publicProcedure
+        .input(z.object({
+        email: z.string().email(),
     }))
         .mutation(async ({ input }) => {
         const { email } = input;
-        const user = await prisma_1.prisma.user.findFirst({
+        const user = await prisma.user.findFirst({
             where: {
                 email,
             },
             select: {
                 id: true,
                 email: true,
+                role: true,
+                schoolId: true,
             },
         });
         if (!user) {
-            throw new server_1.TRPCError({
+            throw new TRPCError({
                 code: "NOT_FOUND",
                 message: "User not found",
             });
         }
-        await prisma_1.prisma.session.deleteMany({
+        await prisma.session.deleteMany({
             where: { userId: user?.id },
         });
-        const verificationToken = await prisma_1.prisma.session.create({
+        const verificationToken = await prisma.session.create({
             data: {
-                id: (0, uuid_1.v4)(),
+                id: uuidv4(),
                 userId: user.id,
                 expiresAt: new Date(Date.now() + 1000 * 60 * 60 * 24 * 30),
             },
         });
-        await email_1.transport.sendMail({
-            from: 'noreply@studious.sh',
-            to: user.email,
-            subject: 'Verify your email',
-            text: `Click the link to verify your email: ${process.env.NEXT_PUBLIC_APP_URL}/verify/${verificationToken.id}`,
-        });
+        // await transport.sendMail({
+        //   from: 'noreply@studious.sh',
+        //   to: user.email,
+        //   subject: 'Verify your email',
+        //   text: `Click the link to verify your email: ${process.env.NEXT_PUBLIC_APP_URL}/verify/${verificationToken.id}`,
+        // });
         return { success: true };
     }),
-    verify: trpc_1.publicProcedure
-        .input(zod_1.z.object({
-        token: zod_1.z.string(),
+    verify: publicProcedure
+        .input(z.object({
+        token: z.string(),
     }))
         .mutation(async ({ input }) => {
         const { token } = input;
-        const session = await prisma_1.prisma.session.findUnique({
+        const session = await prisma.session.findUnique({
             where: { id: token },
         });
         if (!session) {
-            throw new server_1.TRPCError({
+            throw new TRPCError({
                 code: "NOT_FOUND",
                 message: "Session not found",
             });
         }
         if (session.expiresAt && session.expiresAt < new Date()) {
-            throw new server_1.TRPCError({
+            throw new TRPCError({
                 code: "UNAUTHORIZED",
                 message: "Session expired",
             });
         }
-        await prisma_1.prisma.user.update({
+        await prisma.user.update({
             where: { id: session.userId },
             data: {
                 verified: true,
             },
         });
+        // Clean up the verification token
+        await prisma.session.delete({
+            where: { id: token },
+        });
         return { success: true };
     }),
 });