@studious-lms/server 1.1.2 → 1.1.4

package/dist/routers/assignment.d.ts

@@ -771,6 +771,7 @@ export declare const assignmentRouter: import("@trpc/server").TRPCBuiltRouter<{
             classId: string;
             assignmentId: string;
             submissionId: string;
+            feedback?: string | undefined;
             gradeReceived?: number | null | undefined;
             existingFileIds?: string[] | undefined;
             removedAttachments?: string[] | undefined;
@@ -1235,5 +1236,83 @@ export declare const assignmentRouter: import("@trpc/server").TRPCBuiltRouter<{
         };
         meta: object;
     }>;
+    detachGradingBoundary: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            [x: string]: unknown;
+            classId: string;
+            assignmentId: string;
+        };
+        output: {
+            section: {
+                id: string;
+                name: string;
+                color: string | null;
+                classId: string;
+                order: number | null;
+            } | null;
+            teacher: {
+                id: string;
+                username: string;
+                email: string;
+                password: string;
+                verified: boolean;
+                role: import(".prisma/client").$Enums.UserRole;
+                profileId: string | null;
+                schoolId: string | null;
+            };
+            attachments: {
+                path: string;
+                type: string;
+                id: string;
+                name: string;
+                size: number | null;
+                uploadedAt: Date | null;
+                assignmentId: string | null;
+                submissionId: string | null;
+                userId: string | null;
+                thumbnailId: string | null;
+                annotationId: string | null;
+                classDraftId: string | null;
+                folderId: string | null;
+            }[];
+            eventAttached: {
+                id: string;
+                name: string | null;
+                color: string | null;
+                location: string | null;
+                startTime: Date;
+                endTime: Date;
+                remarks: string | null;
+                classId: string | null;
+                userId: string | null;
+            } | null;
+            gradingBoundary: {
+                id: string;
+                classId: string;
+                structured: string;
+            } | null;
+        } & {
+            type: import(".prisma/client").$Enums.AssignmentType;
+            id: string;
+            title: string;
+            dueDate: Date;
+            maxGrade: number | null;
+            classId: string;
+            eventId: string | null;
+            markSchemeId: string | null;
+            gradingBoundaryId: string | null;
+            instructions: string;
+            weight: number;
+            graded: boolean;
+            sectionId: string | null;
+            template: boolean;
+            createdAt: Date | null;
+            modifiedAt: Date | null;
+            teacherId: string;
+            inProgress: boolean;
+            order: number | null;
+        };
+        meta: object;
+    }>;
 }>>;
 //# sourceMappingURL=assignment.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"assignment.d.ts","sourceRoot":"","sources":["../../src/routers/assignment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAqFxB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAioD3B,CAAC"}
