@goscribe/server 1.3.4 → 1.5.0

package/src/routers/worksheets.ts

@@ -1,780 +1,216 @@
 import { z } from 'zod';
-import { TRPCError } from '@trpc/server';
-import { router, authedProcedure, verifiedProcedure, 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 { router, authedProcedure, limitedProcedure } from '../trpc.js';
+import { WorksheetService } from '../services/content/worksheet.service.js';
 import {
-  mergeWorksheetGenerationConfig,
-  normalizeWorksheetProblemForDb,
-  parsePresetConfig,
   worksheetModeSchema,
   worksheetPresetConfigPartialSchema,
-} from '../lib/worksheet-generation.js';
-
-const Difficulty = {
-  EASY: 'EASY',
-  MEDIUM: 'MEDIUM',
-  HARD: 'HARD',
-} as const;
-
-const QuestionType = {
-  MULTIPLE_CHOICE: 'MULTIPLE_CHOICE',
-  TEXT: 'TEXT',
-  NUMERIC: 'NUMERIC',
-  TRUE_FALSE: 'TRUE_FALSE',
-  MATCHING: 'MATCHING',
-  FILL_IN_THE_BLANK: 'FILL_IN_THE_BLANK',
-} as const;
+} 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 as any)) : {} as any;
-          const progressMeta = p.meta ? (typeof p.meta === 'object' ? p.meta : JSON.parse(p.meta as any)) : {} as any;
-          return {
-            ...q,
-            meta: {
-              ...existingMeta,
-              completed: p.modified,
-              userAnswer: p.userAnswer,
-              completedAt: p.completedAt,
-              userMarkScheme: progressMeta.userMarkScheme,
-            },
-          } as typeof q;
-        }),
-      }));
-
-      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 as object,
-        },
-      });
-    }),
+    .input(
+      z.object({
+        workspaceId: z.string().optional(),
+        name: z.string().min(1).max(120),
+        config: z.record(z.string(), z.unknown()),
+      }),
+    )
+    .mutation(({ ctx, input }) =>
+      new WorksheetService(ctx.db).createPreset(ctx.session.user.id, input),
+    ),
 
   updatePreset: authedProcedure
-    .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: { name?: string; config?: object } = {};
-      if (input.name !== undefined) data.name = input.name;
-      if (input.config !== undefined) data.config = parsePresetConfig(input.config) as object;
-
-      return ctx.db.worksheetPreset.update({
-        where: { id: input.id },
-        data,
-      });
-    }),
+    .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(({ 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;
-    }),
+    .mutation(({ ctx, input }) =>
+      new WorksheetService(ctx.db).deletePreset(ctx.session.user.id, input.id),
+    ),
 
-  // Create a worksheet set
   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(),
-      estimatedTime: z.string().optional(),
-      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'),
-        options: z.array(z.string()).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;
+    .input(
+      z.object({
+        workspaceId: z.string(),
+        title: z.string().min(1).max(120),
+        description: z.string().optional(),
+        difficulty: difficultyEnum.optional(),
+        estimatedTime: z.string().optional(),
+        problems: z
+          .array(
+            z.object({
+              question: z.string().min(1),
+              answer: z.string().min(1),
+              type: questionTypeEnum.default('TEXT'),
+              options: z.array(z.string()).optional(),
+            }),
+          )
+          .optional(),
+      }),
+    )
+    .mutation(({ ctx, input }) =>
+      new WorksheetService(ctx.db).create(ctx.session.user.id, input as any),
+    ),
 
-      return ctx.db.artifact.create({
-        data: {
-          workspaceId: input.workspaceId,
-          type: ArtifactType.WORKSHEET,
-          title: input.title,
-          difficulty: input.difficulty as any,
-          estimatedTime: input.estimatedTime,
-          createdById: ctx.session.user.id,
-          questions: problems ? {
-            create: problems.map((problem, index) => ({
-              prompt: problem.question,
-              answer: problem.answer,
-              type: problem.type as any,
-              order: index,
-              meta: problem.options ? { options: problem.options } : undefined,
-            })),
-          } : undefined,
-        },
-        include: {
-          questions: true,
-        },
-      });
-    }),
-
-  // Get a worksheet with its questions
   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]));
