@goscribe/server 1.3.3 → 1.5.0

package/src/routers/flashcards.ts

@@ -1,448 +1,152 @@
 import { z } from 'zod';
-import { TRPCError } from '@trpc/server';
-import { router, authedProcedure, verifiedProcedure,limitedProcedure  } from '../trpc.js';
-import createInferenceService from '../lib/inference.js';
-import { aiSessionService } from '../lib/ai-session.js';
-import PusherService from '../lib/pusher.js';
-import { notifyArtifactFailed, notifyArtifactReady } from '../lib/notification-service.js';
-import { createFlashcardProgressService } from '../services/flashcard-progress.service.js';
-import { ArtifactType } from '../lib/constants.js';
-import { workspaceAccessFilter } from '../lib/workspace-access.js';
-import inference from '../lib/inference.js';
-
-const typedAnswerGradeSchema = z.object({
-  isCorrect: z.boolean(),
-  confidence: z.number().min(0).max(1),
-  reason: z.string().min(1),
-  matchedAnswer: z.string().nullable(),
-});
-
-function normalizeAcceptedAnswers(answers?: string[]): string[] {
-  if (!answers || answers.length === 0) return [];
-
-  const seen = new Set<string>();
-  const normalized: string[] = [];
-
-  for (const answer of answers) {
-    const trimmed = answer.trim();
-    if (!trimmed) continue;
-    const key = trimmed.toLowerCase();
-    if (seen.has(key)) continue;
-    seen.add(key);
-    normalized.push(trimmed);
-  }
-
-  return normalized;
-}
-
-function extractFirstJsonObject(text: string): string | null {
-  const start = text.indexOf('{');
-  const end = text.lastIndexOf('}');
-  if (start === -1 || end === -1 || end <= start) return null;
-  return text.slice(start, end + 1);
-}
+import { router, authedProcedure, limitedProcedure } from '../trpc.js';
+import { FlashcardService } from '../services/content/flashcard.service.js';
+import { createFlashcardProgressService } from '../services/content/flashcard-progress.service.js';
 
 export const flashcards = router({
   listSets: authedProcedure
     .input(z.object({ workspaceId: z.string() }))
-    .query(async ({ ctx, input }) => {
-      const workspace = await ctx.db.workspace.findFirst({
-        where: { id: input.workspaceId, ownerId: ctx.session.user.id },
-      });
-      if (!workspace) throw new TRPCError({ code: 'NOT_FOUND' });
-      return ctx.db.artifact.findMany({
-        where: { workspaceId: input.workspaceId, type: ArtifactType.FLASHCARD_SET },
-        include: {
-          versions: {
-            orderBy: { version: 'desc' },
-            take: 1, // Get only the latest version
-          },
-        },
-        orderBy: { updatedAt: 'desc' },
-      });
-    }),
+    .query(({ ctx, input }) =>
+      new FlashcardService(ctx.db).listSets(ctx.session.user.id, input.workspaceId),
+    ),
+
   listCards: authedProcedure
     .input(z.object({ workspaceId: z.string() }))
-    .query(async ({ ctx, input }) => {
-      const set = await ctx.db.artifact.findFirst({
-        where: { workspaceId: input.workspaceId, type: ArtifactType.FLASHCARD_SET, workspace: workspaceAccessFilter(ctx.session.user.id) },
-        include: {
-          flashcards: {
-            include: {
-              progress: {
-                where: {
-                  userId: ctx.session.user.id,
-                },
-              },
-            }
-          },
+    .query(({ ctx, input }) =>
+      new FlashcardService(ctx.db).listCards(ctx.session.user.id, input.workspaceId),
+    ),
 
-        },
-        orderBy: { createdAt: 'desc' },
-      });
-      if (!set) throw new TRPCError({ code: 'NOT_FOUND' });
-      return set.flashcards;
-    }),
   isGenerating: authedProcedure
     .input(z.object({ workspaceId: z.string() }))
-    .query(async ({ ctx, input }) => {
-      const artifact = await ctx.db.artifact.findFirst({
-        where: { workspaceId: input.workspaceId, type: ArtifactType.FLASHCARD_SET, workspace: workspaceAccessFilter(ctx.session.user.id) },
-        orderBy: { createdAt: 'desc' },
-      });
-      return artifact?.generating;
-    }),
+    .query(({ ctx, input }) =>
+      new FlashcardService(ctx.db).isGenerating(ctx.session.user.id, input.workspaceId),
+    ),
+
   createCard: limitedProcedure
-    .input(z.object({
-      workspaceId: z.string(),
-      front: z.string().min(1),
-      back: z.string().min(1),
-      acceptedAnswers: z.array(z.string()).optional(),
-      tags: z.array(z.string()).optional(),
-      order: z.number().int().optional(),
-    }))
-    .mutation(async ({ ctx, input }) => {
-      const set = await ctx.db.artifact.findFirst({
-        where: {
-          type: ArtifactType.FLASHCARD_SET, workspace: {
-            id: input.workspaceId,
-          }
-        },
-        include: {
-          flashcards: true,
-        },
-        orderBy: { updatedAt: 'desc' },
-      });
-      if (!set) throw new TRPCError({ code: 'NOT_FOUND' });
-      return ctx.db.flashcard.create({
-        data: {
-          artifactId: set.id,
-          front: input.front,
-          back: input.back,
-          acceptedAnswers: normalizeAcceptedAnswers(input.acceptedAnswers),
-          tags: input.tags ?? [],
-          order: input.order ?? 0,
-        },
-      });
-    }),
+    .input(
+      z.object({
+        workspaceId: z.string(),
+        front: z.string().min(1),
+        back: z.string().min(1),
+        acceptedAnswers: z.array(z.string()).optional(),
+        tags: z.array(z.string()).optional(),
+        order: z.number().int().optional(),
+      }),
+    )
+    .mutation(({ ctx, input }) =>
+      new FlashcardService(ctx.db).createCard(ctx.session.user.id, input),
+    ),
 
   updateCard: authedProcedure
-    .input(z.object({
-      cardId: z.string(),
-      front: z.string().optional(),
-      back: z.string().optional(),
-      acceptedAnswers: z.array(z.string()).optional(),
-      tags: z.array(z.string()).optional(),
-      order: z.number().int().optional(),
-    }))
-    .mutation(async ({ ctx, input }) => {
-      const card = await ctx.db.flashcard.findFirst({
-        where: { id: input.cardId, artifact: { type: ArtifactType.FLASHCARD_SET, workspace: workspaceAccessFilter(ctx.session.user.id) } },
-      });
-      if (!card) throw new TRPCError({ code: 'NOT_FOUND' });
-      return ctx.db.flashcard.update({
-        where: { id: input.cardId },
-        data: {
-          front: input.front ?? card.front,
-          back: input.back ?? card.back,
-          acceptedAnswers: input.acceptedAnswers ? normalizeAcceptedAnswers(input.acceptedAnswers) : card.acceptedAnswers,
-          tags: input.tags ?? card.tags,
-          order: input.order ?? card.order,
-        },
-      });
-    }),
+    .input(
+      z.object({
+        cardId: z.string(),
+        front: z.string().optional(),
+        back: z.string().optional(),
+        acceptedAnswers: z.array(z.string()).optional(),
+        tags: z.array(z.string()).optional(),
+        order: z.number().int().optional(),
+      }),
+    )
+    .mutation(({ ctx, input }) =>
+      new FlashcardService(ctx.db).updateCard(ctx.session.user.id, input),
+    ),
 
   gradeTypedAnswer: authedProcedure
-    .input(z.object({
-      flashcardId: z.string().cuid(),
-      userAnswer: z.string().min(1),
-    }))
-    .mutation(async ({ ctx, input }) => {
-      const flashcard = await ctx.db.flashcard.findFirst({
-        where: {
-          id: input.flashcardId,
-          artifact: {
-            type: ArtifactType.FLASHCARD_SET,
-            workspace: workspaceAccessFilter(ctx.session.user.id),
-          },
-        },
-        select: {
-          id: true,
-          front: true,
-          back: true,
-          acceptedAnswers: true,
-        },
-      });
-
-      if (!flashcard) {
-        throw new TRPCError({ code: 'NOT_FOUND', message: 'Flashcard not found' });
-      }
-
-      const acceptedAnswers = [
-        flashcard.back,
-        ...normalizeAcceptedAnswers(flashcard.acceptedAnswers),
-      ];
-
-      const prompt = [
-        'Grade whether the student answer is semantically correct for the flashcard.',
-        '',
-        'Return ONLY valid JSON with this exact shape:',
-        '{"isCorrect": boolean, "confidence": number, "reason": string, "matchedAnswer": string | null}',
-        '',
-        'Rules:',
-        '- Accept synonyms, short paraphrases, and equivalent wording.',
-        '- Reject answers that are contradictory, unrelated, or materially incomplete.',
-        '- confidence must be from 0 to 1.',
-        '- reason must be under 160 characters.',
-        '- matchedAnswer must be the matched canonical/alias answer, or null if incorrect.',
-        '',
-        `Question: ${flashcard.front}`,
-        `Canonical answer: ${flashcard.back}`,
-        `Accepted aliases: ${JSON.stringify(acceptedAnswers)}`,
-        `Student answer: ${input.userAnswer}`,
-      ].join('\n');
-
-      try {
-        const response = await inference([{ role: 'user', content: prompt }]);
-        const content = response.choices?.[0]?.message?.content ?? '';
-        const jsonCandidate = extractFirstJsonObject(content);
-
-        if (!jsonCandidate) {
-          throw new Error('No JSON object found in grading response');
-        }
-
-        const parsed = JSON.parse(jsonCandidate);
-        return typedAnswerGradeSchema.parse(parsed);
-      } catch (error) {
-        throw new TRPCError({
-          code: 'INTERNAL_SERVER_ERROR',
-          message: 'Failed to grade typed answer. Please retry.',
-          cause: error,
-        });
-      }
-    }),
+    .input(
+      z.object({
+        flashcardId: z.string().cuid(),
+        userAnswer: z.string().min(1),
+      }),
+    )
+    .mutation(({ ctx, input }) =>
+      new FlashcardService(ctx.db).gradeTypedAnswer(ctx.session.user.id, input),
+    ),
 
   deleteCard: authedProcedure
     .input(z.object({ cardId: z.string() }))
-    .mutation(async ({ ctx, input }) => {
-      const card = await ctx.db.flashcard.findFirst({
-        where: { id: input.cardId, artifact: { workspace: workspaceAccessFilter(ctx.session.user.id) } },
-      });
-      if (!card) throw new TRPCError({ code: 'NOT_FOUND' });
-      await ctx.db.flashcard.delete({ where: { id: input.cardId } });
-      return true;
-    }),
+    .mutation(({ ctx, input }) =>
+      new FlashcardService(ctx.db).deleteCard(ctx.session.user.id, input.cardId),
+    ),
 
   deleteSet: authedProcedure
     .input(z.object({ setId: z.string().uuid() }))
-    .mutation(async ({ ctx, input }) => {
-      const deleted = await ctx.db.artifact.deleteMany({
-        where: { id: input.setId, type: ArtifactType.FLASHCARD_SET, workspace: workspaceAccessFilter(ctx.session.user.id) },
-      });
-      if (deleted.count === 0) throw new TRPCError({ code: 'NOT_FOUND' });
-      return true;
-    }),
+    .mutation(({ ctx, input }) =>
+      new FlashcardService(ctx.db).deleteSet(ctx.session.user.id, input.setId),
+    ),
 
-  // Generate a flashcard set from a user prompt
   generateFromPrompt: limitedProcedure
-    .input(z.object({
-      workspaceId: z.string(),
-      prompt: z.string().min(1),
-      numCards: z.number().int().min(1).max(50).default(10),
-      difficulty: z.enum(['easy', 'medium', 'hard']).default('medium'),
-      title: z.string().optional(),
-      tags: z.array(z.string()).optional(),
-    }))
-    .mutation(async ({ ctx, input }) => {
-      // Verify workspace ownership
-      const workspace = await ctx.db.workspace.findFirst({
-        where: { id: input.workspaceId, ownerId: ctx.session.user.id },
-      });
-      if (!workspace) throw new TRPCError({ code: 'NOT_FOUND' });
-
-      const flashcardCurrent = await ctx.db.artifact.findFirst({
-        where: {
-          workspaceId: input.workspaceId,
-          type: ArtifactType.FLASHCARD_SET,
-        },
-        select: {
-          id: true,
-          flashcards: true,
-        },
-        orderBy: {
-          updatedAt: 'desc',
-        },
-      });
-
-      try {
-        await PusherService.emitTaskComplete(input.workspaceId, 'flash_card_info', { status: 'generating', numCards: input.numCards, difficulty: input.difficulty });
-
-        const artifact = await ctx.db.artifact.create({
-          data: {
-            workspaceId: input.workspaceId,
-            type: ArtifactType.FLASHCARD_SET,
-            title: input.title || `Flashcards - ${new Date().toLocaleString()}`,
-            createdById: ctx.session.user.id,
-            generating: true,
-            generatingMetadata: { quantity: input.numCards, difficulty: input.difficulty.toLowerCase() },
-            flashcards: {
-              create: flashcardCurrent?.flashcards.map((card) => ({
-                front: card.front,
-                back: card.back,
-              })),
-            },
-          },
-        });
-
-        const currentCards = flashcardCurrent?.flashcards.length || 0;
-        const newCards = input.numCards - currentCards;
+    .input(
+      z.object({
+        workspaceId: z.string(),
+        prompt: z.string().min(1),
+        numCards: z.number().int().min(1).max(50).default(10),
+        difficulty: z.enum(['easy', 'medium', 'hard']).default('medium'),
+        title: z.string().optional(),
+        tags: z.array(z.string()).optional(),
+      }),
+    )
+    .mutation(({ ctx, input }) =>
+      new FlashcardService(ctx.db).generateFromPrompt(ctx.session.user.id, input),
+    ),
 
-
-        // Generate
-        const content = await aiSessionService.generateFlashcardQuestions(input.workspaceId, ctx.session.user.id, input.numCards, input.difficulty, input.prompt);
-
-        let createdCards = 0;
-        try {
-          const parsed = typeof content === 'string' ? JSON.parse(content) : content;
-          const flashcardData = Array.isArray(parsed) ? parsed : (parsed.flashcards || []);
-
-          for (let i = 0; i < Math.min(flashcardData.length, input.numCards); 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}`;
-            await ctx.db.flashcard.create({
-              data: {
-                artifactId: artifact.id,
-                front,
-                back,
-                order: i,
-                tags: input.tags ?? ['ai-generated', input.difficulty],
-              },
-            });
-            createdCards++;
-          }
-        } catch (error) {
-          console.error("Failed to parse flashcard JSON or create cards:", error);
-          // 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, input.numCards); 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: input.tags ?? ['ai-generated', input.difficulty],
-                },
-              });
-              createdCards++;
-            }
-          }
-        }
-
-        // Pusher complete
-        await PusherService.emitFlashcardComplete(input.workspaceId, artifact);
-
-        // Set generating to false on the artifact
-        await ctx.db.artifact.update({ where: { id: artifact.id }, data: { generating: false } });
-
-        await notifyArtifactReady(ctx.db, {
-          userId: ctx.session.user.id,
-          workspaceId: input.workspaceId,
-          artifactId: artifact.id,
-          artifactType: ArtifactType.FLASHCARD_SET,
-          title: artifact.title,
-        }).catch(() => {});
-
-        return { artifact, createdCards };
-
-      } catch (error) {
-        if (flashcardCurrent?.id) {
-          await ctx.db.artifact.update({ where: { id: flashcardCurrent.id }, data: { generating: false } });
-        }
-        await PusherService.emitError(input.workspaceId, `Failed to generate flashcards: ${error}`, 'flash_card_generation');
-        await notifyArtifactFailed(ctx.db, {
-          userId: ctx.session.user.id,
-          workspaceId: input.workspaceId,
-          artifactType: ArtifactType.FLASHCARD_SET,
-          message:
-            error instanceof Error
-              ? error.message
-              : 'Flashcard generation failed.',
-        }).catch(() => {});
-        throw error;
-      }
-    }),
-
-  // Record study attempt
   recordStudyAttempt: authedProcedure
-    .input(z.object({
-      flashcardId: z.string().cuid(),
-      isCorrect: z.boolean(),
-      confidence: z.enum(['easy', 'medium', 'hard']).optional(),
-      timeSpentMs: z.number().optional(),
-    }))
-    .mutation(async ({ ctx, input }) => {
-      const service = createFlashcardProgressService(ctx.db);
-      return service.recordStudyAttempt({
+    .input(
+      z.object({
+        flashcardId: z.string().cuid(),
+        isCorrect: z.boolean(),
+        confidence: z.enum(['easy', 'medium', 'hard']).optional(),
+        timeSpentMs: z.number().optional(),
+      }),
+    )
+    .mutation(({ ctx, input }) =>
+      createFlashcardProgressService(ctx.db).recordStudyAttempt({
         userId: ctx.userId,
         ...input,
-      });
-    }),
+      }),
+    ),
 
-  // Get progress for a flashcard set
   getSetProgress: authedProcedure
     .input(z.object({ artifactId: z.string().cuid() }))
-    .query(async ({ ctx, input }) => {
-      const service = createFlashcardProgressService(ctx.db);
-      return service.getSetProgress(ctx.userId, input.artifactId);
-    }),
+    .query(({ ctx, input }) =>
+      createFlashcardProgressService(ctx.db).getSetProgress(ctx.userId, input.artifactId),
+    ),
 
-  // Get flashcards due for review
   getDueFlashcards: authedProcedure
     .input(z.object({ workspaceId: z.string() }))
-    .query(async ({ ctx, input }) => {
-      const service = createFlashcardProgressService(ctx.db);
+    .query(({ ctx, input }) =>
+      createFlashcardProgressService(ctx.db).getDueFlashcards(ctx.userId, input.workspaceId),
+    ),
 
-      return service.getDueFlashcards(ctx.userId, input.workspaceId);
-    }),
-
-  // Get statistics for a flashcard set
   getSetStatistics: authedProcedure
     .input(z.object({ artifactId: z.string().cuid() }))
-    .query(async ({ ctx, input }) => {
-      const service = createFlashcardProgressService(ctx.db);
-      return service.getSetStatistics(ctx.userId, input.artifactId);
-    }),
+    .query(({ ctx, input }) =>
+      createFlashcardProgressService(ctx.db).getSetStatistics(ctx.userId, input.artifactId),
+    ),
 
-  // Reset progress for a flashcard
   resetProgress: authedProcedure
     .input(z.object({ flashcardId: z.string().cuid() }))
-    .mutation(async ({ ctx, input }) => {
-      const service = createFlashcardProgressService(ctx.db);
-      return service.resetProgress(ctx.userId, input.flashcardId);
-    }),
+    .mutation(({ ctx, input }) =>
+      createFlashcardProgressService(ctx.db).resetProgress(ctx.userId, input.flashcardId),
+    ),
 
-  // Bulk record study session
   recordStudySession: authedProcedure
-    .input(z.object({
-      attempts: z.array(z.object({
-        flashcardId: z.string().cuid(),
-        isCorrect: z.boolean(),
-        confidence: z.enum(['easy', 'medium', 'hard']).optional(),
-        timeSpentMs: z.number().optional(),
-      })),
-    }))
-    .mutation(async ({ ctx, input }) => {
-      const service = createFlashcardProgressService(ctx.db);
-      return service.recordStudySession({
+    .input(
+      z.object({
+        attempts: z.array(
+          z.object({
+            flashcardId: z.string().cuid(),
+            isCorrect: z.boolean(),
+            confidence: z.enum(['easy', 'medium', 'hard']).optional(),
+            timeSpentMs: z.number().optional(),
+          }),
+        ),
+      }),
+    )
+    .mutation(({ ctx, input }) =>
+      createFlashcardProgressService(ctx.db).recordStudySession({
         userId: ctx.userId,
         ...input,
-      });
-    }),
+      }),
+    ),
 });
-
-