@studious-lms/server 1.0.0

package/dist/routers/auth.js

@@ -0,0 +1,255 @@
+"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(),
+});
+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(),
+}).refine((data) => data.password === data.confirmPassword, {
+    message: "Passwords don't match",
+    path: ["confirmPassword"],
+});
+exports.authRouter = (0, trpc_1.createTRPCRouter)({
+    register: trpc_1.publicProcedure
+        .input(registerSchema)
+        .mutation(async ({ input }) => {
+        const { username, email, password } = input;
+        // Check if username already exists
+        const existingUser = await prisma_1.prisma.user.findFirst({
+            where: {
+                OR: [
+                    { username },
+                    { email }
+                ]
+            },
+            select: {
+                id: true,
+                username: true,
+                email: true,
+                verified: true,
+            }
+        });
+        if (existingUser && existingUser.verified) {
+            if (existingUser.username === username) {
+                throw new server_1.TRPCError({
+                    code: "CONFLICT",
+                    message: "Username already exists",
+                });
+            }
+            if (existingUser.email === email) {
+                throw new server_1.TRPCError({
+                    code: "CONFLICT",
+                    message: "Email already exists",
+                });
+            }
+        }
+        else if (existingUser && !existingUser.verified) {
+            await prisma_1.prisma.session.deleteMany({
+                where: { userId: existingUser.id },
+            });
+            await prisma_1.prisma.user.delete({
+                where: { id: existingUser.id },
+            });
+        }
+        // Create new user
+        const user = await prisma_1.prisma.user.create({
+            data: {
+                username,
+                email,
+                password: await (0, bcryptjs_1.hash)(password, 10),
+                profile: {},
+            },
+            select: {
+                id: true,
+                username: true,
+                email: true,
+            }
+        });
+        const verificationToken = await prisma_1.prisma.session.create({
+            data: {
+                id: (0, uuid_1.v4)(),
+                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}`,
+        });
+        return {
+            user: {
+                id: user.id,
+                username: user.username,
+            },
+        };
+    }),
+    login: trpc_1.publicProcedure
+        .input(loginSchema)
+        .mutation(async ({ input }) => {
+        const { username, password } = input;
+        const user = await prisma_1.prisma.user.findFirst({
+            where: { username },
+            select: {
+                id: true,
+                username: true,
+                password: true,
+                email: true,
+                verified: true,
+            }
+        });
+        if (!user) {
+            throw new server_1.TRPCError({
+                code: "UNAUTHORIZED",
+                message: "Invalid username or password",
+            });
+        }
+        if (await (0, bcryptjs_1.compare)(password, user.password)) {
+            throw new server_1.TRPCError({
+                code: "UNAUTHORIZED",
+                message: "Invalid username or password",
+            });
+        }
+        if (!user.verified) {
+            return {
+                verified: false,
+                user: {
+                    email: user.email,
+                },
+            };
+        }
+        // Create a new session
+        const session = await prisma_1.prisma.session.create({
+            data: {
+                id: (0, uuid_1.v4)(),
+                userId: user.id,
+                expiresAt: new Date(Date.now() + 1000 * 60 * 60 * 24 * 30),
+            },
+        });
+        return {
+            token: session.id,
+            user: {
+                id: user.id,
+                username: user.username,
+            },
+        };
+    }),
+    logout: trpc_1.publicProcedure
+        .mutation(async ({ ctx }) => {
+        if (!ctx.user) {
+            throw new server_1.TRPCError({
+                code: "UNAUTHORIZED",
+                message: "Not authenticated",
+            });
+        }
+        // Delete the current session
+        await prisma_1.prisma.session.deleteMany({
+            where: { userId: ctx.user.id },
+        });
+        return { success: true };
+    }),
+    check: trpc_1.protectedProcedure
+        .query(async ({ ctx }) => {
+        if (!ctx.user) {
+            throw new server_1.TRPCError({
+                code: "UNAUTHORIZED",
+                message: "Not authenticated",
+            });
+        }
+        const user = await prisma_1.prisma.user.findUnique({
+            where: { id: ctx.user.id },
+            select: {
+                id: true,
+                username: true,
+            }
+        });
+        if (!user) {
+            throw new server_1.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(),
+    }))
+        .mutation(async ({ input }) => {
+        const { email } = input;
+        const user = await prisma_1.prisma.user.findFirst({
+            where: {
+                email,
+            },
+            select: {
+                id: true,
+                email: true,
+            },
+        });
+        if (!user) {
+            throw new server_1.TRPCError({
+                code: "NOT_FOUND",
+                message: "User not found",
+            });
+        }
+        await prisma_1.prisma.session.deleteMany({
+            where: { userId: user?.id },
+        });
+        const verificationToken = await prisma_1.prisma.session.create({
+            data: {
+                id: (0, uuid_1.v4)(),
+                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}`,
+        });
+        return { success: true };
+    }),
+    verify: trpc_1.publicProcedure
+        .input(zod_1.z.object({
+        token: zod_1.z.string(),
+    }))
+        .mutation(async ({ input }) => {
+        const { token } = input;
+        const session = await prisma_1.prisma.session.findUnique({
+            where: { id: token },
+        });
+        if (!session) {
+            throw new server_1.TRPCError({
+                code: "NOT_FOUND",
+                message: "Session not found",
+            });
+        }
+        if (session.expiresAt && session.expiresAt < new Date()) {
+            throw new server_1.TRPCError({
+                code: "UNAUTHORIZED",
+                message: "Session expired",
+            });
+        }
+        await prisma_1.prisma.user.update({
+            where: { id: session.userId },
+            data: {
+                verified: true,
+            },
+        });
+        return { success: true };
+    }),
+});