+    .query(({ ctx, input }) =>
+      new WorksheetService(ctx.db).get(ctx.session.user.id, input.worksheetId),
+    ),
 
-      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 as any)) : {} as any;
-          const progressMeta = p.meta ? (typeof p.meta === 'object' ? p.meta : JSON.parse(p.meta as any)) : {} as any;
-          return {
-            ...q,
-            meta: {
-              ...existingMeta,
-              completed: p.modified,
-              userAnswer: p.userAnswer,
-              completedAt: p.completedAt,
-              userMarkScheme: progressMeta.userMarkScheme,
-            },
-          } as typeof q;
-        }),
-      };
-
-      return merged;
-    }),
-
-  // Add a question to a worksheet
   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(),
-      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) as any,
-          difficulty: (input.difficulty ?? Difficulty.MEDIUM) as any,
-          order: input.order ?? 0,
-          meta: input.meta as any,
-        },
-      });
-    }),
+    .input(
+      z.object({
+        worksheetId: z.string(),
+        prompt: z.string().min(1),
+        answer: z.string().optional(),
+        type: questionTypeEnum.optional(),
+        difficulty: difficultyEnum.optional(),
+        order: z.number().int().optional(),
+        meta: z.record(z.string(), z.unknown()).optional(),
+      }),
+    )
+    .mutation(({ ctx, input }) =>
+      new WorksheetService(ctx.db).createWorksheetQuestion(ctx.session.user.id, input),
+    ),
 
-  // Update a question
   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(),
-      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) as any,
-          difficulty: (input.difficulty ?? q.difficulty) as any,
-          order: input.order ?? q.order,
-          meta: (input.meta ?? q.meta) as any,
-        },
-      });
-    }),
+    .input(
+      z.object({
+        worksheetQuestionId: z.string(),
+        prompt: z.string().optional(),
+        answer: z.string().optional(),
+        type: questionTypeEnum.optional(),
+        difficulty: difficultyEnum.optional(),
+        order: z.number().int().optional(),
+        meta: z.record(z.string(), z.unknown()).optional(),
+      }),
+    )
+    .mutation(({ ctx, input }) =>
+      new WorksheetService(ctx.db).updateWorksheetQuestion(ctx.session.user.id, input),
+    ),
 
-  // Delete a question
   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;
-    }),
+    .mutation(({ ctx, input }) =>
+      new WorksheetService(ctx.db).deleteWorksheetQuestion(
+        ctx.session.user.id,
+        input.worksheetQuestionId,
+      ),
+    ),
 
-  // Update problem completion status
   updateProblemStatus: authedProcedure
-    .input(z.object({
-      problemId: z.string(),
-      completed: z.boolean(),
-      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,
-        },
-      });
+    .input(
+      z.object({
+        problemId: z.string(),
+        completed: z.boolean(),
+        answer: z.string().optional(),
+        correct: z.boolean().optional(),
+      }),
+    )
+    .mutation(({ ctx, input }) =>
+      new WorksheetService(ctx.db).updateProblemStatus(ctx.session.user.id, input),
+    ),
 
-      return progress;
-    }),
-
-  // Get current user's progress for all questions in a worksheet
   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;
-    }),
+    .query(({ ctx, input }) =>
+      new WorksheetService(ctx.db).getProgress(ctx.session.user.id, input.worksheetId),
+    ),
 
-  // Update a worksheet
   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(),
-      estimatedTime: z.string().optional(),
-      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'),
-        options: z.array(z.string()).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 as any,
-            order: index,
-            meta: problem.options ? { options: problem.options } : undefined,
-          })),
-        });
-      }
+    .input(
+      z.object({
+        id: z.string(),
+        title: z.string().min(1).max(120).optional(),
+        description: z.string().optional(),
+        difficulty: difficultyEnum.optional(),
+        estimatedTime: z.string().optional(),
+        problems: z
+          .array(
+            z.object({
+              id: z.string().optional(),
+              question: z.string().min(1),
+              answer: z.string().min(1),
+              type: questionTypeEnum.default('TEXT'),
+              options: z.array(z.string()).optional(),
+            }),
+          )
+          .optional(),
+      }),
+    )
+    .mutation(({ ctx, input }) =>
+      new WorksheetService(ctx.db).update(ctx.session.user.id, input as any),
+    ),
 
