@goscribe/server 1.3.4 → 1.5.0

package/src/services/content/worksheet-content.service.test.ts

@@ -0,0 +1,83 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  mergeWorksheetQuestionProgress,
+  parseQuestionMeta,
+  parseWorksheetGenerationContent,
+} from './worksheet-content.service.js';
+
+test('parseQuestionMeta: handles null and object inputs', () => {
+  assert.deepEqual(parseQuestionMeta(null), {});
+  assert.deepEqual(parseQuestionMeta({ markScheme: { points: [] } }), {
+    markScheme: { points: [] },
+  });
+});
+
+test('parseQuestionMeta: parses JSON strings', () => {
+  assert.deepEqual(parseQuestionMeta('{"options":["A","B"]}'), { options: ['A', 'B'] });
+});
+
+test('parseQuestionMeta: returns empty object on invalid JSON', () => {
+  assert.deepEqual(parseQuestionMeta('not json'), {});
+});
+
+test('mergeWorksheetQuestionProgress: merges per-user progress into question meta', () => {
+  const questions = [
+    { id: 'q1', meta: { options: ['A', 'B'] } },
+    { id: 'q2', meta: null },
+  ];
+  const progress = [
+    {
+      worksheetQuestionId: 'q1',
+      modified: true,
+      userAnswer: 'A',
+      completedAt: new Date('2024-01-01'),
+      meta: { userMarkScheme: { points: [] } },
+    },
+  ];
+
+  const merged = mergeWorksheetQuestionProgress(questions as any, progress as any);
+  assert.equal((merged[0].meta as any).options?.[0], 'A');
+  assert.equal((merged[0].meta as any).completed, true);
+  assert.equal((merged[0].meta as any).userAnswer, 'A');
+  assert.ok((merged[0].meta as any).userMarkScheme);
+  assert.equal((merged[1].meta as any).completed, undefined);
+});
+
+test('parseWorksheetGenerationContent: unwraps last_response strings', () => {
+  const content = JSON.stringify({
+    last_response: JSON.stringify({
+      title: 'Test Title',
+      description: 'A description',
+      estimatedTime: '15m',
+      problems: [{ question: 'What?' }],
+    }),
+  });
+
+  const parsed = parseWorksheetGenerationContent(content);
+  assert.equal(parsed.title, 'Test Title');
+  assert.equal(parsed.description, 'A description');
+  assert.equal(parsed.estimatedTime, '15m');
+  assert.equal(parsed.problems.length, 1);
+});
+
+test('parseWorksheetGenerationContent: accepts top-level problems', () => {
+  const content = JSON.stringify({
+    title: 'Plain',
+    problems: [{ question: 'Q1' }, { question: 'Q2' }],
+  });
+  const parsed = parseWorksheetGenerationContent(content);
+  assert.equal(parsed.title, 'Plain');
+  assert.equal(parsed.problems.length, 2);
+});
+
+test('parseWorksheetGenerationContent: falls back to questions array', () => {
+  const content = JSON.stringify({ questions: [{ question: 'Q' }] });
+  assert.equal(parseWorksheetGenerationContent(content).problems.length, 1);
+});
+
+test('parseWorksheetGenerationContent: returns empty problems on invalid content', () => {
+  const parsed = parseWorksheetGenerationContent('not json');
+  assert.deepEqual(parsed.problems, []);
+  assert.equal(parsed.title, undefined);
+});

package/src/services/content/worksheet-content.service.ts

