@goscribe/server 1.3.4 → 1.6.0

package/src/routers/workspace.ts

@@ -1,1147 +1,180 @@
 import { z } from 'zod';
-import { TRPCError } from '@trpc/server';
-import { router, publicProcedure, authedProcedure, verifiedProcedure } from '../trpc.js';
-import { supabaseClient } from '../lib/storage.js';
-import { ArtifactType } from '../lib/constants.js';
-import { aiSessionService } from '../lib/ai-session.js';
-import PusherService from '../lib/pusher.js';
+import { router, authedProcedure, verifiedProcedure } from '../trpc.js';
 import { members } from './members.js';
-import { logger } from '../lib/logger.js';
-import type { PrismaClient } from '@prisma/client';
-import { getUserStorageLimit } from '../lib/subscription_service.js';
-import { getUserUsage, getUserPlanLimits } from '../lib/usage_service.js';
-import {
-  notifyArtifactFailed,
-  notifyArtifactReady,
-  notifyWorkspaceDeleted,
-} from '../lib/notification-service.js';
-
-// Helper function to update and emit analysis progress
-async function updateAnalysisProgress(
-  db: PrismaClient,
-  workspaceId: string,
-  progress: any
-) {
-  await db.workspace.update({
-    where: { id: workspaceId },
-    data: { analysisProgress: progress }
-  });
-  await PusherService.emitAnalysisProgress(workspaceId, progress);
-}
-
-// DRY helper to build progress steps for artifact generation pipeline
-type StepStatus = 'pending' | 'in_progress' | 'completed' | 'skipped' | 'error';
-const PIPELINE_STEPS = ['fileUpload', 'fileAnalysis', 'studyGuide', 'flashcards'] as const;
-
-function buildProgressSteps(
-  currentStep: typeof PIPELINE_STEPS[number],
-  currentStatus: StepStatus,
-  config: { generateStudyGuide: boolean; generateFlashcards: boolean },
-  overrides?: Partial<Record<typeof PIPELINE_STEPS[number], StepStatus>>
-): Record<string, { order: number; status: StepStatus }> {
-  const stepIndex = PIPELINE_STEPS.indexOf(currentStep);
-  const steps: Record<string, { order: number; status: StepStatus }> = {};
-
-  for (let i = 0; i < PIPELINE_STEPS.length; i++) {
-    const step = PIPELINE_STEPS[i];
-    let status: StepStatus;
-
-    if (overrides?.[step]) {
-      status = overrides[step]!;
-    } else if (i < stepIndex) {
-      status = 'completed';
-    } else if (i === stepIndex) {
-      status = currentStatus;
-    } else {
-      // Future steps: check if they're configured
-      if (step === 'studyGuide' && !config.generateStudyGuide) {
-        status = 'skipped';
-      } else if (step === 'flashcards' && !config.generateFlashcards) {
-        status = 'skipped';
-      } else {
-        status = 'pending';
-      }
-    }
-
-    steps[step] = { order: i + 1, status };
-  }
-
-  return steps;
-}
-
-function buildProgress(
-  status: string,
-  filename: string,
-  fileType: string,
-  currentStep: typeof PIPELINE_STEPS[number],
-  currentStepStatus: StepStatus,
-  config: { generateStudyGuide: boolean; generateFlashcards: boolean },
-  extra?: Record<string, any>
-) {
-  return {
-    status,
-    filename,
-    fileType,
-    startedAt: new Date().toISOString(),
-    steps: buildProgressSteps(currentStep, currentStepStatus, config, extra as any),
-    ...extra,
-  };
-}
-
-// Helper function to calculate search relevance score
-function calculateRelevance(query: string, ...texts: (string | null | undefined)[]): number {
-  const queryLower = query.toLowerCase();
-  let score = 0;
-
-  for (const text of texts) {
-    if (!text) continue;
-
-    const textLower = text.toLowerCase();
-
-    // Exact match gets highest score
-    if (textLower.includes(queryLower)) {
-      score += 10;
-    }
-
-    // Word boundary matches get good score
-    const words = queryLower.split(/\s+/);
-    for (const word of words) {
-      if (word.length > 2 && textLower.includes(word)) {
-        score += 5;
-      }
-    }
-
-    // Partial matches get lower score
-    const queryChars = queryLower.split('');
-    let consecutiveMatches = 0;
-    for (const char of queryChars) {
-      if (textLower.includes(char)) {
-        consecutiveMatches++;
-      } else {
-        consecutiveMatches = 0;
-      }
-    }
-    score += consecutiveMatches * 0.1;
-  }
-
-  return score;
-}
+import { WorkspaceService } from '../services/workspace/workspace.service.js';
+import { WorkspaceAnalyticsService } from '../services/workspace/workspace-analytics.service.js';
+import { MediaAnalysisService } from '../services/content/media-analysis.service.js';
 
 export const workspace = router({
-  // List current user's workspaces
   list: authedProcedure
-    .input(z.object({
-      parentId: z.string().optional(),
-    }))
-    .query(async ({ ctx, input }) => {
-      const workspaces = await ctx.db.workspace.findMany({
-        where: {
-          ownerId: ctx.session.user.id,
-          folderId: input.parentId ?? null,
-        },
-        orderBy: { updatedAt: 'desc' },
-      });
-
-      const folders = await ctx.db.folder.findMany({
-        where: {
-          ownerId: ctx.session.user.id,
-          parentId: input.parentId ?? null,
-        },
-      });
-
-      return { workspaces, folders };
-    }),
-
-  /**
-   * Fetches the entire directory tree for the user.
-   * Includes Folders, Workspaces (files), and Uploads (sub-files).
-   */
-  getTree: authedProcedure
-    .query(async ({ ctx }) => {
-      const userId = ctx.session.user.id;
-
-      // 1. Fetch all folders
-      const allFolders = await ctx.db.folder.findMany({
-        where: { ownerId: userId },
-        orderBy: { updatedAt: 'desc' },
-      });
-
-      // 2. Fetch all workspaces
-      const allWorkspaces = await ctx.db.workspace.findMany({
-        where: { ownerId: userId },
-        include: {
-          uploads: {
-            select: {
-              id: true,
-              name: true,
-              mimeType: true,
-              createdAt: true,
-            }
-          }
-        },
-        orderBy: { updatedAt: 'desc' },
-      });
-
-      return {
-        folders: allFolders,
-        workspaces: allWorkspaces,
-      };
-    }),
+    .input(
+      z.object({
+        parentId: z.string().optional(),
+      }),
+    )
+    .query(({ ctx, input }) =>
+      new WorkspaceService(ctx.db).list(ctx.session.user.id, input.parentId ?? null),
+    ),
+
+  getTree: authedProcedure.query(({ ctx }) =>
+    new WorkspaceService(ctx.db).getTree(ctx.session.user.id),
+  ),
 
   create: authedProcedure
-    .input(z.object({
-      name: z.string().min(1).max(100),
-      description: z.string().max(500).optional(),
-      parentId: z.string().optional(),
-      markerColor: z.string().nullable().optional(),
-    }))
-    .mutation(async ({ ctx, input }) => {
-      const ws = await ctx.db.workspace.create({
-        data: {
-          title: input.name,
-          description: input.description,
-          ownerId: ctx.session.user.id,
-          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 aiSessionService.initSession(ws.id, ctx.session.user.id).catch((err) => {
-        logger.error('Failed to init AI session on workspace creation:', err);
-      });
-
-      await PusherService.emitLibraryUpdate(ctx.session.user.id);
+    .input(
+      z.object({
+        name: z.string().min(1).max(100),
+        description: z.string().max(500).optional(),
+        parentId: z.string().optional(),
+        markerColor: z.string().nullable().optional(),
+      }),
+    )
+    .mutation(({ ctx, input }) =>
+      new WorkspaceService(ctx.db).create(ctx.session.user.id, input),
+    ),
 
-      return ws;
-    }),
   createFolder: authedProcedure
-    .input(z.object({
-      name: z.string().min(1).max(100),
-      color: z.string().optional(),
-      parentId: z.string().optional(),
-    }))
-    .mutation(async ({ ctx, input }) => {
-      const folder = await ctx.db.folder.create({
-        data: {
-          name: input.name,
-          ownerId: ctx.session.user.id,
-          color: input.color ?? '#9D00FF',
-          parentId: input.parentId ?? null,
-        },
-      });
+    .input(
+      z.object({
+        name: z.string().min(1).max(100),
+        color: z.string().optional(),
+        parentId: z.string().optional(),
+      }),
+    )
+    .mutation(({ ctx, input }) =>
+      new WorkspaceService(ctx.db).createFolder(ctx.session.user.id, input),
+    ),
 
-      await PusherService.emitLibraryUpdate(ctx.session.user.id);
-
-      return folder;
-    }),
   updateFolder: authedProcedure
-    .input(z.object({
-      id: z.string(),
-      name: z.string().min(1).max(100).optional(),
-      markerColor: z.string().nullable().optional(),
-    }))
-    .mutation(async ({ ctx, input }) => {
-      const folder = await ctx.db.folder.update({
-        where: { id: input.id },
-        data: {
-          name: input.name,
-          markerColor: input.markerColor
-        }
-      });
-
-      await PusherService.emitLibraryUpdate(ctx.session.user.id);
+    .input(
+      z.object({
+        id: z.string(),
+        name: z.string().min(1).max(100).optional(),
+        markerColor: z.string().nullable().optional(),
+      }),
+    )
+    .mutation(({ ctx, input }) =>
+      new WorkspaceService(ctx.db).updateFolder(ctx.session.user.id, input),
+    ),
 
-      return folder;
-    }),
   deleteFolder: authedProcedure
-    .input(z.object({
-      id: z.string(),
-    }))
-    .mutation(async ({ ctx, input }) => {
-      const folder = await ctx.db.folder.delete({ where: { id: input.id } });
+    .input(z.object({ id: z.string() }))
+    .mutation(({ ctx, input }) =>
+      new WorkspaceService(ctx.db).deleteFolder(ctx.session.user.id, input.id),
+    ),
 
-      await PusherService.emitLibraryUpdate(ctx.session.user.id);
-
-      return folder;
-    }),
   get: authedProcedure
-    .input(z.object({
-      id: z.string(),
-    }))
-    .query(async ({ ctx, input }) => {
-      const ws = await ctx.db.workspace.findFirst({
-        where: { id: input.id, ownerId: ctx.session.user.id },
-        include: {
-          artifacts: true,
-          folder: true,
-          uploads: true,
-        },
-      });
-      if (!ws) throw new TRPCError({ code: 'NOT_FOUND' });
-      return ws;
-    }),
-  getStats: authedProcedure
-    .query(async ({ ctx }) => {
-      const workspaces = await ctx.db.workspace.findMany({
-        where: { OR: [{ ownerId: ctx.session.user.id }, { sharedWith: { some: { id: ctx.session.user.id } } }] },
-      });
-      const folders = await ctx.db.folder.findMany({
-        where: { OR: [{ ownerId: ctx.session.user.id }] },
-      });
-      const lastUpdated = await ctx.db.workspace.findFirst({
-        where: { OR: [{ ownerId: ctx.session.user.id }, { sharedWith: { some: { id: ctx.session.user.id } } }] },
-        orderBy: { updatedAt: 'desc' },
-      });
-
-      const spaceLeft = await ctx.db.fileAsset.aggregate({
-        where: { workspaceId: { in: workspaces.map((ws: any) => ws.id) }, userId: ctx.session.user.id },
-        _sum: { size: true },
-      });
-
-      const storageLimit = await getUserStorageLimit(ctx.session.user.id);
-
-      return {
-        workspaces: workspaces.length,
-        folders: folders.length,
-        lastUpdated: lastUpdated?.updatedAt,
-        spaceUsed: spaceLeft._sum?.size ?? 0,
-        spaceTotal: storageLimit,
-      };
-    }),
-
-  // Study analytics: streaks, flashcard mastery, worksheet accuracy
-  getStudyAnalytics: authedProcedure
-    .query(async ({ ctx }) => {
-      const userId = ctx.session.user.id;
-
-      // Gather all study activity dates
-      const flashcardProgress = await ctx.db.flashcardProgress.findMany({
-        where: { userId },
-        select: { lastStudiedAt: true },
-      });
-
-      const worksheetProgress = await ctx.db.worksheetQuestionProgress.findMany({
-        where: { userId },
-        select: { updatedAt: true, completedAt: true },
-      });
-
-      // Build a set of unique study days (YYYY-MM-DD)
-      const studyDays = new Set<string>();
-      for (const fp of flashcardProgress) {
-        if (fp.lastStudiedAt) {
-          studyDays.add(fp.lastStudiedAt.toISOString().split('T')[0]);
-        }
-      }
-      for (const wp of worksheetProgress) {
-        if (wp.completedAt) {
-          studyDays.add(wp.completedAt.toISOString().split('T')[0]);
-        } else {
-          studyDays.add(wp.updatedAt.toISOString().split('T')[0]);
-        }
-      }
-
-      // Calculate streak (consecutive days ending today or yesterday)
-      const sortedDays = [...studyDays].sort().reverse();
-      let streak = 0;
-
-      if (sortedDays.length > 0) {
-        const today = new Date();
-        today.setHours(0, 0, 0, 0);
-        const yesterday = new Date(today);
-        yesterday.setDate(yesterday.getDate() - 1);
-
-        const todayStr = today.toISOString().split('T')[0];
-        const yesterdayStr = yesterday.toISOString().split('T')[0];
-
-        // Streak only counts if the most recent study day is today or yesterday
-        if (sortedDays[0] === todayStr || sortedDays[0] === yesterdayStr) {
-          streak = 1;
-          for (let i = 1; i < sortedDays.length; i++) {
-            const current = new Date(sortedDays[i - 1]);
-            const prev = new Date(sortedDays[i]);
-            const diffDays = (current.getTime() - prev.getTime()) / (1000 * 60 * 60 * 24);
-            if (diffDays === 1) {
-              streak++;
-            } else {
-              break;
-            }
-          }
-        }
-      }
-
-      // Weekly activity (last 7 days)
-      const weeklyActivity: boolean[] = [];
-      const today = new Date();
-      today.setHours(0, 0, 0, 0);
-      for (let i = 6; i >= 0; i--) {
-        const d = new Date(today);
-        d.setDate(d.getDate() - i);
-        const dayStr = d.toISOString().split('T')[0];
-        weeklyActivity.push(studyDays.has(dayStr));
-      }
+    .input(z.object({ id: z.string() }))
+    .query(({ ctx, input }) => new WorkspaceService(ctx.db).get(ctx.session.user.id, input.id)),
 
-      // Flashcard stats
-      const totalCards = await ctx.db.flashcardProgress.count({ where: { userId } });
-      const masteredCards = await ctx.db.flashcardProgress.count({
-        where: { userId, masteryLevel: { gte: 80 } },
-      });
-      const dueCards = await ctx.db.flashcardProgress.count({
-        where: { userId, nextReviewAt: { lte: new Date() } },
-      });
+  getStats: authedProcedure.query(({ ctx }) =>
+    new WorkspaceService(ctx.db).getStats(ctx.session.user.id),
+  ),
 
-      // Worksheet stats
-      const completedQuestions = await ctx.db.worksheetQuestionProgress.count({
-        where: { userId, completedAt: { not: null } },
-      });
-      const correctQuestions = await ctx.db.worksheetQuestionProgress.count({
-        where: { userId, correct: true },
-      });
+  getAccountSummary: authedProcedure.query(({ ctx }) =>
+    new WorkspaceService(ctx.db).getAccountSummary(ctx.session.user.id),
+  ),
 
-      return {
-        streak,
-        totalStudyDays: studyDays.size,
-        weeklyActivity,
-        flashcards: {
-          total: totalCards,
-          mastered: masteredCards,
-          dueForReview: dueCards,
-        },
-        worksheets: {
-          completed: completedQuestions,
-          correct: correctQuestions,
-          accuracy: completedQuestions > 0 ? Math.round((correctQuestions / completedQuestions) * 100) : 0,
-        },
-      };
-    }),
+  getStudyAnalytics: authedProcedure.query(({ ctx }) =>
+    new WorkspaceAnalyticsService(ctx.db).getStudyAnalytics(ctx.session.user.id),
+  ),
 
   update: authedProcedure
-    .input(z.object({
-      id: z.string(),
-      name: z.string().min(1).max(100).optional(),
-      description: z.string().max(500).optional(),
-      markerColor: z.string().nullable().optional(),
-      icon: z.string().optional(),
-    }))
-    .mutation(async ({ ctx, input }) => {
-      const existed = await ctx.db.workspace.findFirst({
-        where: { id: input.id, ownerId: ctx.session.user.id },
-      });
-      if (!existed) throw new TRPCError({ code: 'NOT_FOUND' });
-      const updated = await ctx.db.workspace.update({
-        where: { id: input.id },
-        data: {
-          title: input.name ?? existed.title,
-          description: input.description,
-          // Preserve explicit null ("None color") instead of falling back.
-          markerColor: input.markerColor !== undefined ? input.markerColor : existed.markerColor,
-          icon: input.icon ?? existed.icon,
-        },
-      });
-
-      await PusherService.emitLibraryUpdate(ctx.session.user.id);
+    .input(
+      z.object({
+        id: z.string(),
+        name: z.string().min(1).max(100).optional(),
+        description: z.string().max(500).optional(),
+        markerColor: z.string().nullable().optional(),
+        icon: z.string().optional(),
+      }),
+    )
+    .mutation(({ ctx, input }) =>
+      new WorkspaceService(ctx.db).update(ctx.session.user.id, input),
+    ),
 
-      return updated;
-    }),
   delete: authedProcedure
-    .input(z.object({
-      id: z.string(),
-    }))
-    .mutation(async ({ ctx, input }) => {
-      const workspaceToDelete = await ctx.db.workspace.findFirst({
-        where: { id: input.id, ownerId: ctx.session.user.id },
-        select: {
-          id: true,
-          title: true,
-          ownerId: true,
-          members: {
-            select: { userId: true },
-          },
-        },
-      });
-
-      if (!workspaceToDelete) throw new TRPCError({ code: 'NOT_FOUND' });
-
-      const actor = await ctx.db.user.findUnique({
-        where: { id: ctx.session.user.id },
-        select: { name: true, email: true },
-      });
-      const actorName = actor?.name || actor?.email || 'A user';
-
-      await notifyWorkspaceDeleted(ctx.db, {
-        recipientUserIds: workspaceToDelete.members.map((m) => m.userId),
-        actorUserId: ctx.session.user.id,
-        actorName,
-        workspaceId: workspaceToDelete.id,
-        workspaceTitle: workspaceToDelete.title,
-      });
-
-      const deleted = await ctx.db.workspace.deleteMany({
-        where: { id: input.id, ownerId: ctx.session.user.id },
-      });
-      if (deleted.count === 0) throw new TRPCError({ code: 'NOT_FOUND' });
-
-      await PusherService.emitLibraryUpdate(ctx.session.user.id);
+    .input(z.object({ id: z.string() }))
+    .mutation(({ ctx, input }) =>
+      new WorkspaceService(ctx.db).delete(ctx.session.user.id, input.id),
+    ),
 
-      return true;
-    }),
   getFolderInformation: authedProcedure
-    .input(z.object({
-      id: z.string(),
-    }))
-    .query(async ({ ctx, input }) => {
-      const folder = await ctx.db.folder.findFirst({ where: { id: input.id, ownerId: ctx.session.user.id } });
-      // find all of its parents
-      if (!folder) throw new TRPCError({ code: 'NOT_FOUND' });
-
-      const parents = [];
-      let current = folder;
-
-      while (current.parentId) {
-        const parent = await ctx.db.folder.findFirst({ where: { id: current.parentId, ownerId: ctx.session.user.id } });
-        if (!parent) break;
-        parents.push(parent);
-        current = parent;
-      }
-
-      return { folder, parents };
-    }),
+    .input(z.object({ id: z.string() }))
+    .query(({ ctx, input }) =>
+      new WorkspaceService(ctx.db).getFolderInformation(ctx.session.user.id, input.id),
+    ),
 
   getSharedWith: authedProcedure
-    .input(z.object({
-      id: z.string(),
-    }))
-    .query(async ({ ctx, input }) => {
+    .input(z.object({ id: z.string() }))
+    .query(({ ctx, input }) =>
+      new WorkspaceService(ctx.db).getSharedWith(ctx.session.user.id, input.id),
+    ),
 
-      const user = await ctx.db.user.findFirst({ where: { id: ctx.session.user.id } });
-      if (!user || !user.email) throw new TRPCError({ code: 'NOT_FOUND' });
-      const sharedWith = await ctx.db.workspace.findMany({ where: { members: { some: { userId: ctx.session.user.id } } } });
-      const invitations = await ctx.db.workspaceInvitation.findMany({
-        where: { email: user.email, acceptedAt: null }, include: {
-          workspace: true,
-        }
-      });
-
-      return { shared: sharedWith, invitations };
-    }),
   uploadFiles: authedProcedure
-    .input(z.object({
-      id: z.string(),
-      files: z.array(
-        z.object({
-          filename: z.string().min(1).max(255),
-          contentType: z.string().min(1).max(100),
-          size: z.number().min(1), // size in bytes
-        })
-      ),
-    }))
-    .mutation(async ({ ctx, input }) => {
-      // ensure workspace belongs to user
-      const ws = await ctx.db.workspace.findFirst({ where: { id: input.id, ownerId: ctx.session.user.id } });
-      if (!ws) throw new TRPCError({ code: 'NOT_FOUND' });
-
-      // Check storage limit
-      const workspaces = await ctx.db.workspace.findMany({
-        where: { OR: [{ ownerId: ctx.session.user.id }, { sharedWith: { some: { id: ctx.session.user.id } } }] },
-      });
-      const spaceUsed = await ctx.db.fileAsset.aggregate({
-        where: { workspaceId: { in: workspaces.map((w: any) => w.id) }, userId: ctx.session.user.id },
-        _sum: { size: true },
-      });
-      const storageLimit = await getUserStorageLimit(ctx.session.user.id);
-      const totalSize = input.files.reduce((acc, file) => acc + file.size, 0);
-      if ((spaceUsed._sum?.size ?? 0) + totalSize > storageLimit) {
-        logger.warn(`Storage limit exceeded for user ${ctx.session.user.id}. Used: ${spaceUsed._sum?.size}, Tried to upload: ${totalSize}, Limit: ${storageLimit}`);
-        throw new TRPCError({
-          code: 'FORBIDDEN',
-          message: `Storage limit exceeded. Maximum allowed storage is ${(storageLimit / (1024 * 1024 * 1024)).toFixed(1)}GB.`
-        });
-      }
-      const results = [];
-
-      for (const file of input.files) {
-        // 1. Insert into DB
-        const record = await ctx.db.fileAsset.create({
-          data: {
-            userId: ctx.session.user.id,
-            name: file.filename,
-            mimeType: file.contentType,
-            size: file.size,
-            workspaceId: input.id,
-          },
-        });
-
-        // 2. Generate signed URL for direct upload
-        const objectKey = `${ctx.session.user.id}/${record.id}-${file.filename}`;
-        const { data: signedUrlData, error: signedUrlError } = await supabaseClient.storage
-          .from('media')
-          .createSignedUploadUrl(objectKey); // 5 minutes
-
-        if (signedUrlError) {
-          throw new TRPCError({
-            code: 'INTERNAL_SERVER_ERROR',
-            message: `Failed to upload file`
-          });
-        }
-
-        // 3. Update record with bucket info
-        await ctx.db.fileAsset.update({
-          where: { id: record.id },
-          data: {
-            bucket: 'media',
-            objectKey: objectKey,
-          },
-        });
-
-        results.push({
-          fileId: record.id,
-          uploadUrl: signedUrlData.signedUrl,
-        });
-      }
-
-      return results;
+    .input(
+      z.object({
+        id: z.string(),
+        files: z.array(
+          z.object({
+            filename: z.string().min(1).max(255),
+            contentType: z.string().min(1).max(100),
+            size: z.number().min(1),
+          }),
+        ),
+      }),
+    )
+    .mutation(({ ctx, input }) =>
+      new WorkspaceService(ctx.db).uploadFiles(ctx.session.user.id, input),
+    ),
 
-    }),
   deleteFiles: authedProcedure
-    .input(z.object({
-      fileId: z.array(z.string()),
-      id: z.string(),
-    }))
-    .mutation(async ({ ctx, input }) => {
-      // ensure files are in the user's workspace
-      const files = await ctx.db.fileAsset.findMany({
-        where: {
-          id: { in: input.fileId },
-          workspaceId: input.id,
-          userId: ctx.session.user.id,
-        },
-      });
-      // Delete from Supabase Storage (best-effort)
-      for (const file of files) {
-        if (file.bucket && file.objectKey) {
-          supabaseClient.storage
-            .from(file.bucket)
-            .remove([file.objectKey])
-            .catch((err: unknown) => {
-              logger.error(`Error deleting file ${file.objectKey} from bucket ${file.bucket}:`, err);
-            });
-        }
-      }
+    .input(
+      z.object({
+        fileId: z.array(z.string()),
+        id: z.string(),
+      }),
+    )
+    .mutation(({ ctx, input }) =>
+      new WorkspaceService(ctx.db).deleteFiles(ctx.session.user.id, input),
+    ),
 
-      await ctx.db.fileAsset.deleteMany({
-        where: {
-          id: { in: input.fileId },
-          workspaceId: input.id,
-          userId: ctx.session.user.id,
-        },
-      });
-      return true;
-    }),
   getFileUploadUrl: authedProcedure
-    .input(z.object({
-      workspaceId: z.string(),
-      filename: z.string(),
-      contentType: z.string(),
-      size: z.number(),
-    }))
-    .query(async ({ ctx, input }) => {
-      // Check storage limit
-      const workspaces = await ctx.db.workspace.findMany({
-        where: { OR: [{ ownerId: ctx.session.user.id }, { sharedWith: { some: { id: ctx.session.user.id } } }] },
-      });
-      const spaceUsed = await ctx.db.fileAsset.aggregate({
-        where: { workspaceId: { in: workspaces.map((w: any) => w.id) }, userId: ctx.session.user.id },
-        _sum: { size: true },
-      });
-      const storageLimit = await getUserStorageLimit(ctx.session.user.id);
-      if ((spaceUsed._sum?.size ?? 0) + input.size > storageLimit) {
-        logger.warn(`Storage limit exceeded for user ${ctx.session.user.id}. Used: ${spaceUsed._sum?.size}, Tried to upload: ${input.size}, Limit: ${storageLimit}`);
-        throw new TRPCError({
-          code: 'FORBIDDEN',
-          message: `Storage limit exceeded. Maximum allowed storage is ${(storageLimit / (1024 * 1024 * 1024)).toFixed(1)}GB.`
-        });
-      }
+    .input(
+      z.object({
+        workspaceId: z.string(),
+        filename: z.string(),
+        contentType: z.string(),
+        size: z.number(),
+      }),
+    )
+    .query(({ ctx, input }) =>
+      new WorkspaceService(ctx.db).getFileUploadUrl(ctx.session.user.id, input),
+    ),
 
-      const objectKey = `workspace_${ctx.session.user.id}/${input.workspaceId}-file_${input.filename}`;
-      const fileAsset = await ctx.db.fileAsset.create({
-        data: {
-          workspaceId: input.workspaceId,
-          name: input.filename,
-          mimeType: input.contentType,
-          size: input.size,
-          userId: ctx.session.user.id,
-          bucket: 'media',
-          objectKey: objectKey,
-        },
-      });
-      const { data: signedUrlData, error: signedUrlError } = await supabaseClient.storage
-        .from('media')
-        .createSignedUploadUrl(objectKey, { upsert: true });
-      if (signedUrlError) {
-        logger.error('Signed upload URL error:', signedUrlError);
-        throw new TRPCError({ code: 'INTERNAL_SERVER_ERROR', message: `Failed to create upload URL: ${signedUrlError.message}` });
-      }
-
-      await ctx.db.workspace.update({
-        where: { id: input.workspaceId },
-        data: { needsAnalysis: true },
-      });
-
-      return {
-        fileId: fileAsset.id,
-        uploadUrl: signedUrlData.signedUrl,
-      };
-    }),
   uploadAndAnalyzeMedia: verifiedProcedure
-    .input(z.object({
-      workspaceId: z.string(),
-      files: z.array(z.object({
-        id: z.string(),
-      })),
-      generateStudyGuide: z.boolean().default(true),
-      generateFlashcards: z.boolean().default(true),
-      generateWorksheet: z.boolean().default(true),
-    }))
-    .mutation(async ({ ctx, input }) => {
-      // Verify workspace ownership
-      const workspace = await ctx.db.workspace.findFirst({
-        where: { id: input.workspaceId, ownerId: ctx.session.user.id }
-      });
-      if (!workspace) {
-        logger.error('Workspace not found', { workspaceId: input.workspaceId, userId: ctx.session.user.id });
-        throw new TRPCError({ code: 'NOT_FOUND' });
-      }
-
-      // Check if analysis is already in progress
-      if (workspace.fileBeingAnalyzed) {
-        throw new TRPCError({
-          code: 'CONFLICT',
-          message: 'File analysis is already in progress for this workspace. Please wait for it to complete.'
-        });
-      }
-
-      // Fetch files from database
-      const files = await ctx.db.fileAsset.findMany({
-        where: {
-          id: { in: input.files.map(file => file.id) },
-          workspaceId: input.workspaceId,
-          userId: ctx.session.user.id,
-        },
-      });
-
-      if (files.length === 0) {
-        throw new TRPCError({
-          code: 'NOT_FOUND',
-          message: 'No files found with the provided IDs'
-        });
-      }
-
-      // Validate all files have bucket and objectKey
-      for (const file of files) {
-        if (!file.bucket || !file.objectKey) {
-          throw new TRPCError({
-            code: 'BAD_REQUEST',
-            message: `File ${file.id} does not have bucket or objectKey set`
-          });
-        }
-      }
-
-      // Use the first file for progress tracking and artifact naming
-      const primaryFile = files[0];
-      const fileType = primaryFile.mimeType.startsWith('image/') ? 'image' : 'pdf';
-      try {
-        // Set analysis in progress flag
-        await ctx.db.workspace.update({
-          where: { id: input.workspaceId },
-          data: { fileBeingAnalyzed: true },
-        });
-
-        const genConfig = { generateStudyGuide: input.generateStudyGuide, generateFlashcards: input.generateFlashcards };
-
-        PusherService.emitAnalysisProgress(input.workspaceId,
-          buildProgress('starting', primaryFile.name, fileType, 'fileUpload', 'pending', genConfig)
-        );
-
-        try {
-          await updateAnalysisProgress(ctx.db, input.workspaceId,
-            buildProgress('starting', primaryFile.name, fileType, 'fileUpload', 'pending', genConfig)
-          );
-        } catch (error) {
-          logger.error('Failed to update analysis progress:', error);
-          await ctx.db.workspace.update({
-            where: { id: input.workspaceId },
-            data: { fileBeingAnalyzed: false },
-          });
-          await PusherService.emitError(input.workspaceId, `Failed to update analysis progress: ${error}`, 'file_analysis');
-          throw error;
-        }
-
-        await updateAnalysisProgress(ctx.db, input.workspaceId,
-          buildProgress('uploading', primaryFile.name, fileType, 'fileUpload', 'in_progress', genConfig)
-        );
-
-        // Process all files using the new process_file endpoint
-        for (const file of files) {
-          // TypeScript: We already validated bucket and objectKey exist above
-          if (!file.bucket || !file.objectKey) {
-            continue; // Skip if somehow missing (shouldn't happen due to validation above)
-          }
-
-          const { data: signedUrlData, error: signedUrlError } = await supabaseClient.storage
-            .from(file.bucket)
-            .createSignedUrl(file.objectKey, 24 * 60 * 60); // 24 hours expiry
-
-          if (signedUrlError) {
-            await ctx.db.workspace.update({
-              where: { id: input.workspaceId },
-              data: { fileBeingAnalyzed: false },
-            });
-            throw new TRPCError({
-              code: 'INTERNAL_SERVER_ERROR',
-              message: `Failed to upload file`
-            });
-          }
-
-          const fileUrl = signedUrlData.signedUrl;
-          const currentFileType = file.mimeType.startsWith('image/') ? 'image' : 'pdf';
-
-          // Use maxPages for large PDFs (>50 pages) to limit processing
-          const maxPages = currentFileType === 'pdf' && file.size && file.size > 50 ? 50 : undefined;
-
-          const processResult = await aiSessionService.processFile(
-            input.workspaceId,
-            ctx.session.user.id,
-            fileUrl,
-            currentFileType,
-            maxPages
-          );
-
-          if (processResult.status === 'error') {
-            logger.error(`Failed to process file ${file.name}:`, processResult.error);
-            // Continue processing other files even if one fails
-            // Optionally, you could throw an error or mark this file as failed
-          } else {
-            logger.info(`Successfully processed file ${file.name}: ${processResult.pageCount} pages`);
+    .input(
+      z.object({
+        workspaceId: z.string(),
+        files: z.array(z.object({ id: z.string() })),
+        generateStudyGuide: z.boolean().default(true),
+        generateFlashcards: z.boolean().default(true),
+        generateWorksheet: z.boolean().default(true),
+      }),
+    )
+    .mutation(({ ctx, input }) =>
+      new MediaAnalysisService(ctx.db).uploadAndAnalyzeMedia(input, ctx.session.user.id),
+    ),
 
-            // Store the comprehensive description in aiTranscription field
-            await ctx.db.fileAsset.update({
-              where: { id: file.id },
-              data: {
-                aiTranscription: {
-                  comprehensiveDescription: processResult.comprehensiveDescription,
-                  textContent: processResult.textContent,
-                  imageDescriptions: processResult.imageDescriptions,
-                },
-              }
-            });
-          }
-        }
-
-        await updateAnalysisProgress(ctx.db, input.workspaceId,
-          buildProgress('analyzing', primaryFile.name, fileType, 'fileAnalysis', 'in_progress', genConfig)
-        );
-
-        try {
-          // Analyze all files - use PDF analysis if any file is a PDF, otherwise use image analysis
-          // const hasPDF = files.some(f => !f.mimeType.startsWith('image/'));
-          // if (hasPDF) {
-          //   await aiSessionService.analysePDF(input.workspaceId, ctx.session.user.id, file.id);
-          // } else {
-          //   // If all files are images, analyze them
-          //   for (const file of files) {
-          //     await aiSessionService.analyseImage(input.workspaceId, ctx.session.user.id, file.id);
-          //   }
-          // }
-
-          await updateAnalysisProgress(ctx.db, input.workspaceId,
-            buildProgress('generating_artifacts', primaryFile.name, fileType, 'studyGuide', 'pending', genConfig)
-          );
-        } catch (error) {
-          logger.error('Failed to analyze files:', error);
-          await updateAnalysisProgress(ctx.db, input.workspaceId,
-            buildProgress('error', primaryFile.name, fileType, 'fileAnalysis', 'error', genConfig, {
-              error: `Failed to analyze ${fileType}: ${error}`,
-              studyGuide: 'skipped', flashcards: 'skipped',
-            })
-          );
-          await ctx.db.workspace.update({
-            where: { id: input.workspaceId },
-            data: { fileBeingAnalyzed: false },
-          });
-          throw error;
-        }
-
-        const results: {
-          filename: string;
-          artifacts: {
-            studyGuide: any | null;
-            flashcards: any | null;
-            worksheet: any | null;
-          };
-        } = {
-          filename: primaryFile.name,
-          artifacts: {
-            studyGuide: null,
-            flashcards: null,
-            worksheet: null,
-          }
-        };
-
-        // Ensure AI session is initialized before generating artifacts
-        try {
-          await aiSessionService.initSession(input.workspaceId, ctx.session.user.id);
-        } catch (initError) {
-          logger.error('Failed to init AI session (continuing with workspace context):', initError);
-        }
-
-        // Fetch current usage and limits to enforce plan restrictions for auto-generation
-        const [usage, limits] = await Promise.all([
-          getUserUsage(ctx.session.user.id),
-          getUserPlanLimits(ctx.session.user.id)
-        ]);
-
-        // Generate artifacts - each step is isolated so failures don't block subsequent steps
-        if (input.generateStudyGuide) {
-          // Enforcement: Skip if limit reached
-          if (limits && usage.studyGuides >= limits.maxStudyGuides) {
-            await updateAnalysisProgress(ctx.db, input.workspaceId,
-              buildProgress('skipped', primaryFile.name, fileType, 'studyGuide', 'skipped', genConfig)
-            );
-            await PusherService.emitError(input.workspaceId, 'Study guide skipped: Limit reached.', 'study_guide');
-            await notifyArtifactFailed(ctx.db, {
-              userId: ctx.session.user.id,
-              workspaceId: input.workspaceId,
-              artifactType: ArtifactType.STUDY_GUIDE,
-              message: 'Study guide was skipped because your plan limit was reached.',
-            }).catch(() => {});
-          } else {
-            try {
-              await updateAnalysisProgress(ctx.db, input.workspaceId,
-                buildProgress('generating_study_guide', primaryFile.name, fileType, 'studyGuide', 'in_progress', genConfig)
-              );
-
-              const content = await aiSessionService.generateStudyGuide(input.workspaceId, ctx.session.user.id);
-
-              let artifact = await ctx.db.artifact.findFirst({
-                where: { workspaceId: input.workspaceId, type: ArtifactType.STUDY_GUIDE },
-              });
-              if (!artifact) {
-                artifact = await ctx.db.artifact.create({
-                  data: {
-                    workspaceId: input.workspaceId,
-                    type: ArtifactType.STUDY_GUIDE,
-                    title: files.length === 1 ? `Study Guide - ${primaryFile.name}` : `Study Guide - ${files.length} files`,
-                    createdById: ctx.session.user.id,
-                  },
-                });
-              }
-
-              const lastVersion = await ctx.db.artifactVersion.findFirst({
-                where: { artifact: { workspaceId: input.workspaceId, type: ArtifactType.STUDY_GUIDE } },
-                orderBy: { version: 'desc' },
-              });
-
-              await ctx.db.artifactVersion.create({
-                data: { artifactId: artifact.id, version: lastVersion ? lastVersion.version + 1 : 1, content: content, createdById: ctx.session.user.id },
-              });
-
-              results.artifacts.studyGuide = artifact;
-              await PusherService.emitStudyGuideComplete(input.workspaceId, artifact);
-              await notifyArtifactReady(ctx.db, {
-                userId: ctx.session.user.id,
-                workspaceId: input.workspaceId,
-                artifactId: artifact.id,
-                artifactType: ArtifactType.STUDY_GUIDE,
-                title: artifact.title,
-              }).catch(() => {});
-            } catch (sgError) {
-              logger.error('Study guide generation failed after retries:', sgError);
-              await PusherService.emitError(input.workspaceId, 'Study guide generation failed. Please try regenerating later.', 'study_guide');
-              await notifyArtifactFailed(ctx.db, {
-                userId: ctx.session.user.id,
-                workspaceId: input.workspaceId,
-                artifactType: ArtifactType.STUDY_GUIDE,
-                message: 'Study guide generation failed. Please try regenerating later.',
-              }).catch(() => {});
-              // Continue to flashcards - don't abort the whole pipeline
-            }
-          }
-        }
-
-        if (input.generateFlashcards) {
-          // Enforcement: Skip if limit reached
-          if (limits && usage.flashcards >= limits.maxFlashcards) {
-            await updateAnalysisProgress(ctx.db, input.workspaceId,
-              buildProgress('skipped', primaryFile.name, fileType, 'flashcards', 'skipped', genConfig)
-            );
-            await PusherService.emitError(input.workspaceId, 'Flashcards skipped: Limit reached.', 'flashcards');
-            await notifyArtifactFailed(ctx.db, {
-              userId: ctx.session.user.id,
-              workspaceId: input.workspaceId,
-              artifactType: ArtifactType.FLASHCARD_SET,
-              message: 'Flashcards were skipped because your plan limit was reached.',
-            }).catch(() => {});
-          } else {
-            try {
-              const sgStatus = input.generateStudyGuide ? (results.artifacts.studyGuide ? 'completed' : 'error') : 'skipped';
-              await updateAnalysisProgress(ctx.db, input.workspaceId,
-                buildProgress('generating_flashcards', primaryFile.name, fileType, 'flashcards', 'in_progress', genConfig,
-                  { studyGuide: sgStatus } as any)
-              );
-
-              const content = await aiSessionService.generateFlashcardQuestions(input.workspaceId, ctx.session.user.id, 10, 'medium');
-
-              const artifact = await ctx.db.artifact.create({
-                data: {
-                  workspaceId: input.workspaceId,
-                  type: ArtifactType.FLASHCARD_SET,
-                  title: files.length === 1 ? `Flashcards - ${primaryFile.name}` : `Flashcards - ${files.length} files`,
-                  createdById: ctx.session.user.id,
-                },
-              });
-
-              // Parse JSON flashcard content
-              try {
-                const parsed = typeof content === 'string' ? JSON.parse(content) : content;
-                const flashcardData = Array.isArray(parsed) ? parsed : (parsed.flashcards || []);
-
-                for (let i = 0; i < Math.min(flashcardData.length, 10); i++) {
-                  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 ctx.db.flashcard.create({
-                    data: {
-                      artifactId: artifact.id,
-                      front: front,
-                      back: back,
-                      order: i,
-                      tags: ['ai-generated', 'medium'],
-                    },
-                  });
-                }
-              } catch (parseError) {
-                console.error("Failed to parse flashcard JSON or create cards in workspace router:", parseError);
-                // Fallback to text parsing if JSON fails
-                const lines = content.split('\n').filter((line: string) => line.trim());
-                for (let i = 0; i < Math.min(lines.length, 10); i++) {
-                  const line = lines[i];
-                  if (line.includes(' - ')) {
-                    const [front, back] = line.split(' - ');
-                    await ctx.db.flashcard.create({
-                      data: {
-                        artifactId: artifact.id,
-                        front: front.trim(),
-                        back: back.trim(),
-                        order: i,
-                        tags: ['ai-generated', 'medium'],
-                      },
-                    });
-                  }
-                }
-              }
-
-              results.artifacts.flashcards = artifact;
-              await PusherService.emitFlashcardComplete(input.workspaceId, artifact);
-              await notifyArtifactReady(ctx.db, {
-                userId: ctx.session.user.id,
-                workspaceId: input.workspaceId,
-                artifactId: artifact.id,
-                artifactType: ArtifactType.FLASHCARD_SET,
-                title: artifact.title,
-              }).catch(() => {});
-            } catch (fcError) {
-              logger.error('Flashcard generation failed after retries:', fcError);
-              await PusherService.emitError(input.workspaceId, 'Flashcard generation failed. Please try regenerating later.', 'flashcards');
-              await notifyArtifactFailed(ctx.db, {
-                userId: ctx.session.user.id,
-                workspaceId: input.workspaceId,
-                artifactType: ArtifactType.FLASHCARD_SET,
-                message: 'Flashcard generation failed. Please try regenerating later.',
-              }).catch(() => {});
-            }
-          }
-        }
-
-        await ctx.db.workspace.update({
-          where: { id: input.workspaceId },
-          data: { fileBeingAnalyzed: false },
-        });
-
-        await updateAnalysisProgress(ctx.db, input.workspaceId, {
-          ...buildProgress('completed', primaryFile.name, fileType, 'flashcards', 'completed', genConfig),
-          completedAt: new Date().toISOString(),
-        });
-        return results;
-      } catch (error) {
-        logger.error('Failed to update analysis progress:', error);
-        await ctx.db.workspace.update({
-          where: { id: input.workspaceId },
-          data: { fileBeingAnalyzed: false },
-        });
-        await PusherService.emitError(input.workspaceId, `Failed to update analysis progress: ${error}`, 'file_analysis');
-        throw error;
-      }
-    }),
   search: authedProcedure
-    .input(z.object({
-      query: z.string(),
-      color: z.string().optional(),
-      limit: z.number().min(1).max(100).default(20),
-    }))
-    .query(async ({ ctx, input }) => {
-      const { query, color } = input;
-
-      // 1. Search Workspaces
-      const workspaces = await ctx.db.workspace.findMany({
-        where: {
-          ownerId: ctx.session.user.id,
-          markerColor: color || undefined,
-          ...(query ? {
-            OR: [
-              { title: { contains: query, mode: 'insensitive' } },
-              { description: { contains: query, mode: 'insensitive' } },
-            ],
-          } : {}),
-        },
-        orderBy: { updatedAt: 'desc' },
-        take: input.limit,
-      });
-
-      // 2. Search Folders
-      const folders = await ctx.db.folder.findMany({
-        where: {
-          ownerId: ctx.session.user.id,
-          markerColor: color || undefined,
-          ...(query ? {
-            name: { contains: query, mode: 'insensitive' },
-          } : {}),
-        },
-        orderBy: { updatedAt: 'desc' },
-        take: input.limit,
-      });
-
-      // Combined results with type discriminator
-      const results = [
-        ...workspaces.map((w: any) => ({ ...w, type: 'workspace' as const })),
-        ...folders.map((f: any) => ({ ...f, type: 'folder' as const, title: f.name })), // normalize name to title
-      ].sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime())
-        .slice(0, input.limit);
-
-      return results;
-    }),
+    .input(
+      z.object({
+        query: z.string(),
+        color: z.string().optional(),
+        limit: z.number().min(1).max(100).default(20),
+      }),
+    )
+    .query(({ ctx, input }) => new WorkspaceService(ctx.db).search(ctx.session.user.id, input)),
 
-  // Members sub-router
   members,
 });