@goscribe/server 1.3.3 → 1.5.0

package/dist/services/worksheet.service.js

@@ -0,0 +1,596 @@
+import { TRPCError } from '@trpc/server';
+import { BaseService } from './base.service.js';
+import { ArtifactType } from '../lib/constants.js';
+import { workspaceAccessWhere } from '../repositories/workspace.repository.js';
+import PusherService from '../lib/pusher.js';
+import { aiSessionService } from './ai-session.service.js';
+import { notifyArtifactFailed, notifyArtifactReady } from './notification.service.js';
+import { mergeWorksheetGenerationConfig, normalizeWorksheetProblemForDb, parsePresetConfig, } from './worksheet-generation.service.js';
+import { mergeWorksheetQuestionProgress } from './worksheet-content.service.js';
+const Difficulty = { EASY: 'EASY', MEDIUM: 'MEDIUM', HARD: 'HARD' };
+const QuestionType = {
+    MULTIPLE_CHOICE: 'MULTIPLE_CHOICE',
+    TEXT: 'TEXT',
+    NUMERIC: 'NUMERIC',
+    TRUE_FALSE: 'TRUE_FALSE',
+    MATCHING: 'MATCHING',
+    FILL_IN_THE_BLANK: 'FILL_IN_THE_BLANK',
+};
+export class WorksheetService extends BaseService {
+    constructor(db) {
+        super(db);
+    }
+    async list(userId, workspaceId) {
+        const worksheets = await this.db.artifact.findMany({
+            where: { workspaceId, type: ArtifactType.WORKSHEET },
+            include: {
+                versions: { orderBy: { version: 'desc' }, take: 1 },
+                questions: true,
+            },
+            orderBy: { updatedAt: 'desc' },
+        });
+        if (!worksheets)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        const allQuestionIds = worksheets.flatMap((w) => w.questions.map((q) => q.id));
+        if (allQuestionIds.length === 0)
+            return worksheets;
+        const progress = await this.db.worksheetQuestionProgress.findMany({
+            where: { userId, worksheetQuestionId: { in: allQuestionIds } },
+        });
+        return worksheets.map((w) => ({
+            ...w,
+            questions: mergeWorksheetQuestionProgress(w.questions, progress),
+        }));
+    }
+    async listPresets(userId, workspaceId) {
+        const ws = await this.db.workspace.findFirst({
+            where: { id: workspaceId, ...workspaceAccessWhere(userId) },
+        });
+        if (!ws)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        return this.db.worksheetPreset.findMany({
+            where: {
+                OR: [
+                    { isSystem: true },
+                    {
+                        userId,
+                        OR: [{ workspaceId }, { workspaceId: null }],
+                    },
+                ],
+            },
+            orderBy: [{ isSystem: 'desc' }, { name: 'asc' }],
+        });
+    }
+    async createPreset(userId, input) {
+        if (input.workspaceId) {
+            const ws = await this.db.workspace.findFirst({
+                where: { id: input.workspaceId, ...workspaceAccessWhere(userId) },
+            });
+            if (!ws)
+                throw new TRPCError({ code: 'NOT_FOUND' });
+        }
+        const config = parsePresetConfig(input.config);
+        return this.db.worksheetPreset.create({
+            data: {
+                userId,
+                workspaceId: input.workspaceId ?? null,
+                name: input.name,
+                isSystem: false,
+                config: config,
+            },
+        });
+    }
+    async updatePreset(userId, input) {
+        const existing = await this.db.worksheetPreset.findFirst({
+            where: { id: input.id, userId, isSystem: false },
+        });
+        if (!existing) {
+            throw new TRPCError({ code: 'NOT_FOUND', message: 'Preset not found or read-only' });
+        }
+        const data = {};
+        if (input.name !== undefined)
+            data.name = input.name;
+        if (input.config !== undefined)
+            data.config = parsePresetConfig(input.config);
+        return this.db.worksheetPreset.update({
+            where: { id: input.id },
+            data,
+        });
+    }
+    async deletePreset(userId, id) {
+        const existing = await this.db.worksheetPreset.findFirst({
+            where: { id, userId, isSystem: false },
+        });
+        if (!existing) {
+            throw new TRPCError({ code: 'NOT_FOUND', message: 'Preset not found or read-only' });
+        }
+        await this.db.worksheetPreset.delete({ where: { id } });
+        return true;
+    }
+    async create(userId, input) {
+        const workspace = await this.db.workspace.findFirst({
+            where: { id: input.workspaceId, ownerId: userId },
+        });
+        if (!workspace)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        const { problems } = input;
+        return this.db.artifact.create({
+            data: {
+                workspaceId: input.workspaceId,
+                type: ArtifactType.WORKSHEET,
+                title: input.title,
+                difficulty: input.difficulty,
+                estimatedTime: input.estimatedTime,
+                createdById: userId,
+                questions: problems
+                    ? {
+                        create: problems.map((problem, index) => ({
+                            prompt: problem.question,
+                            answer: problem.answer,
+                            type: problem.type,
+                            order: index,
+                            meta: problem.options ? { options: problem.options } : undefined,
+                        })),
+                    }
+                    : undefined,
+            },
+            include: { questions: true },
+        });
+    }
+    async get(userId, worksheetId) {
+        const worksheet = await this.db.artifact.findFirst({
+            where: {
+                id: worksheetId,
+                type: ArtifactType.WORKSHEET,
+                workspace: workspaceAccessWhere(userId),
+            },
+            include: { questions: true },
+            orderBy: { updatedAt: 'desc' },
+        });
+        if (!worksheet)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        const questionIds = worksheet.questions.map((q) => q.id);
+        if (questionIds.length === 0)
+            return worksheet;
+        const progress = await this.db.worksheetQuestionProgress.findMany({
+            where: { userId, worksheetQuestionId: { in: questionIds } },
+        });
+        return {
+            ...worksheet,
+            questions: mergeWorksheetQuestionProgress(worksheet.questions, progress),
+        };
+    }
+    async createWorksheetQuestion(userId, input) {
+        const worksheet = await this.db.artifact.findFirst({
+            where: {
+                id: input.worksheetId,
+                type: ArtifactType.WORKSHEET,
+                workspace: workspaceAccessWhere(userId),
+            },
+        });
+        if (!worksheet)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        return this.db.worksheetQuestion.create({
+            data: {
+                artifactId: input.worksheetId,
+                prompt: input.prompt,
+                answer: input.answer,
+                type: (input.type ?? QuestionType.TEXT),
+                difficulty: (input.difficulty ?? Difficulty.MEDIUM),
+                order: input.order ?? 0,
+                meta: input.meta,
+            },
+        });
+    }
+    async updateWorksheetQuestion(userId, input) {
+        const q = await this.db.worksheetQuestion.findFirst({
+            where: {
+                id: input.worksheetQuestionId,
+                artifact: {
+                    type: ArtifactType.WORKSHEET,
+                    workspace: workspaceAccessWhere(userId),
+                },
+            },
+        });
+        if (!q)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        return this.db.worksheetQuestion.update({
+            where: { id: input.worksheetQuestionId },
+            data: {
+                prompt: input.prompt ?? q.prompt,
+                answer: input.answer ?? q.answer,
+                type: (input.type ?? q.type),
+                difficulty: (input.difficulty ?? q.difficulty),
+                order: input.order ?? q.order,
+                meta: (input.meta ?? q.meta),
+            },
+        });
+    }
+    async deleteWorksheetQuestion(userId, worksheetQuestionId) {
+        const q = await this.db.worksheetQuestion.findFirst({
+            where: {
+                id: worksheetQuestionId,
+                artifact: { workspace: workspaceAccessWhere(userId) },
+            },
+        });
+        if (!q)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        await this.db.worksheetQuestion.delete({ where: { id: worksheetQuestionId } });
+        return true;
+    }
+    async updateProblemStatus(userId, input) {
+        const question = await this.db.worksheetQuestion.findFirst({
+            where: {
+                id: input.problemId,
+                artifact: {
+                    type: ArtifactType.WORKSHEET,
+                    workspace: workspaceAccessWhere(userId),
+                },
+            },
+        });
+        if (!question)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        return this.db.worksheetQuestionProgress.upsert({
+            where: {
+                worksheetQuestionId_userId: {
+                    worksheetQuestionId: input.problemId,
+                    userId,
+                },
+            },
+            create: {
+                worksheetQuestionId: input.problemId,
+                userId,
+                modified: input.completed,
+                userAnswer: input.answer,
+                correct: input.correct,
+                completedAt: input.completed ? new Date() : null,
+                attempts: 1,
+            },
+            update: {
+                modified: input.completed,
+                userAnswer: input.answer,
+                completedAt: input.completed ? new Date() : null,
+                attempts: { increment: 1 },
+                correct: input.correct,
+            },
+        });
+    }
+    async getProgress(userId, worksheetId) {
+        const worksheet = await this.db.artifact.findFirst({
+            where: {
+                id: worksheetId,
+                type: ArtifactType.WORKSHEET,
+                workspace: workspaceAccessWhere(userId),
+            },
+        });
+        if (!worksheet)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        const questions = await this.db.worksheetQuestion.findMany({
+            where: { artifactId: worksheetId },
+            select: { id: true },
+        });
+        const questionIds = questions.map((q) => q.id);
+        return this.db.worksheetQuestionProgress.findMany({
+            where: { userId, worksheetQuestionId: { in: questionIds } },
+        });
+    }
+    async update(userId, input) {
+        const { id, problems, ...updateData } = input;
+        const existingWorksheet = await this.db.artifact.findFirst({
+            where: {
+                id,
+                type: ArtifactType.WORKSHEET,
+                workspace: workspaceAccessWhere(userId),
+            },
+        });
+        if (!existingWorksheet)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        if (problems) {
+            await this.db.worksheetQuestion.deleteMany({ where: { artifactId: id } });
+            await this.db.worksheetQuestion.createMany({
+                data: problems.map((problem, index) => ({
+                    artifactId: id,
+                    prompt: problem.question,
+                    answer: problem.answer,
+                    type: problem.type,
+                    order: index,
+                    meta: problem.options ? { options: problem.options } : undefined,
+                })),
+            });
+        }
+        const processedUpdateData = {
+            ...updateData,
+            difficulty: updateData.difficulty,
+        };
+        return this.db.artifact.update({
+            where: { id },
+            data: processedUpdateData,
+            include: {
+                questions: { orderBy: { order: 'asc' } },
+            },
+        });
+    }
+    async delete(userId, id) {
+        const deleted = await this.db.artifact.deleteMany({
+            where: {
+                id,
+                type: ArtifactType.WORKSHEET,
+                workspace: workspaceAccessWhere(userId),
+            },
+        });
+        if (deleted.count === 0)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        return true;
+    }
+    async generateFromPrompt(userId, input) {
+        const workspace = await this.db.workspace.findFirst({
+            where: { id: input.workspaceId, ...workspaceAccessWhere(userId) },
+        });
+        if (!workspace)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        let presetRow = null;
+        if (input.presetId) {
+            presetRow = await this.db.worksheetPreset.findFirst({
+                where: {
+                    id: input.presetId,
+                    OR: [
+                        { isSystem: true },
+                        {
+                            userId,
+                            OR: [{ workspaceId: input.workspaceId }, { workspaceId: null }],
+                        },
+                    ],
+                },
+            });
+            if (!presetRow)
+                throw new TRPCError({ code: 'NOT_FOUND', message: 'Preset not found' });
+        }
+        const presetConfig = presetRow?.config ? parsePresetConfig(presetRow.config) : undefined;
+        const resolved = mergeWorksheetGenerationConfig(presetConfig, input.configOverride ?? undefined, {
+            numQuestions: input.numQuestions,
+            difficulty: input.difficulty,
+            mode: input.mode,
+        });
+        const difficultyUpper = resolved.difficulty.toUpperCase();
+        console.log('[DEBUG TRPC PAYLOAD] input =', input);
+        console.log('[DEBUG TRPC PAYLOAD] presetConfig =', presetConfig);
+        console.log('[DEBUG TRPC PAYLOAD] legacy merged legacy values:', {
+            numQuestions: input.numQuestions,
+            difficulty: input.difficulty,
+            mode: input.mode,
+        });
+        console.log('[DEBUG TRPC PAYLOAD] RESOLVED =', resolved);
+        const worksheetConfigSnapshot = {
+            mode: resolved.mode,
+            presetId: input.presetId ?? null,
+            presetName: presetRow?.name ?? null,
+            numQuestions: resolved.numQuestions,
+            difficulty: resolved.difficulty,
+            mcqRatio: resolved.mcqRatio ?? null,
+            questionTypes: resolved.questionTypes ?? null,
+        };
+        await PusherService.emitWorksheetGenerationStart(input.workspaceId);
+        const artifact = await this.db.artifact.create({
+            data: {
+                workspaceId: input.workspaceId,
+                type: ArtifactType.WORKSHEET,
+                title: input.title ||
+                    (resolved.mode === 'quiz'
+                        ? `Quiz - ${new Date().toLocaleString()}`
+                        : `Worksheet - ${new Date().toLocaleString()}`),
+                createdById: userId,
+                difficulty: difficultyUpper,
+                estimatedTime: input.estimatedTime,
+                generating: true,
+                generatingMetadata: {
+                    quantity: resolved.numQuestions,
+                    difficulty: resolved.difficulty,
+                    mode: resolved.mode,
+                    presetId: input.presetId ?? null,
+                },
+                worksheetConfig: worksheetConfigSnapshot,
+            },
+        });
+        await PusherService.emitTaskComplete(input.workspaceId, 'worksheet_info', {
+            contentLength: resolved.numQuestions,
+        });
+        await PusherService.emitWorksheetNew(input.workspaceId, artifact);
+        const workspaceId = input.workspaceId;
+        const promptText = input.prompt;
+        const estTime = input.estimatedTime;
+        (async () => {
+            try {
+                const content = await aiSessionService.generateWorksheetQuestions(workspaceId, userId, resolved.numQuestions, difficultyUpper, {
+                    mode: resolved.mode,
+                    mcqRatio: resolved.mcqRatio,
+                    questionTypes: resolved.questionTypes,
+                    prompt: promptText,
+                });
+                let problems = [];
+                try {
+                    const worksheetData = JSON.parse(content);
+                    let actualWorksheetData = worksheetData;
+                    if (worksheetData.last_response) {
+                        try {
+                            actualWorksheetData = JSON.parse(worksheetData.last_response);
+                        }
+                        catch {
+                            /* noop */
+                        }
+                    }
+                    problems =
+                        actualWorksheetData.problems ||
+                            actualWorksheetData.questions ||
+                            actualWorksheetData ||
+                            [];
+                    if (!Array.isArray(problems))
+                        problems = [];
+                }
+                catch (parseError) {
+                    this.logger.error('Failed to parse worksheet JSON', parseError);
+                    throw new Error('Failed to parse worksheet JSON');
+                }
+                const forceMcq = resolved.mode === 'quiz';
+                const questionsToCreate = [];
+                for (let i = 0; i < Math.min(problems.length, resolved.numQuestions); i++) {
+                    const problem = problems[i] && typeof problems[i] === 'object'
+                        ? problems[i]
+                        : {};
+                    const row = normalizeWorksheetProblemForDb(problem, i, difficultyUpper, forceMcq);
+                    const metaPayload = {};
+                    if (row.meta.options?.length)
+                        metaPayload.options = row.meta.options;
+                    if (row.meta.markScheme != null)
+                        metaPayload.markScheme = row.meta.markScheme;
+                    questionsToCreate.push({
+                        artifactId: artifact.id,
+                        prompt: row.prompt,
+                        answer: row.answer ?? '',
+                        difficulty: row.difficulty,
+                        order: row.order,
+                        type: row.type,
+                        meta: Object.keys(metaPayload).length ? metaPayload : undefined,
+                    });
+                }
+                if (questionsToCreate.length > 0) {
+                    await this.db.worksheetQuestion.createMany({ data: questionsToCreate });
+                }
+                let parsedTitle;
+                let parsedDescription;
+                let parsedEstimated;
+                try {
+                    const worksheetData = JSON.parse(content);
+                    let actualWorksheetData = worksheetData;
+                    if (worksheetData.last_response) {
+                        try {
+                            actualWorksheetData = JSON.parse(worksheetData.last_response);
+                        }
+                        catch {
+                            /* noop */
+                        }
+                    }
+                    parsedTitle =
+                        typeof actualWorksheetData.title === 'string' ? actualWorksheetData.title : undefined;
+                    parsedDescription =
+                        typeof actualWorksheetData.description === 'string'
+                            ? actualWorksheetData.description
+                            : undefined;
+                    parsedEstimated =
+                        typeof actualWorksheetData.estimatedTime === 'string'
+                            ? actualWorksheetData.estimatedTime
+                            : undefined;
+                }
+                catch {
+                    /* noop */
+                }
+                await this.db.artifact.update({
+                    where: { id: artifact.id },
+                    data: {
+                        generating: false,
+                        title: parsedTitle || artifact.title,
+                        description: parsedDescription ?? undefined,
+                        estimatedTime: estTime || parsedEstimated || undefined,
+                        worksheetConfig: worksheetConfigSnapshot,
+                    },
+                });
+                const updatedWorksheet = await this.db.artifact.findFirst({
+                    where: { id: artifact.id },
+                    include: { questions: true },
+                });
+                await PusherService.emitWorksheetGenerationComplete(workspaceId, updatedWorksheet);
+                await PusherService.emitWorksheetComplete(workspaceId, artifact);
+                await notifyArtifactReady(this.db, {
+                    userId,
+                    workspaceId,
+                    artifactId: artifact.id,
+                    artifactType: ArtifactType.WORKSHEET,
+                    title: updatedWorksheet?.title ?? artifact.title,
+                }).catch(() => { });
+            }
+            catch (error) {
+                this.logger.error(`Background generation failed for artifact ${artifact.id}:`, error);
+                await notifyArtifactFailed(this.db, {
+                    userId,
+                    workspaceId,
+                    artifactId: artifact.id,
+                    artifactType: ArtifactType.WORKSHEET,
+                    title: artifact.title,
+                    message: `Failed to generate worksheet: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                }).catch(() => { });
+                await this.db.artifact.deleteMany({ where: { id: artifact.id } }).catch(() => { });
+                await PusherService.emitError(workspaceId, `Failed to generate worksheet: ${error instanceof Error ? error.message : 'Unknown error'}`, 'worksheet_generation');
+            }
+        })();
+        return { artifact };
+    }
+    async checkAnswer(userId, input) {
+        const worksheet = await this.db.artifact.findFirst({
+            where: {
+                id: input.worksheetId,
+                type: ArtifactType.WORKSHEET,
+                workspace: workspaceAccessWhere(userId),
+            },
+            include: { workspace: true },
+        });
+        if (!worksheet)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        const question = await this.db.worksheetQuestion.findFirst({
+            where: { id: input.questionId, artifactId: input.worksheetId },
+        });
+        if (!question)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        const questionMeta = question.meta
+            ? typeof question.meta === 'object'
+                ? question.meta
+                : JSON.parse(question.meta)
+            : {};
+        const markScheme = questionMeta.markScheme;
+        let isCorrect = false;
+        let userMarkScheme = null;
+        if (markScheme && markScheme.points && markScheme.points.length > 0) {
+            try {
+                userMarkScheme = await aiSessionService.checkWorksheetQuestions(worksheet.workspace.id, userId, question.prompt, input.answer, markScheme);
+                const achievedTotal = userMarkScheme.points.reduce((sum, p) => sum + (p.achievedPoints || 0), 0);
+                isCorrect = achievedTotal === markScheme.totalPoints;
+            }
+            catch (error) {
+                this.logger.error('Failed to check answer with AI', error instanceof Error ? error.message : 'Unknown error');
+                isCorrect = question.answer === input.answer;
+            }
+        }
+        else {
+            throw new TRPCError({ code: 'BAD_REQUEST', message: 'No mark scheme found for question' });
+        }
+        const progress = await this.db.worksheetQuestionProgress.upsert({
+            where: {
+                worksheetQuestionId_userId: {
+                    worksheetQuestionId: input.questionId,
+                    userId,
+                },
+            },
+            create: {
+                worksheetQuestionId: input.questionId,
+                userId,
+                modified: true,
+                userAnswer: input.answer,
+                correct: isCorrect,
+                completedAt: new Date(),
+                attempts: 1,
+                meta: userMarkScheme
+                    ? { userMarkScheme: JSON.parse(JSON.stringify(userMarkScheme)) }
+                    : { userMarkScheme: null },
+            },
+            update: {
+                modified: true,
+                userAnswer: input.answer,
+                correct: isCorrect,
+                completedAt: new Date(),
+                attempts: { increment: 1 },
+                meta: userMarkScheme
+                    ? { userMarkScheme: JSON.parse(JSON.stringify(userMarkScheme)) }
+                    : { userMarkScheme: null },
+            },
+        });
+        return { isCorrect, userMarkScheme, progress };
+    }
+}

package/dist/services/workspace/workspace-analytics.service.d.ts

@@ -0,0 +1,24 @@
+import type { PrismaClient } from '@prisma/client';
+import { BaseService } from '../base.service.js';
+/**
+ * Study analytics: streaks, weekly activity, flashcard mastery, worksheet
+ * accuracy. Behavior-preserving extraction from `workspace.getStudyAnalytics`.
+ */
+export declare class WorkspaceAnalyticsService extends BaseService {
+    constructor(db: PrismaClient);
+    getStudyAnalytics(userId: string): Promise<{
+        streak: number;
+        totalStudyDays: number;
+        weeklyActivity: boolean[];
+        flashcards: {
+            total: number;
+            mastered: number;
+            dueForReview: number;
+        };
+        worksheets: {
+            completed: number;
+            correct: number;
+            accuracy: number;
+        };
+    }>;
+}