+{"version":3,"file":"assignment.d.ts","sourceRoot":"","sources":["../../src/routers/assignment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAsFxB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0qD3B,CAAC"}

package/dist/routers/assignment.js

@@ -68,6 +68,7 @@ const updateSubmissionSchema = z.object({
     newAttachments: z.array(fileSchema).optional(),
     existingFileIds: z.array(z.string()).optional(),
     removedAttachments: z.array(z.string()).optional(),
+    feedback: z.string().optional(),
     rubricGrades: z.array(z.object({
         criteriaId: z.string(),
         selectedLevelId: z.string(),
@@ -1037,7 +1038,7 @@ export const assignmentRouter = createTRPCRouter({
                 message: "User must be authenticated",
             });
         }
-        const { submissionId, return: returnSubmission, gradeReceived, newAttachments, existingFileIds, removedAttachments, rubricGrades } = input;
+        const { submissionId, return: returnSubmission, gradeReceived, newAttachments, existingFileIds, removedAttachments, rubricGrades, feedback } = input;
         const submission = await prisma.submission.findFirst({
             where: {
                 id: submissionId,
@@ -1181,6 +1182,7 @@ export const assignmentRouter = createTRPCRouter({
             data: {
                 ...(gradeReceived !== undefined && { gradeReceived }),
                 ...(rubricGrades && { rubricState: JSON.stringify(rubricGrades) }),
+                ...(feedback && { teacherComments: feedback }),
                 ...(removedAttachments && removedAttachments.length > 0 && {
                     annotations: {
                         deleteMany: {
@@ -1188,6 +1190,7 @@ export const assignmentRouter = createTRPCRouter({
                         },
                     },
                 }),
+                ...(returnSubmission && { returned: returnSubmission }),
             },
             include: {
                 attachments: {
@@ -1605,4 +1608,39 @@ export const assignmentRouter = createTRPCRouter({
         });
         return updatedAssignment;
     }),
+    detachGradingBoundary: protectedTeacherProcedure
+        .input(z.object({
+        classId: z.string(),
+        assignmentId: z.string(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        const { assignmentId } = input;
+        const assignment = await prisma.assignment.findFirst({
+            where: {
+                id: assignmentId,
+            },
+        });
+        if (!assignment) {
+            throw new TRPCError({
+                code: "NOT_FOUND",
+                message: "Assignment not found",
+            });
+        }
+        const updatedAssignment = await prisma.assignment.update({
+            where: { id: assignmentId },
+            data: {
+                gradingBoundary: {
+                    disconnect: true,
+                },
+            },
+            include: {
+                attachments: true,
+                section: true,
+                teacher: true,
+                eventAttached: true,
+                gradingBoundary: true,
+            },
+        });
+        return updatedAssignment;
+    }),
 });

package/dist/routers/folder.d.ts

@@ -78,6 +78,7 @@ export declare const folderRouter: import("@trpc/server").TRPCBuiltRouter<{
                     childFolders: number;
                 };
                 name: string;
+                color: string | null;
             }[];
             parentFolder: {
                 id: string;

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

@@ -1 +1 @@
-{"version":3,"file":"folder.d.ts","sourceRoot":"","sources":["../../src/routers/folder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA4BxB,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmuBvB,CAAC"}
+{"version":3,"file":"folder.d.ts","sourceRoot":"","sources":["../../src/routers/folder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA4BxB,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAouBvB,CAAC"}

package/dist/routers/folder.js

@@ -167,6 +167,7 @@ export const folderRouter = createTRPCRouter({
                     select: {
                         id: true,
                         name: true,
+                        color: true,
                         _count: {
                             select: {
                                 files: true,

package/dist/routers/user.d.ts

@@ -22,29 +22,57 @@ export declare const userRouter: import("@trpc/server").TRPCBuiltRouter<{
             id: string;
             username: string;
             profile: {
-                id: string;
-                userId: string;
-            } | null;
+                displayName: any;
+                bio: any;
+                location: any;
+                website: any;
+                profilePicture: string | null;
+                profilePictureThumbnail: string | null;
+            };
         };
         meta: object;
     }>;
     updateProfile: import("@trpc/server").TRPCMutationProcedure<{
         input: {
-            profile: Record<string, any>;
+            profile?: {
+                location?: string | null | undefined;
+                displayName?: string | null | undefined;
+                bio?: string | null | undefined;
+                website?: string | null | undefined;
+            } | undefined;
             profilePicture?: {
-                type: string;
-                name: string;
-                size: number;
-                data: string;
+                filePath: string;
+                fileName: string;
+                fileType: string;
+                fileSize: number;
+            } | undefined;
+            dicebearAvatar?: {
+                url: string;
             } | undefined;
         };
         output: {
             id: string;
             username: string;
             profile: {
-                id: string;
-                userId: string;
-            } | null;
+                displayName: any;
+                bio: any;
+                location: any;
+                website: any;
+                profilePicture: string | null;
+                profilePictureThumbnail: string | null;
+            };
+        };
+        meta: object;
+    }>;
+    getUploadUrl: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            fileName: string;
+            fileType: string;
+        };
+        output: {
+            uploadUrl: string;
+            filePath: string;
+            fileName: string;
         };
         meta: object;
     }>;

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;AA2DxB,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqMrB,CAAC"}

package/dist/routers/user.js

@@ -2,16 +2,50 @@ import { z } from "zod";
 import { createTRPCRouter, protectedProcedure } from "../trpc.js";
 import { TRPCError } from "@trpc/server";
 import { prisma } from "../lib/prisma.js";
-import { uploadFiles } from "../lib/fileUpload.js";
-const fileSchema = z.object({
-    name: z.string(),
-    type: z.string(),
-    size: z.number(),
-    data: z.string(), // base64 encoded file data
+import { getSignedUrl } from "../lib/googleCloudStorage.js";
+import { logger } from "../utils/logger.js";
+// Helper function to convert file path to backend proxy URL
+function getFileUrl(filePath) {
+    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"),
+    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(),
 });
 const updateProfileSchema = z.object({
-    profile: z.record(z.any()),
-    profilePicture: fileSchema.optional(),
+    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"),
 });
 export const userRouter = createTRPCRouter({
     getProfile: protectedProcedure
@@ -27,7 +61,6 @@ export const userRouter = createTRPCRouter({
             select: {
                 id: true,
                 username: true,
-                profile: true,
             },
         });
         if (!user) {
@@ -36,7 +69,29 @@ export const userRouter = createTRPCRouter({
                 message: "User not found",
             });
         }
-        return user;
+        // 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.displayName || null,
+                bio: userProfile.bio || null,
+                location: userProfile.location || null,
+                website: userProfile.website || null,
+                profilePicture: getFileUrl(userProfile.profilePicture),
+                profilePictureThumbnail: getFileUrl(userProfile.profilePictureThumbnail),
+            } : {
+                displayName: null,
+                bio: null,
+                location: null,
+                website: null,
+                profilePicture: null,
+                profilePictureThumbnail: null,
+            },
+        };
     }),
     updateProfile: protectedProcedure
         .input(updateProfileSchema)
@@ -47,25 +102,130 @@ export const userRouter = createTRPCRouter({
                 message: "User must be authenticated",
             });
         }
-        let uploadedFiles = [];
+        // Get current profile to clean up old profile picture
+        const currentProfile = await prisma.userProfile.findUnique({
+            where: { userId: ctx.user.id },
+        });
+        let profilePictureUrl = null;
+        let profilePictureThumbnail = null;
+        // Handle custom profile picture (already uploaded to GCS)
         if (input.profilePicture) {
-            // Store profile picture in a user-specific directory
-            uploadedFiles = await uploadFiles([input.profilePicture], ctx.user.id, `users/${ctx.user.id}/profile`);
-            // Add profile picture path to profile data
-            input.profile.profilePicture = uploadedFiles[0].path;
-            input.profile.profilePictureThumbnail = uploadedFiles[0].thumbnailId;
+            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?.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.",
+                });
+            }
         }
-        const updatedUser = await prisma.user.update({
-            where: { id: ctx.user.id },
-            data: {
-                profile: input.profile,
+        // 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 = {};
+        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,
             },
-            select: {
-                id: true,
-                username: true,
-                profile: true,
+            update: {
+                ...updateData,
+                updatedAt: new Date(),
             },
         });
-        return updatedUser;
+        // 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.displayName || null,
+                bio: updatedProfile.bio || null,
+                location: updatedProfile.location || null,
+                website: updatedProfile.website || null,
+                profilePicture: getFileUrl(updatedProfile.profilePicture),
+                profilePictureThumbnail: getFileUrl(updatedProfile.profilePictureThumbnail),
+            },
+        };
+    }),
+    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 signed URL for direct upload (write permission)
+            const uploadUrl = await getSignedUrl(filePath, 'write', input.fileType);
+            logger.info('Generated upload URL', {
+                userId: ctx.user.id,
+                filePath,
+                fileName: uniqueFilename,
+                fileType: input.fileType
+            });
+            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",
+            });
+        }
     }),
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@studious-lms/server",
-  "version": "1.1.2",
+  "version": "1.1.4",
   "description": "Backend server for Studious application",
   "main": "dist/exportType.js",
   "types": "dist/exportType.d.ts",

package/prisma/migrations/20250920143543_add_profile_fields/migration.sql

@@ -0,0 +1,15 @@
+/*
+  Warnings:
+
+  - Added the required column `updatedAt` to the `UserProfile` table without a default value. This is not possible if the table is not empty.
+
+*/
+-- AlterTable
+ALTER TABLE "public"."UserProfile" ADD COLUMN     "bio" TEXT,
+ADD COLUMN     "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+ADD COLUMN     "displayName" TEXT,
+ADD COLUMN     "location" TEXT,
+ADD COLUMN     "profilePicture" TEXT,
+ADD COLUMN     "profilePictureThumbnail" TEXT,
+ADD COLUMN     "updatedAt" TIMESTAMP(3) NOT NULL,
+ADD COLUMN     "website" TEXT;

package/prisma/schema.prisma

@@ -82,7 +82,16 @@ model UserProfile {
   id String @id @default(uuid())
   userId String @unique
   user User? @relation(fields: [userId], references: [id], onDelete: Cascade)
-
+  
+  displayName String?
+  bio String?
+  location String?
+  website String?
+  profilePicture String?
+  profilePictureThumbnail String?
+  
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
 } 
 
 model Class {