@goscribe/server 1.5.0 → 1.6.0

package/dist/services/content/media-analysis.service.js

@@ -7,6 +7,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';
 const PIPELINE_STEPS = ['fileUpload', 'fileAnalysis', 'studyGuide', 'flashcards'];
 const PROGRESS_FILENAME_MAX_CHARS = 20;
 function truncateProgressFilename(value, maxChars = PROGRESS_FILENAME_MAX_CHARS) {
@@ -312,16 +313,27 @@ export class MediaAnalysisService extends BaseService {
                         }));
                         const flashcardRag = await workspaceKbService.retrieveContext(input.workspaceId, 'flashcard key concepts facts definitions questions', 8);
                         const content = await ai.backend.generateFlashcardQuestions(input.workspaceId, userId, 10, 'medium', undefined, { 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, back, index) => {
+                            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 || []);
@@ -329,15 +341,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) {
@@ -347,18 +351,14 @@ 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/dist/services/content/worksheet-generation.service.test.js

@@ -4,8 +4,8 @@ import { mergeWorksheetGenerationConfig, normalizeWorksheetProblemForDb } from '
 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');
+    assert.equal(r.numQuestions, 3);
+    assert.equal(r.difficulty, 'hard');
 });
 test('normalizeWorksheetProblemForDb coerces MCQ answer to option index', () => {
     const row = normalizeWorksheetProblemForDb({

package/dist/services/workspace/workspace.service.d.ts

@@ -33,35 +33,26 @@ export declare class WorkspaceService extends BaseService {
         folders: {
             name: string;
             id: string;
-            createdAt: Date;
             updatedAt: Date;
-            ownerId: string;
             parentId: string | null;
             color: string;
             markerColor: string | null;
         }[];
-        workspaces: ({
-            uploads: {
-                name: string;
-                id: string;
-                createdAt: Date;
-                mimeType: string;
-            }[];
-        } & {
+        workspaces: {
             id: string;
-            createdAt: Date;
             updatedAt: Date;
             title: string;
-            description: string | null;
-            ownerId: string;
             color: string;
             markerColor: string | null;
             icon: string;
             folderId: string | null;
-            fileBeingAnalyzed: boolean;
-            analysisProgress: import("@prisma/client/runtime/library").JsonValue | null;
-            needsAnalysis: boolean;
-        })[];
+            uploads: {
+                name: string;
+                id: string;
+                createdAt: Date;
+                mimeType: string;
+            }[];
+        }[];
     }>;
     create(userId: string, input: {
         name: string;
@@ -122,70 +113,35 @@ export declare class WorkspaceService extends BaseService {
         markerColor: string | null;
     }>;
     get(userId: string, id: string): Promise<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        title: string;
+        description: string | null;
         folder: {
             name: string;
             id: string;
-            createdAt: Date;
-            updatedAt: Date;
-            ownerId: string;
-            parentId: string | null;
             color: string;
-            markerColor: string | null;
         } | null;
-        artifacts: {
-            id: string;
-            createdAt: Date;
-            updatedAt: Date;
-            workspaceId: string;
-            type: import("@prisma/client").$Enums.ArtifactType;
-            title: string;
-            isArchived: boolean;
-            difficulty: import("@prisma/client").$Enums.Difficulty | null;
-            estimatedTime: string | null;
-            createdById: string | null;
-            description: string | null;
-            generating: boolean;
-            generatingMetadata: import("@prisma/client/runtime/library").JsonValue | null;
-            worksheetConfig: import("@prisma/client/runtime/library").JsonValue | null;
-            imageObjectKey: string | null;
-        }[];
+        ownerId: string;
+        color: string;
+        markerColor: string | null;
+        icon: string;
+        folderId: string | null;
+        fileBeingAnalyzed: boolean;
+        analysisProgress: import("@prisma/client/runtime/library").JsonValue;
+        needsAnalysis: boolean;
         uploads: {
-            meta: import("@prisma/client/runtime/library").JsonValue | null;
             name: string;
             id: string;
             createdAt: Date;
-            workspaceId: string | null;
-            userId: string | null;
             mimeType: string;
             size: number;
-            bucket: string | null;
             objectKey: string | null;
-            url: string | null;
-            checksum: string | null;
-            aiTranscription: import("@prisma/client/runtime/library").JsonValue | null;
         }[];
-    } & {
-        id: string;
-        createdAt: Date;
-        updatedAt: Date;
-        title: string;
-        description: string | null;
-        ownerId: string;
-        color: string;
-        markerColor: string | null;
-        icon: string;
-        folderId: string | null;
-        fileBeingAnalyzed: boolean;
-        analysisProgress: import("@prisma/client/runtime/library").JsonValue | null;
-        needsAnalysis: boolean;
-    }>;
-    getStats(userId: string): Promise<{
-        workspaces: number;
-        folders: number;
-        lastUpdated: Date | undefined;
-        spaceUsed: number;
-        spaceTotal: number;
     }>;
+    getAccountSummary(userId: string): Promise<import("../billing/usage.service.js").AccountSummary>;
+    getStats(userId: string): Promise<import("../billing/usage.service.js").AccountStats>;
     update(userId: string, input: {
         id: string;
         name?: string;

package/dist/services/workspace/workspace.service.js

@@ -1,10 +1,10 @@
 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';
 export class WorkspaceService extends BaseService {
@@ -22,24 +22,41 @@ export class WorkspaceService extends BaseService {
         return { workspaces, folders };
     }
     async getTree(userId) {
-        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 };
     }
     async create(userId, input) {
@@ -50,27 +67,16 @@ 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;
     }
     async createFolder(userId, input) {
@@ -101,43 +107,44 @@ export class WorkspaceService extends BaseService {
     async get(userId, id) {
         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 getAccountSummary(userId) {
+        return getAccountSummary(userId);
+    }
     async getStats(userId) {
-        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) => ws.id) }, userId },
-            _sum: { size: true },
-        });
-        const storageLimit = await getUserStorageLimit(userId);
-        return {
-            workspaces: workspaces.length,
-            folders: folders.length,
-            lastUpdated: lastUpdated?.updatedAt,
-            spaceUsed: spaceLeft._sum?.size ?? 0,
-            spaceTotal: storageLimit,
-        };
+        const summary = await getAccountSummary(userId);
+        return summary.stats;
     }
     async update(userId, input) {
         const existed = await this.db.workspace.findFirst({

package/dist/trpc.d.ts

@@ -20,7 +20,9 @@ export declare const publicProcedure: import("@trpc/server").TRPCProcedureBuilde
 /** Exported procedures with middleware */
 export declare const authedProcedure: import("@trpc/server").TRPCProcedureBuilder<Context, object, {
     userId: any;
-    session: any;
+    session: {
+        user: import("./context.js").SessionUser;
+    };
     req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
     res: import("express").Response<any, Record<string, any>>;
     db: import("@prisma/client").PrismaClient<import("@prisma/client").Prisma.PrismaClientOptions, never, import("@prisma/client/runtime/library").DefaultArgs>;
@@ -28,7 +30,9 @@ export declare const authedProcedure: import("@trpc/server").TRPCProcedureBuilde
 }, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, false>;
 export declare const verifiedProcedure: import("@trpc/server").TRPCProcedureBuilder<Context, object, {
     userId: any;
-    session: any;
+    session: {
+        user: import("./context.js").SessionUser;
+    };
     req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
     res: import("express").Response<any, Record<string, any>>;
     db: import("@prisma/client").PrismaClient<import("@prisma/client").Prisma.PrismaClientOptions, never, import("@prisma/client/runtime/library").DefaultArgs>;
@@ -36,7 +40,9 @@ export declare const verifiedProcedure: import("@trpc/server").TRPCProcedureBuil
 }, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, false>;
 export declare const adminProcedure: import("@trpc/server").TRPCProcedureBuilder<Context, object, {
     userId: any;
-    session: any;
+    session: {
+        user: import("./context.js").SessionUser;
+    };
     req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
     res: import("express").Response<any, Record<string, any>>;
     db: import("@prisma/client").PrismaClient<import("@prisma/client").Prisma.PrismaClientOptions, never, import("@prisma/client/runtime/library").DefaultArgs>;
@@ -44,7 +50,9 @@ export declare const adminProcedure: import("@trpc/server").TRPCProcedureBuilder
 }, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, false>;
 export declare const limitedProcedure: import("@trpc/server").TRPCProcedureBuilder<Context, object, {
     userId: any;
-    session: any;
+    session: {
+        user: import("./context.js").SessionUser;
+    };
     req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
     res: import("express").Response<any, Record<string, any>>;
     db: import("@prisma/client").PrismaClient<import("@prisma/client").Prisma.PrismaClientOptions, never, import("@prisma/client/runtime/library").DefaultArgs>;

package/dist/trpc.js

@@ -79,11 +79,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.user.id },
-        select: { emailVerified: true },
-    });
+const isVerified = middleware(({ ctx, next }) => {
+    const user = ctx.session?.user;
     if (!user?.emailVerified) {
         throw new TRPCError({
             code: "FORBIDDEN",
@@ -139,12 +136,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.user.id },
-        include: { role: true },
-    });
-    if (user?.role?.name !== 'System Admin') {
+const isAdmin = middleware(({ ctx, next }) => {
+    const user = ctx.session?.user;
+    if (!user?.isSystemAdmin) {
         throw new TRPCError({
             code: "FORBIDDEN",
             message: "You do not have permission to access this resource",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goscribe/server",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/context.ts

@@ -4,14 +4,44 @@ import { prisma } from "./lib/prisma.js";
 import { verifyCustomAuthCookie } from "./lib/auth.js";
 import cookie from "cookie";
 
+export type SessionUser = {
+  id: string;
+  emailVerified: boolean;
+  isSystemAdmin: boolean;
+};
+
 export async function createContext({ req, res }: CreateExpressContextOptions) {
   const cookies = cookie.parse(req.headers.cookie ?? "");
 
-  // Only use custom auth cookie
   const custom = verifyCustomAuthCookie(cookies["auth_token"]);
-  
+
   if (custom) {
-    return { db: prisma, session: { user: { id: custom.userId } } as any, req, res, cookies };
+    const user = await prisma.user.findUnique({
+      where: { id: custom.userId },
+      select: {
+        id: true,
+        emailVerified: true,
+        role: { select: { name: true } },
+      },
+    });
+
+    if (!user) {
+      return { db: prisma, session: null, req, res, cookies };
+    }
+
+    const sessionUser: SessionUser = {
+      id: user.id,
+      emailVerified: !!user.emailVerified,
+      isSystemAdmin: user.role?.name === "System Admin",
+    };
+
+    return {
+      db: prisma,
+      session: { user: sessionUser } as { user: SessionUser },
+      req,
+      res,
+      cookies,
+    };
   }
 
   return { db: prisma, session: null, req, res, cookies };

package/src/lib/ai/index.ts

@@ -2,6 +2,7 @@ import { aiConfig } from './config.js';
 import {
   complete,
   completeText,
+  streamComplete,
 } from './llm-client.js';
 import {
   DEFAULT_EMBEDDING_DIM,
@@ -21,6 +22,7 @@ export const ai = {
   llm: {
     complete,
     completeText,
+    streamComplete,
   },
   embed: {
     texts: embedTexts,
@@ -49,6 +51,7 @@ export {
   aiConfig,
   complete,
   completeText,
+  streamComplete,
   DEFAULT_EMBEDDING_DIM,
   DEFAULT_EMBEDDING_MODEL,
   embedQuery,

package/src/lib/ai/llm-client.ts

@@ -27,5 +27,28 @@ export async function completeText(
   return response.choices?.[0]?.message?.content ?? '';
 }
 
+export async function streamComplete(
+  messages: ChatMessage[],
+  onDelta: (delta: string) => void | Promise<void>,
+  options: CompleteOptions = {},
+): Promise<string> {
+  const stream = await client.chat.completions.create({
+    model: options.model ?? aiConfig.llm.model,
+    messages,
+    stream: true,
+    ...(options.temperature !== undefined ? { temperature: options.temperature } : {}),
+  });
+
+  let content = '';
+  for await (const chunk of stream) {
+    const delta = chunk.choices?.[0]?.delta?.content ?? '';
+    if (!delta) continue;
+    content += delta;
+    await onDelta(delta);
+  }
+
+  return content;
+}
+
 /** @deprecated Use `complete()` from the ai module instead. */
 export default complete;

package/src/routers/auth.ts

@@ -30,7 +30,7 @@ const passwordFieldSchema = z
   .regex(/[^a-zA-Z0-9]/, 'Password must contain at least one special character');
 
 export const auth = router({
-  updateProfile: publicProcedure
+  updateProfile: authedProcedure
     .input(z.object({ name: z.string().min(1) }))
     .mutation(({ ctx, input }) =>
       new AuthService(ctx.db).updateProfile(ctx.session.user.id, input),

package/src/routers/workspace.ts

@@ -71,6 +71,10 @@ export const workspace = router({
     new WorkspaceService(ctx.db).getStats(ctx.session.user.id),
   ),
 
+  getAccountSummary: authedProcedure.query(({ ctx }) =>
+    new WorkspaceService(ctx.db).getAccountSummary(ctx.session.user.id),
+  ),
+
   getStudyAnalytics: authedProcedure.query(({ ctx }) =>
     new WorkspaceAnalyticsService(ctx.db).getStudyAnalytics(ctx.session.user.id),
   ),

package/src/services/billing/payment.service.ts

@@ -5,7 +5,7 @@ import { Stripe } from 'stripe';
 import { BaseService } from '../base.service.js';
 import { stripe } from '../../lib/stripe.js';
 import { env } from '../../lib/env.js';
-import { getUserUsage, getUserPlanLimits } from './usage.service.js';
+import { getAccountSummary, getUserUsage, getUserPlanLimits } from './usage.service.js';
 import {
   notifyPaymentSucceeded,
   notifySubscriptionActivated,
@@ -423,11 +423,8 @@ export class PaymentService extends BaseService {
   }
 
   async getUsageOverview(userId: string) {
-    const [usage, limits] = await Promise.all([
-      getUserUsage(userId),
-      getUserPlanLimits(userId),
-    ]);
-    return { usage, limits, hasActivePlan: !!limits };
+    const { usage, limits, hasActivePlan } = await getAccountSummary(userId);
+    return { usage, limits, hasActivePlan };
   }
 
   getResourcePrices() {