@goscribe/server 1.1.7 → 1.3.0

package/src/lib/usage_service.ts

@@ -0,0 +1,74 @@
+import { prisma } from './prisma.js';
+
+export interface UserUsage {
+    flashcards: number;
+    worksheets: number;
+    studyGuides: number;
+    podcasts: number;
+    storageBytes: number;
+}
+
+/**
+ * Counts all resources consumed by a user across the platform.
+ */
+export async function getUserUsage(userId: string): Promise<UserUsage> {
+    const [flashcards, worksheets, studyGuides, podcasts, storageResult] = await Promise.all([
+        prisma.artifact.count({ where: { createdById: userId, type: 'FLASHCARD_SET' } }),
+        prisma.artifact.count({ where: { createdById: userId, type: 'WORKSHEET' } }),
+        prisma.artifact.count({ where: { createdById: userId, type: 'STUDY_GUIDE' } }),
+        prisma.artifact.count({ where: { createdById: userId, type: 'PODCAST_EPISODE' } }),
+        prisma.fileAsset.aggregate({
+            _sum: { size: true },
+            where: { userId }
+        })
+    ]);
+
+    return {
+        flashcards,
+        worksheets,
+        studyGuides,
+        podcasts,
+        storageBytes: Number(storageResult._sum.size || 0)
+    };
+}
+
+/**
+ * Retrieves the specific plan limits for a user based on their active subscription 
+ * PLUS any extra credits purchased.
+ */
+export async function getUserPlanLimits(userId: string) {
+    const [activeSub, userCredits] = await Promise.all([
+        prisma.subscription.findFirst({
+            where: { userId, status: 'active' },
+            include: { plan: { include: { limit: true } } },
+            orderBy: { createdAt: 'desc' }
+        }),
+        prisma.userCredit.groupBy({
+            by: ['resourceType'],
+            where: { userId },
+            _sum: { amount: true }
+        })
+    ]);
+
+    const baseLimit = activeSub?.plan?.limit;
+
+    // If no active subscription and no credits, user has no active limits
+    if (!baseLimit && userCredits.length === 0) return null;
+
+    // Fast lookup for credits
+    const getCreditSum = (type: string) =>
+        userCredits.find(c => c.resourceType === type)?._sum.amount || 0;
+
+    // Return the merged total limit
+    return {
+        id: baseLimit?.id || 'credits-only',
+        planId: baseLimit?.planId || 'credits-only',
+        maxStorageBytes: BigInt(Number(baseLimit?.maxStorageBytes || 0) + (getCreditSum('STORAGE') * 1024 * 1024)),
+        maxWorksheets: (baseLimit?.maxWorksheets || 0) + getCreditSum('WORKSHEET'),
+        maxFlashcards: (baseLimit?.maxFlashcards || 0) + getCreditSum('FLASHCARD_SET'),
+        maxPodcasts: (baseLimit?.maxPodcasts || 0) + getCreditSum('PODCAST_EPISODE'),
+        maxStudyGuides: (baseLimit?.maxStudyGuides || 0) + getCreditSum('STUDY_GUIDE'),
+        createdAt: baseLimit?.createdAt || new Date(),
+        updatedAt: baseLimit?.updatedAt || new Date(),
+    };
+}

package/src/lib/worksheet-generation.test.ts

@@ -0,0 +1,31 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mergeWorksheetGenerationConfig, normalizeWorksheetProblemForDb } from './worksheet-generation.js';
+
+test('mergeWorksheetGenerationConfig: override beats preset and legacy', () => {
+  const r = mergeWorksheetGenerationConfig(
+    { mode: 'practice', numQuestions: 5, difficulty: 'easy' },
+    { mode: 'quiz', numQuestions: 10, difficulty: 'medium' },
+    { numQuestions: 3, difficulty: 'hard' },
+  );
+  assert.equal(r.mode, 'quiz');
+  assert.equal(r.numQuestions, 10);
+  assert.equal(r.difficulty, 'medium');
+});
+
+test('normalizeWorksheetProblemForDb coerces MCQ answer to option index', () => {
+  const row = normalizeWorksheetProblemForDb(
+    {
+      question: 'Capital of France?',
+      answer: 'Paris',
+      type: 'MULTIPLE_CHOICE',
+      options: ['London', 'Paris', 'Berlin'],
+    },
+    0,
+    'MEDIUM',
+    true,
+  );
+  assert.equal(row.type, 'MULTIPLE_CHOICE');
+  assert.equal(row.answer, '1');
+  assert.ok(row.meta.options && row.meta.options.length >= 2);
+});

