@studious-lms/server 1.1.24 → 1.2.6

package/src/routers/user.ts

@@ -1,259 +1,82 @@
 import { z } from "zod";
 import { createTRPCRouter, protectedProcedure } from "../trpc.js";
-import { TRPCError } from "@trpc/server";
-import { prisma } from "../lib/prisma.js";
-import { createDirectUploadFiles, type DirectUploadFile } from "../lib/fileUpload.js";
-import { getSignedUrl } from "../lib/googleCloudStorage.js";
-import { logger } from "../utils/logger.js";
-import { bucket } from "../lib/googleCloudStorage.js";
+import {
+  getProfile,
+  updateProfile,
+  getUploadUrl,
+} from "../services/user.js";
 
-// Helper function to convert file path to backend proxy URL
-function getFileUrl(filePath: string | null): string | null {
-  if (!filePath) return null;
-  
-  // If it's already a full URL (DiceBear or external), return as is
-  if (filePath.startsWith('http')) {
-    return filePath;
-  }
-  
-  // Convert GCS path to full backend proxy URL
-  const backendUrl = process.env.BACKEND_URL || 'http://localhost:3001';
-  return `${backendUrl}/api/files/${encodeURIComponent(filePath)}`;
-}
-
-// For direct file uploads (file already uploaded to GCS)
 const fileUploadSchema = z.object({
   filePath: z.string().min(1, "File path is required"),
   fileName: z.string().min(1, "File name is required"),
-  fileType: z.string().regex(/^image\/(jpeg|jpg|png|gif|webp)$/i, "Only image files (JPEG, PNG, GIF, WebP) are allowed"),
+  fileType: z
+    .string()
+    .regex(
+      /^image\/(jpeg|jpg|png|gif|webp)$/i,
+      "Only image files (JPEG, PNG, GIF, WebP) are allowed"
+    ),
   fileSize: z.number().max(5 * 1024 * 1024, "File size must be less than 5MB"),
 });
 
