@goscribe/server 1.3.0 → 1.3.1

package/dist/routers/worksheets.js

@@ -1,13 +1,13 @@
 import { z } from 'zod';
 import { TRPCError } from '@trpc/server';
-import { router, authedProcedure } from '../trpc.js';
+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';
-// Avoid importing Prisma enums directly; mirror values as string literals
-const ArtifactType = {
-    WORKSHEET: 'WORKSHEET',
-};
+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',
@@ -69,8 +69,87 @@ 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,
+            },
+        });
+    }),
+    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 = {};
+        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,
+        });
+    }),
+    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
+    create: limitedProcedure
         .input(z.object({
         workspaceId: z.string(),
         title: z.string().min(1).max(120),
@@ -122,7 +201,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' },
@@ -160,7 +239,7 @@ export const worksheets = router({
         return merged;
     }),
     // Add a question to a worksheet
-    createWorksheetQuestion: authedProcedure
+    createWorksheetQuestion: limitedProcedure
         .input(z.object({
         worksheetId: z.string(),
         prompt: z.string().min(1),
@@ -172,7 +251,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' });
@@ -201,7 +280,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' });
@@ -222,7 +301,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' });
@@ -244,7 +323,7 @@ export const worksheets = router({
                 id: input.problemId,
                 artifact: {
                     type: ArtifactType.WORKSHEET,
-                    workspace: { ownerId: ctx.session.user.id },
+                    workspace: workspaceAccessFilter(ctx.session.user.id),
                 },
             },
         });
@@ -286,7 +365,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)
@@ -327,7 +406,7 @@ export const worksheets = router({
             where: {
                 id,
                 type: ArtifactType.WORKSHEET,
-                workspace: { ownerId: ctx.session.user.id },
+                workspace: workspaceAccessFilter(ctx.session.user.id),
             },
         });
         if (!existingWorksheet)
@@ -369,93 +448,204 @@ 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 = 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 || `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()),
+                difficulty: difficultyUpper,
                 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,
             },
         });
-        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);
+        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 worksheetData = JSON.parse(content);
-                let actualWorksheetData = worksheetData;
-                if (worksheetData.last_response) {
-                    try {
-                        actualWorksheetData = JSON.parse(worksheetData.last_response);
+                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 */ }
                     }
-                    catch { }
+                    problems = actualWorksheetData.problems || actualWorksheetData.questions || actualWorksheetData || [];
+                    if (!Array.isArray(problems))
+                        problems = [];
                 }
-                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: {
-                            artifactId: artifact.id,
-                            prompt,
-                            answer,
-                            difficulty: (input.difficulty.toUpperCase()),
-                            order: i,
-                            type,
-                            meta: {
-                                options: options.length > 0 ? options : undefined,
-                                markScheme: problem.mark_scheme || undefined,
-                            },
-                        },
+                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,
                     });
                 }
-            }
-            catch {
-                logger.error('Failed to parse worksheet JSON,');
-                await ctx.db.artifact.delete({
+                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 }
                 });
-                throw new TRPCError({ code: 'INTERNAL_SERVER_ERROR', message: 'Failed to parse worksheet JSON' });
+                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(() => { });
             }
-            await ctx.db.artifact.update({
-                where: { id: artifact.id },
-                data: { generating: false },
-            });
-            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;
-        }
+            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
@@ -465,7 +655,7 @@ export const worksheets = router({
         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 } });