@goscribe/server 1.3.3 → 1.5.0

package/dist/routers/flashcards.js

@@ -1,94 +1,17 @@
 import { z } from 'zod';
-import { TRPCError } from '@trpc/server';
 import { router, authedProcedure, limitedProcedure } from '../trpc.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) {
-    if (!answers || answers.length === 0)
-        return [];
-    const seen = new Set();
-    const normalized = [];
-    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) {
-    const start = text.indexOf('{');
-    const end = text.lastIndexOf('}');
-    if (start === -1 || end === -1 || end <= start)
-        return null;
-    return text.slice(start, end + 1);
-}
+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,
-                            },
-                        },
-                    }
-                },
-            },
-            orderBy: { createdAt: 'desc' },
-        });
-        if (!set)
-            throw new TRPCError({ code: 'NOT_FOUND' });
-        return set.flashcards;
-    }),
+        .query(({ ctx, input }) => new FlashcardService(ctx.db).listCards(ctx.session.user.id, input.workspaceId)),
     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(),
@@ -98,31 +21,7 @@ export const flashcards = router({
         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,
-            },
-        });
-    }),
+        .mutation(({ ctx, input }) => new FlashcardService(ctx.db).createCard(ctx.session.user.id, input)),
     updateCard: authedProcedure
         .input(z.object({
         cardId: z.string(),
@@ -132,109 +31,19 @@ export const flashcards = router({
         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,
-            },
-        });
-    }),
+        .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,
-            });
-        }
-    }),
+        .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;
-    }),
-    // Generate a flashcard set from a user prompt
+        .mutation(({ ctx, input }) => new FlashcardService(ctx.db).deleteSet(ctx.session.user.id, input.setId)),
     generateFromPrompt: limitedProcedure
         .input(z.object({
         workspaceId: z.string(),
@@ -244,119 +53,7 @@ export const flashcards = router({
         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;
-            // 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
+        .mutation(({ ctx, input }) => new FlashcardService(ctx.db).generateFromPrompt(ctx.session.user.id, input)),
     recordStudyAttempt: authedProcedure
         .input(z.object({
         flashcardId: z.string().cuid(),
@@ -364,42 +61,22 @@ export const flashcards = router({
         confidence: z.enum(['easy', 'medium', 'hard']).optional(),
         timeSpentMs: z.number().optional(),
     }))
-        .mutation(async ({ ctx, input }) => {
-        const service = createFlashcardProgressService(ctx.db);
-        return service.recordStudyAttempt({
-            userId: ctx.userId,
-            ...input,
-        });
-    }),
-    // Get progress for a flashcard set
+        .mutation(({ ctx, input }) => createFlashcardProgressService(ctx.db).recordStudyAttempt({
+        userId: ctx.userId,
+        ...input,
+    })),
     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);
-    }),
-    // Get flashcards due for review
+        .query(({ ctx, input }) => createFlashcardProgressService(ctx.db).getSetProgress(ctx.userId, input.artifactId)),
     getDueFlashcards: authedProcedure
         .input(z.object({ workspaceId: z.string() }))
-        .query(async ({ ctx, input }) => {
-        const service = createFlashcardProgressService(ctx.db);
-        return service.getDueFlashcards(ctx.userId, input.workspaceId);
-    }),
-    // Get statistics for a flashcard set
+        .query(({ ctx, input }) => createFlashcardProgressService(ctx.db).getDueFlashcards(ctx.userId, input.workspaceId)),
     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);
-    }),
-    // Reset progress for a flashcard
+        .query(({ ctx, input }) => createFlashcardProgressService(ctx.db).getSetStatistics(ctx.userId, input.artifactId)),
     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);
-    }),
-    // Bulk record study session
+        .mutation(({ ctx, input }) => createFlashcardProgressService(ctx.db).resetProgress(ctx.userId, input.flashcardId)),
     recordStudySession: authedProcedure
         .input(z.object({
         attempts: z.array(z.object({
@@ -409,11 +86,8 @@ export const flashcards = router({
             timeSpentMs: z.number().optional(),
         })),
     }))
-        .mutation(async ({ ctx, input }) => {
-        const service = createFlashcardProgressService(ctx.db);
-        return service.recordStudySession({
-            userId: ctx.userId,
-            ...input,
-        });
-    }),
+        .mutation(({ ctx, input }) => createFlashcardProgressService(ctx.db).recordStudySession({
+        userId: ctx.userId,
+        ...input,
+    })),
 });