@goscribe/server 1.5.0 → 1.6.0

package/dist/services/billing/usage.service.js

@@ -1,4 +1,5 @@
 import { prisma } from '../../lib/prisma.js';
+import { workspaceAccessWhere } from '../../repositories/workspace.repository.js';
 const FALLBACK_PLAN_LIMITS = {
     id: 'fallback-free',
     planId: 'fallback-free',
@@ -8,10 +9,37 @@ const FALLBACK_PLAN_LIMITS = {
     maxPodcasts: 0,
     maxStudyGuides: 1,
 };
+const CACHE_TTL_MS = 30000;
+const usageCache = new Map();
+const limitsCache = new Map();
+const accountSummaryCache = new Map();
+function readCache(map, userId) {
+    const entry = map.get(userId);
+    if (!entry || entry.expiresAt <= Date.now()) {
+        map.delete(userId);
+        return null;
+    }
+    return entry.value;
+}
+function writeCache(map, userId, value) {
+    map.set(userId, { value, expiresAt: Date.now() + CACHE_TTL_MS });
+}
+/** Bust cached usage/limit reads after creates, deletes, or billing changes. */
+export function invalidateUserBillingCache(userId) {
+    usageCache.delete(userId);
+    limitsCache.delete(userId);
+    accountSummaryCache.delete(userId);
+}
+function workspaceAccessFilter(userId) {
+    return workspaceAccessWhere(userId);
+}
 /**
  * Counts all resources consumed by a user across the platform.
  */
 export async function getUserUsage(userId) {
+    const cached = readCache(usageCache, userId);
+    if (cached)
+        return cached;
     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' } }),
@@ -19,53 +47,55 @@ export async function getUserUsage(userId) {
         prisma.artifact.count({ where: { createdById: userId, type: 'PODCAST_EPISODE' } }),
         prisma.fileAsset.aggregate({
             _sum: { size: true },
-            where: { userId }
-        })
+            where: { userId },
+        }),
     ]);
-    return {
+    const usage = {
         flashcards,
         worksheets,
         studyGuides,
         podcasts,
-        storageBytes: Number(storageResult._sum.size || 0)
+        storageBytes: Number(storageResult._sum.size || 0),
     };
+    writeCache(usageCache, userId, usage);
+    return usage;
 }
 /**
  * Retrieves the specific plan limits for a user based on their active subscription
  * PLUS any extra credits purchased.
  */
 export async function getUserPlanLimits(userId) {
+    const cached = readCache(limitsCache, userId);
+    if (cached)
+        return cached;
     const [activeSub, freePlan, userCredits] = await Promise.all([
         prisma.subscription.findFirst({
             where: { userId, status: 'active' },
             include: { plan: { include: { limit: true } } },
-            orderBy: { createdAt: 'desc' }
+            orderBy: { createdAt: 'desc' },
         }),
         prisma.plan.findFirst({
             where: {
                 active: true,
                 price: 0,
-                limit: { isNot: null }
+                limit: { isNot: null },
             },
             include: { limit: true },
-            orderBy: { createdAt: 'asc' }
+            orderBy: { createdAt: 'asc' },
         }),
         prisma.userCredit.groupBy({
             by: ['resourceType'],
             where: { userId },
-            _sum: { amount: true }
-        })
+            _sum: { amount: true },
+        }),
     ]);
     const baseLimit = activeSub?.plan?.limit ?? freePlan?.limit;
-    // Prefer subscription limits, then DB free-plan limits, then hardcoded safety fallback.
     const base = baseLimit ?? FALLBACK_PLAN_LIMITS;
