@goscribe/server 1.3.4 → 1.6.0

package/dist/routers/worksheets.js

@@ -1,314 +1,89 @@
 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 { logger } from '../lib/logger.js';
-import { ArtifactType } from '../lib/constants.js';
-import { workspaceAccessFilter } from '../lib/workspace-access.js';
-import { mergeWorksheetGenerationConfig, normalizeWorksheetProblemForDb, parsePresetConfig, worksheetModeSchema, worksheetPresetConfigPartialSchema, } from '../lib/worksheet-generation.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',
-};
+import { WorksheetService } from '../services/content/worksheet.service.js';
+import { worksheetModeSchema, worksheetPresetConfigPartialSchema, } from '../services/content/worksheet-generation.service.js';
+const questionTypeEnum = z.enum([
+    'MULTIPLE_CHOICE',
+    'TEXT',
+    'NUMERIC',
+    'TRUE_FALSE',
+    'MATCHING',
+    'FILL_IN_THE_BLANK',
+]);
+const difficultyEnum = z.enum(['EASY', 'MEDIUM', 'HARD']);
 export const worksheets = router({
-    // List all worksheet artifacts for a workspace
     list: authedProcedure
         .input(z.object({ workspaceId: z.string() }))
-        .query(async ({ ctx, input }) => {
-        const worksheets = await ctx.db.artifact.findMany({
-            where: { workspaceId: input.workspaceId, type: ArtifactType.WORKSHEET },
-            include: {
-                versions: {
-                    orderBy: { version: 'desc' },
-                    take: 1, // Get only the latest version
-                },
-                questions: true,
-            },
-            orderBy: { updatedAt: 'desc' },
-        });
-        if (!worksheets)
-            throw new TRPCError({ code: 'NOT_FOUND' });
-        // Merge per-user progress into question.meta for compatibility with UI
-        const allQuestionIds = worksheets.flatMap(w => w.questions.map(q => q.id));
-        if (allQuestionIds.length === 0)
-            return worksheets;
-        const progress = await ctx.db.worksheetQuestionProgress.findMany({
-            where: { userId: ctx.session.user.id, worksheetQuestionId: { in: allQuestionIds } },
-        });
-        const progressByQuestionId = new Map(progress.map(p => [p.worksheetQuestionId, p]));
-        const merged = worksheets.map(w => ({
-            ...w,
-            questions: w.questions.map(q => {
-                const p = progressByQuestionId.get(q.id);
-                if (!p)
-                    return q;
-                const existingMeta = q.meta ? (typeof q.meta === 'object' ? q.meta : JSON.parse(q.meta)) : {};
-                const progressMeta = p.meta ? (typeof p.meta === 'object' ? p.meta : JSON.parse(p.meta)) : {};
-                return {
-                    ...q,
-                    meta: {
-                        ...existingMeta,
-                        completed: p.modified,
-                        userAnswer: p.userAnswer,
-                        completedAt: p.completedAt,
-                        userMarkScheme: progressMeta.userMarkScheme,
-                    },
-                };
-            }),
-        }));
-        return merged;
-    }),
+        .query(({ ctx, input }) => new WorksheetService(ctx.db).list(ctx.session.user.id, input.workspaceId)),
     listPresets: authedProcedure
         .input(z.object({ workspaceId: z.string() }))
-        .query(async ({ ctx, input }) => {
-        const ws = await ctx.db.workspace.findFirst({
-            where: { id: input.workspaceId, ...workspaceAccessFilter(ctx.session.user.id) },
-        });
-        if (!ws)
-            throw new TRPCError({ code: 'NOT_FOUND' });
-        return ctx.db.worksheetPreset.findMany({
-            where: {
-                OR: [
-                    { isSystem: true },
-                    {
-                        userId: ctx.session.user.id,
-                        OR: [{ workspaceId: input.workspaceId }, { workspaceId: null }],
-                    },
-                ],
-            },
-            orderBy: [{ isSystem: 'desc' }, { name: 'asc' }],
-        });
-    }),
+        .query(({ ctx, input }) => new WorksheetService(ctx.db).listPresets(ctx.session.user.id, input.workspaceId)),
     createPreset: authedProcedure
         .input(z.object({
         workspaceId: z.string().optional(),
         name: z.string().min(1).max(120),
         config: z.record(z.string(), z.unknown()),
     }))
-        .mutation(async ({ ctx, input }) => {
-        if (input.workspaceId) {
-            const ws = await ctx.db.workspace.findFirst({
-                where: { id: input.workspaceId, ...workspaceAccessFilter(ctx.session.user.id) },
-            });
-            if (!ws)
-                throw new TRPCError({ code: 'NOT_FOUND' });
-        }
-        const config = parsePresetConfig(input.config);
-        return ctx.db.worksheetPreset.create({
-            data: {
-                userId: ctx.session.user.id,
-                workspaceId: input.workspaceId ?? null,
-                name: input.name,
-                isSystem: false,
-                config: config,
-            },
-        });
-    }),
+        .mutation(({ ctx, input }) => new WorksheetService(ctx.db).createPreset(ctx.session.user.id, input)),
     updatePreset: authedProcedure
-        .input(z.object({
+        .input(z
+        .object({
         id: z.string(),
         name: z.string().min(1).max(120).optional(),
         config: z.record(z.string(), z.unknown()).optional(),
-    }).refine(d => d.name !== undefined || d.config !== undefined, { message: 'Provide name and/or config' }))
-        .mutation(async ({ ctx, input }) => {
-        const existing = await ctx.db.worksheetPreset.findFirst({
-            where: { id: input.id, userId: ctx.session.user.id, 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 ctx.db.worksheetPreset.update({
-            where: { id: input.id },
-            data,
-        });
-    }),
+    })
+        .refine((d) => d.name !== undefined || d.config !== undefined, {
+        message: 'Provide name and/or config',
+    }))
+        .mutation(({ ctx, input }) => new WorksheetService(ctx.db).updatePreset(ctx.session.user.id, input)),
     deletePreset: authedProcedure
         .input(z.object({ id: z.string() }))
-        .mutation(async ({ ctx, input }) => {
-        const existing = await ctx.db.worksheetPreset.findFirst({
-            where: { id: input.id, userId: ctx.session.user.id, isSystem: false },
-        });
-        if (!existing)
-            throw new TRPCError({ code: 'NOT_FOUND', message: 'Preset not found or read-only' });
-        await ctx.db.worksheetPreset.delete({ where: { id: input.id } });
-        return true;
-    }),
-    // Create a worksheet set
+        .mutation(({ ctx, input }) => new WorksheetService(ctx.db).deletePreset(ctx.session.user.id, input.id)),
     create: limitedProcedure
         .input(z.object({
         workspaceId: z.string(),
         title: z.string().min(1).max(120),
         description: z.string().optional(),
-        difficulty: z.enum(['EASY', 'MEDIUM', 'HARD']).optional(),
+        difficulty: difficultyEnum.optional(),
         estimatedTime: z.string().optional(),
-        problems: z.array(z.object({
+        problems: z
+            .array(z.object({
             question: z.string().min(1),
             answer: z.string().min(1),
-            type: z.enum(['MULTIPLE_CHOICE', 'TEXT', 'NUMERIC', 'TRUE_FALSE', 'MATCHING', 'FILL_IN_THE_BLANK']).default('TEXT'),
+            type: questionTypeEnum.default('TEXT'),
             options: z.array(z.string()).optional(),
-        })).optional(),
+        }))
+            .optional(),
     }))
-        .mutation(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' });
-        const { problems, ...worksheetData } = input;
-        return ctx.db.artifact.create({
-            data: {
-                workspaceId: input.workspaceId,
-                type: ArtifactType.WORKSHEET,
-                title: input.title,
-                difficulty: input.difficulty,
-                estimatedTime: input.estimatedTime,
-                createdById: ctx.session.user.id,
-                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,
-            },
-        });
-    }),
-    // Get a worksheet with its questions
+        .mutation(({ ctx, input }) => new WorksheetService(ctx.db).create(ctx.session.user.id, input)),
     get: authedProcedure
         .input(z.object({ worksheetId: z.string() }))
-        .query(async ({ ctx, input }) => {
-        const worksheet = await ctx.db.artifact.findFirst({
-            where: {
-                id: input.worksheetId,
-                type: ArtifactType.WORKSHEET,
-                workspace: workspaceAccessFilter(ctx.session.user.id),
-            },
-            include: { questions: true },
-            orderBy: { updatedAt: 'desc' },
-        });
-        if (!worksheet)
-            throw new TRPCError({ code: 'NOT_FOUND' });
-        // Merge per-user progress into question.meta for compatibility with UI
-        const questionIds = worksheet.questions.map(q => q.id);
-        if (questionIds.length === 0)
-            return worksheet;
-        const progress = await ctx.db.worksheetQuestionProgress.findMany({
-            where: { userId: ctx.session.user.id, worksheetQuestionId: { in: questionIds } },
-        });
-        const progressByQuestionId = new Map(progress.map(p => [p.worksheetQuestionId, p]));
-        const merged = {
-            ...worksheet,
-            questions: worksheet.questions.map(q => {
-                const p = progressByQuestionId.get(q.id);
-                if (!p)
-                    return q;
-                const existingMeta = q.meta ? (typeof q.meta === 'object' ? q.meta : JSON.parse(q.meta)) : {};
-                const progressMeta = p.meta ? (typeof p.meta === 'object' ? p.meta : JSON.parse(p.meta)) : {};
-                return {
-                    ...q,
-                    meta: {
-                        ...existingMeta,
-                        completed: p.modified,
-                        userAnswer: p.userAnswer,
-                        completedAt: p.completedAt,
-                        userMarkScheme: progressMeta.userMarkScheme,
-                    },
-                };
-            }),
-        };
-        return merged;
-    }),
-    // Add a question to a worksheet
+        .query(({ ctx, input }) => new WorksheetService(ctx.db).get(ctx.session.user.id, input.worksheetId)),
     createWorksheetQuestion: limitedProcedure
         .input(z.object({
         worksheetId: z.string(),
         prompt: z.string().min(1),
         answer: z.string().optional(),
-        type: z.enum(['MULTIPLE_CHOICE', 'TEXT', 'NUMERIC', 'TRUE_FALSE', 'MATCHING', 'FILL_IN_THE_BLANK']).optional(),
-        difficulty: z.enum(['EASY', 'MEDIUM', 'HARD']).optional(),
+        type: questionTypeEnum.optional(),
+        difficulty: difficultyEnum.optional(),
         order: z.number().int().optional(),
         meta: z.record(z.string(), z.unknown()).optional(),
     }))
-        .mutation(async ({ ctx, input }) => {
-        const worksheet = await ctx.db.artifact.findFirst({
-            where: { id: input.worksheetId, type: ArtifactType.WORKSHEET, workspace: workspaceAccessFilter(ctx.session.user.id) },
-        });
-        if (!worksheet)
-            throw new TRPCError({ code: 'NOT_FOUND' });
-        return ctx.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,
-            },
-        });
-    }),
-    // Update a question
+        .mutation(({ ctx, input }) => new WorksheetService(ctx.db).createWorksheetQuestion(ctx.session.user.id, input)),
     updateWorksheetQuestion: authedProcedure
         .input(z.object({
         worksheetQuestionId: z.string(),
         prompt: z.string().optional(),
         answer: z.string().optional(),
-        type: z.enum(['MULTIPLE_CHOICE', 'TEXT', 'NUMERIC', 'TRUE_FALSE', 'MATCHING', 'FILL_IN_THE_BLANK']).optional(),
-        difficulty: z.enum(['EASY', 'MEDIUM', 'HARD']).optional(),
+        type: questionTypeEnum.optional(),
+        difficulty: difficultyEnum.optional(),
         order: z.number().int().optional(),
         meta: z.record(z.string(), z.unknown()).optional(),
     }))
-        .mutation(async ({ ctx, input }) => {
-        const q = await ctx.db.worksheetQuestion.findFirst({
-            where: { id: input.worksheetQuestionId, artifact: { type: ArtifactType.WORKSHEET, workspace: workspaceAccessFilter(ctx.session.user.id) } },
-        });
-        if (!q)
-            throw new TRPCError({ code: 'NOT_FOUND' });
-        return ctx.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),
-            },
-        });
-    }),
-    // Delete a question
+        .mutation(({ ctx, input }) => new WorksheetService(ctx.db).updateWorksheetQuestion(ctx.session.user.id, input)),
     deleteWorksheetQuestion: authedProcedure
         .input(z.object({ worksheetQuestionId: z.string() }))
