@goscribe/server 1.5.0 → 1.6.0

package/src/services/content/media-analysis.service.ts

@@ -8,6 +8,7 @@ import { ai } from '../../lib/ai/index.js';
 import { workspaceKbService } from '../workspace/workspace-kb.service.js';
 import { getUserUsage, getUserPlanLimits } from '../billing/usage.service.js';
 import { notifyArtifactFailed, notifyArtifactReady } from '../notifications/notification.service.js';
+import { FlashcardService } from './flashcard.service.js';
 
 type StepStatus = 'pending' | 'in_progress' | 'completed' | 'skipped' | 'error';
 const PIPELINE_STEPS = ['fileUpload', 'fileAnalysis', 'studyGuide', 'flashcards'] as const;
@@ -449,18 +450,34 @@ export class MediaAnalysisService extends BaseService {
               { ragContext: flashcardRag },
             );
 
-            const artifact = await this.db.artifact.create({
-              data: {
-                workspaceId: input.workspaceId,
-                type: ArtifactType.FLASHCARD_SET,
-                title:
-                  files.length === 1
-                    ? `Flashcards - ${primaryFile.name}`
-                    : `Flashcards - ${files.length} files`,
-                createdById: userId,
-              },
+            const flashcardService = new FlashcardService(this.db);
+            const primarySet = await flashcardService.ensurePrimarySet(userId, input.workspaceId);
+            const orderOffset = primarySet.flashcards.reduce(
+              (max, card) => Math.max(max, card.order),
+              -1,
+            );
+            const flashcardTitle =
+              files.length === 1
+                ? `Flashcards - ${primaryFile.name}`
+                : `Flashcards - ${files.length} files`;
+
+            await this.db.artifact.update({
+              where: { id: primarySet.id },
+              data: { title: flashcardTitle },
             });
 
+            const appendCard = async (front: string, back: string, index: number) => {
+              await this.db.flashcard.create({
+                data: {
+                  artifactId: primarySet.id,
+                  front,
+                  back,
+                  order: orderOffset + 1 + index,
+                  tags: ['ai-generated', 'medium'],
+                },
+              });
+            };
+
             try {
               const parsed = typeof content === 'string' ? JSON.parse(content) : content;
               const flashcardData = Array.isArray(parsed) ? parsed : (parsed.flashcards || []);
@@ -469,16 +486,7 @@ export class MediaAnalysisService extends BaseService {
                 const card = flashcardData[i];
                 const front = card.term || card.front || card.question || card.prompt || `Question ${i + 1}`;
                 const back = card.definition || card.back || card.answer || card.solution || `Answer ${i + 1}`;
-
-                await this.db.flashcard.create({
-                  data: {
-                    artifactId: artifact.id,
-                    front: front,
-                    back: back,
-                    order: i,
-                    tags: ['ai-generated', 'medium'],
-                  },
-                });
+                await appendCard(front, back, i);
               }
             } catch (parseError) {
               console.error(
@@ -490,19 +498,16 @@ export class MediaAnalysisService extends BaseService {
                 const line = lines[i];
                 if (line.includes(' - ')) {
                   const [front, back] = line.split(' - ');
-                  await this.db.flashcard.create({
-                    data: {
-                      artifactId: artifact.id,
-                      front: front.trim(),
-                      back: back.trim(),
-                      order: i,
-                      tags: ['ai-generated', 'medium'],
-                    },
-                  });
+                  await appendCard(front.trim(), back.trim(), i);
                 }
               }
             }
 
+            const artifact = await this.db.artifact.findUniqueOrThrow({
+              where: { id: primarySet.id },
+              include: { flashcards: true },
+            });
+
             results.artifacts.flashcards = artifact;
             await PusherService.emitFlashcardComplete(input.workspaceId, artifact);
             await notifyArtifactReady(this.db, {

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

@@ -9,8 +9,8 @@ test('mergeWorksheetGenerationConfig: override beats preset and legacy', () => {
     { numQuestions: 3, difficulty: 'hard' },
   );
   assert.equal(r.mode, 'quiz');
-  assert.equal(r.numQuestions, 10);
-  assert.equal(r.difficulty, 'medium');
+  assert.equal(r.numQuestions, 3);
+  assert.equal(r.difficulty, 'hard');
 });
 
 test('normalizeWorksheetProblemForDb coerces MCQ answer to option index', () => {

package/src/services/workspace/workspace.service.ts

@@ -1,11 +1,14 @@
 import type { PrismaClient } from '@prisma/client';
 import { TRPCError } from '@trpc/server';
 import { BaseService } from '../base.service.js';
-import { ArtifactType } from '../../lib/constants.js';
 import { supabaseClient } from '../../lib/storage.js';
 import PusherService from '../../lib/pusher.js';
 import { ai } from '../../lib/ai/index.js';
 import { workspaceKbService } from './workspace-kb.service.js';
+import {
+  getAccountSummary,
+  invalidateUserBillingCache,
+} from '../billing/usage.service.js';
 import { getUserStorageLimit } from '../billing/subscription.service.js';
 import { notifyWorkspaceDeleted } from '../notifications/notification.service.js';
 
@@ -26,25 +29,41 @@ export class WorkspaceService extends BaseService {
   }
 
   async getTree(userId: string) {
-    const allFolders = await this.db.folder.findMany({
-      where: { ownerId: userId },
-      orderBy: { updatedAt: 'desc' },
-    });
-
-    const allWorkspaces = await this.db.workspace.findMany({
-      where: { ownerId: userId },
-      include: {
-        uploads: {
-          select: {
-            id: true,
-            name: true,
-            mimeType: true,
-            createdAt: true,
+    const [allFolders, allWorkspaces] = await Promise.all([
+      this.db.folder.findMany({
+        where: { ownerId: userId },
+        select: {
+          id: true,
+          name: true,
+          parentId: true,
+          color: true,
+          markerColor: true,
+          updatedAt: true,
+        },
+        orderBy: { updatedAt: 'desc' },
+      }),
+      this.db.workspace.findMany({
+        where: { ownerId: userId },
+        select: {
+          id: true,
+          title: true,
+          folderId: true,
+          icon: true,
+          color: true,
+          markerColor: true,
+          updatedAt: true,
+          uploads: {
+            select: {
+              id: true,
+              name: true,
+              mimeType: true,
+              createdAt: true,
+            },
           },
         },
-      },
-      orderBy: { updatedAt: 'desc' },
-    });
+        orderBy: { updatedAt: 'desc' },
+      }),
+    ]);
 
     return { folders: allFolders, workspaces: allWorkspaces };
   }
@@ -65,30 +84,19 @@ export class WorkspaceService extends BaseService {
         ownerId: userId,
         folderId: input.parentId ?? null,
         ...(input.markerColor !== undefined ? { markerColor: input.markerColor } : {}),
-        artifacts: {
-          create: {
-            type: ArtifactType.FLASHCARD_SET,
-            title: 'New Flashcard Set',
-          },
-          createMany: {
-            data: [
-              { type: ArtifactType.WORKSHEET, title: 'Worksheet 1' },
-              { type: ArtifactType.WORKSHEET, title: 'Worksheet 2' },
-            ],
-          },
-        },
       },
     });
 
-    await ai.backend.initSession(ws.id, userId).catch((err) => {
+    void ai.backend.initSession(ws.id, userId).catch((err) => {
       this.logger.error('Failed to init AI session on workspace creation:', err);
     });
 
-    await workspaceKbService.ensureWorkspaceKb(ws.id, userId, input.name).catch((err) => {
+    void workspaceKbService.ensureWorkspaceKb(ws.id, userId, input.name).catch((err) => {
       this.logger.error('Failed to create workspace knowledge base:', err);
     });
 
-    await PusherService.emitLibraryUpdate(userId);
+    invalidateUserBillingCache(userId);
+    void PusherService.emitLibraryUpdate(userId);
 
     return ws;
   }
@@ -130,46 +138,45 @@ export class WorkspaceService extends BaseService {
   async get(userId: string, id: string) {
     const ws = await this.db.workspace.findFirst({
       where: { id, ownerId: userId },
-      include: {
-        artifacts: true,
-        folder: true,
-        uploads: true,
+      select: {
+        id: true,
+        title: true,
+        description: true,
+        icon: true,
+        color: true,
+        markerColor: true,
+        ownerId: true,
+        folderId: true,
+        fileBeingAnalyzed: true,
+        analysisProgress: true,
+        needsAnalysis: true,
+        createdAt: true,
+        updatedAt: true,
+        folder: { select: { id: true, name: true, color: true } },
+        uploads: {
+          select: {
+            id: true,
+            name: true,
+            mimeType: true,
+            size: true,
+            createdAt: true,
+            objectKey: true,
+          },
+          orderBy: { createdAt: 'desc' },
+        },
       },
     });
     if (!ws) throw new TRPCError({ code: 'NOT_FOUND' });
     return ws;
   }
 
-  async getStats(userId: string) {
-    const workspaces = await this.db.workspace.findMany({
-      where: {
-        OR: [{ ownerId: userId }, { sharedWith: { some: { id: userId } } }],
-      },
-    });
-    const folders = await this.db.folder.findMany({
-      where: { OR: [{ ownerId: userId }] },
-    });
-    const lastUpdated = await this.db.workspace.findFirst({
-      where: {
-        OR: [{ ownerId: userId }, { sharedWith: { some: { id: userId } } }],
-      },
-      orderBy: { updatedAt: 'desc' },
-    });
-
-    const spaceLeft = await this.db.fileAsset.aggregate({
-      where: { workspaceId: { in: workspaces.map((ws: any) => ws.id) }, userId },
-      _sum: { size: true },
-    });
-
-    const storageLimit = await getUserStorageLimit(userId);
+  async getAccountSummary(userId: string) {
+    return getAccountSummary(userId);
+  }
 
-    return {
-      workspaces: workspaces.length,
-      folders: folders.length,
-      lastUpdated: lastUpdated?.updatedAt,
-      spaceUsed: spaceLeft._sum?.size ?? 0,
-      spaceTotal: storageLimit,
-    };
+  async getStats(userId: string) {
+    const summary = await getAccountSummary(userId);
+    return summary.stats;
   }
 
   async update(

package/src/trpc.ts

@@ -95,12 +95,8 @@ const errorHandler = middleware(async ({ next }) => {
 /**
  * Middleware that enforces email verification
  */
-const isVerified = middleware(async ({ ctx, next }) => {
-  const user = await ctx.db.user.findUnique({
-    where: { id: (ctx.session as any).user.id },
-    select: { emailVerified: true },
-  });
-
+const isVerified = middleware(({ ctx, next }) => {
+  const user = (ctx.session as { user?: { emailVerified?: boolean } })?.user;
   if (!user?.emailVerified) {
     throw new TRPCError({
       code: "FORBIDDEN",
@@ -168,13 +164,9 @@ const checkUsageLimit = middleware(async ({ ctx, next, path }) => {
 /**
  * Middleware that enforces system admin role
  */
-const isAdmin = middleware(async ({ ctx, next }) => {
-  const user = await ctx.db.user.findUnique({
-    where: { id: (ctx.session as any).user.id },
-    include: { role: true },
-  });
-
-  if (user?.role?.name !== 'System Admin') {
+const isAdmin = middleware(({ ctx, next }) => {
+  const user = (ctx.session as { user?: { isSystemAdmin?: boolean } })?.user;
+  if (!user?.isSystemAdmin) {
     throw new TRPCError({
       code: "FORBIDDEN",
       message: "You do not have permission to access this resource",