@goscribe/server 1.0.11 → 1.1.1

package/src/routers/workspace.ts

@@ -1,10 +1,25 @@
 import { z } from 'zod';
 import { TRPCError } from '@trpc/server';
 import { router, publicProcedure, authedProcedure } from '../trpc.js';
-import { bucket } from '../lib/storage.js';
+import { supabaseClient } from '../lib/storage.js';
 import { ArtifactType } from '@prisma/client';
 import { aiSessionService } from '../lib/ai-session.js';
 import PusherService from '../lib/pusher.js';
+import { members } from './members.js';
+import type { PrismaClient } from '@prisma/client';
+
+// Helper function to update and emit analysis progress
+async function updateAnalysisProgress(
+  db: PrismaClient,
+  workspaceId: string,
+  progress: any
+) {
+  await db.workspace.update({
+    where: { id: workspaceId },
+    data: { analysisProgress: progress }
+  });
+  await PusherService.emitAnalysisProgress(workspaceId, progress);
+}
 
 // Helper function to calculate search relevance score
 function calculateRelevance(query: string, ...texts: (string | null | undefined)[]): number {
@@ -97,11 +112,14 @@ export const workspace = router({
           },
         },
       });
+
+      aiSessionService.initSession(ws.id, ctx.session.user.id);
       return ws;
     }),
   createFolder: authedProcedure
     .input(z.object({
         name: z.string().min(1).max(100),
+        color: z.string().optional(),
         parentId: z.string().optional(),
      }))
     .mutation(async ({ ctx, input }) => {
@@ -109,11 +127,30 @@ export const workspace = router({
         data: {
           name: input.name,
           ownerId: ctx.session.user.id,
+          color: input.color ?? '#9D00FF',
           parentId: input.parentId ?? null,
         },
       });
       return folder;
     }),
