@studious-lms/server 1.1.26 → 1.2.6

package/dist/routers/school.js

@@ -1,481 +0,0 @@
-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/src/lib/notificationHandler.ts

@@ -1,36 +0,0 @@
-import { prisma } from "./prisma.js";
-
-interface notificationData {
-    title: string,
-    content: string
-}
-
-export async function sendNotification(receiver: string, data: notificationData) {
-    const notification = await prisma.notification.create({
-        data: {
-            receiverId: receiver,
-            title: data.title,
-            content: data.content,
-        },
-    });
-    return notification;
-}
-
-export async function sendNotifications(receiverIds: Array<string>, data: notificationData) {
-    const notifications = await prisma.notification.createMany({
-        data: receiverIds.map(receiverId => ({
-            receiverId: receiverId,
-            title: data.title,
-            content: data.content,
-        })),
-    });
-    return notifications;
-}
-
-export async function markRead(id: string, read: boolean = true) {
-    const notification = await prisma.notification.update({
-        where: {id},
-        data: {read: read},
-    });
-    return notification;
-}

package/tests/auth.test.ts

@@ -1,25 +0,0 @@
-import { test, expect } from 'vitest';
-import { appRouter } from '../src/routers/_app';
-import { createTRPCContext } from '../src/trpc';
-import { prisma } from '../src/lib/prisma';
-import { caller, login1, login2, session1, session2, user1Caller, verification1, verification2 } from './setup';
-
-test('registration', async () => {
-    expect(session1).toBeDefined();
-    expect(session2).toBeDefined();
-});
-
-test('email verification', async () => {
-    expect(verification1).toBeDefined();
-    expect(verification2).toBeDefined();
-});
-
-test('login', async () => {
-    expect(login1).toBeDefined();
-    expect(login2).toBeDefined();
-});
-
-test('logout', async () => {
-    const logout = await user1Caller.auth.logout();
-    expect(logout).toBeDefined();
-});