package/src/lib/worksheet-generation.ts

@@ -0,0 +1,139 @@
+import { z } from 'zod';
+
+/** Persisted on Artifact.worksheetConfig and inside generatingMetadata while generating */
+export const worksheetModeSchema = z.enum(['practice', 'quiz']);
+export type WorksheetMode = z.infer<typeof worksheetModeSchema>;
+
+export const worksheetDifficultyInputSchema = z.enum(['easy', 'medium', 'hard']);
+export type WorksheetDifficultyInput = z.infer<typeof worksheetDifficultyInputSchema>;
+
+export const questionTypeSchema = z.enum([
+  'MULTIPLE_CHOICE',
+  'TEXT',
+  'NUMERIC',
+  'TRUE_FALSE',
+  'MATCHING',
+  'FILL_IN_THE_BLANK',
+]);
+export type WorksheetQuestionTypeConfig = z.infer<typeof questionTypeSchema>;
+
+/** Shape stored in WorksheetPreset.config and used for generation */
+export const worksheetPresetConfigSchema = z.object({
+  mode: worksheetModeSchema.default('practice'),
+  numQuestions: z.number().int().min(1).max(20).default(8),
+  difficulty: worksheetDifficultyInputSchema.default('medium'),
+  /** When omitted, quiz mode implies MCQ-only on the inference side */
+  questionTypes: z.array(questionTypeSchema).optional(),
+  /** 0–1 fraction of problems that should be MCQ (practice mode); ignored when quiz forces all MCQ */
+  mcqRatio: z.number().min(0).max(1).optional(),
+});
+
+export type WorksheetPresetConfig = z.infer<typeof worksheetPresetConfigSchema>;
+
+export const worksheetPresetConfigPartialSchema = worksheetPresetConfigSchema.partial();
+
+/** Resolved config used by generateFromPrompt background job */
+export type ResolvedWorksheetGeneration = WorksheetPresetConfig & {
+  prompt: string;
+  title?: string;
+  estimatedTime?: string;
+  presetId?: string | null;
+};
+
+const defaultConfig: WorksheetPresetConfig = worksheetPresetConfigSchema.parse({});
+
+export function parsePresetConfig(raw: unknown): WorksheetPresetConfig {
+  return worksheetPresetConfigSchema.parse(raw);
+}
+
+export function mergeWorksheetGenerationConfig(
+  presetConfig: Partial<WorksheetPresetConfig> | null | undefined,
+  configOverride: Partial<WorksheetPresetConfig> | null | undefined,
+  legacy: { numQuestions?: number; difficulty?: WorksheetDifficultyInput; mode?: WorksheetMode },
+): WorksheetPresetConfig {
+  // Precedence: legacy flat fields > configOverride > preset > defaults
+  // We place legacy AFTER configOverride because configOverride's Zod partial schema injects defaults (like medium) 
+  // that shouldn't overwrite explicit explicit user choices passing via legacy parameters.
+  const merged = {
+    ...defaultConfig,
+    ...presetConfig,
+    ...configOverride,
+    ...(legacy.numQuestions !== undefined ? { numQuestions: legacy.numQuestions } : {}),
+    ...(legacy.difficulty !== undefined ? { difficulty: legacy.difficulty } : {}),
+    ...(legacy.mode !== undefined ? { mode: legacy.mode } : {}),
+  };
+  return worksheetPresetConfigSchema.parse(merged);
+}
+
+/** Normalize one LLM problem row before DB insert */
+export function normalizeWorksheetProblemForDb(
+  problem: Record<string, unknown>,
+  index0: number,
+  difficultyUpper: 'EASY' | 'MEDIUM' | 'HARD',
+  forceMcq: boolean,
+): {
+  prompt: string;
+  answer: string | null;
+  type: string;
+  difficulty: 'EASY' | 'MEDIUM' | 'HARD';
+  order: number;
+  meta: { options?: string[]; markScheme?: unknown };
+} {
+  const prompt =
+    (typeof problem.question === 'string' && problem.question) ||
+    (typeof problem.prompt === 'string' && problem.prompt) ||
+    `Question ${index0 + 1}`;
+
+  let type = String(problem.type || 'TEXT').toUpperCase().replace(/[\s-]/g, '_');
+  if (forceMcq) type = 'MULTIPLE_CHOICE';
+
+  let options: string[] = [];
+  if (Array.isArray(problem.options)) {
+    options = problem.options.filter((o): o is string => typeof o === 'string' && o.trim().length > 0);
+  }
+
+  let answer =
+    (typeof problem.answer === 'string' && problem.answer) ||
+    (typeof problem.solution === 'string' && problem.solution) ||
+    '';
+
+  if (type === 'MULTIPLE_CHOICE') {
+    if (options.length < 2) {
+      options = ['Option A', 'Option B', 'Option C', 'Option D'];
+    }
+    const correctIndex = resolveMcqCorrectIndex(answer, options);
+    answer = String(correctIndex);
+  }
+
+  return {
+    prompt,
+    answer: answer || null,
+    type,
+    difficulty: difficultyUpper,
+    order: index0,
+    meta: {
+      ...(options.length > 0 ? { options } : {}),
+      ...(problem.mark_scheme !== undefined ? { markScheme: problem.mark_scheme } : {}),
+      // Non-MCQ questions are AI-marked via markScheme; provide a safe fallback
+      ...(type === 'TEXT' && problem.mark_scheme === undefined
+        ? {
+            markScheme: {
+              points: [{ point: 1, requirements: 'Typed answer matches expected content.' }],
+              totalPoints: 1,
+            },
+          }
+        : {}),
+    },
+  };
+}
+
+function resolveMcqCorrectIndex(answer: string, options: string[]): number {
+  const trimmed = answer.trim();
+  const asNum = parseInt(trimmed, 10);
+  if (!Number.isNaN(asNum) && asNum >= 0 && asNum < options.length) {
+    return asNum;
+  }
+  const byText = options.findIndex((o) => o.trim() === trimmed);
+  if (byText >= 0) return byText;
+  return 0;
+}

package/src/lib/workspace-access.ts

@@ -0,0 +1,13 @@
+/**
+ * Prisma `where` filter for workspace access checks.
+ * Allows access if the user is the owner OR a member of the workspace.
+ * Use this instead of `{ ownerId: userId }` to support collaborative workspaces.
+ */
+export function workspaceAccessFilter(userId: string) {
+  return {
+    OR: [
+      { ownerId: userId },
+      { members: { some: { userId } } },
+    ],
+  };
+}

package/src/routers/_app.ts

@@ -8,6 +8,12 @@ import { studyguide } from './studyguide.js';
 import { podcast } from './podcast.js';
 import { chat } from './chat.js';
 import { members } from './members.js';
+import { annotations } from './annotations.js';
+import { admin } from './admin.js';
+
+import { paymentRouter } from './payment.js';
+import { copilot } from './copilot.js';
+import { notifications } from './notifications.js';
 
 export const appRouter = router({
   auth,
@@ -17,6 +23,11 @@ export const appRouter = router({
   studyguide,
   podcast,
   chat,
+  annotations,
+  admin,
+  payment: paymentRouter,
+  copilot,
+  notifications,
   // Public member endpoints (for invitation acceptance)
   member: router({
     acceptInvite: members.acceptInvite,