@studious-lms/server 1.1.3 → 1.1.5

package/src/routers/user.ts

@@ -3,17 +3,58 @@ import { createTRPCRouter, protectedProcedure } from "../trpc.js";
 import { TRPCError } from "@trpc/server";
 import { prisma } from "../lib/prisma.js";
 import { uploadFiles, type UploadedFile } from "../lib/fileUpload.js";
+import { getSignedUrl } from "../lib/googleCloudStorage.js";
+import { logger } from "../utils/logger.js";
+import { bucket } from "../lib/googleCloudStorage.js";
 
-const fileSchema = z.object({
-  name: z.string(),
-  type: z.string(),
-  size: z.number(),
-  data: z.string(), // base64 encoded file data
+// 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"),
+  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({
@@ -31,7 +72,6 @@ export const userRouter = createTRPCRouter({
         select: {
           id: true,
           username: true,
-          profile: true,
         },
       });
 
@@ -42,7 +82,30 @@ export const userRouter = createTRPCRouter({
         });
       }
 
-      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 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,
+        },
+      };
     }),
 
   updateProfile: protectedProcedure
@@ -55,28 +118,140 @@ export const userRouter = createTRPCRouter({
         });
       }
 
-      let uploadedFiles: UploadedFile[] = [];
+      // 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) {
-        // 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 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.",
+          });
+        }
       }
 
-      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: 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,
         },
-        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 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),
+        },
+      };
+    }),
+
+  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",
+        });
+      }
     }),
 });