@@ -0,0 +1,117 @@
+import type { PrismaClient, WorksheetQuestion } from '@prisma/client';
+import { BaseService } from '../base.service.js';
+
+export type WorksheetQuestionWithProgress = Omit<WorksheetQuestion, 'meta'> & {
+  meta: Record<string, unknown>;
+};
+
+type ProgressLike = {
+  worksheetQuestionId: string;
+  modified: boolean;
+  userAnswer: string | null;
+  completedAt: Date | null;
+  meta?: unknown;
+};
+
+function parseObjectValue(value: unknown): Record<string, unknown> {
+  if (!value) return {};
+  if (typeof value === 'object') {
+    return value as Record<string, unknown>;
+  }
+  if (typeof value === 'string') {
+    try {
+      const parsed = JSON.parse(value);
+      return typeof parsed === 'object' && parsed ? (parsed as Record<string, unknown>) : {};
+    } catch {
+      return {};
+    }
+  }
+  return {};
+}
+
+export function mergeWorksheetQuestionProgress(
+  questions: WorksheetQuestion[],
+  progressRows: ProgressLike[],
+): WorksheetQuestionWithProgress[] {
+  const progressByQuestionId = new Map(progressRows.map((row) => [row.worksheetQuestionId, row]));
+
+  return questions.map((question) => {
+    const progress = progressByQuestionId.get(question.id);
+    const existingMeta = parseObjectValue(question.meta);
+
+    if (!progress) {
+      return {
+        ...question,
+        meta: existingMeta,
+      };
+    }
+
+    const progressMeta = parseObjectValue(progress.meta);
+    return {
+      ...question,
+      meta: {
+        ...existingMeta,
+        completed: progress.modified,
+        userAnswer: progress.userAnswer,
+        completedAt: progress.completedAt,
+        userMarkScheme: progressMeta.userMarkScheme,
+      },
+    };
+  });
+}
+
+export function parseWorksheetGenerationContent(content: string): {
+  problems: Record<string, unknown>[];
+  title?: string;
+  description?: string;
+  estimatedTime?: string;
+} {
+  const parsedRoot = parseObjectValue(content);
+  let payload = parsedRoot;
+
+  if (typeof parsedRoot.last_response === 'string') {
+    const nested = parseObjectValue(parsedRoot.last_response);
+    if (Object.keys(nested).length > 0) {
+      payload = nested;
+    }
+  }
+
+  const rawProblems = payload.problems ?? payload.questions ?? payload;
+  const problems = Array.isArray(rawProblems)
+    ? rawProblems.map((problem) => (typeof problem === 'object' && problem ? (problem as Record<string, unknown>) : {}))
+    : [];
+
+  return {
+    problems,
+    title: typeof payload.title === 'string' ? payload.title : undefined,
+    description: typeof payload.description === 'string' ? payload.description : undefined,
+    estimatedTime: typeof payload.estimatedTime === 'string' ? payload.estimatedTime : undefined,
+  };
+}
+
+export function parseQuestionMeta(meta: unknown): Record<string, unknown> {
+  return parseObjectValue(meta);
+}
+
+/**
+ * Class wrapper around the pure worksheet-content helpers so consumers can
+ * depend on a service the same way they depend on other domain services.
+ * The standalone function exports remain part of the public surface.
+ */
+export class WorksheetContentService extends BaseService {
+  constructor(db: PrismaClient) {
+    super(db);
+  }
+
+  mergeProgress(questions: WorksheetQuestion[], progress: ProgressLike[]) {
+    return mergeWorksheetQuestionProgress(questions, progress);
+  }
+
+  parseGenerationContent(content: string) {
+    return parseWorksheetGenerationContent(content);
+  }
+
+  parseQuestionMeta(meta: unknown) {
+    return parseQuestionMeta(meta);
+  }
+}

package/src/{lib/worksheet-generation.test.ts → services/content/worksheet-generation.service.test.ts}

@@ -1,6 +1,6 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
-import { mergeWorksheetGenerationConfig, normalizeWorksheetProblemForDb } from './worksheet-generation.js';
+import { mergeWorksheetGenerationConfig, normalizeWorksheetProblemForDb } from './worksheet-generation.service.js';
 
 test('mergeWorksheetGenerationConfig: override beats preset and legacy', () => {
   const r = mergeWorksheetGenerationConfig(