@studious-lms/server 1.1.23 → 1.1.26

package/src/routers/section.ts

@@ -64,43 +64,137 @@ export const sectionRouter = createTRPCRouter({
         },
       });
 
-      // find all root items in the class and reorder them
-      const sections = await prisma.section.findMany({
-        where: {
-          classId: input.classId,
-        },
-      });
+      // Insert new section at top of unified list (sections + assignments) and normalize
+      const [sections, assignments] = await Promise.all([
+        prisma.section.findMany({
+          where: { classId: input.classId },
+          select: { id: true, order: true },
+        }),
+        prisma.assignment.findMany({
+          where: { classId: input.classId },
+          select: { id: true, order: true },
+        }),
+      ]);
 
-      const assignments = await prisma.assignment.findMany({
-        where: {
-          classId: input.classId,
-          sectionId: null,
-        },
-      });
+      const unified = [
+        ...sections.map(s => ({ id: s.id, order: s.order, type: 'section' as const })),
+        ...assignments.map(a => ({ id: a.id, order: a.order, type: 'assignment' as const })),
+      ].sort((a, b) => (a.order ?? Number.MAX_SAFE_INTEGER) - (b.order ?? Number.MAX_SAFE_INTEGER));
 
-      const stack = [...sections, ...assignments].sort((a, b) => (a.order || 0) - (b.order || 0)).map((item, index) => ({
-        id: item.id,
-        order: index + 1,
-      })).map((item) => ({
-        where: { id: item.id },
-        data: { order: item.order },
-      }));
-
-      // Update sections and assignments with their new order
-      await Promise.all([
-        ...stack.filter(item => sections.some(s => s.id === item.where.id))
-          .map(({ where, data }) => 
-            prisma.section.update({ where, data })
-          ),
-        ...stack.filter(item => assignments.some(a => a.id === item.where.id))
-          .map(({ where, data }) => 
-            prisma.assignment.update({ where, data })
-          )
-      ]);
+      const withoutNew = unified.filter(item => !(item.id === section.id && item.type === 'section'));
+      const reindexed = [{ id: section.id, type: 'section' as const }, ...withoutNew.map(item => ({ id: item.id, type: item.type }))];
+
+      await Promise.all(
+        reindexed.map((item, index) => {
+          if (item.type === 'section') {
+            return prisma.section.update({ where: { id: item.id }, data: { order: index + 1 } });
+          } else {
+            return prisma.assignment.update({ where: { id: item.id }, data: { order: index + 1 } });
+          }
+        })
+      );
 
       return section;
     }),
 