-        .mutation(async ({ ctx, input }) => {
-        const q = await ctx.db.worksheetQuestion.findFirst({
-            where: { id: input.worksheetQuestionId, artifact: { workspace: workspaceAccessFilter(ctx.session.user.id) } },
-        });
-        if (!q)
-            throw new TRPCError({ code: 'NOT_FOUND' });
-        await ctx.db.worksheetQuestion.delete({ where: { id: input.worksheetQuestionId } });
-        return true;
-    }),
-    // Update problem completion status
+        .mutation(({ ctx, input }) => new WorksheetService(ctx.db).deleteWorksheetQuestion(ctx.session.user.id, input.worksheetQuestionId)),
     updateProblemStatus: authedProcedure
         .input(z.object({
         problemId: z.string(),
@@ -316,145 +91,31 @@ export const worksheets = router({
         answer: z.string().optional(),
         correct: z.boolean().optional(),
     }))
-        .mutation(async ({ ctx, input }) => {
-        // Verify question ownership through worksheet
-        const question = await ctx.db.worksheetQuestion.findFirst({
-            where: {
-                id: input.problemId,
-                artifact: {
-                    type: ArtifactType.WORKSHEET,
-                    workspace: workspaceAccessFilter(ctx.session.user.id),
-                },
-            },
-        });
-        if (!question)
-            throw new TRPCError({ code: 'NOT_FOUND' });
-        // Upsert per-user progress row
-        const progress = await ctx.db.worksheetQuestionProgress.upsert({
-            where: {
-                worksheetQuestionId_userId: {
-                    worksheetQuestionId: input.problemId,
-                    userId: ctx.session.user.id,
-                },
-            },
-            create: {
-                worksheetQuestionId: input.problemId,
-                userId: ctx.session.user.id,
-                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,
-            },
-        });
-        return progress;
-    }),
-    // Get current user's progress for all questions in a worksheet
+        .mutation(({ ctx, input }) => new WorksheetService(ctx.db).updateProblemStatus(ctx.session.user.id, input)),
     getProgress: authedProcedure
         .input(z.object({ worksheetId: z.string() }))
-        .query(async ({ ctx, input }) => {
-        // Verify worksheet ownership
-        const worksheet = await ctx.db.artifact.findFirst({
-            where: {
-                id: input.worksheetId,
-                type: ArtifactType.WORKSHEET,
-                workspace: workspaceAccessFilter(ctx.session.user.id),
-            },
-        });
-        if (!worksheet)
-            throw new TRPCError({ code: 'NOT_FOUND' });
-        const questions = await ctx.db.worksheetQuestion.findMany({
-            where: { artifactId: input.worksheetId },
-            select: { id: true },
-        });
-        const questionIds = questions.map(q => q.id);
-        const progress = await ctx.db.worksheetQuestionProgress.findMany({
-            where: {
-                userId: ctx.session.user.id,
-                worksheetQuestionId: { in: questionIds },
-            },
-        });
-        return progress;
-    }),
-    // Update a worksheet
+        .query(({ ctx, input }) => new WorksheetService(ctx.db).getProgress(ctx.session.user.id, input.worksheetId)),
     update: authedProcedure
         .input(z.object({
         id: z.string(),
         title: z.string().min(1).max(120).optional(),
         description: z.string().optional(),
-        difficulty: z.enum(['EASY', 'MEDIUM', 'HARD']).optional(),
+        difficulty: difficultyEnum.optional(),
         estimatedTime: z.string().optional(),
-        problems: z.array(z.object({
+        problems: z
+            .array(z.object({
             id: z.string().optional(),
             question: z.string().min(1),
             answer: z.string().min(1),
-            type: z.enum(['MULTIPLE_CHOICE', 'TEXT', 'NUMERIC', 'TRUE_FALSE', 'MATCHING', 'FILL_IN_THE_BLANK']).default('TEXT'),
+            type: questionTypeEnum.default('TEXT'),
             options: z.array(z.string()).optional(),
-        })).optional(),
+        }))
+            .optional(),
     }))
-        .mutation(async ({ ctx, input }) => {
-        const { id, problems, ...updateData } = input;
-        // Verify worksheet ownership
-        const existingWorksheet = await ctx.db.artifact.findFirst({
-            where: {
-                id,
-                type: ArtifactType.WORKSHEET,
-                workspace: workspaceAccessFilter(ctx.session.user.id),
-            },
-        });
-        if (!existingWorksheet)
-            throw new TRPCError({ code: 'NOT_FOUND' });
-        // Handle questions update if provided
-        if (problems) {
-            // Delete existing questions and create new ones
-            await ctx.db.worksheetQuestion.deleteMany({
-                where: { artifactId: id },
-            });
-            await ctx.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,
-                })),
-            });
-        }
-        // Process update data
-        const processedUpdateData = {
-            ...updateData,
-            difficulty: updateData.difficulty,
-        };
-        return ctx.db.artifact.update({
-            where: { id },
-            data: processedUpdateData,
-            include: {
-                questions: {
-                    orderBy: { order: 'asc' },
-                },
-            },
-        });
-    }),
-    // Delete a worksheet set and its questions
+        .mutation(({ ctx, input }) => new WorksheetService(ctx.db).update(ctx.session.user.id, input)),
     delete: authedProcedure
         .input(z.object({ id: z.string() }))