+  updateFolder: authedProcedure
+    .input(z.object({
+        id: z.string(),
+        name: z.string().min(1).max(100).optional(),
+        color: z.string().optional(),
+     }))
+    .mutation(async ({ ctx, input }) => {
+      const folder = await ctx.db.folder.update({ where: { id: input.id }, data: { name: input.name, color: input.color ?? '#9D00FF' } });
+      return folder;
+    }),
+  deleteFolder: authedProcedure
+    .input(z.object({
+        id: z.string(),
+     }))
+    .mutation(async ({ ctx, input }) => {
+      const folder = await ctx.db.folder.delete({ where: { id: input.id } });
+      return folder;
+    }),
   get: authedProcedure
     .input(z.object({
         id: z.string(),
@@ -130,56 +167,30 @@ export const workspace = router({
       if (!ws) throw new TRPCError({ code: 'NOT_FOUND' });
       return ws;
     }),
-  share: authedProcedure
-    .input(z.object({
-        id: z.string(),
-     }))
-    .query(async ({ ctx, input }) => {
-      const ws = await ctx.db.workspace.findFirst({
-        where: { id: input.id, ownerId: ctx.session.user.id },
+  getStats: authedProcedure
+    .query(async ({ ctx }) => {
+      const workspaces = await ctx.db.workspace.findMany({
+        where: {OR: [{ ownerId: ctx.session.user.id }, { sharedWith: { some: { id: ctx.session.user.id } } }]},
       });
-      if (!ws) throw new TRPCError({ code: 'NOT_FOUND' });
-    
-      // generate a unique share link if not exists
-      if (!ws.shareLink) {
-        const shareLink = [...Array(30)].map(() => (Math.random() * 36 | 0).toString(36)).join('');
-        const updated = await ctx.db.workspace.update({
-          where: { id: ws.id },
-          data: { shareLink },
-        });
-        return { shareLink: updated.shareLink };
-      }
-    }),
-  join: authedProcedure
-    .input(z.object({
-        shareLink: z.string().min(10).max(100),
-     }))
-    .mutation(async ({ ctx, input }) => {
-      const ws = await ctx.db.workspace.findFirst({
-        where: { shareLink: input.shareLink },
+      const folders = await ctx.db.folder.findMany({
+        where: {OR: [{ ownerId: ctx.session.user.id } ]},
       });
-      if (!ws) throw new TRPCError({ code: 'NOT_FOUND', message: 'Workspace not found' }); 
-      if (ws.ownerId === ctx.session.user.id) {
-        throw new TRPCError({ code: 'BAD_REQUEST', message: 'Cannot join your own workspace' });
-      }
-      // add to sharedWith if not already
-      const alreadyShared = await ctx.db.workspace.findFirst({
-        where: { id: ws.id, sharedWith: { some: { id: ctx.session.user.id } } },
+      const lastUpdated = await ctx.db.workspace.findFirst({
+        where: {OR: [{ ownerId: ctx.session.user.id }, { sharedWith: { some: { id: ctx.session.user.id } } }]},
+        orderBy: { updatedAt: 'desc' },
       });
-      if (alreadyShared) {
-        throw new TRPCError({ code: 'BAD_REQUEST', message: 'Already joined this workspace' });
-      }
-      await ctx.db.workspace.update({
-        where: { id: ws.id }, 
-        data: { sharedWith: { connect: { id: ctx.session.user.id } } },
+
+      const spaceLeft = await ctx.db.fileAsset.aggregate({
+        where: { workspaceId: { in: workspaces.map(ws => ws.id) }, userId: ctx.session.user.id },
+        _sum: { size: true },
       });
+
       return {
-        id: ws.id,
-        title: ws.title,
-        description: ws.description,
-        ownerId: ws.ownerId,
-        createdAt: ws.createdAt,
-        updatedAt: ws.updatedAt,
+        workspaces: workspaces.length,
+        folders: folders.length,
+        lastUpdated: lastUpdated?.updatedAt,
+        spaceUsed: spaceLeft._sum?.size ?? 0,
+        spaceLeft: 1000000000 - (spaceLeft._sum?.size ?? 0) || 0,
       };
     }),
   update: authedProcedure
@@ -187,6 +198,8 @@ export const workspace = router({
         id: z.string(),
         name: z.string().min(1).max(100).optional(),
         description: z.string().max(500).optional(),
+        color: z.string().optional(),
+        icon: z.string().optional(),
      }))
     .mutation(async ({ ctx, input }) => {
       const existed = await ctx.db.workspace.findFirst({
@@ -198,6 +211,8 @@ export const workspace = router({
         data: {
           title: input.name ?? existed.title,
           description: input.description,
+          color: input.color ?? existed.color,
+          icon: input.icon ?? existed.icon,
         },
       });
       return updated; 
@@ -264,26 +279,30 @@ export const workspace = router({
         });
 
         // 2. Generate signed URL for direct upload
-        const [url] = await bucket
-          .file(`${ctx.session.user.id}/${record.id}-${file.filename}`)
-          .getSignedUrl({
-            action: "write",
-            expires: Date.now() + 5 * 60 * 1000, // 5 min
-            contentType: file.contentType,
+        const objectKey = `${ctx.session.user.id}/${record.id}-${file.filename}`;
+        const { data: signedUrlData, error: signedUrlError } = await supabaseClient.storage
+          .from('files')
+          .createSignedUploadUrl(objectKey); // 5 minutes
+
+        if (signedUrlError) {
+          throw new TRPCError({ 
+            code: 'INTERNAL_SERVER_ERROR', 
+            message: `Failed to generate upload URL: ${signedUrlError.message}` 
           });
+        }
 
         // 3. Update record with bucket info
         await ctx.db.fileAsset.update({
           where: { id: record.id },
           data: {
-            bucket: bucket.name,
-            objectKey: `${ctx.session.user.id}/${record.id}-${file.filename}`,
+            bucket: 'files',
+            objectKey: objectKey,
           },
         }); 
 
         results.push({
           fileId: record.id,
-          uploadUrl: url,
+          uploadUrl: signedUrlData.signedUrl,
         });
       }
 
@@ -304,13 +323,15 @@ export const workspace = router({
           userId: ctx.session.user.id,
         },
       });
-      // Delete from GCS (best-effort)
+      // Delete from Supabase Storage (best-effort)
       for (const file of files) {
         if (file.bucket && file.objectKey) {
-          const gcsFile: import('@google-cloud/storage').File = bucket.file(file.objectKey);
-          gcsFile.delete({ ignoreNotFound: true }).catch((err: unknown) => {
-            console.error(`Error deleting file ${file.objectKey} from bucket ${file.bucket}:`, err);
-          });
+          supabaseClient.storage
+            .from(file.bucket)
+            .remove([file.objectKey])
+            .catch((err: unknown) => {
+              console.error(`Error deleting file ${file.objectKey} from bucket ${file.bucket}:`, err);
+            });
         }
       }
 
@@ -323,6 +344,34 @@ export const workspace = router({
       });
       return true;
     }),
+    getFileUploadUrl: authedProcedure
+    .input(z.object({
+      workspaceId: z.string(),
+      filename: z.string(),
+      contentType: z.string(),
+      size: z.number(),
+    }))
+    .query(async ({ ctx, input }) => {
+      const objectKey = `workspace_${ctx.session.user.id}/${input.workspaceId}-file_${input.filename}`;
+      await ctx.db.fileAsset.create({
+        data: {
+          workspaceId: input.workspaceId,
+          name: input.filename,
+          mimeType: input.contentType,
+          size: input.size,
+          userId: ctx.session.user.id,
+          bucket: 'media',
+          objectKey: objectKey,
+        },
+      });
+      const { data: signedUrlData, error: signedUrlError } = await supabaseClient.storage
+        .from('media')
+        .createSignedUploadUrl(objectKey); // 5 minutes
+      if (signedUrlError) {
+        throw new TRPCError({ code: 'INTERNAL_SERVER_ERROR', message: `Failed to generate upload URL: ${signedUrlError.message}` });
+      }
+      return signedUrlData.signedUrl;
+    }),
     uploadAndAnalyzeMedia: authedProcedure
     .input(z.object({
       workspaceId: z.string(),
@@ -354,12 +403,51 @@ export const workspace = router({
         console.error('❌ Workspace not found', { workspaceId: input.workspaceId, userId: ctx.session.user.id });
         throw new TRPCError({ code: 'NOT_FOUND' });
       }
-      console.log('✅ Workspace verified', { workspaceId: workspace.id, workspaceTitle: workspace.title });
 
-      // Convert base64 to buffer
-      console.log('📁 Converting base64 to buffer...');
+      const fileType = input.file.contentType.startsWith('image/') ? 'image' : 'pdf';
+      
+      await ctx.db.workspace.update({
+        where: { id: input.workspaceId },
+        data: { fileBeingAnalyzed: true },
+      });
+
+      try {
+      
+      await updateAnalysisProgress(ctx.db, input.workspaceId, {
+        status: 'starting',
+        filename: input.file.filename,
+        fileType,
+        startedAt: new Date().toISOString(),
+        steps: {
+          fileUpload: {
+            order: 1,
+            status: 'pending',
+          },
+          fileAnalysis: {
+            order: 2,
+            status: 'pending',
+          },
+          studyGuide: {
+            order: 3,
+            status: input.generateStudyGuide ? 'pending' : 'skipped',
+          },
+          flashcards: {
+            order: 4,
+            status: input.generateFlashcards ? 'pending' : 'skipped',
+          },
+        }
+      });
+      } catch (error) {
+        console.error('❌ Failed to update analysis progress:', error);
+        await ctx.db.workspace.update({
+          where: { id: input.workspaceId },
+          data: { fileBeingAnalyzed: false },
+        });
+        await PusherService.emitError(input.workspaceId, `Failed to update analysis progress: ${error}`, 'file_analysis');
+        throw error;
+      }
+
       const fileBuffer = Buffer.from(input.file.content, 'base64');
-      console.log('✅ File buffer created', { bufferSize: fileBuffer.length });
 
       // // Check AI service health first
       // console.log('🏥 Checking AI service health...');
@@ -374,41 +462,118 @@ export const workspace = router({
       // }
       // console.log('✅ AI service is healthy');
 
-      // Initialize AI session
-      console.log('🤖 Initializing AI session...');
-      const session = await aiSessionService.initSession(input.workspaceId, ctx.session.user.id);
-      console.log('✅ AI session initialized', { sessionId: session.id });
-      
       const fileObj = new File([fileBuffer], input.file.filename, { type: input.file.contentType });
-      const fileType = input.file.contentType.startsWith('image/') ? 'image' : 'pdf';
-      console.log('📤 Uploading file to AI service...', { filename: input.file.filename, fileType });
-      await aiSessionService.uploadFile(session.id, fileObj, fileType);
-      console.log('✅ File uploaded to AI service');
-      
-      console.log('🚀 Starting LLM session...');
-      try {
-        await aiSessionService.startLLMSession(session.id);
-        console.log('✅ LLM session started');
-      } catch (error) {
-        console.error('❌ Failed to start LLM session:', error);
-        throw error;
-      }
 
-      // Analyze the file first
-      console.log('🔍 Analyzing file...', { fileType });
-      await PusherService.emitTaskComplete(input.workspaceId, 'file_analysis_start', { filename: input.file.filename, fileType });
+      await updateAnalysisProgress(ctx.db, input.workspaceId, {
+        status: 'uploading',
+        filename: input.file.filename,
+        fileType,
+        startedAt: new Date().toISOString(),
+        steps: {
+          fileUpload: {
+            order: 1,
+            status: 'in_progress',
+          },
+          fileAnalysis: {
+            order: 2,
+            status: 'pending',
+          },
+          studyGuide: {
+            order: 3,
+            status: input.generateStudyGuide ? 'pending' : 'skipped',
+          },
+          flashcards: {
+            order: 4,
+            status: input.generateFlashcards ? 'pending' : 'skipped',
+          },
+        }
+      });
+
+      await aiSessionService.uploadFile(input.workspaceId, ctx.session.user.id, fileObj, fileType);
+
+      await updateAnalysisProgress(ctx.db, input.workspaceId, {
+        status: 'analyzing',
+        filename: input.file.filename,
+        fileType,
+        startedAt: new Date().toISOString(),
+        steps: {
+          fileUpload: {
+            order: 1,
+            status: 'completed',
+          },
+          fileAnalysis: {
+            order: 2,
+            status: 'in_progress',
+          },
+          studyGuide: {
+            order: 3,
+            status: input.generateStudyGuide ? 'pending' : 'skipped',
+          },
+          flashcards: {
+            order: 4,
+            status: input.generateFlashcards ? 'pending' : 'skipped',
+          },
+        }
+      });
+
       try {
         if (fileType === 'image') {
-          await aiSessionService.analyseImage(session.id);
-          console.log('✅ Image analysis completed');
+          await aiSessionService.analyseImage(input.workspaceId, ctx.session.user.id);
         } else {
-          await aiSessionService.analysePDF(session.id);
-          console.log('✅ PDF analysis completed');
+          await aiSessionService.analysePDF(input.workspaceId, ctx.session.user.id );
         }
-        await PusherService.emitTaskComplete(input.workspaceId, 'file_analysis_complete', { filename: input.file.filename, fileType });
+        
+        await updateAnalysisProgress(ctx.db, input.workspaceId, {
+          status: 'generating_artifacts',
+          filename: input.file.filename,
+          fileType,
+          startedAt: new Date().toISOString(),
+          steps: {
+            fileUpload: {
+              order: 1,
+              status: 'completed',
+            },
+            fileAnalysis: {
+              order: 2,
+              status: 'completed',
+            },
+            studyGuide: {
+              order: 3,
+              status: input.generateStudyGuide ? 'pending' : 'skipped',
+            },
+            flashcards: {
+              order: 4,
+              status: input.generateFlashcards ? 'pending' : 'skipped',
+            },
+          }
+        });
       } catch (error) {
         console.error('❌ Failed to analyze file:', error);
-        await PusherService.emitError(input.workspaceId, `Failed to analyze ${fileType}: ${error}`, 'file_analysis');
+        await updateAnalysisProgress(ctx.db, input.workspaceId, {
+          status: 'error',
+          filename: input.file.filename,
+          fileType,
+          error: `Failed to analyze ${fileType}: ${error}`,
+          startedAt: new Date().toISOString(),
+          steps: {
+            fileUpload: {
+              order: 1,
+              status: 'completed',
+            },
+            fileAnalysis: {
+              order: 2,
+              status: 'error',
+            },
+            studyGuide: {
+              order: 3,
+              status: 'skipped',
+            },
+            flashcards: {
+              order: 4,
+              status: 'skipped',
+            },
+          }
+        });
         throw error;
       }
 
@@ -430,11 +595,32 @@ export const workspace = router({
 
       // Generate artifacts
       if (input.generateStudyGuide) {
-        await PusherService.emitTaskComplete(input.workspaceId, 'study_guide_load_start', { filename: input.file.filename });
-        const content = await aiSessionService.generateStudyGuide(session.id);
-
-        await PusherService.emitTaskComplete(input.workspaceId, 'study_guide_info', { contentLength: content.length });
+        await updateAnalysisProgress(ctx.db, input.workspaceId, {
+          status: 'generating_study_guide',
+          filename: input.file.filename,
+          fileType,
+          startedAt: new Date().toISOString(),
+          steps: {
+            fileUpload: {
+              order: 1,
+              status: 'completed',
+            },
+            fileAnalysis: {
+              order: 2,
+              status: 'completed',
+            },
+            studyGuide: {
+              order: 3,
+              status: 'in_progress',
+            },
+            flashcards: {
+              order: 4,
+              status: input.generateFlashcards ? 'pending' : 'skipped',
+            },
+          }
+        });
         
+        const content = await aiSessionService.generateStudyGuide(input.workspaceId, ctx.session.user.id);
 
         let artifact = await ctx.db.artifact.findFirst({
           where: { workspaceId: input.workspaceId, type: ArtifactType.STUDY_GUIDE },
@@ -460,16 +646,35 @@ export const workspace = router({
         });
 
         results.artifacts.studyGuide = artifact;
-        
-        // Emit Pusher notification
-        await PusherService.emitStudyGuideComplete(input.workspaceId, artifact);
       }
 
       if (input.generateFlashcards) {
-        await PusherService.emitTaskComplete(input.workspaceId, 'flash_card_load_start', { filename: input.file.filename });
-        const content = await aiSessionService.generateFlashcardQuestions(session.id, 10, 'medium');
-
-        await PusherService.emitTaskComplete(input.workspaceId, 'flash_card_info', { contentLength: content.length });
+        await updateAnalysisProgress(ctx.db, input.workspaceId, {
+          status: 'generating_flashcards',
+          filename: input.file.filename,
+          fileType,
+          startedAt: new Date().toISOString(),
+          steps: {
+            fileUpload: {
+              order: 1,
+              status: 'completed',
+            },
+            fileAnalysis: {
+              order: 2,
+              status: 'completed',
+            },
+            studyGuide: {
+              order: 3,
+              status: input.generateStudyGuide ? 'completed' : 'skipped',
+            },
+            flashcards: {
+              order: 4,
+              status: 'in_progress',
+            },
+          }
+        });
+        
+        const content = await aiSessionService.generateFlashcardQuestions(input.workspaceId, ctx.session.user.id, 10, 'medium');
         
         const artifact = await ctx.db.artifact.create({
           data: {
@@ -482,7 +687,7 @@ export const workspace = router({
         
         // Parse JSON flashcard content
         try {
-          const flashcardData = JSON.parse(content);
+          const flashcardData: any = content;
           
           let createdCards = 0;
           for (let i = 0; i < Math.min(flashcardData.length, 10); i++) {
@@ -523,101 +728,38 @@ export const workspace = router({
         }
         
         results.artifacts.flashcards = artifact;
-        
-        // Emit Pusher notification
-        await PusherService.emitFlashcardComplete(input.workspaceId, artifact);
       }
 
-      if (input.generateWorksheet) {
-        await PusherService.emitTaskComplete(input.workspaceId, 'worksheet_load_start', { filename: input.file.filename });
-        const content = await aiSessionService.generateWorksheetQuestions(session.id, 8, 'medium');
-        await PusherService.emitTaskComplete(input.workspaceId, 'worksheet_info', { contentLength: content.length });
-        
-        const artifact = await ctx.db.artifact.create({
-          data: {
-            workspaceId: input.workspaceId,
-            type: ArtifactType.WORKSHEET,
-            title: `Worksheet - ${input.file.filename}`,
-            createdById: ctx.session.user.id,
+      await ctx.db.workspace.update({
+        where: { id: input.workspaceId },
+        data: { fileBeingAnalyzed: false },
+      });
+
+      await updateAnalysisProgress(ctx.db, input.workspaceId, {
+        status: 'completed',
+        filename: input.file.filename,
+        fileType,
+        startedAt: new Date().toISOString(),
+        completedAt: new Date().toISOString(),
+        steps: {
+          fileUpload: {
+            order: 1,
+            status: 'completed',
+          },
+          fileAnalysis: {
+            order: 2,
+            status: 'completed',
+          },
+          studyGuide: {
+            order: 3,
+            status: input.generateStudyGuide ? 'completed' : 'skipped',
+          },
+          flashcards: {
+            order: 4,
+            status: input.generateFlashcards ? 'completed' : 'skipped',
           },
-        });
-        
-        // Parse JSON worksheet content
-        try {
-          const worksheetData = JSON.parse(content);
-          
-          // The actual worksheet data is in last_response as JSON
-          let actualWorksheetData = worksheetData;
-          if (worksheetData.last_response) {
-            try {
-              actualWorksheetData = JSON.parse(worksheetData.last_response);
-            } catch (parseError) {
-              console.error('❌ Failed to parse last_response JSON:', parseError);
-              console.log('📋 Raw last_response:', worksheetData.last_response);
-            }
-          }
-          
-          // Handle different JSON structures
-          const problems = actualWorksheetData.problems || actualWorksheetData.questions || actualWorksheetData || [];
-          let createdQuestions = 0;
-          
-          for (let i = 0; i < Math.min(problems.length, 8); i++) {
-            const problem = problems[i];
-            const prompt = problem.question || problem.prompt || `Question ${i + 1}`;
-            const answer = problem.answer || problem.solution || `Answer ${i + 1}`;
-            const type = problem.type || 'TEXT';
-            const options = problem.options || [];
-            
-            await ctx.db.worksheetQuestion.create({
-              data: {
-                artifactId: artifact.id,
-                prompt: prompt,
-                answer: answer,
-                difficulty: 'MEDIUM' as any,
-                order: i,
-                meta: { 
-                  type: type,
-                  options: options.length > 0 ? options : undefined
-                },
-              },
-            });
-            createdQuestions++;
-          }
-          
-        } catch (parseError) {
-          console.error('❌ Failed to parse worksheet JSON, using fallback parsing:', parseError);
-          // Fallback to text parsing if JSON fails
-          const lines = content.split('\n').filter(line => line.trim());
-          for (let i = 0; i < Math.min(lines.length, 8); i++) {
-            const line = lines[i];
-            if (line.includes(' - ')) {
-              const [prompt, answer] = line.split(' - ');
-              await ctx.db.worksheetQuestion.create({
-                data: {
-                  artifactId: artifact.id,
-                  prompt: prompt.trim(),
-                  answer: answer.trim(),
-                  difficulty: 'MEDIUM' as any,
-                  order: i,
-                  meta: { type: 'TEXT', },
-                },
-              });
-            }
-          }
         }
-        
-        results.artifacts.worksheet = artifact;
-        
-        // Emit Pusher notification
-        await PusherService.emitWorksheetComplete(input.workspaceId, artifact);
-      }
-
-      await PusherService.emitTaskComplete(input.workspaceId, 'analysis_cleanup_start', { filename: input.file.filename });
-      aiSessionService.deleteSession(session.id);
-      await PusherService.emitTaskComplete(input.workspaceId, 'analysis_cleanup_complete', { filename: input.file.filename });
-      
-      // Emit overall completion notification
-      await PusherService.emitOverallComplete(input.workspaceId, input.file.filename, results.artifacts);
+      });
       
       return results;
     }),
@@ -651,7 +793,26 @@ export const workspace = router({
             },
             take: input.limit,
           });
+          
+          // Update analysisProgress for each workspace with search metadata
+          const workspaceUpdates = workspaces.map(ws => 
+            ctx.db.workspace.update({
+              where: { id: ws.id },
+              data: {
+                analysisProgress: {
+                  lastSearched: new Date().toISOString(),
+                  searchQuery: query,
+                  matchedIn: ws.title.toLowerCase().includes(query.toLowerCase()) ? 'title' : 'description',
+                }
+              }
+            })
+          );
+          
+          await Promise.all(workspaceUpdates);
+          
           return workspaces;
-        })
+        }),
 
+  // Members sub-router
+  members,
 });