@studious-lms/server 1.0.6 → 1.0.8

package/dist/routers/school.js

@@ -0,0 +1,481 @@
+import { z } from 'zod';
+import { createTRPCRouter, protectedProcedure } from '../trpc';
+import { prisma } from '../lib/prisma';
+import { TRPCError } from '@trpc/server';
+import { UserRole } from '@prisma/client';
+import { transport } from '../utils/email';
+import { generateInviteCode } from '../utils/generateInviteCode';
+import { hash } from 'bcryptjs';
+export const schoolRouter = createTRPCRouter({
+    // Create a new school
+    createSchool: protectedProcedure
+        .input(z.object({
+        name: z.string().min(1),
+        subdomain: z.string().regex(/^[a-z0-9-]+$/, 'Subdomain can only contain lowercase letters, numbers, and hyphens')
+    }))
+        .mutation(async ({ input, ctx }) => {
+        if (!ctx.user) {
+            throw new TRPCError({
+                code: 'UNAUTHORIZED',
+                message: 'User must be authenticated'
+            });
+        }
+        // Check if subdomain is already taken
+        const existingSchool = await prisma.school.findUnique({
+            where: { subdomain: input.subdomain }
+        });
+        if (existingSchool) {
+            throw new TRPCError({
+                code: 'CONFLICT',
+                message: 'This subdomain is already taken'
+            });
+        }
+        // Create a placeholder file for the logo
+        const placeholderLogo = await prisma.file.create({
+            data: {
+                name: 'placeholder-logo',
+                path: '/placeholder-logo.png',
+                type: 'image/png',
+                userId: ctx.user.id
+            }
+        });
+        // Create the school
+        const school = await prisma.school.create({
+            data: {
+                name: input.name,
+                subdomain: input.subdomain,
+                logoId: placeholderLogo.id,
+                users: {
+                    connect: { id: ctx.user.id }
+                }
+            }
+        });
+        // Update the user to be an admin of this school
+        await prisma.user.update({
+            where: { id: ctx.user.id },
+            data: {
+                role: UserRole.ADMIN,
+                schoolId: school.id
+            }
+        });
+        return school;
+    }),
+    // Check if user is admin of the school
+    checkAdmin: protectedProcedure
+        .input(z.object({ schoolId: z.string() }))
+        .query(async ({ input, ctx }) => {
+        if (!ctx.user) {
+            throw new TRPCError({
+                code: 'UNAUTHORIZED',
+                message: 'User must be authenticated'
+            });
+        }
+        const user = await prisma.user.findFirst({
+            where: {
+                id: ctx.user.id,
+                schoolId: input.schoolId,
+                role: UserRole.ADMIN
+            }
+        });
+        if (!user) {
+            throw new TRPCError({
+                code: 'FORBIDDEN',
+                message: 'You must be a school admin to access this'
+            });
+        }
+        return true;
+    }),
+    // Get all users in a school
+    getUsers: protectedProcedure
+        .input(z.object({
+        schoolId: z.string(),
+        role: z.enum(['STUDENT', 'TEACHER', 'ADMIN', 'NONE']).optional()
+    }))
+        .query(async ({ input, ctx }) => {
+        if (!ctx.user) {
+            throw new TRPCError({
+                code: 'UNAUTHORIZED',
+                message: 'User must be authenticated'
+            });
+        }
+        // Check admin permission
+        const isAdmin = await prisma.user.findFirst({
+            where: {
+                id: ctx.user.id,
+                schoolId: input.schoolId,
+                role: UserRole.ADMIN
+            }
+        });
+        if (!isAdmin) {
+            throw new TRPCError({ code: 'FORBIDDEN' });
+        }
+        return prisma.user.findMany({
+            where: {
+                schoolId: input.schoolId,
+                ...(input.role && { role: input.role })
+            },
+            select: {
+                id: true,
+                username: true,
+                email: true,
+                role: true,
+                verified: true,
+                profile: true
+            },
+            orderBy: [
+                { role: 'asc' },
+                { username: 'asc' }
+            ]
+        });
+    }),
+    // Create a new user
+    createUser: protectedProcedure
+        .input(z.object({
+        schoolId: z.string(),
+        email: z.string().email(),
+        username: z.string().min(3),
+        role: z.enum(['STUDENT', 'TEACHER', 'ADMIN', 'NONE']),
+        sendInvite: z.boolean().default(true)
+    }))
+        .mutation(async ({ input, ctx }) => {
+        // Check admin permission
+        const isAdmin = await prisma.user.findFirst({
+            where: {
+                id: ctx.user.id,
+                schoolId: input.schoolId,
+                role: UserRole.ADMIN
+            }
+        });
+        if (!isAdmin) {
+            throw new TRPCError({ code: 'FORBIDDEN' });
+        }
+        // Check if user already exists
+        const existingUser = await prisma.user.findFirst({
+            where: {
+                OR: [
+                    { email: input.email },
+                    { username: input.username }
+                ]
+            }
+        });
+        if (existingUser) {
+            throw new TRPCError({
+                code: 'CONFLICT',
+                message: 'User with this email or username already exists'
+            });
+        }
+        // Generate temporary password
+        const tempPassword = generateInviteCode();
+        const hashedPassword = await hash(tempPassword, 10);
+        const user = await prisma.user.create({
+            data: {
+                email: input.email,
+                username: input.username,
+                password: hashedPassword,
+                role: input.role,
+                schoolId: input.schoolId,
+                verified: false
+            }
+        });
+        // Send invite email
+        if (input.sendInvite) {
+            await transport.sendMail({
+                from: process.env.EMAIL_FROM || 'noreply@studious.app',
+                to: input.email,
+                subject: 'Welcome to Studious',
+                text: `You have been invited to join Studious. Your temporary password is: ${tempPassword}\n\nPlease change your password after logging in.`
+            });
+        }
+        return user;
+    }),
+    // Bulk create users from JSON
+    bulkCreateUsers: protectedProcedure
+        .input(z.object({
+        schoolId: z.string(),
+        users: z.array(z.object({
+            email: z.string().email(),
+            username: z.string().min(3),
+            role: z.enum(['STUDENT', 'TEACHER', 'ADMIN', 'NONE'])
+        }))
+    }))
+        .mutation(async ({ input, ctx }) => {
+        if (!ctx.user) {
+            throw new TRPCError({
+                code: 'UNAUTHORIZED',
+                message: 'User must be authenticated'
+            });
+        }
+        // Check admin permission
+        const isAdmin = await prisma.user.findFirst({
+            where: {
+                id: ctx.user.id,
+                schoolId: input.schoolId,
+                role: UserRole.ADMIN
+            }
+        });
+        if (!isAdmin) {
+            throw new TRPCError({ code: 'FORBIDDEN' });
+        }
+        const results = [];
+        const errors = [];
+        for (const userData of input.users) {
+            try {
+                const tempPassword = generateInviteCode();
+                const hashedPassword = await hash(tempPassword, 10);
+                const user = await prisma.user.create({
+                    data: {
+                        email: userData.email,
+                        username: userData.username,
+                        password: hashedPassword,
+                        role: userData.role,
+                        schoolId: input.schoolId,
+                        verified: false
+                    }
+                });
+                // Send invite email
+                await transport.sendMail({
+                    from: process.env.EMAIL_FROM || 'noreply@studious.app',
+                    to: userData.email,
+                    subject: 'Welcome to Studious',
+                    text: `You have been invited to join Studious. Your temporary password is: ${tempPassword}\n\nPlease change your password after logging in.`
+                });
+                results.push({ success: true, user });
+            }
+            catch (error) {
+                errors.push({
+                    email: userData.email,
+                    error: error instanceof Error ? error.message : 'Unknown error'
+                });
+            }
+        }
+        return { results, errors };
+    }),
+    // Update user
+    updateUser: protectedProcedure
+        .input(z.object({
+        userId: z.string(),
+        schoolId: z.string(),
+        role: z.enum(['STUDENT', 'TEACHER', 'ADMIN', 'NONE']).optional(),
+        verified: z.boolean().optional()
+    }))
+        .mutation(async ({ input, ctx }) => {
+        if (!ctx.user) {
+            throw new TRPCError({
+                code: 'UNAUTHORIZED',
+                message: 'User must be authenticated'
+            });
+        }
+        // Check admin permission
+        const isAdmin = await prisma.user.findFirst({
+            where: {
+                id: ctx.user.id,
+                schoolId: input.schoolId,
+                role: UserRole.ADMIN
+            }
+        });
+        if (!isAdmin) {
+            throw new TRPCError({ code: 'FORBIDDEN' });
+        }
+        return prisma.user.update({
+            where: { id: input.userId },
+            data: {
+                ...(input.role && { role: input.role }),
+                ...(input.verified !== undefined && { verified: input.verified })
+            }
+        });
+    }),
+    // Delete user
+    deleteUser: protectedProcedure
+        .input(z.object({
+        userId: z.string(),
+        schoolId: z.string()
+    }))
+        .mutation(async ({ input, ctx }) => {
+        if (!ctx.user) {
+            throw new TRPCError({
+                code: 'UNAUTHORIZED',
+                message: 'User must be authenticated'
+            });
+        }
+        // Check admin permission
+        const isAdmin = await prisma.user.findFirst({
+            where: {
+                id: ctx.user.id,
+                schoolId: input.schoolId,
+                role: UserRole.ADMIN
+            }
+        });
+        if (!isAdmin) {
+            throw new TRPCError({ code: 'FORBIDDEN' });
+        }
+        // Don't allow deleting yourself
+        if (input.userId === ctx.user.id) {
+            throw new TRPCError({
+                code: 'BAD_REQUEST',
+                message: 'You cannot delete yourself'
+            });
+        }
+        return prisma.user.delete({
+            where: { id: input.userId }
+        });
+    }),
+    // Get school info
+    getSchool: protectedProcedure
+        .input(z.object({ schoolId: z.string() }))
+        .query(async ({ input }) => {
+        return prisma.school.findUnique({
+            where: { id: input.schoolId },
+            include: {
+                logo: true,
+                _count: {
+                    select: {
+                        users: true,
+                        classes: true
+                    }
+                }
+            }
+        });
+    }),
+    // Update school settings
+    updateSchool: protectedProcedure
+        .input(z.object({
+        schoolId: z.string(),
+        name: z.string().optional(),
+        subdomain: z.string().optional(),
+        logoId: z.string().optional()
+    }))
+        .mutation(async ({ input, ctx }) => {
+        if (!ctx.user) {
+            throw new TRPCError({
+                code: 'UNAUTHORIZED',
+                message: 'User must be authenticated'
+            });
+        }
+        // Check admin permission
+        const isAdmin = await prisma.user.findFirst({
+            where: {
+                id: ctx.user.id,
+                schoolId: input.schoolId,
+                role: UserRole.ADMIN
+            }
+        });
+        if (!isAdmin) {
+            throw new TRPCError({ code: 'FORBIDDEN' });
+        }
+        const updateData = {};
+        if (input.name)
+            updateData.name = input.name;
+        if (input.subdomain)
+            updateData.subdomain = input.subdomain;
+        if (input.logoId)
+            updateData.logoId = input.logoId;
+        return prisma.school.update({
+            where: { id: input.schoolId },
+            data: updateData
+        });
+    }),
+    // Get all classes in school
+    getClasses: protectedProcedure
+        .input(z.object({ schoolId: z.string() }))
+        .query(async ({ input, ctx }) => {
+        if (!ctx.user) {
+            throw new TRPCError({
+                code: 'UNAUTHORIZED',
+                message: 'User must be authenticated'
+            });
+        }
+        // Check if user belongs to school
+        const user = await prisma.user.findFirst({
+            where: {
+                id: ctx.user.id,
+                schoolId: input.schoolId
+            }
+        });
+        if (!user) {
+            throw new TRPCError({ code: 'FORBIDDEN' });
+        }
+        return prisma.class.findMany({
+            where: { schoolId: input.schoolId },
+            include: {
+                _count: {
+                    select: {
+                        students: true,
+                        teachers: true,
+                        assignments: true
+                    }
+                }
+            },
+            orderBy: { name: 'asc' }
+        });
+    }),
+    // Send bulk email
+    sendBulkEmail: protectedProcedure
+        .input(z.object({
+        schoolId: z.string(),
+        subject: z.string(),
+        content: z.string(),
+        recipientRole: z.enum(['ALL', 'STUDENT', 'TEACHER', 'ADMIN']).optional(),
+        recipientIds: z.array(z.string()).optional()
+    }))
+        .mutation(async ({ input, ctx }) => {
+        if (!ctx.user) {
+            throw new TRPCError({
+                code: 'UNAUTHORIZED',
+                message: 'User must be authenticated'
+            });
+        }
+        // Check admin permission
+        const isAdmin = await prisma.user.findFirst({
+            where: {
+                id: ctx.user.id,
+                schoolId: input.schoolId,
+                role: UserRole.ADMIN
+            }
+        });
+        if (!isAdmin) {
+            throw new TRPCError({ code: 'FORBIDDEN' });
+        }
+        // Get recipients
+        let recipients = [];
+        if (input.recipientIds && input.recipientIds.length > 0) {
+            recipients = await prisma.user.findMany({
+                where: {
+                    id: { in: input.recipientIds },
+                    schoolId: input.schoolId
+                },
+                select: { email: true }
+            });
+        }
+        else {
+            const whereClause = { schoolId: input.schoolId };
+            if (input.recipientRole && input.recipientRole !== 'ALL') {
+                whereClause.role = input.recipientRole;
+            }
+            recipients = await prisma.user.findMany({
+                where: whereClause,
+                select: { email: true }
+            });
+        }
+        // Send emails
+        const results = [];
+        for (const recipient of recipients) {
+            try {
+                await transport.sendMail({
+                    from: process.env.EMAIL_FROM || 'noreply@studious.app',
+                    to: recipient.email,
+                    subject: input.subject,
+                    text: input.content
+                });
+                results.push({ email: recipient.email, success: true });
+            }
+            catch (error) {
+                results.push({
+                    email: recipient.email,
+                    success: false,
+                    error: error instanceof Error ? error.message : 'Unknown error'
+                });
+            }
+        }
+        return results;
+    })
+});