+  reorder: protectedProcedure
+    .input(z.object({
+      classId: z.string(),
+      movedId: z.string(), // Section ID
+      // One of: place at start/end of unified list, or relative to targetId (can be section or assignment)
+      position: z.enum(['start', 'end', 'before', 'after']),
+      targetId: z.string().optional(), // Can be a section ID or assignment ID
+    }))
+    .mutation(async ({ ctx, input }) => {
+      if (!ctx.user) {
+        throw new TRPCError({
+          code: "UNAUTHORIZED",
+          message: "User must be authenticated",
+        });
+      }
+
+      const { classId, movedId, position, targetId } = input;
+
+      const moved = await prisma.section.findFirst({
+        where: { id: movedId, classId },
+        select: { id: true, classId: true },
+      });
+
+      if (!moved) {
+        throw new TRPCError({ code: 'NOT_FOUND', message: 'Section not found' });
+      }
+
+      if ((position === 'before' || position === 'after') && !targetId) {
+        throw new TRPCError({ code: 'BAD_REQUEST', message: 'targetId required for before/after' });
+      }
+
+      const result = await prisma.$transaction(async (tx) => {
+        const [sections, assignments] = await Promise.all([
+          tx.section.findMany({
+            where: { classId },
+            select: { id: true, order: true },
+          }),
+          tx.assignment.findMany({
+            where: { classId },
+            select: { id: true, order: true },
+          }),
+        ]);
+
+        const unified = [
+          ...sections.map(s => ({ id: s.id, order: s.order, type: 'section' as const })),
+          ...assignments.map(a => ({ id: a.id, order: a.order, type: 'assignment' as const })),
+        ].sort((a, b) => (a.order ?? Number.MAX_SAFE_INTEGER) - (b.order ?? Number.MAX_SAFE_INTEGER));
+
+        const movedIdx = unified.findIndex(item => item.id === movedId && item.type === 'section');
+        if (movedIdx === -1) {
+          throw new TRPCError({ code: 'NOT_FOUND', message: 'Section not found in unified list' });
+        }
+
+        const withoutMoved = unified.filter(item => !(item.id === movedId && item.type === 'section'));
+
+        let next: Array<{ id: string; type: 'section' | 'assignment' }> = [];
+
+        if (position === 'start') {
+          next = [{ id: movedId, type: 'section' }, ...withoutMoved.map(item => ({ id: item.id, type: item.type }))];
+        } else if (position === 'end') {
+          next = [...withoutMoved.map(item => ({ id: item.id, type: item.type })), { id: movedId, type: 'section' }];
+        } else {
+          const targetIdx = withoutMoved.findIndex(item => item.id === targetId);
+          if (targetIdx === -1) {
+            throw new TRPCError({ code: 'BAD_REQUEST', message: 'targetId not found in unified list' });
+          }
+          if (position === 'before') {
+            next = [
+              ...withoutMoved.slice(0, targetIdx).map(item => ({ id: item.id, type: item.type })),
+              { id: movedId, type: 'section' },
+              ...withoutMoved.slice(targetIdx).map(item => ({ id: item.id, type: item.type })),
+            ];
+          } else {
+            next = [
+              ...withoutMoved.slice(0, targetIdx + 1).map(item => ({ id: item.id, type: item.type })),
+              { id: movedId, type: 'section' },
+              ...withoutMoved.slice(targetIdx + 1).map(item => ({ id: item.id, type: item.type })),
+            ];
+          }
+        }
+
+        // Normalize to 1..n
+        await Promise.all(
+          next.map((item, index) => {
+            if (item.type === 'section') {
+              return tx.section.update({ where: { id: item.id }, data: { order: index + 1 } });
+            } else {
+              return tx.assignment.update({ where: { id: item.id }, data: { order: index + 1 } });
+            }
+          })
+        );
+
+        return tx.section.findUnique({ where: { id: movedId } });
+      });
+
+      return result;
+    }),
+
   update: protectedProcedure
     .input(updateSectionSchema)
     .mutation(async ({ ctx, input }) => {
@@ -176,11 +270,39 @@ export const sectionRouter = createTRPCRouter({
         });
       }
 
-      await prisma.section.update({
-        where: { id: input.id },
-        data: {
-          order: input.order,
-        },
+      // Update order and normalize unified list
+      await prisma.$transaction(async (tx) => {
+        await tx.section.update({
+          where: { id: input.id },
+          data: { order: input.order },
+        });
+
+        // Normalize entire unified list
+        const [sections, assignments] = await Promise.all([
+          tx.section.findMany({
+            where: { classId: input.classId },
+            select: { id: true, order: true },
+          }),
+          tx.assignment.findMany({
+            where: { classId: input.classId },
+            select: { id: true, order: true },
+          }),
+        ]);
+
+        const unified = [
+          ...sections.map(s => ({ id: s.id, order: s.order, type: 'section' as const })),
+          ...assignments.map(a => ({ id: a.id, order: a.order, type: 'assignment' as const })),
+        ].sort((a, b) => (a.order ?? Number.MAX_SAFE_INTEGER) - (b.order ?? Number.MAX_SAFE_INTEGER));
+
+        await Promise.all(
+          unified.map((item, index) => {
+            if (item.type === 'section') {
+              return tx.section.update({ where: { id: item.id }, data: { order: index + 1 } });
+            } else {
+              return tx.assignment.update({ where: { id: item.id }, data: { order: index + 1 } });
+            }
+          })
+        );
       });
 
       return { id: input.id };

package/src/seedDatabase.ts

@@ -5,6 +5,7 @@ import { logger } from "./utils/logger.js";
 export async function clearDatabase() {
     // Delete in order to respect foreign key constraints
     // Delete notifications first (they reference users)
+    logger.info('Clearing database');
     await prisma.notification.deleteMany();
     
     // Delete chat-related records
@@ -94,7 +95,7 @@ export const seedDatabase = async () => {
 
     // 3. Create Students (realistic names)
     const students = await Promise.all([
-        createUser('alex.martinez@student.riverside.edu', 'student123', 'alex.martinez'),
+        createUser('alex.martinez@student.rverside.eidu', 'student123', 'alex.martinez'),
         createUser('sophia.williams@student.riverside.edu', 'student123', 'sophia.williams'),
         createUser('james.brown@student.riverside.edu', 'student123', 'james.brown'),
         createUser('olivia.taylor@student.riverside.edu', 'student123', 'olivia.taylor'),

package/src/utils/logger.ts

@@ -26,7 +26,24 @@ const colors = {
   magenta: '\x1b[35m',
   cyan: '\x1b[36m',
   white: '\x1b[37m',
-  gray: '\x1b[90m'
+  gray: '\x1b[90m',
+  // Background colors
+  bgRed: '\x1b[41m',
+  bgGreen: '\x1b[42m',
+  bgYellow: '\x1b[43m',
+  bgBlue: '\x1b[44m',
+  bgMagenta: '\x1b[45m',
+  bgCyan: '\x1b[46m',
+  bgWhite: '\x1b[47m',
+  bgGray: '\x1b[100m',
+  // Bright background colors
+  bgBrightRed: '\x1b[101m',
+  bgBrightGreen: '\x1b[102m',
+  bgBrightYellow: '\x1b[103m',
+  bgBrightBlue: '\x1b[104m',
+  bgBrightMagenta: '\x1b[105m',
+  bgBrightCyan: '\x1b[106m',
+  bgBrightWhite: '\x1b[107m'
 };
 
 class Logger {
@@ -34,6 +51,7 @@ class Logger {
   private isDevelopment: boolean;
   private mode: LogMode;
   private levelColors: Record<LogLevel, string>;
+  private levelBgColors: Record<LogLevel, string>;
   private levelEmojis: Record<LogLevel, string>;
 
   private constructor() {
@@ -51,6 +69,13 @@ class Logger {
       [LogLevel.DEBUG]: colors.magenta
     };
 
+    this.levelBgColors = {
+      [LogLevel.INFO]: colors.bgBlue,
+      [LogLevel.WARN]: colors.bgYellow,
+      [LogLevel.ERROR]: colors.bgRed,
+      [LogLevel.DEBUG]: colors.bgMagenta
+    };
+
     this.levelEmojis = {
       [LogLevel.INFO]: 'ℹ️',
       [LogLevel.WARN]: '⚠️',
@@ -95,10 +120,12 @@ class Logger {
   private formatMessage(logMessage: LogMessage): string {
     const { level, message, timestamp, context } = logMessage;
     const color = this.levelColors[level];
+    const bgColor = this.levelBgColors[level];
     const emoji = this.levelEmojis[level];
     
     const timestampStr = colors.gray + `[${timestamp}]` + colors.reset;
-    const levelStr = color + `[${level.toUpperCase()}]` + colors.reset;
+    // Use background color for level badge like Vitest
+    const levelStr = colors.white + bgColor + ` ${level.toUpperCase()} ` + colors.reset;
     const emojiStr = emoji + ' ';
     const messageStr = colors.bright + message + colors.reset;
     

package/tests/setup.ts

@@ -5,6 +5,7 @@ import { logger } from '../src/utils/logger';
 import { appRouter } from '../src/routers/_app';
 import { createTRPCContext } from '../src/trpc';
 import { Session } from '@prisma/client';
+import { clearDatabase } from '../src/seedDatabase';
 
 const getCaller = async (token: string) => {
   const ctx = await createTRPCContext({
@@ -19,15 +20,8 @@ const getCaller = async (token: string) => {
 
   // Before the entire test suite runs
   beforeAll(async () => {
-  //   // Run migrations so the test DB has the latest schema
-  //   try {
-  //     logger.info('Setting up test database');
-  //     execSync('rm -f prisma/test.db');
-  //     execSync('npx prisma db push --force-reset --schema=prisma/schema.prisma');
-    
-  //   } catch (error) {
-  //     logger.error('Error initializing test database');
-  //   }
+
+    await clearDatabase();
 
     logger.info('Getting caller');