-// For DiceBear avatar URL
 const dicebearSchema = z.object({
   url: z.string().url("Invalid DiceBear avatar URL"),
 });
 
 const profileSchema = z.object({
-  displayName: z.string().nullable().optional().transform(val => val === null ? undefined : val),
-  bio: z.string().nullable().optional().transform(val => val === null ? undefined : val),
-  location: z.string().nullable().optional().transform(val => val === null ? undefined : val),
-  website: z.union([
-    z.string().url(),
-    z.literal(""),
-    z.null().transform(() => undefined)
-  ]).optional(),
+  displayName: z
+    .string()
+    .nullable()
+    .optional()
+    .transform((val) => (val === null ? undefined : val)),
+  bio: z
+    .string()
+    .nullable()
+    .optional()
+    .transform((val) => (val === null ? undefined : val)),
+  location: z
+    .string()
+    .nullable()
+    .optional()
+    .transform((val) => (val === null ? undefined : val)),
+  website: z
+    .union([
+      z.string().url(),
+      z.literal(""),
+      z.null().transform(() => undefined),
+    ])
+    .optional(),
 });
 
 const updateProfileSchema = z.object({
   profile: profileSchema.optional(),
-  // Support both custom file upload and DiceBear avatar
   profilePicture: fileUploadSchema.optional(),
   dicebearAvatar: dicebearSchema.optional(),
 });
 
 const getUploadUrlSchema = z.object({
   fileName: z.string().min(1, "File name is required"),
-  fileType: z.string().regex(/^image\/(jpeg|jpg|png|gif|webp)$/i, "Only image files are allowed"),
+  fileType: z
+    .string()
+    .regex(
+      /^image\/(jpeg|jpg|png|gif|webp)$/i,
+      "Only image files are allowed"
+    ),
 });
 
 export const userRouter = createTRPCRouter({
-  getProfile: protectedProcedure
-    .query(async ({ ctx }) => {
-      if (!ctx.user) {
-        throw new TRPCError({
-          code: "UNAUTHORIZED",
-          message: "User must be authenticated",
-        });
-      }
-
-      const user = await prisma.user.findUnique({
-        where: { id: ctx.user.id },
-        select: {
-          id: true,
-          username: true,
-        },
-      });
-
-      if (!user) {
-        throw new TRPCError({
-          code: "NOT_FOUND",
-          message: "User not found",
-        });
-      }
-
-      // Get user profile separately
-      const userProfile = await prisma.userProfile.findUnique({
-        where: { userId: ctx.user.id },
-      });
-
-      return {
-        id: user.id,
-        username: user.username,
-        profile: userProfile ? {
-          displayName: (userProfile as any).displayName || null,
-          bio: (userProfile as any).bio || null,
-          location: (userProfile as any).location || null,
-          website: (userProfile as any).website || null,
-          profilePicture: getFileUrl((userProfile as any).profilePicture),
-          profilePictureThumbnail: getFileUrl((userProfile as any).profilePictureThumbnail),
-        } : {
-          displayName: null,
-          bio: null,
-          location: null,
-          website: null,
-          profilePicture: null,
-          profilePictureThumbnail: null,
-        },
-      };
-    }),
+  getProfile: protectedProcedure.query(({ ctx }) =>
+    getProfile(ctx.user!.id)
+  ),
 
   updateProfile: protectedProcedure
     .input(updateProfileSchema)
-    .mutation(async ({ ctx, input }) => {
-      if (!ctx.user) {
-        throw new TRPCError({
-          code: "UNAUTHORIZED",
-          message: "User must be authenticated",
-        });
-      }
-
-      // Get current profile to clean up old profile picture
-      const currentProfile = await prisma.userProfile.findUnique({
-        where: { userId: ctx.user.id },
-      });
-
-      let profilePictureUrl: string | null = null;
-      let profilePictureThumbnail: string | null = null;
-
-      // Handle custom profile picture (already uploaded to GCS)
-      if (input.profilePicture) {
-        try {
-          // File is already uploaded to GCS, just use the path
-          profilePictureUrl = input.profilePicture.filePath;
-          
-          // Generate thumbnail for the uploaded file
-          // TODO: Implement thumbnail generation for direct uploads
-          profilePictureThumbnail = null;
-
-          // Clean up old profile picture if it exists
-          if ((currentProfile as any)?.profilePicture) {
-            // TODO: Implement file deletion logic here
-            // await deleteFile((currentProfile as any).profilePicture);
-          }
-        } catch (error) {
-          logger.error('Profile picture processing failed', { 
-            userId: ctx.user.id, 
-            error: error instanceof Error ? error.message : 'Unknown error' 
-          });
-          throw new TRPCError({
-            code: "INTERNAL_SERVER_ERROR",
-            message: "Failed to process profile picture. Please try again.",
-          });
-        }
-      }
-
-      // Handle DiceBear avatar URL
-      if (input.dicebearAvatar) {
-        profilePictureUrl = input.dicebearAvatar.url;
-        // No thumbnail for DiceBear avatars since they're SVG URLs
-        profilePictureThumbnail = null;
-      }
-
-      // Prepare update data
-      const updateData: any = {};
-      if (input.profile) {
-        if (input.profile.displayName !== undefined && input.profile.displayName !== null) {
-          updateData.displayName = input.profile.displayName;
-        }
-        if (input.profile.bio !== undefined && input.profile.bio !== null) {
-          updateData.bio = input.profile.bio;
-        }
-        if (input.profile.location !== undefined && input.profile.location !== null) {
-          updateData.location = input.profile.location;
-        }
-        if (input.profile.website !== undefined && input.profile.website !== null) {
-          updateData.website = input.profile.website;
-        }
-      }
-      if (profilePictureUrl !== null) updateData.profilePicture = profilePictureUrl;
-      if (profilePictureThumbnail !== null) updateData.profilePictureThumbnail = profilePictureThumbnail;
-
-      // Upsert user profile with structured data
-      const updatedProfile = await prisma.userProfile.upsert({
-        where: { userId: ctx.user.id },
-        create: {
-          userId: ctx.user.id,
-          ...updateData,
-        },
-        update: {
-          ...updateData,
-          updatedAt: new Date(),
-        },
-      });
-
-      // Get username for response
-      const user = await prisma.user.findUnique({
-        where: { id: ctx.user.id },
-        select: { username: true },
-      });
-
-      return {
-        id: ctx.user.id,
-        username: user?.username || '',
-        profile: {
-          displayName: (updatedProfile as any).displayName || null,
-          bio: (updatedProfile as any).bio || null,
-          location: (updatedProfile as any).location || null,
-          website: (updatedProfile as any).website || null,
-          profilePicture: getFileUrl((updatedProfile as any).profilePicture),
-          profilePictureThumbnail: getFileUrl((updatedProfile as any).profilePictureThumbnail),
-        },
-      };
-    }),
+    .mutation(({ ctx, input }) =>
+      updateProfile(ctx.user!.id, input)
+    ),
 
   getUploadUrl: protectedProcedure
     .input(getUploadUrlSchema)
-    .mutation(async ({ ctx, input }) => {
-      if (!ctx.user) {
-        throw new TRPCError({
-          code: "UNAUTHORIZED",
-          message: "User must be authenticated",
-        });
-      }
-
-      try {
-        // Generate unique filename
-        const fileExtension = input.fileName.split('.').pop();
-        const uniqueFilename = `${ctx.user.id}-${Date.now()}.${fileExtension}`;
-        const filePath = `users/${ctx.user.id}/profile/${uniqueFilename}`;
-
-        // Generate backend proxy upload URL instead of direct GCS signed URL
-        const backendUrl = process.env.BACKEND_URL || 'http://localhost:3001';
-        const uploadUrl = `${backendUrl}/api/upload/${encodeURIComponent(filePath)}`;
-
-        logger.info('Generated upload URL', {
-          userId: ctx.user.id,
-          filePath,
-          fileName: uniqueFilename,
-          fileType: input.fileType,
-          uploadUrl
-        });
-
-        return {
-          uploadUrl,
-          filePath,
-          fileName: uniqueFilename,
-        };
-      } catch (error) {
-        logger.error('Failed to generate upload URL', { 
-          userId: ctx.user.id, 
-          error: error instanceof Error ? error.message : 'Unknown error' 
-        });
-        throw new TRPCError({
-          code: "INTERNAL_SERVER_ERROR",
-          message: "Failed to generate upload URL",
-        });
-      }
-    }),
-}); 
+    .mutation(({ ctx, input }) =>
+      getUploadUrl(ctx.user!.id, input.fileName, input.fileType)
+    ),
+});

