@goscribe/server 1.1.6 → 1.2.0

package/src/routers/workspace.ts

@@ -22,6 +22,65 @@ async function updateAnalysisProgress(
   await PusherService.emitAnalysisProgress(workspaceId, progress);
 }
 
+// DRY helper to build progress steps for artifact generation pipeline
+type StepStatus = 'pending' | 'in_progress' | 'completed' | 'skipped' | 'error';
+const PIPELINE_STEPS = ['fileUpload', 'fileAnalysis', 'studyGuide', 'flashcards'] as const;
+
+function buildProgressSteps(
+  currentStep: typeof PIPELINE_STEPS[number],
+  currentStatus: StepStatus,
+  config: { generateStudyGuide: boolean; generateFlashcards: boolean },
+  overrides?: Partial<Record<typeof PIPELINE_STEPS[number], StepStatus>>
+): Record<string, { order: number; status: StepStatus }> {
+  const stepIndex = PIPELINE_STEPS.indexOf(currentStep);
+  const steps: Record<string, { order: number; status: StepStatus }> = {};
+
+  for (let i = 0; i < PIPELINE_STEPS.length; i++) {
+    const step = PIPELINE_STEPS[i];
+    let status: StepStatus;
+
+    if (overrides?.[step]) {
+      status = overrides[step]!;
+    } else if (i < stepIndex) {
+      status = 'completed';
+    } else if (i === stepIndex) {
+      status = currentStatus;
+    } else {
+      // Future steps: check if they're configured
+      if (step === 'studyGuide' && !config.generateStudyGuide) {
+        status = 'skipped';
+      } else if (step === 'flashcards' && !config.generateFlashcards) {
+        status = 'skipped';
+      } else {
+        status = 'pending';
+      }
+    }
+
+    steps[step] = { order: i + 1, status };
+  }
+
+  return steps;
+}
+
+function buildProgress(
+  status: string,
+  filename: string,
+  fileType: string,
+  currentStep: typeof PIPELINE_STEPS[number],
+  currentStepStatus: StepStatus,
+  config: { generateStudyGuide: boolean; generateFlashcards: boolean },
+  extra?: Record<string, any>
+) {
+  return {
+    status,
+    filename,
+    fileType,
+    startedAt: new Date().toISOString(),
+    steps: buildProgressSteps(currentStep, currentStepStatus, config, extra as any),
+    ...extra,
+  };
+}
+
 // Helper function to calculate search relevance score
 function calculateRelevance(query: string, ...texts: (string | null | undefined)[]): number {
   const queryLower = query.toLowerCase();
@@ -194,6 +253,112 @@ export const workspace = router({
         spaceTotal: 1000000000,
       };
     }),
