@goscribe/server 1.1.2 → 1.1.3

package/dist/services/flashcard-progress.service.d.ts

@@ -94,7 +94,7 @@ export declare class FlashcardProgressService {
     /**
      * Get flashcards due for review, non-studied flashcards, and flashcards with low mastery
      */
-    getDueFlashcards(userId: string, workspaceId: string): Promise<({
+    getDueFlashcards(userId: string, workspaceId: string): Promise<(({
         artifact: {
             id: string;
             createdAt: Date;
@@ -119,6 +119,30 @@ export declare class FlashcardProgressService {
         front: string;
         back: string;
         tags: string[];
+    }) | {
+        artifact: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            title: string;
+            description: string | null;
+            workspaceId: string;
+            type: import("@prisma/client").$Enums.ArtifactType;
+            isArchived: boolean;
+            generating: boolean;
+            generatingMetadata: import("@prisma/client/runtime/library").JsonValue | null;
+            difficulty: import("@prisma/client").$Enums.Difficulty | null;
+            estimatedTime: string | null;
+            imageObjectKey: string | null;
+            createdById: string | null;
+        };
+        id: string;
+        createdAt: Date;
+        artifactId: string;
+        order: number;
+        front: string;
+        back: string;
+        tags: string[];
     })[]>;
     /**
      * Get user statistics for a flashcard set

package/dist/services/flashcard-progress.service.js

@@ -226,12 +226,23 @@ export class FlashcardProgressService {
     async getDueFlashcards(userId, workspaceId) {
         const now = new Date();
         const LOW_MASTERY_THRESHOLD = 50; // Consider mastery < 50 as low
-        // Get all flashcards in the workspace
+        // Get the latest artifact in the workspace
+        const latestArtifact = await this.db.artifact.findFirst({
+            where: {
+                workspaceId,
+                type: 'FLASHCARD_SET',
+            },
+            orderBy: {
+                updatedAt: 'desc',
+            },
+        });
+        if (!latestArtifact) {
+            return [];
+        }
+        // Get all flashcards from the latest artifact
         const allFlashcards = await this.db.flashcard.findMany({
             where: {
-                artifact: {
-                    workspaceId,
-                },
+                artifactId: latestArtifact.id,
             },
             include: {
                 artifact: true,
@@ -242,6 +253,7 @@ export class FlashcardProgressService {
                 },
             },
         });
+        console.log('allFlashcards', allFlashcards.length);
         const TAKE_NUMBER = (allFlashcards.length > 10) ? 10 : allFlashcards.length;
         // Get progress records for flashcards that are due or have low mastery
         const progressRecords = await this.db.flashcardProgress.findMany({
@@ -265,9 +277,7 @@ export class FlashcardProgressService {
                     }
                 ],
                 flashcard: {
-                    artifact: {
-                        workspaceId,
-                    },
+                    artifactId: latestArtifact.id,
                 },
             },
             include: {
@@ -279,6 +289,38 @@ export class FlashcardProgressService {
             },
             take: TAKE_NUMBER,
         });
+        console.log('TAKE_NUMBER', TAKE_NUMBER);
+        console.log('TAKE_NUMBER - progressRecords.length', TAKE_NUMBER - progressRecords.length);
+        console.log('progressRecords', progressRecords.map((progress) => progress.flashcard.id));
+        // Get flashcard IDs that already have progress records
+        const flashcardIdsWithProgress = new Set(progressRecords.map((progress) => progress.flashcard.id));
+        // Find flashcards without progress records (non-studied) to pad the results
+        const nonStudiedFlashcards = allFlashcards
+            .filter((flashcard) => !flashcardIdsWithProgress.has(flashcard.id))
+            .slice(0, TAKE_NUMBER - progressRecords.length);
+        // Create progress-like structures for non-studied flashcards
+        const progressRecordsPadding = nonStudiedFlashcards.map((flashcard) => {
+            const { progress, ...flashcardWithoutProgress } = flashcard;
+            return {
+                id: `temp-${flashcard.id}`,
+                userId,
+                flashcardId: flashcard.id,
+                timesStudied: 0,
+                timesCorrect: 0,
+                timesIncorrect: 0,
+                timesIncorrectConsecutive: 0,
+                easeFactor: 2.5,
+                interval: 0,
+                repetitions: 0,
+                masteryLevel: 0,
+                lastStudiedAt: null,
+                nextReviewAt: null,
+                flashcard: flashcardWithoutProgress,
+            };
+        });
+        console.log('progressRecordsPadding', progressRecordsPadding.length);
+        console.log('progressRecords', progressRecords.length);
+        const selectedCards = [...progressRecords, ...progressRecordsPadding];
         // Build result array: include progress records and non-studied flashcards
         const results = [];
         // Add flashcards with progress (due or low mastery)
@@ -286,30 +328,27 @@ export class FlashcardProgressService {
             results.push(progress);
         }
         // Sort by priority: due first (by nextReviewAt), then low mastery, then non-studied
-        results.sort((a, b) => {
-            // Due flashcards first (nextReviewAt <= now)
-            const aIsDue = a.nextReviewAt && a.nextReviewAt <= now;
-            const bIsDue = b.nextReviewAt && b.nextReviewAt <= now;
-            if (aIsDue && !bIsDue)
-                return -1;
-            if (!aIsDue && bIsDue)
-                return 1;
-            // Among due flashcards, sort by nextReviewAt
-            if (aIsDue && bIsDue && a.nextReviewAt && b.nextReviewAt) {
-                return a.nextReviewAt.getTime() - b.nextReviewAt.getTime();
-            }
-            // Then low mastery (lower mastery first)
-            if (a.masteryLevel !== b.masteryLevel) {
-                return a.masteryLevel - b.masteryLevel;
-            }
-            // Finally, non-studied (timesStudied === 0)
-            if (a.timesStudied === 0 && b.timesStudied !== 0)
-                return -1;
-            if (a.timesStudied !== 0 && b.timesStudied === 0)
-                return 1;
-            return 0;
-        });
-        return results.map((progress) => progress.flashcard);
+        // @todo: make an actual algorithm. research
+        // results.sort((a, b) => {
+        //   // Due flashcards first (nextReviewAt <= now)
+        //   const aIsDue = a.nextReviewAt && a.nextReviewAt <= now;
+        //   const bIsDue = b.nextReviewAt && b.nextReviewAt <= now;
+        //   // if (aIsDue && !bIsDue) return -1;
+        //   // if (!aIsDue && bIsDue) return 1;
+        //   // Among due flashcards, sort by nextReviewAt
+        //   if (aIsDue && bIsDue && a.nextReviewAt && b.nextReviewAt) {
+        //     return a.nextReviewAt.getTime() - b.nextReviewAt.getTime();
+        //   }
+        //   // Then low mastery (lower mastery first)
+        //   if (a.masteryLevel !== b.masteryLevel) {
+        //     return a.masteryLevel - b.masteryLevel;
+        //   }
+        //   // Finally, non-studied (timesStudied === 0)
+        //   if (a.timesStudied === 0 && b.timesStudied !== 0) return -1;
+        //   if (a.timesStudied !== 0 && b.timesStudied === 0) return 1;
+        //   return 0;
+        // });
+        return selectedCards.map((progress) => progress.flashcard);
     }
     /**
      * Get user statistics for a flashcard set

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goscribe/server",
-  "version": "1.1.2",
+  "version": "1.1.3",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -22,7 +22,7 @@
   "dependencies": {
     "@auth/express": "^0.11.0",
     "@auth/prisma-adapter": "^2.10.0",
-    "@goscribe/server": "^1.0.8",
+    "@goscribe/server": "^1.1.2",
     "@prisma/client": "^6.14.0",
     "@supabase/supabase-js": "^2.76.1",
     "@trpc/server": "^11.5.0",

package/prisma/schema.prisma

@@ -63,11 +63,21 @@ model User {
   // Invitations
   sentInvitations WorkspaceInvitation[] @relation("UserInvitations")
 
+  notifications Notification[]
   chats         Chat[]
   createdAt     DateTime  @default(now())
-  updatedAt     DateTime  @updatedAt
+  updatedAt     DateTime  @updatedAt  
 }
 
+model Notification {
+  id String @id @default(cuid())
+  userId String
+  user User @relation(fields: [userId], references: [id], onDelete: Cascade)
+  content String
+  read Boolean @default(false)
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+}
 model Session {
   id String @id @default(cuid())
   userId String
@@ -193,7 +203,7 @@ model FileAsset {
   objectKey String?
   url       String?  // optional if serving via signed GET per-view
   checksum  String?  // optional server-side integrity
-  aiTranscription String?
+  aiTranscription Json? @default("{}")
 
   meta      Json?    // arbitrary metadata
 

package/src/lib/ai-session.ts

@@ -136,11 +136,6 @@ export class AISessionService {
     fileType: 'image' | 'pdf',
     maxPages?: number
   ): Promise<ProcessFileResult> {
-    const session = this.sessions.get(sessionId);
-    if (!session) {
-      throw new TRPCError({ code: 'NOT_FOUND', message: 'AI session not found' });
-    }
-
     await new Promise(resolve => setTimeout(resolve, IMITATE_WAIT_TIME_MS));
     
     // Mock mode - return fake processing result
@@ -168,6 +163,8 @@ export class AISessionService {
       formData.append('maxPages', maxPages.toString());
     }
 
+    console.log('formData', formData);
+
     // Retry logic for file processing
     const maxRetries = 3;
     let lastError: Error | null = null;
@@ -183,7 +180,7 @@ export class AISessionService {
         const response = await fetch(AI_SERVICE_URL, {
           method: 'POST',
           body: formData,
-          signal: controller.signal,
+          // signal: controller.signal,
         });
 
         clearTimeout(timeoutId);
@@ -201,11 +198,6 @@ export class AISessionService {
           throw new Error(result.error || 'File processing failed');
         }
 
-        // Update session
-        session.files.push(fileUrl);
-        session.updatedAt = new Date();
-        this.sessions.set(sessionId, session);
-
         return result as ProcessFileResult;
         
       } catch (error) {
@@ -235,11 +227,6 @@ export class AISessionService {
 
   // Generate study guide
   async generateStudyGuide(sessionId: string, user: string): Promise<string> {
-    const session = this.sessions.get(sessionId);
-    if (!session) {
-      throw new TRPCError({ code: 'NOT_FOUND', message: 'AI session not found' });
-    }
-
     await new Promise(resolve => setTimeout(resolve, IMITATE_WAIT_TIME_MS));
     // Mock mode - return fake study guide
     if (MOCK_MODE) {
@@ -291,11 +278,6 @@ This mock study guide demonstrates the structure and format that would be genera
 
   // Generate flashcard questions
   async generateFlashcardQuestions(sessionId: string, user: string, numQuestions: number, difficulty: 'easy' | 'medium' | 'hard'): Promise<string> {
-    // const session = this.sessions.get(sessionId);
-    // if (!session) {
-    //   throw new TRPCError({ code: 'NOT_FOUND', message: 'AI session not found' });
-    // }
-
     await new Promise(resolve => setTimeout(resolve, IMITATE_WAIT_TIME_MS));
     // Mock mode - return fake flashcard questions
     if (MOCK_MODE) {

package/src/routers/flashcards.ts

@@ -177,22 +177,6 @@ export const flashcards = router({
 
       await PusherService.emitTaskComplete(input.workspaceId, 'flash_card_info', { status: 'generating', numCards: input.numCards, difficulty: input.difficulty });
 
-      const formattedPreviousCards = flashcardCurrent?.flashcards.map((card) => ({
-        front: card.front,
-        back: card.back,
-      }));
-
-
-      const partialPrompt = `
-      This is the users previous flashcards, avoid repeating any existing cards.
-      Please generate ${input.numCards} new cards,
-      Of a ${input.difficulty} difficulty,
-      Of a ${input.tags?.join(', ')} tag,
-      Of a ${input.title} title.
-      ${formattedPreviousCards?.map((card) => `Front: ${card.front}\nBack: ${card.back}`).join('\n')}
-
-      The user has also left you this prompt: ${input.prompt}
-      `
       const artifact = await ctx.db.artifact.create({
         data: {
           workspaceId: input.workspaceId,

package/src/routers/members.ts

@@ -230,7 +230,16 @@ export const members = router({
         invitedByName: invitation.workspace.owner.name || invitation.workspace.owner.email,
       };
     }),
-
+  getInvitations: authedProcedure
+    .input(z.object({
+      workspaceId: z.string(),
+    }))
+    .query(async ({ ctx, input }) => {
+      const invitations = await ctx.db.workspaceInvitation.findMany({
+        where: { workspaceId: input.workspaceId },
+      });
+      return invitations;
+    }),
   /**
    * Accept an invitation (public endpoint)
    */
@@ -277,8 +286,10 @@ export const members = router({
         });
       }
 
+      const user = await ctx.db.user.findFirst({ where: { id: ctx.session.user.id } });
+      if (!user || !user.email) throw new TRPCError({ code: 'NOT_FOUND' });
       // Check if the email matches the user's email
-      if (ctx.session.user.email !== invitation.email) {
+      if (user.email !== invitation.email) {
         throw new TRPCError({ 
           code: 'BAD_REQUEST', 
           message: 'This invitation was sent to a different email address'