@goscribe/server 1.1.7 → 1.3.0

package/src/routers/worksheets.ts

@@ -1,14 +1,19 @@
 import { z } from 'zod';
 import { TRPCError } from '@trpc/server';
-import { router, authedProcedure } from '../trpc.js';
+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';
-
-// Avoid importing Prisma enums directly; mirror values as string literals
-const ArtifactType = {
-  WORKSHEET: 'WORKSHEET',
-} as const;
+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',
@@ -75,10 +80,91 @@ export const worksheets = router({
       return merged;
     }),
 
+  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' }],
+      });
+    }),
+
+  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,
+        },
+      });
+    }),
+
+  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,
+      });
+    }),
+
+  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
-  create: authedProcedure
-    .input(z.object({ 
-      workspaceId: z.string(), 
+  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(),
@@ -130,7 +216,7 @@ export const worksheets = router({
         where: {
           id: input.worksheetId,
           type: ArtifactType.WORKSHEET,
-          workspace: { ownerId: ctx.session.user.id },
+          workspace: workspaceAccessFilter(ctx.session.user.id),
         },
         include: { questions: true },
         orderBy: { updatedAt: 'desc' },
@@ -169,7 +255,7 @@ export const worksheets = router({
     }),
 
   // Add a question to a worksheet
-  createWorksheetQuestion: authedProcedure
+  createWorksheetQuestion: limitedProcedure
     .input(z.object({
       worksheetId: z.string(),
       prompt: z.string().min(1),
@@ -181,7 +267,7 @@ export const worksheets = router({
     }))
     .mutation(async ({ ctx, input }) => {
       const worksheet = await ctx.db.artifact.findFirst({
-        where: { id: input.worksheetId, type: ArtifactType.WORKSHEET, workspace: { ownerId: ctx.session.user.id } },
+        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({
@@ -210,7 +296,7 @@ export const worksheets = router({
     }))
     .mutation(async ({ ctx, input }) => {
       const q = await ctx.db.worksheetQuestion.findFirst({
-        where: { id: input.worksheetQuestionId, artifact: { type: ArtifactType.WORKSHEET, workspace: { ownerId: ctx.session.user.id } } },
+        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({
@@ -231,7 +317,7 @@ export const worksheets = router({
     .input(z.object({ worksheetQuestionId: z.string() }))
     .mutation(async ({ ctx, input }) => {
       const q = await ctx.db.worksheetQuestion.findFirst({
-        where: { id: input.worksheetQuestionId, artifact: { workspace: { ownerId: ctx.session.user.id } } },
+        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 } });
@@ -253,7 +339,7 @@ export const worksheets = router({
           id: input.problemId,
           artifact: {
             type: ArtifactType.WORKSHEET,
-            workspace: { ownerId: ctx.session.user.id },
+            workspace: workspaceAccessFilter(ctx.session.user.id),
           },
         },
       });
@@ -297,7 +383,7 @@ export const worksheets = router({
         where: {
           id: input.worksheetId,
           type: ArtifactType.WORKSHEET,
-          workspace: { ownerId: ctx.session.user.id },
+          workspace: workspaceAccessFilter(ctx.session.user.id),
         },
       });
       if (!worksheet) throw new TRPCError({ code: 'NOT_FOUND' });
@@ -336,13 +422,13 @@ export const worksheets = router({
     }))
     .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: { ownerId: ctx.session.user.id },
+          workspace: workspaceAccessFilter(ctx.session.user.id),
         },
       });
       if (!existingWorksheet) throw new TRPCError({ code: 'NOT_FOUND' });
@@ -388,107 +474,241 @@ export const worksheets = router({
     .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: { ownerId: ctx.session.user.id } },
+        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
-  generateFromPrompt: authedProcedure
+  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, ownerId: ctx.session.user.id } });
+      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;
+
+      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 || `Worksheet - ${new Date().toLocaleString()}`,
+          title: input.title || (resolved.mode === 'quiz' ? `Quiz - ${new Date().toLocaleString()}` : `Worksheet - ${new Date().toLocaleString()}`),
           createdById: ctx.session.user.id,
-          difficulty: (input.difficulty.toUpperCase()) as any,
+          difficulty: difficultyUpper as any,
           estimatedTime: input.estimatedTime,
           generating: true,
-          generatingMetadata: { quantity: input.numQuestions, difficulty: input.difficulty.toLowerCase() },
+          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: input.numQuestions });
-      try {
-      
-      const content = await aiSessionService.generateWorksheetQuestions(input.workspaceId, ctx.session.user.id, input.numQuestions, input.difficulty as any);
-      try {
-        const worksheetData = JSON.parse(content);
-        let actualWorksheetData = worksheetData;
-        if (worksheetData.last_response) {
-          try { actualWorksheetData = JSON.parse(worksheetData.last_response); } catch {}
-        }
-        const problems = actualWorksheetData.problems || actualWorksheetData.questions || actualWorksheetData || [];
-        for (let i = 0; i < Math.min(problems.length, input.numQuestions); i++) {
-          const problem = problems[i];
-          const prompt = problem.question || problem.prompt || `Question ${i + 1}`;
-          const answer = problem.answer || problem.solution || `Answer ${i + 1}`;
-          const type = problem.type || 'TEXT';
-          const options = problem.options || [];
-
-          await ctx.db.worksheetQuestion.create({
-            data: {
+
+      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,
-              answer,
-              difficulty: (input.difficulty.toUpperCase()) as any,
-              order: i,
-              type,
-              meta: { 
-                options: options.length > 0 ? options : undefined,
-                markScheme: problem.mark_scheme || undefined,
-              },
+              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,
             },
           });
-        }
-      } catch {
-        logger.error('Failed to parse worksheet JSON,');
-        await ctx.db.artifact.delete({
-          where: { id: artifact.id },
-        });
-        throw new TRPCError({ code: 'INTERNAL_SERVER_ERROR', message: 'Failed to parse worksheet JSON' });
-      }
 
-      await ctx.db.artifact.update({
-        where: { id: artifact.id },
-        data: { generating: false },
-      });
+          const updatedWorksheet = await ctx.db.artifact.findFirst({
+            where: { id: artifact.id },
+            include: { questions: true }
+          });
 
-      await PusherService.emitWorksheetComplete(input.workspaceId, artifact);
-    } catch (error) {
-      await ctx.db.artifact.delete({
-        where: { id: artifact.id },
-      });
-      await PusherService.emitError(input.workspaceId, `Failed to generate worksheet: ${error instanceof Error ? error.message : 'Unknown error'}`, 'worksheet_generation');
-      throw error;
-    }
+          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
+  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: { ownerId: ctx.session.user.id } }, include: { workspace: true } });
+      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;
@@ -506,11 +726,11 @@ export const worksheets = router({
             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
@@ -522,7 +742,7 @@ export const worksheets = router({
       }
 
 
-      
+
       // @todo: figure out this wierd fix
       const progress = await ctx.db.worksheetQuestionProgress.upsert({
         where: {
@@ -555,6 +775,6 @@ export const worksheets = router({
 
       return { isCorrect, userMarkScheme, progress };
     }),
-  });
+});