@goscribe/server 1.5.0 → 1.7.0

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

@@ -1,94 +1,207 @@
+import type { Prisma } from '@prisma/client';
 import { prisma } from '../../lib/prisma.js';
+import { workspaceAccessWhere } from '../../repositories/workspace.repository.js';
 
 export interface UserUsage {
-    flashcards: number;
-    worksheets: number;
-    studyGuides: number;
-    podcasts: number;
-    storageBytes: number;
+  flashcards: number;
+  worksheets: number;
+  studyGuides: number;
+  podcasts: number;
+  storageBytes: number;
+}
+
+export interface AccountStats {
+  workspaces: number;
+  folders: number;
+  lastUpdated: Date | null;
+  spaceUsed: number;
+  spaceTotal: number;
+}
+
+export interface UserPlanLimits {
+  id: string;
+  planId: string;
+  maxStorageBytes: bigint;
+  maxWorksheets: number;
+  maxFlashcards: number;
+  maxPodcasts: number;
+  maxStudyGuides: number;
+  createdAt: Date;
+  updatedAt: Date;
+  isFallbackPlan: boolean;
+}
+
+export interface AccountSummary {
+  stats: AccountStats;
+  usage: UserUsage;
+  limits: UserPlanLimits;
+  hasActivePlan: boolean;
 }
 
 const FALLBACK_PLAN_LIMITS = {
-    id: 'fallback-free',
-    planId: 'fallback-free',
-    maxStorageBytes: BigInt(1024 * 1024 * 1024), // 1GB
-    maxWorksheets: 3,
-    maxFlashcards: 20,
-    maxPodcasts: 0,
-    maxStudyGuides: 1,
+  id: 'fallback-free',
+  planId: 'fallback-free',
+  maxStorageBytes: BigInt(1024 * 1024 * 1024), // 1GB
+  maxWorksheets: 3,
+  maxFlashcards: 20,
+  maxPodcasts: 0,
+  maxStudyGuides: 1,
 } as const;
 