package/dist/routers/class.d.ts

@@ -0,0 +1,427 @@
+import { z } from "zod";
+export declare const classRouter: 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<{
+    getAll: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            teacherInClass: {
+                id: string;
+                name: string;
+                section: string;
+                subject: string;
+                dueToday: {
+                    id: string;
+                    title: string;
+                }[];
+                color: string | null;
+            }[];
+            studentInClass: {
+                id: string;
+                name: string;
+                section: string;
+                subject: string;
+                dueToday: {
+                    id: string;
+                    title: string;
+                }[];
+                color: string | null;
+            }[];
+            adminInClass: {
+                id: string;
+                name: string;
+                section: string;
+                subject: string;
+                dueToday: {
+                    id: string;
+                    title: string;
+                }[];
+                color: string | null;
+            }[];
+        };
+    }>;
+    get: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            classId: string;
+        };
+        output: {
+            class: {
+                assignments: {
+                    late: boolean;
+                    submitted: boolean;
+                    returned: boolean;
+                    type: import(".prisma/client").$Enums.AssignmentType;
+                    id: string;
+                    submissions: {
+                        id: string;
+                        studentId: string;
+                        submittedAt: Date | null;
+                        submitted: boolean | null;
+                        returned: boolean | null;
+                    }[];
+                    section: {
+                        id: string;
+                        name: string;
+                    } | null;
+                    title: string;
+                    instructions: string;
+                    dueDate: Date;
+                    createdAt: Date | null;
+                    graded: boolean;
+                    maxGrade: number | null;
+                    weight: number;
+                    markScheme: {
+                        id: string;
+                        structured: string;
+                    } | null;
+                    gradingBoundary: {
+                        id: string;
+                        structured: string;
+                    } | null;
+                }[];
+                sections: {
+                    id: string;
+                    name: string;
+                    classId: string;
+                }[];
+                announcements: {
+                    id: string;
+                    teacher: {
+                        id: string;
+                        username: string;
+                    };
+                    createdAt: Date;
+                    remarks: string;
+                }[];
+                students: {
+                    id: string;
+                    username: string;
+                }[];
+                teachers: {
+                    id: string;
+                    username: string;
+                }[];
+                id: string;
+                name: string;
+                subject: string;
+                color: string | null;
+                section: string;
+            };
+        };
+    }>;
+    update: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            [x: string]: unknown;
+            classId: string;
+            name?: string | undefined;
+            subject?: string | undefined;
+            section?: string | undefined;
+        };
+        output: {
+            updatedClass: {
+                id: string;
+                name: string;
+                subject: string;
+                section: string;
+            };
+        };
+    }>;
+    create: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            name: string;
+            subject: string;
+            section: string;
+            students?: string[] | undefined;
+            teachers?: string[] | undefined;
+        };
+        output: {
+            id: string;
+            name: string;
+            subject: string;
+            color: string | null;
+            section: string;
+        };
+    }>;
+    delete: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            [x: string]: unknown;
+            classId: string;
+            id: string;
+        };
+        output: {
+            deletedClass: {
+                id: string;
+            };
+        };
+    }>;
+    addStudent: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            [x: string]: unknown;
+            classId: string;
+            studentId: string;
+        };
+        output: {
+            updatedClass: {
+                id: string;
+                name: string;
+                subject: string;
+                section: string;
+            };
+            newStudent: {
+                id: string;
+                username: string;
+                email: string;
+                password: string;
+                verified: boolean;
+                profileId: string | null;
+            };
+        };
+    }>;
+    changeRole: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            [x: string]: unknown;
+            classId: string;
+            type: "teacher" | "student";
+            userId: string;
+        };
+        output: {
+            updatedClass: {
+                id: string;
+                name: string;
+                subject: string;
+                color: string | null;
+                section: string;
+            };
+            user: {
+                type: "teacher" | "student";
+                id: string;
+                username: string;
+            };
+        };
+    }>;
+    removeMember: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            [x: string]: unknown;
+            classId: string;
+            userId: string;
+        };
+        output: {
+            updatedClass: {
+                id: string;
+                name: string;
+                subject: string;
+                color: string | null;
+                section: string;
+            };
+            removedUserId: string;
+        };
+    }>;
+    join: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            classCode: string;
+        };
+        output: {
+            joinedClass: {
+                id: string;
+                name: string;
+                subject: string;
+                section: string;
+            };
+        };
+    }>;
+    getInviteCode: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            [x: string]: unknown;
+            classId: string;
+        };
+        output: {
+            code: string;
+        };
+    }>;
+    createInviteCode: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            [x: string]: unknown;
+            classId: string;
+        };
+        output: {
+            code: string;
+        };
+    }>;
+    getGrades: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            [x: string]: unknown;
+            classId: string;
+            userId: string;
+        };
+        output: {
+            grades: ({
+                assignment: {
+                    id: string;
+                    title: string;
+                    maxGrade: number | null;
+                    weight: number;
+                };
+            } & {
+                id: string;
+                studentId: string;
+                assignmentId: string;
+                gradeReceived: number | null;
+                createdAt: Date;
+                modifiedAt: Date;
+                rubricState: string | null;
+                submittedAt: Date | null;
+                submitted: boolean | null;
+                returned: boolean | null;
+            })[];
+        };
+    }>;
+    updateGrade: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            [x: string]: unknown;
+            classId: string;
+            assignmentId: string;
+            submissionId: string;
+            gradeReceived: number | null;
+        };
+        output: {
+            assignment: {
+                id: string;
+                title: string;
+                maxGrade: number | null;
+                weight: number;
+            };
+        } & {
+            id: string;
+            studentId: string;
+            assignmentId: string;
+            gradeReceived: number | null;
+            createdAt: Date;
+            modifiedAt: Date;
+            rubricState: string | null;
+            submittedAt: Date | null;
+            submitted: boolean | null;
+            returned: boolean | null;
+        };
+    }>;
+    getEvents: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            [x: string]: unknown;
+            classId: string;
+        };
+        output: {
+            name: string | null;
+            startTime: Date;
+            endTime: Date;
+        }[];
+    }>;
+    listMarkSchemes: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            [x: string]: unknown;
+            classId: string;
+        };
+        output: {
+            id: string;
+            classId: string;
+            structured: string;
+        }[];
+    }>;
+    createMarkScheme: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            [x: string]: unknown;
+            classId: string;
+            structure: string;
+        };
+        output: {
+            id: string;
+            classId: string;
+            structured: string;
+        };
+    }>;
+    updateMarkScheme: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            [x: string]: unknown;
+            classId: string;
+            structure: string;
+            markSchemeId: string;
+        };
+        output: {
+            id: string;
+            classId: string;
+            structured: string;
+        };
+    }>;
+    deleteMarkScheme: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            [x: string]: unknown;
+            classId: string;
+            markSchemeId: string;
+        };
+        output: {
+            id: string;
+            classId: string;
+            structured: string;
+        };
+    }>;
+    listGradingBoundaries: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            [x: string]: unknown;
+            classId: string;
+        };
+        output: {
+            id: string;
+            classId: string;
+            structured: string;
+        }[];
+    }>;
+    createGradingBoundary: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            [x: string]: unknown;
+            classId: string;
+            structure: string;
+        };
+        output: {
+            id: string;
+            classId: string;
+            structured: string;
+        };
+    }>;
+    updateGradingBoundary: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            [x: string]: unknown;
+            classId: string;
+            structure: string;
+            gradingBoundaryId: string;
+        };
+        output: {
+            id: string;
+            classId: string;
+            structured: string;
+        };
+    }>;
+    deleteGradingBoundary: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            [x: string]: unknown;
+            classId: string;
+            gradingBoundaryId: string;
+        };
+        output: {
+            id: string;
+            classId: string;
+            structured: string;
+        };
+    }>;
+}>>;
+//# sourceMappingURL=class.d.ts.map

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

@@ -0,0 +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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0uBtB,CAAC"}