@goscribe/server 1.3.0 → 1.3.1

package/dist/lib/usage_service.js

@@ -0,0 +1,59 @@
+import { prisma } from './prisma.js';
+/**
+ * Counts all resources consumed by a user across the platform.
+ */
+export async function getUserUsage(userId) {
+    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) {
+    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) => 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/dist/lib/worksheet-generation.d.ts

@@ -0,0 +1,91 @@
+import { z } from 'zod';
+/** Persisted on Artifact.worksheetConfig and inside generatingMetadata while generating */
+export declare const worksheetModeSchema: z.ZodEnum<{
+    practice: "practice";
+    quiz: "quiz";
+}>;
+export type WorksheetMode = z.infer<typeof worksheetModeSchema>;
+export declare const worksheetDifficultyInputSchema: z.ZodEnum<{
+    easy: "easy";
+    medium: "medium";
+    hard: "hard";
+}>;
+export type WorksheetDifficultyInput = z.infer<typeof worksheetDifficultyInputSchema>;
+export declare const questionTypeSchema: z.ZodEnum<{
+    MULTIPLE_CHOICE: "MULTIPLE_CHOICE";
+    TEXT: "TEXT";
+    NUMERIC: "NUMERIC";
+    TRUE_FALSE: "TRUE_FALSE";
+    MATCHING: "MATCHING";
+    FILL_IN_THE_BLANK: "FILL_IN_THE_BLANK";
+}>;
+export type WorksheetQuestionTypeConfig = z.infer<typeof questionTypeSchema>;
+/** Shape stored in WorksheetPreset.config and used for generation */
+export declare const worksheetPresetConfigSchema: z.ZodObject<{
+    mode: z.ZodDefault<z.ZodEnum<{
+        practice: "practice";
+        quiz: "quiz";
+    }>>;
+    numQuestions: z.ZodDefault<z.ZodNumber>;
+    difficulty: z.ZodDefault<z.ZodEnum<{
+        easy: "easy";
+        medium: "medium";
+        hard: "hard";
+    }>>;
+    questionTypes: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        MULTIPLE_CHOICE: "MULTIPLE_CHOICE";
+        TEXT: "TEXT";
+        NUMERIC: "NUMERIC";
+        TRUE_FALSE: "TRUE_FALSE";
+        MATCHING: "MATCHING";
+        FILL_IN_THE_BLANK: "FILL_IN_THE_BLANK";
+    }>>>;
+    mcqRatio: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type WorksheetPresetConfig = z.infer<typeof worksheetPresetConfigSchema>;
+export declare const worksheetPresetConfigPartialSchema: z.ZodObject<{
+    mode: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+        practice: "practice";
+        quiz: "quiz";
+    }>>>;
+    numQuestions: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    difficulty: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+        easy: "easy";
+        medium: "medium";
+        hard: "hard";
+    }>>>;
+    questionTypes: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        MULTIPLE_CHOICE: "MULTIPLE_CHOICE";
+        TEXT: "TEXT";
+        NUMERIC: "NUMERIC";
+        TRUE_FALSE: "TRUE_FALSE";
+        MATCHING: "MATCHING";
+        FILL_IN_THE_BLANK: "FILL_IN_THE_BLANK";
+    }>>>>;
+    mcqRatio: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+}, z.core.$strip>;
+/** Resolved config used by generateFromPrompt background job */
+export type ResolvedWorksheetGeneration = WorksheetPresetConfig & {
+    prompt: string;
+    title?: string;
+    estimatedTime?: string;
+    presetId?: string | null;
+};
+export declare function parsePresetConfig(raw: unknown): WorksheetPresetConfig;
+export declare function mergeWorksheetGenerationConfig(presetConfig: Partial<WorksheetPresetConfig> | null | undefined, configOverride: Partial<WorksheetPresetConfig> | null | undefined, legacy: {
+    numQuestions?: number;
+    difficulty?: WorksheetDifficultyInput;
+    mode?: WorksheetMode;
+}): WorksheetPresetConfig;
+/** Normalize one LLM problem row before DB insert */
+export declare 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;
+    };
+};

package/dist/lib/worksheet-generation.js

@@ -0,0 +1,95 @@
+import { z } from 'zod';
+/** Persisted on Artifact.worksheetConfig and inside generatingMetadata while generating */
+export const worksheetModeSchema = z.enum(['practice', 'quiz']);
+export const worksheetDifficultyInputSchema = z.enum(['easy', 'medium', 'hard']);
+export const questionTypeSchema = z.enum([
+    'MULTIPLE_CHOICE',
+    'TEXT',
+    'NUMERIC',
+    'TRUE_FALSE',
+    'MATCHING',
+    'FILL_IN_THE_BLANK',
+]);
+/** 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 const worksheetPresetConfigPartialSchema = worksheetPresetConfigSchema.partial();
+const defaultConfig = worksheetPresetConfigSchema.parse({});
+export function parsePresetConfig(raw) {
+    return worksheetPresetConfigSchema.parse(raw);
+}
+export function mergeWorksheetGenerationConfig(presetConfig, configOverride, legacy) {
+    // 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, index0, difficultyUpper, forceMcq) {
+    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 = [];
+    if (Array.isArray(problem.options)) {
+        options = problem.options.filter((o) => 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, options) {
+    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/dist/lib/worksheet-generation.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/worksheet-generation.test.js

@@ -0,0 +1,20 @@
+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/dist/lib/workspace-access.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 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 declare function workspaceAccessFilter(userId: string): {
+    OR: ({
+        ownerId: string;
+        members?: undefined;
+    } | {
+        members: {
+            some: {
+                userId: string;
+            };
+        };
+        ownerId?: undefined;
+    })[];
+};

package/dist/lib/workspace-access.js

@@ -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) {
+    return {
+        OR: [
+            { ownerId: userId },
+            { members: { some: { userId } } },
+        ],
+    };
+}