package/dist/routers/section.d.ts

@@ -1,10 +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.js").PrismaErrorInfo | null;
             code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
             httpStatus: number;
             path?: string;

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

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

package/dist/routers/section.js

@@ -1,35 +1,32 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sectionRouter = 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 createSectionSchema = zod_1.z.object({
-    classId: zod_1.z.string(),
-    name: zod_1.z.string(),
+import { z } from "zod";
+import { createTRPCRouter, protectedProcedure } from "../trpc.js";
+import { TRPCError } from "@trpc/server";
+import { prisma } from "../lib/prisma.js";
+const createSectionSchema = z.object({
+    classId: z.string(),
+    name: z.string(),
 });
-const updateSectionSchema = zod_1.z.object({
-    id: zod_1.z.string(),
-    classId: zod_1.z.string(),
-    name: zod_1.z.string(),
+const updateSectionSchema = z.object({
+    id: z.string(),
+    classId: z.string(),
+    name: z.string(),
 });
-const deleteSectionSchema = zod_1.z.object({
-    id: zod_1.z.string(),
-    classId: zod_1.z.string(),
+const deleteSectionSchema = z.object({
+    id: z.string(),
+    classId: z.string(),
 });
-exports.sectionRouter = (0, trpc_1.createTRPCRouter)({
-    create: trpc_1.protectedProcedure
+export const sectionRouter = createTRPCRouter({
+    create: protectedProcedure
         .input(createSectionSchema)
         .mutation(async ({ ctx, input }) => {
         if (!ctx.user) {
-            throw new server_1.TRPCError({
+            throw new TRPCError({
                 code: "UNAUTHORIZED",
                 message: "User must be authenticated",
             });
         }
         // Verify user is a teacher of the class
-        const classData = await prisma_1.prisma.class.findFirst({
+        const classData = await prisma.class.findFirst({
             where: {
                 id: input.classId,
                 teachers: {
@@ -40,12 +37,12 @@ exports.sectionRouter = (0, trpc_1.createTRPCRouter)({
             },
         });
         if (!classData) {
-            throw new server_1.TRPCError({
+            throw new TRPCError({
                 code: "NOT_FOUND",
                 message: "Class not found or you are not a teacher",
             });
         }
-        const section = await prisma_1.prisma.section.create({
+        const section = await prisma.section.create({
             data: {
                 name: input.name,
                 class: {
@@ -55,17 +52,17 @@ exports.sectionRouter = (0, trpc_1.createTRPCRouter)({
         });
         return section;
     }),
-    update: trpc_1.protectedProcedure
+    update: protectedProcedure
         .input(updateSectionSchema)
         .mutation(async ({ ctx, input }) => {
         if (!ctx.user) {
-            throw new server_1.TRPCError({
+            throw new TRPCError({
                 code: "UNAUTHORIZED",
                 message: "User must be authenticated",
             });
         }
         // Verify user is a teacher of the class
-        const classData = await prisma_1.prisma.class.findFirst({
+        const classData = await prisma.class.findFirst({
             where: {
                 id: input.classId,
                 teachers: {
@@ -76,12 +73,12 @@ exports.sectionRouter = (0, trpc_1.createTRPCRouter)({
             },
         });
         if (!classData) {
-            throw new server_1.TRPCError({
+            throw new TRPCError({
                 code: "NOT_FOUND",
                 message: "Class not found or you are not a teacher",
             });
         }
-        const section = await prisma_1.prisma.section.update({
+        const section = await prisma.section.update({
             where: { id: input.id },
             data: {
                 name: input.name,
@@ -89,17 +86,17 @@ exports.sectionRouter = (0, trpc_1.createTRPCRouter)({
         });
         return section;
     }),
-    delete: trpc_1.protectedProcedure
+    delete: protectedProcedure
         .input(deleteSectionSchema)
         .mutation(async ({ ctx, input }) => {
         if (!ctx.user) {
-            throw new server_1.TRPCError({
+            throw new TRPCError({
                 code: "UNAUTHORIZED",
                 message: "User must be authenticated",
             });
         }
         // Verify user is a teacher of the class
-        const classData = await prisma_1.prisma.class.findFirst({
+        const classData = await prisma.class.findFirst({
             where: {
                 id: input.classId,
                 teachers: {
@@ -110,12 +107,12 @@ exports.sectionRouter = (0, trpc_1.createTRPCRouter)({
             },
         });
         if (!classData) {
-            throw new server_1.TRPCError({
+            throw new TRPCError({
                 code: "NOT_FOUND",
                 message: "Class not found or you are not a teacher",
             });
         }
-        await prisma_1.prisma.section.delete({
+        await prisma.section.delete({
             where: { id: input.id },
         });
         return { id: input.id };

package/dist/routers/user.d.ts

@@ -1,10 +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.js").PrismaErrorInfo | null;
             code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
             httpStatus: number;
             path?: string;
@@ -33,8 +34,8 @@ export declare const userRouter: import("@trpc/server").TRPCBuiltRouter<{
             profilePicture?: {
                 type: string;
                 name: string;
-                data: string;
                 size: number;
+                data: string;
             } | undefined;
         };
         output: {

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

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