-    // Fast lookup for credits
-    const getCreditSum = (type) => userCredits.find(c => c.resourceType === type)?._sum.amount || 0;
-    // Return the merged total limit
-    return {
+    const getCreditSum = (type) => userCredits.find((c) => c.resourceType === type)?._sum.amount || 0;
+    const limits = {
         id: base.id,
         planId: base.planId,
-        maxStorageBytes: BigInt(Number(base.maxStorageBytes) + (getCreditSum('STORAGE') * 1024 * 1024)),
+        maxStorageBytes: BigInt(Number(base.maxStorageBytes) + getCreditSum('STORAGE') * 1024 * 1024),
         maxWorksheets: base.maxWorksheets + getCreditSum('WORKSHEET'),
         maxFlashcards: base.maxFlashcards + getCreditSum('FLASHCARD_SET'),
         maxPodcasts: base.maxPodcasts + getCreditSum('PODCAST_EPISODE'),
@@ -74,4 +104,46 @@ export async function getUserPlanLimits(userId) {
         updatedAt: baseLimit?.updatedAt || new Date(),
         isFallbackPlan: !baseLimit,
     };
+    writeCache(limitsCache, userId, limits);
+    return limits;
+}
+/**
+ * Sidebar/dashboard summary: stats + usage + limits in one parallel DB round-trip batch.
+ */
+export async function getAccountSummary(userId) {
+    const cached = readCache(accountSummaryCache, userId);
+    if (cached)
+        return cached;
+    const workspaceWhere = workspaceAccessFilter(userId);
+    const [workspaceMeta, folderCount, usage, limits, storageUsed] = await Promise.all([
+        prisma.workspace.aggregate({
+            where: workspaceWhere,
+            _count: { _all: true },
+            _max: { updatedAt: true },
+        }),
+        prisma.folder.count({ where: { ownerId: userId } }),
+        getUserUsage(userId),
+        getUserPlanLimits(userId),
+        prisma.fileAsset.aggregate({
+            where: {
+                userId,
+                workspace: workspaceWhere,
+            },
+            _sum: { size: true },
+        }),
+    ]);
+    const summary = {
+        stats: {
+            workspaces: workspaceMeta._count._all,
+            folders: folderCount,
+            lastUpdated: workspaceMeta._max.updatedAt,
+            spaceUsed: Number(storageUsed._sum.size ?? 0),
+            spaceTotal: Number(limits.maxStorageBytes),
+        },
+        usage,
+        limits,
+        hasActivePlan: !limits.isFallbackPlan,
+    };
+    writeCache(accountSummaryCache, userId, summary);
+    return summary;
 }

package/dist/services/content/copilot.service.js

@@ -6,7 +6,7 @@ import { workspaceKbService } from '../workspace/workspace-kb.service.js';
 import { sanitizeString } from '../../lib/validation.js';
 import { workspaceAccessWhere } from '../../repositories/workspace.repository.js';
 import PusherService from '../../lib/pusher.js';
-import { ArtifactType } from '../../lib/constants.js';
+import { FlashcardService } from './flashcard.service.js';
 export const copilotArtifactType = z.enum([
     'study-guide',
     'worksheet',
@@ -304,9 +304,6 @@ export class CopilotService extends BaseService {
     async ask(userId, input) {
         enforceRateLimit(userId, input.context.workspaceId);
         await this.assertWorkspaceAccess(userId, input.context.workspaceId);
-        await PusherService.emitTaskComplete(input.context.workspaceId, 'copilot:thinking', {
-            status: 'started',
-        });
         const history = await this.loadHistory(input.conversationId);
         const model = await callCopilotModel({
             mode: 'ask',
@@ -318,9 +315,6 @@ export class CopilotService extends BaseService {
             model.rawContent ||
             'I could not generate a response.';
         const safeHighlights = normalizeHighlightInstructions(model.parsed?.highlights, input.context.documentPlainText ?? input.context.documentContent);
-        await PusherService.emitTaskComplete(input.context.workspaceId, 'copilot:response', {
-            status: 'completed',
-        });
         await this.persistConversationExchange({
             userId,
             workspaceId: input.context.workspaceId,
@@ -333,9 +327,6 @@ export class CopilotService extends BaseService {
     async explainSelection(userId, input) {
         enforceRateLimit(userId, input.context.workspaceId);
         await this.assertWorkspaceAccess(userId, input.context.workspaceId);
-        await PusherService.emitTaskComplete(input.context.workspaceId, 'copilot:thinking', {
-            status: 'started',
-        });
         const question = input.message && input.message.trim().length > 0
             ? input.message
             : 'Explain the selected text in simple study-friendly terms and include one practical example.';
@@ -349,9 +340,6 @@ export class CopilotService extends BaseService {
         const answer = getAnswerFromParsedJSON(model.parsed) ||
             model.rawContent ||
             'I could not explain this selection.';
-        await PusherService.emitTaskComplete(input.context.workspaceId, 'copilot:response', {
-            status: 'completed',
-        });
         await this.persistConversationExchange({
             userId,
             workspaceId: input.context.workspaceId,
@@ -413,22 +401,20 @@ export class CopilotService extends BaseService {
                 message: 'Copilot did not return valid flashcards.',
             });
         }
-        const artifact = await this.db.artifact.create({
-            data: {
-                workspaceId: input.context.workspaceId,
-                type: ArtifactType.FLASHCARD_SET,
-                title: `Copilot Flashcards - ${new Date().toLocaleString()}`,
-                createdById: userId,
-                generating: false,
-                flashcards: {
-                    create: cards.map((card, index) => ({
-                        front: sanitizeString(card.front, 200),
-                        back: sanitizeString(card.back, 500),
-                        order: index,
-                        tags: ['copilot-generated'],
-                    })),
-                },
-            },
+        const flashcardService = new FlashcardService(this.db);
+        const primarySet = await flashcardService.ensurePrimarySet(userId, input.context.workspaceId);
+        const orderOffset = primarySet.flashcards.reduce((max, card) => Math.max(max, card.order), -1);
+        await this.db.flashcard.createMany({
+            data: cards.map((card, index) => ({
+                artifactId: primarySet.id,
+                front: sanitizeString(card.front, 200),
+                back: sanitizeString(card.back, 500),
+                order: orderOffset + 1 + index,
+                tags: ['copilot-generated'],
+            })),
+        });
+        const artifact = await this.db.artifact.findUniqueOrThrow({
+            where: { id: primarySet.id },
             include: { flashcards: true },
         });
         await PusherService.emitTaskComplete(input.context.workspaceId, 'copilot:response', {

package/dist/services/content/flashcard-progress.service.js

@@ -239,23 +239,23 @@ export class FlashcardProgressService extends BaseService {
     async getDueFlashcards(userId, workspaceId) {
         const now = new Date();
         const LOW_MASTERY_THRESHOLD = 50; // Consider mastery < 50 as low
-        // Get the latest artifact in the workspace
-        const latestArtifact = await this.db.artifact.findFirst({
+        const flashcardSets = await this.db.artifact.findMany({
             where: {
                 workspaceId,
                 type: 'FLASHCARD_SET',
             },
-            orderBy: {
-                updatedAt: 'desc',
-            },
+            include: { _count: { select: { flashcards: true } } },
+            orderBy: { createdAt: 'asc' },
         });
-        if (!latestArtifact) {
+        if (flashcardSets.length === 0) {
             return [];
         }
-        // Get all flashcards from the latest artifact
+        const withCards = flashcardSets.filter((set) => set._count.flashcards > 0);
+        const candidates = withCards.length > 0 ? withCards : flashcardSets;
+        const primaryArtifact = candidates.reduce((best, current) => current._count.flashcards > best._count.flashcards ? current : best);
         const allFlashcards = await this.db.flashcard.findMany({
             where: {
-                artifactId: latestArtifact.id,
+                artifactId: primaryArtifact.id,
             },
             include: {
                 artifact: true,
@@ -290,7 +290,7 @@ export class FlashcardProgressService extends BaseService {
                     }
                 ],
                 flashcard: {
-                    artifactId: latestArtifact.id,
+                    artifactId: primaryArtifact.id,
                 },
             },
             include: {

package/dist/services/content/flashcard.service.d.ts

@@ -9,6 +9,39 @@ export declare const typedAnswerGradeSchema: z.ZodObject<{
 }, z.core.$strip>;
 export declare class FlashcardService extends BaseService {
     constructor(db: PrismaClient);
+    private findPrimarySet;
+    /** Returns the primary set, creating one only when flashcard content is first added. */
+    ensurePrimarySet(userId: string, workspaceId: string): Promise<{
+        flashcards: {
+            id: string;
+            createdAt: Date;
+            artifactId: string;
+            tags: string[];
+            order: number;
+            front: string;
+            back: string;
+            acceptedAnswers: string[];
+        }[];
+        _count: {
+            flashcards: number;
+        };
+    } & {
+        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;
+    }>;
     listSets(userId: string, workspaceId: string): Promise<({
         versions: {
             id: string;
@@ -64,7 +97,7 @@ export declare class FlashcardService extends BaseService {
         back: string;
         acceptedAnswers: string[];
     })[]>;
-    isGenerating(userId: string, workspaceId: string): Promise<boolean | undefined>;
+    isGenerating(userId: string, workspaceId: string): Promise<boolean>;
     createCard(userId: string, input: {
         workspaceId: string;
         front: string;
@@ -119,6 +152,17 @@ export declare class FlashcardService extends BaseService {
         tags?: string[];
     }): Promise<{
         artifact: {
+            flashcards: {
+                id: string;
+                createdAt: Date;
+                artifactId: string;
+                tags: string[];
+                order: number;
+                front: string;
+                back: string;
+                acceptedAnswers: string[];
+            }[];
+        } & {
             id: string;
             createdAt: Date;
             updatedAt: Date;

package/dist/services/content/flashcard.service.js

@@ -7,6 +7,7 @@ import { ai } from '../../lib/ai/index.js';
 import { workspaceKbService } from '../workspace/workspace-kb.service.js';
 import PusherService from '../../lib/pusher.js';
 import { notifyArtifactFailed, notifyArtifactReady } from '../notifications/notification.service.js';
+import { invalidateUserBillingCache } from '../billing/usage.service.js';
 export const typedAnswerGradeSchema = z.object({
     isCorrect: z.boolean(),
     confidence: z.number().min(0).max(1),
@@ -41,6 +42,50 @@ export class FlashcardService extends BaseService {
     constructor(db) {
         super(db);
     }
+    async findPrimarySet(userId, workspaceId) {
+        const sets = await this.db.artifact.findMany({
+            where: {
+                workspaceId,
+                type: ArtifactType.FLASHCARD_SET,
+                workspace: workspaceAccessWhere(userId),
+            },
+            include: {
+                flashcards: { orderBy: { order: 'asc' } },
+                _count: { select: { flashcards: true } },
+            },
+            orderBy: { createdAt: 'asc' },
+        });
+        if (sets.length === 0)
+            return null;
+        const withCards = sets.filter((set) => set._count.flashcards > 0);
+        const candidates = withCards.length > 0 ? withCards : sets;
+        return candidates.reduce((best, current) => current._count.flashcards > best._count.flashcards ? current : best);
+    }
+    /** Returns the primary set, creating one only when flashcard content is first added. */
+    async ensurePrimarySet(userId, workspaceId) {
+        const existing = await this.findPrimarySet(userId, workspaceId);
+        if (existing)
+            return existing;
+        const workspace = await this.db.workspace.findFirst({
+            where: { id: workspaceId, ...workspaceAccessWhere(userId) },
+            select: { id: true, title: true },
+        });
+        if (!workspace) {
+            throw new TRPCError({ code: 'NOT_FOUND', message: 'Workspace not found' });
+        }
+        return this.db.artifact.create({
+            data: {
+                workspaceId,
+                type: ArtifactType.FLASHCARD_SET,
+                title: 'Flashcards',
+                createdById: userId,
+            },
+            include: {
+                flashcards: { orderBy: { order: 'asc' } },
+                _count: { select: { flashcards: true } },
+            },
+        });
+    }
     async listSets(userId, workspaceId) {
         const workspace = await this.db.workspace.findFirst({
             where: { id: workspaceId, ownerId: userId },
@@ -56,57 +101,37 @@ export class FlashcardService extends BaseService {
         });
     }
     async listCards(userId, workspaceId) {
-        const set = await this.db.artifact.findFirst({
-            where: {
-                workspaceId,
-                type: ArtifactType.FLASHCARD_SET,
-                workspace: workspaceAccessWhere(userId),
-            },
+        const set = await this.findPrimarySet(userId, workspaceId);
+        if (!set)
+            return [];
+        return this.db.flashcard.findMany({
+            where: { artifactId: set.id },
             include: {
-                flashcards: {
-                    include: {
-                        progress: { where: { userId } },
-                    },
-                },
+                progress: { where: { userId } },
             },
-            orderBy: { createdAt: 'desc' },
+            orderBy: { order: 'asc' },
         });
-        if (!set)
-            throw new TRPCError({ code: 'NOT_FOUND' });
-        return set.flashcards;
     }
     async isGenerating(userId, workspaceId) {
-        const artifact = await this.db.artifact.findFirst({
-            where: {
-                workspaceId,
-                type: ArtifactType.FLASHCARD_SET,
-                workspace: workspaceAccessWhere(userId),
-            },
-            orderBy: { createdAt: 'desc' },
-        });
-        return artifact?.generating;
+        const set = await this.findPrimarySet(userId, workspaceId);
+        return set?.generating ?? false;
     }
     async createCard(userId, input) {
-        const set = await this.db.artifact.findFirst({
-            where: {
-                type: ArtifactType.FLASHCARD_SET,
-                workspace: { id: input.workspaceId },
-            },
-            include: { flashcards: true },
-            orderBy: { updatedAt: 'desc' },
-        });
-        if (!set)
-            throw new TRPCError({ code: 'NOT_FOUND' });
-        return this.db.flashcard.create({
+        const set = await this.ensurePrimarySet(userId, input.workspaceId);
+        const nextOrder = input.order ??
+            (set.flashcards.reduce((max, card) => Math.max(max, card.order), -1) + 1);
+        const card = await this.db.flashcard.create({
             data: {
                 artifactId: set.id,
                 front: input.front,
                 back: input.back,
                 acceptedAnswers: normalizeAcceptedAnswers(input.acceptedAnswers),
                 tags: input.tags ?? [],
-                order: input.order ?? 0,
+                order: nextOrder,
             },
         });
+        invalidateUserBillingCache(userId);
+        return card;
     }
     async updateCard(userId, input) {
         const card = await this.db.flashcard.findFirst({
@@ -217,37 +242,23 @@ export class FlashcardService extends BaseService {
         });
         if (!workspace)
             throw new TRPCError({ code: 'NOT_FOUND' });
-        const flashcardCurrent = await this.db.artifact.findFirst({
-            where: {
-                workspaceId: input.workspaceId,
-                type: ArtifactType.FLASHCARD_SET,
-            },
-            select: { id: true, flashcards: true },
-            orderBy: { updatedAt: 'desc' },
-        });
+        const primarySet = await this.ensurePrimarySet(userId, input.workspaceId);
+        const orderOffset = primarySet.flashcards.reduce((max, card) => Math.max(max, card.order), -1);
         try {
             await PusherService.emitTaskComplete(input.workspaceId, 'flash_card_info', {
                 status: 'generating',
                 numCards: input.numCards,
                 difficulty: input.difficulty,
             });
-            const artifact = await this.db.artifact.create({
+            await this.db.artifact.update({
+                where: { id: primarySet.id },
                 data: {
-                    workspaceId: input.workspaceId,
-                    type: ArtifactType.FLASHCARD_SET,
-                    title: input.title || `Flashcards - ${new Date().toLocaleString()}`,
-                    createdById: userId,
                     generating: true,
                     generatingMetadata: {
                         quantity: input.numCards,
                         difficulty: input.difficulty.toLowerCase(),
                     },
-                    flashcards: {
-                        create: flashcardCurrent?.flashcards.map((card) => ({
-                            front: card.front,
-                            back: card.back,
-                        })),
-                    },
+                    ...(input.title ? { title: input.title } : {}),
                 },
             });
             const ragContext = await workspaceKbService.retrieveContext(input.workspaceId, input.prompt ?? 'flashcard key concepts facts definitions', 8);
@@ -262,10 +273,10 @@ export class FlashcardService extends BaseService {
                     const back = card.definition || card.back || card.answer || card.solution || `Answer ${i + 1}`;
                     await this.db.flashcard.create({
                         data: {
-                            artifactId: artifact.id,
+                            artifactId: primarySet.id,
                             front,
                             back,
-                            order: i,
+                            order: orderOffset + 1 + i,
                             tags: input.tags ?? ['ai-generated', input.difficulty],
                         },
                     });
@@ -281,10 +292,10 @@ export class FlashcardService extends BaseService {
                         const [front, back] = line.split(' - ');
                         await this.db.flashcard.create({
                             data: {
-                                artifactId: artifact.id,
+                                artifactId: primarySet.id,
                                 front: front.trim(),
                                 back: back.trim(),
-                                order: i,
+                                order: orderOffset + 1 + i,
                                 tags: input.tags ?? ['ai-generated', input.difficulty],
                             },
                         });
@@ -292,11 +303,12 @@ export class FlashcardService extends BaseService {
                     }
                 }
             }
-            await PusherService.emitFlashcardComplete(input.workspaceId, artifact);
-            await this.db.artifact.update({
-                where: { id: artifact.id },
+            const artifact = await this.db.artifact.update({
+                where: { id: primarySet.id },
                 data: { generating: false },
+                include: { flashcards: true },
             });
+            await PusherService.emitFlashcardComplete(input.workspaceId, artifact);
             await notifyArtifactReady(this.db, {
                 userId,
                 workspaceId: input.workspaceId,
@@ -304,15 +316,16 @@ export class FlashcardService extends BaseService {
                 artifactType: ArtifactType.FLASHCARD_SET,
                 title: artifact.title,
             }).catch(() => { });
+            invalidateUserBillingCache(userId);
             return { artifact, createdCards };
         }
         catch (error) {
-            if (flashcardCurrent?.id) {
-                await this.db.artifact.update({
-                    where: { id: flashcardCurrent.id },
-                    data: { generating: false },
-                });
-            }
+            await this.db.artifact
+                .update({
+                where: { id: primarySet.id },
+                data: { generating: false },
+            })
+                .catch(() => { });
             await PusherService.emitError(input.workspaceId, `Failed to generate flashcards: ${error}`, 'flash_card_generation');
             await notifyArtifactFailed(this.db, {
                 userId,