-        .mutation(async ({ ctx, input }) => {
-        const deleted = await ctx.db.artifact.deleteMany({
-            where: { id: input.id, type: ArtifactType.WORKSHEET, workspace: workspaceAccessFilter(ctx.session.user.id) },
-        });
-        if (deleted.count === 0)
-            throw new TRPCError({ code: 'NOT_FOUND' });
-        return true;
-    }),
-    // Generate a worksheet from a user prompt
+        .mutation(({ ctx, input }) => new WorksheetService(ctx.db).delete(ctx.session.user.id, input.id)),
     generateFromPrompt: limitedProcedure
         .input(z.object({
         workspaceId: z.string(),
@@ -467,252 +128,12 @@ export const worksheets = router({
         title: z.string().optional(),
         estimatedTime: z.string().optional(),
     }))
-        .mutation(async ({ ctx, input }) => {
-        const workspace = await ctx.db.workspace.findFirst({
-            where: { id: input.workspaceId, ...workspaceAccessFilter(ctx.session.user.id) },
-        });
-        if (!workspace)
-            throw new TRPCError({ code: 'NOT_FOUND' });
-        let presetRow = null;
-        if (input.presetId) {
-            presetRow = await ctx.db.worksheetPreset.findFirst({
-                where: {
-                    id: input.presetId,
-                    OR: [
-                        { isSystem: true },
-                        {
-                            userId: ctx.session.user.id,
-                            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 ctx.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: ctx.session.user.id,
-                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 userId = ctx.session.user.id;
-        const workspaceId = input.workspaceId;
-        const promptText = input.prompt;
-        const estTime = input.estimatedTime;
-        // Launch generation in the background to free up the connection pool immediately
-        (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) {
-                    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 ctx.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 ctx.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 ctx.db.artifact.findFirst({
-                    where: { id: artifact.id },
-                    include: { questions: true }
-                });
-                await PusherService.emitWorksheetGenerationComplete(workspaceId, updatedWorksheet);
-                await PusherService.emitWorksheetComplete(workspaceId, artifact);
-                await notifyArtifactReady(ctx.db, {
-                    userId,
-                    workspaceId,
-                    artifactId: artifact.id,
-                    artifactType: ArtifactType.WORKSHEET,
-                    title: updatedWorksheet?.title ?? artifact.title,
-                }).catch(() => { });
-            }
-            catch (error) {
-                logger.error(`Background generation failed for artifact ${artifact.id}:`, error);
-                await notifyArtifactFailed(ctx.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 ctx.db.artifact.deleteMany({
-                    where: { id: artifact.id },
-                }).catch(() => { }); // Ignore delete errors if already gone
-                await PusherService.emitError(workspaceId, `Failed to generate worksheet: ${error instanceof Error ? error.message : 'Unknown error'}`, 'worksheet_generation');
-            }
-        })();
-        return { artifact };
-    }),
+        .mutation(({ ctx, input }) => new WorksheetService(ctx.db).generateFromPrompt(ctx.session.user.id, input)),
     checkAnswer: authedProcedure
         .input(z.object({
         worksheetId: z.string(),
         questionId: z.string(),
         answer: z.string().min(1),
     }))
-        .mutation(async ({ ctx, input }) => {
-        const worksheet = await ctx.db.artifact.findFirst({ where: { id: input.worksheetId, type: ArtifactType.WORKSHEET, workspace: workspaceAccessFilter(ctx.session.user.id) }, include: { workspace: true } });
-        if (!worksheet)
-            throw new TRPCError({ code: 'NOT_FOUND' });
-        const question = await ctx.db.worksheetQuestion.findFirst({ where: { id: input.questionId, artifactId: input.worksheetId } });
-        if (!question)
-            throw new TRPCError({ code: 'NOT_FOUND' });
-        // Parse question meta to get mark_scheme
-        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 mark scheme exists, use AI marking
-        if (markScheme && markScheme.points && markScheme.points.length > 0) {
-            try {
-                userMarkScheme = await aiSessionService.checkWorksheetQuestions(worksheet.workspace.id, ctx.session.user.id, question.prompt, input.answer, markScheme);
-                // Determine if correct by comparing achieved points vs total points
-                const achievedTotal = userMarkScheme.points.reduce((sum, p) => sum + (p.achievedPoints || 0), 0);
-                isCorrect = achievedTotal === markScheme.totalPoints;
-            }
-            catch (error) {
-                logger.error('Failed to check answer with AI', error instanceof Error ? error.message : 'Unknown error');
-                // Fallback to simple string comparison
-                isCorrect = question.answer === input.answer;
-            }
-        }
-        else {
-            // Simple string comparison if no mark scheme
-            throw new TRPCError({ code: 'BAD_REQUEST', message: 'No mark scheme found for question' });
-        }
-        // @todo: figure out this wierd fix
-        const progress = await ctx.db.worksheetQuestionProgress.upsert({
-            where: {
-                worksheetQuestionId_userId: {
-                    worksheetQuestionId: input.questionId,
-                    userId: ctx.session.user.id,
-                },
-            },
-            create: {
-                worksheetQuestionId: input.questionId,
-                userId: ctx.session.user.id,
-                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 };
-    }),
+        .mutation(({ ctx, input }) => new WorksheetService(ctx.db).checkAnswer(ctx.session.user.id, input)),
 });