package/src/routers/worksheet.ts

@@ -0,0 +1,252 @@
+import { TRPCError } from "@trpc/server";
+import {
+  createTRPCRouter,
+  protectedClassMemberProcedure,
+  protectedProcedure,
+} from "../trpc.js";
+import { z } from "zod";
+import {
+  getWorksheet,
+  worksheetExists,
+  listWorksheets,
+  updateWorksheetRecord,
+  deleteWorksheetRecord,
+  createWorksheetRecord,
+  addQuestionToWorksheet,
+  reorderWorksheetQuestions,
+  updateWorksheetQuestionRecord,
+  deleteWorksheetQuestionRecord,
+  getWorksheetSubmission,
+  answerWorksheetQuestion,
+  cancelGrading,
+  regradeQuestion,
+  gradeAnswer,
+  addCommentToResponse,
+} from "../services/worksheet.js";
+
+export const worksheetRouter = createTRPCRouter({
+  getWorksheet: protectedProcedure
+    .input(z.object({ worksheetId: z.string() }))
+    .query(({ input }) => getWorksheet(input.worksheetId)),
+
+  exists: protectedClassMemberProcedure
+    .input(z.object({ id: z.string() }))
+    .query(async ({ ctx, input }) => {
+      if (!ctx.user) {
+        throw new TRPCError({
+          code: "UNAUTHORIZED",
+          message: "User must be authenticated",
+        });
+      }
+      return worksheetExists(input.id);
+    }),
+
+  listWorksheets: protectedProcedure
+    .input(z.object({ classId: z.string() }))
+    .query(({ input }) => listWorksheets(input.classId)),
+
+  updateWorksheet: protectedProcedure
+    .input(z.object({ worksheetId: z.string(), name: z.string().optional() }))
+    .mutation(({ input }) =>
+      updateWorksheetRecord(input.worksheetId, { name: input.name })
+    ),
+
+  deleteWorksheet: protectedProcedure
+    .input(z.object({ worksheetId: z.string() }))
+    .mutation(({ input }) => deleteWorksheetRecord(input.worksheetId)),
+
+  create: protectedProcedure
+    .input(z.object({ classId: z.string(), name: z.string() }))
+    .mutation(({ input }) =>
+      createWorksheetRecord(input.classId, input.name)
+    ),
+
+  addQuestion: protectedProcedure
+    .input(
+      z.object({
+        worksheetId: z.string(),
+        question: z.string(),
+        answer: z.string(),
+        points: z.number().optional(),
+        options: z.any().optional(),
+        markScheme: z.any().optional(),
+        type: z.enum([
+          "MULTIPLE_CHOICE",
+          "TRUE_FALSE",
+          "SHORT_ANSWER",
+          "LONG_ANSWER",
+          "MATH_EXPRESSION",
+          "ESSAY",
+        ]),
+      })
+    )
+    .mutation(({ input }) =>
+      addQuestionToWorksheet(input.worksheetId, {
+        question: input.question,
+        answer: input.answer,
+        points: input.points,
+        options: input.options,
+        markScheme: input.markScheme,
+        type: input.type,
+      })
+    ),
+
+  reorderQuestions: protectedProcedure
+    .input(
+      z.object({
+        worksheetId: z.string(),
+        movedId: z.string(),
+        position: z.enum(["before", "after"]),
+        targetId: z.string(),
+      })
+    )
+    .mutation(({ input }) =>
+      reorderWorksheetQuestions(
+        input.worksheetId,
+        input.movedId,
+        input.position,
+        input.targetId
+      )
+    ),
+
+  updateQuestion: protectedProcedure
+    .input(
+      z.object({
+        worksheetId: z.string(),
+        questionId: z.string(),
+        question: z.string().optional(),
+        answer: z.string().optional(),
+        points: z.number().optional(),
+        options: z.any().optional(),
+        markScheme: z.any().optional(),
+        type: z
+          .enum([
+            "MULTIPLE_CHOICE",
+            "TRUE_FALSE",
+            "SHORT_ANSWER",
+            "LONG_ANSWER",
+            "MATH_EXPRESSION",
+            "ESSAY",
+          ])
+          .optional(),
+      })
+    )
+    .mutation(({ input }) =>
+      updateWorksheetQuestionRecord(
+        input.worksheetId,
+        input.questionId,
+        {
+          question: input.question,
+          answer: input.answer,
+          points: input.points,
+          options: input.options,
+          markScheme: input.markScheme,
+          type: input.type,
+        }
+      )
+    ),
+
+  deleteQuestion: protectedProcedure
+    .input(
+      z.object({
+        worksheetId: z.string(),
+        questionId: z.string(),
+      })
+    )
+    .mutation(({ input }) =>
+      deleteWorksheetQuestionRecord(input.worksheetId, input.questionId)
+    ),
+
+  getWorksheetSubmission: protectedProcedure
+    .input(
+      z.object({
+        worksheetId: z.string(),
+        submissionId: z.string(),
+      })
+    )
+    .query(({ input }) =>
+      getWorksheetSubmission(input.worksheetId, input.submissionId)
+    ),
+
+  answerQuestion: protectedProcedure
+    .input(
+      z.object({
+        worksheetResponseId: z.string(),
+        questionId: z.string(),
+        response: z.string(),
+      })
+    )
+    .mutation(({ ctx, input }) =>
+      answerWorksheetQuestion(
+        input.worksheetResponseId,
+        input.questionId,
+        input.response,
+        ctx.user!.id
+      )
+    ),
+
+  cancelGrading: protectedProcedure
+    .input(
+      z.object({
+        worksheetResponseId: z.string(),
+        progressId: z.string(),
+      })
+    )
+    .mutation(({ input }) =>
+      cancelGrading(input.worksheetResponseId, input.progressId)
+    ),
+
+  regradeQuestion: protectedProcedure
+    .input(
+      z.object({
+        worksheetResponseId: z.string(),
+        progressId: z.string(),
+      })
+    )
+    .mutation(({ input }) =>
+      regradeQuestion(input.worksheetResponseId, input.progressId)
+    ),
+
+  gradeAnswer: protectedProcedure
+    .input(
+      z.object({
+        questionId: z.string(),
+        responseId: z.string().optional(),
+        studentWorksheetResponseId: z.string(),
+        response: z.string().optional(),
+        isCorrect: z.boolean(),
+        feedback: z.string().optional(),
+        markschemeState: z.any().optional(),
+        points: z.number().optional(),
+      })
+    )
+    .mutation(({ input }) =>
+      gradeAnswer(
+        input.questionId,
+        input.studentWorksheetResponseId,
+        {
+          responseId: input.responseId,
+          response: input.response,
+          isCorrect: input.isCorrect,
+          feedback: input.feedback,
+          markschemeState: input.markschemeState,
+          points: input.points,
+        }
+      )
+    ),
+
+  addComment: protectedProcedure
+    .input(
+      z.object({
+        responseId: z.string(),
+        comment: z.string(),
+      })
+    )
+    .mutation(({ ctx, input }) =>
+      addCommentToResponse(
+        input.responseId,
+        input.comment,
+        ctx.user!.id
+      )
+    ),
+});