-      // Process update data
-      const processedUpdateData = {
-        ...updateData,
-        difficulty: updateData.difficulty as any,
-      };
-
-      return ctx.db.artifact.update({
-        where: { id },
-        data: processedUpdateData,
-        include: {
-          questions: {
-            orderBy: { order: 'asc' },
-          },
-        },
-      });
-    }),
-
-  // Delete a worksheet set and its questions
   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;
-    }),
+    .mutation(({ ctx, input }) =>
+      new WorksheetService(ctx.db).delete(ctx.session.user.id, input.id),
+    ),
 
-  // Generate a worksheet from a user prompt
   generateFromPrompt: limitedProcedure
-    .input(z.object({
-      workspaceId: z.string(),
-      prompt: z.string().min(1),
-      numQuestions: z.number().int().min(1).max(20).default(8),
-      difficulty: z.enum(['easy', 'medium', 'hard']).default('medium'),
-      mode: worksheetModeSchema.optional(),
-      presetId: z.string().optional(),
-      configOverride: worksheetPresetConfigPartialSchema.optional(),
-      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: Awaited<ReturnType<typeof ctx.db.worksheetPreset.findFirst>> = 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;
+    .input(
+      z.object({
+        workspaceId: z.string(),
+        prompt: z.string().min(1),
+        numQuestions: z.number().int().min(1).max(20).default(8),
+        difficulty: z.enum(['easy', 'medium', 'hard']).default('medium'),
+        mode: worksheetModeSchema.optional(),
+        presetId: z.string().optional(),
+        configOverride: worksheetPresetConfigPartialSchema.optional(),
+        title: z.string().optional(),
+        estimatedTime: z.string().optional(),
+      }),
+    )
+    .mutation(({ ctx, input }) =>
+      new WorksheetService(ctx.db).generateFromPrompt(ctx.session.user.id, input),
+    ),
 
-      const resolved = mergeWorksheetGenerationConfig(
-        presetConfig,
-        input.configOverride ?? undefined,
-        {
-          numQuestions: input.numQuestions,
-          difficulty: input.difficulty,
-          mode: input.mode,
-        },
-      );
-
-      const difficultyUpper = resolved.difficulty.toUpperCase() as 'EASY' | 'MEDIUM' | 'HARD';
-      
-      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 as any,
-          estimatedTime: input.estimatedTime,
-          generating: true,
-          generatingMetadata: {
-            quantity: resolved.numQuestions,
-            difficulty: resolved.difficulty,
-            mode: resolved.mode,
-            presetId: input.presetId ?? null,
-          },
-          worksheetConfig: worksheetConfigSnapshot as object,
-        },
-      });
-
-      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: any[] = [];
-          try {
-            const worksheetData = JSON.parse(content);
-            let actualWorksheetData: any = 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] as Record<string, unknown> : {};
-            const row = normalizeWorksheetProblemForDb(problem, i, difficultyUpper, forceMcq);
-            const metaPayload: Record<string, unknown> = {};
-            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 as any,
-              order: row.order,
-              type: row.type as any,
-              meta: Object.keys(metaPayload).length ? (metaPayload as object) : undefined,
-            });
-          }
-
-          if (questionsToCreate.length > 0) {
-            await ctx.db.worksheetQuestion.createMany({
-              data: questionsToCreate,
-            });
-          }
-
-          let parsedTitle: string | undefined;
-          let parsedDescription: string | undefined;
-          let parsedEstimated: string | undefined;
-          try {
-            const worksheetData = JSON.parse(content);
-            let actualWorksheetData: any = 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 as object,
-            },
-          });
-
-          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 };
-    }),
   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 as any)) : {} as any;
-      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: number, p: any) => 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 };
-    }),
+    .input(
+      z.object({
+        worksheetId: z.string(),
+        questionId: z.string(),
+        answer: z.string().min(1),
+      }),
+    )
+    .mutation(({ ctx, input }) =>
+      new WorksheetService(ctx.db).checkAnswer(ctx.session.user.id, input),
+    ),
 });
-
-