+const CACHE_TTL_MS = 30_000;
+
+type CacheEntry<T> = { value: T; expiresAt: number };
+
+const usageCache = new Map<string, CacheEntry<UserUsage>>();
+const limitsCache = new Map<string, CacheEntry<UserPlanLimits>>();
+const accountSummaryCache = new Map<string, CacheEntry<AccountSummary>>();
+
+function readCache<T>(map: Map<string, CacheEntry<T>>, userId: string): T | null {
+  const entry = map.get(userId);
+  if (!entry || entry.expiresAt <= Date.now()) {
+    map.delete(userId);
+    return null;
+  }
+  return entry.value;
+}
+
+function writeCache<T>(map: Map<string, CacheEntry<T>>, userId: string, value: T) {
+  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: string) {
+  usageCache.delete(userId);
+  limitsCache.delete(userId);
+  accountSummaryCache.delete(userId);
+}
+
+function workspaceAccessFilter(userId: string): Prisma.WorkspaceWhereInput {
+  return workspaceAccessWhere(userId);
+}
+
 /**
  * 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)
-    };
+  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' } }),
+    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 },
+    }),
+  ]);
+
+  const usage: UserUsage = {
+    flashcards,
+    worksheets,
+    studyGuides,
+    podcasts,
+    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 
+ * 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, freePlan, userCredits] = await Promise.all([
-        prisma.subscription.findFirst({
-            where: { userId, status: 'active' },
-            include: { plan: { include: { limit: true } } },
-            orderBy: { createdAt: 'desc' }
-        }),
-        prisma.plan.findFirst({
-            where: {
-                active: true,
-                price: 0,
-                limit: { isNot: null }
-            },
-            include: { limit: true },
-            orderBy: { createdAt: 'asc' }
-        }),
-        prisma.userCredit.groupBy({
-            by: ['resourceType'],
-            where: { userId },
-            _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: string) =>
-        userCredits.find(c => c.resourceType === type)?._sum.amount || 0;
-
-    // Return the merged total limit
-    return {
-        id: base.id,
-        planId: base.planId,
-        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'),
-        maxStudyGuides: base.maxStudyGuides + getCreditSum('STUDY_GUIDE'),
-        createdAt: baseLimit?.createdAt || new Date(),
-        updatedAt: baseLimit?.updatedAt || new Date(),
-        isFallbackPlan: !baseLimit,
-    };
-}
+export async function getUserPlanLimits(userId: string): Promise<UserPlanLimits> {
+  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' },
+    }),
+    prisma.plan.findFirst({
+      where: {
+        active: true,
+        price: 0,
+        limit: { isNot: null },
+      },
+      include: { limit: true },
+      orderBy: { createdAt: 'asc' },
+    }),
+    prisma.userCredit.groupBy({
+      by: ['resourceType'],
+      where: { userId },
+      _sum: { amount: true },
+    }),
+  ]);
+
+  const baseLimit = activeSub?.plan?.limit ?? freePlan?.limit;
+  const base = baseLimit ?? FALLBACK_PLAN_LIMITS;
+
+  const getCreditSum = (type: string) =>
+    userCredits.find((c) => c.resourceType === type)?._sum.amount || 0;
+
+  const limits: UserPlanLimits = {
+    id: base.id,
+    planId: base.planId,
+    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'),
+    maxStudyGuides: base.maxStudyGuides + getCreditSum('STUDY_GUIDE'),
+    createdAt: baseLimit?.createdAt || new Date(),
+    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: string): Promise<AccountSummary> {
+  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: AccountSummary = {
+    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/src/services/content/copilot.service.ts

@@ -8,6 +8,7 @@ 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',
@@ -382,10 +383,6 @@ export class CopilotService extends BaseService {
     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',
@@ -404,10 +401,6 @@ export class CopilotService extends BaseService {
       input.context.documentPlainText ?? input.context.documentContent,
     );
 
-    await PusherService.emitTaskComplete(input.context.workspaceId, 'copilot:response', {
-      status: 'completed',
-    });
-
     await this.persistConversationExchange({
       userId,
       workspaceId: input.context.workspaceId,
@@ -426,10 +419,6 @@ export class CopilotService extends BaseService {
     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
@@ -448,10 +437,6 @@ export class CopilotService extends BaseService {
       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,
@@ -551,22 +536,28 @@ export class CopilotService extends BaseService {
       });
     }
 
-    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 },
     });
 

package/src/services/content/flashcard-progress.service.ts

@@ -320,25 +320,28 @@ export class FlashcardProgressService extends BaseService {
     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,
@@ -376,7 +379,7 @@ export class FlashcardProgressService extends BaseService {
           }
         ],
         flashcard: {
-          artifactId: latestArtifact.id,
+          artifactId: primaryArtifact.id,
         },
       },
       include: {

package/src/services/content/flashcard.service.ts

@@ -8,6 +8,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(),
@@ -46,6 +47,55 @@ export class FlashcardService extends BaseService {
     super(db);
   }
 
+  private async findPrimarySet(userId: string, workspaceId: string) {
+    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: string, workspaceId: string) {
+    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: string, workspaceId: string) {
     const workspace = await this.db.workspace.findFirst({
       where: { id: workspaceId, ownerId: userId },
@@ -61,35 +111,20 @@ export class FlashcardService extends BaseService {
   }
 
   async listCards(userId: string, workspaceId: string) {
-    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: string, workspaceId: string) {
-    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(
@@ -103,25 +138,22 @@ export class FlashcardService extends BaseService {
       order?: number;
     },
   ) {
-    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(
@@ -262,14 +294,11 @@ 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', {
@@ -278,23 +307,15 @@ export class FlashcardService extends BaseService {
         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 } : {}),
         },
       });
 
@@ -324,10 +345,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],
             },
           });
@@ -342,10 +363,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],
               },
             });
@@ -354,13 +375,14 @@ 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,
@@ -369,14 +391,15 @@ export class FlashcardService extends BaseService {
         title: artifact.title,
       }).catch(() => {});
 
+      invalidateUserBillingCache(userId);
       return { artifact, createdCards };
     } catch (error) {
-      if (flashcardCurrent?.id) {
-        await this.db.artifact.update({
-          where: { id: flashcardCurrent.id },
+      await this.db.artifact
+        .update({
+          where: { id: primarySet.id },
           data: { generating: false },
-        });
-      }
+        })
+        .catch(() => {});
       await PusherService.emitError(
         input.workspaceId,
         `Failed to generate flashcards: ${error}`,