+
+  // Study analytics: streaks, flashcard mastery, worksheet accuracy
+  getStudyAnalytics: authedProcedure
+    .query(async ({ ctx }) => {
+      const userId = ctx.session.user.id;
+
+      // Gather all study activity dates
+      const flashcardProgress = await ctx.db.flashcardProgress.findMany({
+        where: { userId },
+        select: { lastStudiedAt: true },
+      });
+
+      const worksheetProgress = await ctx.db.worksheetQuestionProgress.findMany({
+        where: { userId },
+        select: { updatedAt: true, completedAt: true },
+      });
+
+      // Build a set of unique study days (YYYY-MM-DD)
+      const studyDays = new Set<string>();
+      for (const fp of flashcardProgress) {
+        if (fp.lastStudiedAt) {
+          studyDays.add(fp.lastStudiedAt.toISOString().split('T')[0]);
+        }
+      }
+      for (const wp of worksheetProgress) {
+        if (wp.completedAt) {
+          studyDays.add(wp.completedAt.toISOString().split('T')[0]);
+        } else {
+          studyDays.add(wp.updatedAt.toISOString().split('T')[0]);
+        }
+      }
+
+      // Calculate streak (consecutive days ending today or yesterday)
+      const sortedDays = [...studyDays].sort().reverse();
+      let streak = 0;
+
+      if (sortedDays.length > 0) {
+        const today = new Date();
+        today.setHours(0, 0, 0, 0);
+        const yesterday = new Date(today);
+        yesterday.setDate(yesterday.getDate() - 1);
+
+        const todayStr = today.toISOString().split('T')[0];
+        const yesterdayStr = yesterday.toISOString().split('T')[0];
+
+        // Streak only counts if the most recent study day is today or yesterday
+        if (sortedDays[0] === todayStr || sortedDays[0] === yesterdayStr) {
+          streak = 1;
+          for (let i = 1; i < sortedDays.length; i++) {
+            const current = new Date(sortedDays[i - 1]);
+            const prev = new Date(sortedDays[i]);
+            const diffDays = (current.getTime() - prev.getTime()) / (1000 * 60 * 60 * 24);
+            if (diffDays === 1) {
+              streak++;
+            } else {
+              break;
+            }
+          }
+        }
+      }
+
+      // Weekly activity (last 7 days)
+      const weeklyActivity: boolean[] = [];
+      const today = new Date();
+      today.setHours(0, 0, 0, 0);
+      for (let i = 6; i >= 0; i--) {
+        const d = new Date(today);
+        d.setDate(d.getDate() - i);
+        const dayStr = d.toISOString().split('T')[0];
+        weeklyActivity.push(studyDays.has(dayStr));
+      }
+
+      // Flashcard stats
+      const totalCards = await ctx.db.flashcardProgress.count({ where: { userId } });
+      const masteredCards = await ctx.db.flashcardProgress.count({
+        where: { userId, masteryLevel: { gte: 80 } },
+      });
+      const dueCards = await ctx.db.flashcardProgress.count({
+        where: { userId, nextReviewAt: { lte: new Date() } },
+      });
+
+      // Worksheet stats
+      const completedQuestions = await ctx.db.worksheetQuestionProgress.count({
+        where: { userId, completedAt: { not: null } },
+      });
+      const correctQuestions = await ctx.db.worksheetQuestionProgress.count({
+        where: { userId, correct: true },
+      });
+
+      return {
+        streak,
+        totalStudyDays: studyDays.size,
+        weeklyActivity,
+        flashcards: {
+          total: totalCards,
+          mastered: masteredCards,
+          dueForReview: dueCards,
+        },
+        worksheets: {
+          completed: completedQuestions,
+          correct: correctQuestions,
+          accuracy: completedQuestions > 0 ? Math.round((correctQuestions / completedQuestions) * 100) : 0,
+        },
+      };
+    }),
+
   update: authedProcedure
     .input(z.object({
       id: z.string(),
@@ -304,7 +469,7 @@ export const workspace = router({
         if (signedUrlError) {
           throw new TRPCError({
             code: 'INTERNAL_SERVER_ERROR',
-            message: `Failed to generate upload URL: ${signedUrlError.message}`
+            message: `Failed to upload file`
           });
         }
 
@@ -347,7 +512,7 @@ export const workspace = router({
             .from(file.bucket)
             .remove([file.objectKey])
             .catch((err: unknown) => {
-              console.error(`Error deleting file ${file.objectKey} from bucket ${file.bucket}:`, err);
+              logger.error(`Error deleting file ${file.objectKey} from bucket ${file.bucket}:`, err);
             });
         }
       }
@@ -385,7 +550,7 @@ export const workspace = router({
         .from('media')
         .createSignedUploadUrl(objectKey); // 5 minutes
       if (signedUrlError) {
-        throw new TRPCError({ code: 'INTERNAL_SERVER_ERROR', message: `Failed to generate upload URL: ${signedUrlError.message}` });
+        throw new TRPCError({ code: 'INTERNAL_SERVER_ERROR', message: `Failed to upload file` });
       }
 
       await ctx.db.workspace.update({
@@ -414,7 +579,7 @@ export const workspace = router({
         where: { id: input.workspaceId, ownerId: ctx.session.user.id }
       });
       if (!workspace) {
-        console.error('❌ Workspace not found', { workspaceId: input.workspaceId, userId: ctx.session.user.id });
+        logger.error('Workspace not found', { workspaceId: input.workspaceId, userId: ctx.session.user.id });
         throw new TRPCError({ code: 'NOT_FOUND' });
       }
 
@@ -462,43 +627,18 @@ export const workspace = router({
           data: { fileBeingAnalyzed: true },
         });
 
-        PusherService.emitAnalysisProgress(input.workspaceId, {
-          status: 'starting',
-          filename: primaryFile.name,
-          fileType,
-          startedAt: new Date().toISOString(),
-          steps: {
-            fileUpload: { order: 1, status: 'pending' },
-          },
-        });
+        const genConfig = { generateStudyGuide: input.generateStudyGuide, generateFlashcards: input.generateFlashcards };
+
+        PusherService.emitAnalysisProgress(input.workspaceId,
+          buildProgress('starting', primaryFile.name, fileType, 'fileUpload', 'pending', genConfig)
+        );
 
         try {
-          await updateAnalysisProgress(ctx.db, input.workspaceId, {
-            status: 'starting',
-            filename: primaryFile.name,
-            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',
-              },
-            }
-          });
+          await updateAnalysisProgress(ctx.db, input.workspaceId,
+            buildProgress('starting', primaryFile.name, fileType, 'fileUpload', 'pending', genConfig)
+          );
         } catch (error) {
-          console.error('❌ Failed to update analysis progress:', error);
+          logger.error('Failed to update analysis progress:', error);
           await ctx.db.workspace.update({
             where: { id: input.workspaceId },
             data: { fileBeingAnalyzed: false },
@@ -507,30 +647,9 @@ export const workspace = router({
           throw error;
         }
 
-        await updateAnalysisProgress(ctx.db, input.workspaceId, {
-          status: 'uploading',
-          filename: primaryFile.name,
-          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 updateAnalysisProgress(ctx.db, input.workspaceId,
+          buildProgress('uploading', primaryFile.name, fileType, 'fileUpload', 'in_progress', genConfig)
+        );
 
         // Process all files using the new process_file endpoint
         for (const file of files) {
@@ -550,7 +669,7 @@ export const workspace = router({
             });
             throw new TRPCError({
               code: 'INTERNAL_SERVER_ERROR',
-              message: `Failed to generate signed URL for file ${file.name}: ${signedUrlError.message}`
+              message: `Failed to upload file`
             });
           }
 
@@ -589,30 +708,9 @@ export const workspace = router({
           }
         }
 
-        await updateAnalysisProgress(ctx.db, input.workspaceId, {
-          status: 'analyzing',
-          filename: primaryFile.name,
-          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',
-            },
-          }
-        });
+        await updateAnalysisProgress(ctx.db, input.workspaceId,
+          buildProgress('analyzing', primaryFile.name, fileType, 'fileAnalysis', 'in_progress', genConfig)
+        );
 
         try {
           // Analyze all files - use PDF analysis if any file is a PDF, otherwise use image analysis
@@ -626,57 +724,17 @@ export const workspace = router({
           //   }
           // }
 
-          await updateAnalysisProgress(ctx.db, input.workspaceId, {
-            status: 'generating_artifacts',
-            filename: primaryFile.name,
-            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',
-              },
-            }
-          });
+          await updateAnalysisProgress(ctx.db, input.workspaceId,
+            buildProgress('generating_artifacts', primaryFile.name, fileType, 'studyGuide', 'pending', genConfig)
+          );
         } catch (error) {
-          console.error('❌ Failed to analyze files:', error);
-          await updateAnalysisProgress(ctx.db, input.workspaceId, {
-            status: 'error',
-            filename: primaryFile.name,
-            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',
-              },
-            }
-          });
+          logger.error('Failed to analyze files:', error);
+          await updateAnalysisProgress(ctx.db, input.workspaceId,
+            buildProgress('error', primaryFile.name, fileType, 'fileAnalysis', 'error', genConfig, {
+              error: `Failed to analyze ${fileType}: ${error}`,
+              studyGuide: 'skipped', flashcards: 'skipped',
+            })
+          );
           await ctx.db.workspace.update({
             where: { id: input.workspaceId },
             data: { fileBeingAnalyzed: false },
@@ -700,142 +758,109 @@ export const workspace = router({
           }
         };
 
-        // Generate artifacts
+        // Generate artifacts - each step is isolated so failures don't block subsequent steps
         if (input.generateStudyGuide) {
-          await updateAnalysisProgress(ctx.db, input.workspaceId, {
-            status: 'generating_study_guide',
-            filename: primaryFile.name,
-            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',
-              },
-            }
-          });
+          try {
+            await updateAnalysisProgress(ctx.db, input.workspaceId,
+              buildProgress('generating_study_guide', primaryFile.name, fileType, 'studyGuide', 'in_progress', genConfig)
+            );
 
-          const content = await aiSessionService.generateStudyGuide(input.workspaceId, ctx.session.user.id);
+            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 },
-          });
-          if (!artifact) {
-            const fileNames = files.map(f => f.name).join(', ');
-            artifact = await ctx.db.artifact.create({
-              data: {
-                workspaceId: input.workspaceId,
-                type: ArtifactType.STUDY_GUIDE,
-                title: files.length === 1 ? `Study Guide - ${primaryFile.name}` : `Study Guide - ${files.length} files`,
-                createdById: ctx.session.user.id,
-              },
+            let artifact = await ctx.db.artifact.findFirst({
+              where: { workspaceId: input.workspaceId, type: ArtifactType.STUDY_GUIDE },
             });
-          }
+            if (!artifact) {
+              artifact = await ctx.db.artifact.create({
+                data: {
+                  workspaceId: input.workspaceId,
+                  type: ArtifactType.STUDY_GUIDE,
+                  title: files.length === 1 ? `Study Guide - ${primaryFile.name}` : `Study Guide - ${files.length} files`,
+                  createdById: ctx.session.user.id,
+                },
+              });
+            }
 
-          const lastVersion = await ctx.db.artifactVersion.findFirst({
-            where: { artifact: { workspaceId: input.workspaceId, type: ArtifactType.STUDY_GUIDE } },
-            orderBy: { version: 'desc' },
-          });
+            const lastVersion = await ctx.db.artifactVersion.findFirst({
+              where: { artifact: { workspaceId: input.workspaceId, type: ArtifactType.STUDY_GUIDE } },
+              orderBy: { version: 'desc' },
+            });
 
-          await ctx.db.artifactVersion.create({
-            data: { artifactId: artifact.id, version: lastVersion ? lastVersion.version + 1 : 1, content: content, createdById: ctx.session.user.id },
-          });
+            await ctx.db.artifactVersion.create({
+              data: { artifactId: artifact.id, version: lastVersion ? lastVersion.version + 1 : 1, content: content, createdById: ctx.session.user.id },
+            });
 
-          results.artifacts.studyGuide = artifact;
+            results.artifacts.studyGuide = artifact;
+          } catch (sgError) {
+            logger.error('Study guide generation failed after retries:', sgError);
+            await PusherService.emitError(input.workspaceId, 'Study guide generation failed. Please try regenerating later.', 'study_guide');
+            // Continue to flashcards - don't abort the whole pipeline
+          }
         }
 
         if (input.generateFlashcards) {
-          await updateAnalysisProgress(ctx.db, input.workspaceId, {
-            status: 'generating_flashcards',
-            filename: primaryFile.name,
-            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');
+          try {
+            const sgStatus = input.generateStudyGuide ? (results.artifacts.studyGuide ? 'completed' : 'error') : 'skipped';
+            await updateAnalysisProgress(ctx.db, input.workspaceId,
+              buildProgress('generating_flashcards', primaryFile.name, fileType, 'flashcards', 'in_progress', genConfig,
+                { studyGuide: sgStatus } as any)
+            );
 
-          const artifact = await ctx.db.artifact.create({
-            data: {
-              workspaceId: input.workspaceId,
-              type: ArtifactType.FLASHCARD_SET,
-              title: files.length === 1 ? `Flashcards - ${primaryFile.name}` : `Flashcards - ${files.length} files`,
-              createdById: ctx.session.user.id,
-            },
-          });
+            const content = await aiSessionService.generateFlashcardQuestions(input.workspaceId, ctx.session.user.id, 10, 'medium');
 
-          // Parse JSON flashcard content
-          try {
-            const flashcardData: any = content;
+            const artifact = await ctx.db.artifact.create({
+              data: {
+                workspaceId: input.workspaceId,
+                type: ArtifactType.FLASHCARD_SET,
+                title: files.length === 1 ? `Flashcards - ${primaryFile.name}` : `Flashcards - ${files.length} files`,
+                createdById: ctx.session.user.id,
+              },
+            });
 
-            let createdCards = 0;
-            for (let i = 0; i < Math.min(flashcardData.length, 10); i++) {
-              const card = flashcardData[i];
-              const front = card.term || card.front || card.question || card.prompt || `Question ${i + 1}`;
-              const back = card.definition || card.back || card.answer || card.solution || `Answer ${i + 1}`;
+            // Parse JSON flashcard content
+            try {
+              const flashcardData: any = content;
 
-              await ctx.db.flashcard.create({
-                data: {
-                  artifactId: artifact.id,
-                  front: front,
-                  back: back,
-                  order: i,
-                  tags: ['ai-generated', 'medium'],
-                },
-              });
-              createdCards++;
-            }
+              for (let i = 0; i < Math.min(flashcardData.length, 10); i++) {
+                const card = flashcardData[i];
+                const front = card.term || card.front || card.question || card.prompt || `Question ${i + 1}`;
+                const back = card.definition || card.back || card.answer || card.solution || `Answer ${i + 1}`;
 
-          } catch (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, 10); i++) {
-              const line = lines[i];
-              if (line.includes(' - ')) {
-                const [front, back] = line.split(' - ');
                 await ctx.db.flashcard.create({
                   data: {
                     artifactId: artifact.id,
-                    front: front.trim(),
-                    back: back.trim(),
+                    front: front,
+                    back: back,
                     order: i,
                     tags: ['ai-generated', 'medium'],
                   },
                 });
               }
+            } catch (parseError) {
+              // Fallback to text parsing if JSON fails
+              const lines = content.split('\n').filter((line: string) => line.trim());
+              for (let i = 0; i < Math.min(lines.length, 10); i++) {
+                const line = lines[i];
+                if (line.includes(' - ')) {
+                  const [front, back] = line.split(' - ');
+                  await ctx.db.flashcard.create({
+                    data: {
+                      artifactId: artifact.id,
+                      front: front.trim(),
+                      back: back.trim(),
+                      order: i,
+                      tags: ['ai-generated', 'medium'],
+                    },
+                  });
+                }
+              }
             }
-          }
 
-          results.artifacts.flashcards = artifact;
+            results.artifacts.flashcards = artifact;
+          } catch (fcError) {
+            logger.error('Flashcard generation failed after retries:', fcError);
+            await PusherService.emitError(input.workspaceId, 'Flashcard generation failed. Please try regenerating later.', 'flashcards');
+          }
         }
 
         await ctx.db.workspace.update({
@@ -844,34 +869,12 @@ export const workspace = router({
         });
 
         await updateAnalysisProgress(ctx.db, input.workspaceId, {
-          status: 'completed',
-          filename: primaryFile.name,
-          fileType,
-          startedAt: new Date().toISOString(),
+          ...buildProgress('completed', primaryFile.name, fileType, 'flashcards', 'completed', genConfig),
           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',
-            },
-          }
-
         });
         return results;
       } catch (error) {
-        console.error('❌ Failed to update analysis progress:', error);
+        logger.error('Failed to update analysis progress:', error);
         await ctx.db.workspace.update({
           where: { id: input.workspaceId },
           data: { fileBeingAnalyzed: false },

package/src/server.ts

@@ -18,15 +18,17 @@ async function main() {
   const app = express();
 
   // Middlewares
-  app.use(helmet());
   app.use(cors({
-    origin: process.env.FRONTEND_URL || "http://localhost:3000",
+    origin: ['https://www.scribe.study', 'https://scribe.study', 'http://localhost:3000'],
     credentials: true, // allow cookies
     methods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
     allowedHeaders: ['Content-Type', 'Authorization', 'Cookie', 'Set-Cookie'],
     exposedHeaders: ['Set-Cookie'],
+    preflightContinue: false, // Important: stop further handling of OPTIONS
   }));
 
+  app.use(helmet());
+
   // Custom morgan middleware with logger integration
   app.use(morgan('combined', {
     stream: {