@goscribe/server 1.3.4 → 1.6.0

package/dist/routers/workspace.js

@@ -1,153 +1,16 @@
 import { z } from 'zod';
-import { TRPCError } from '@trpc/server';
 import { router, 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 { members } from './members.js';
-import { logger } from '../lib/logger.js';
-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, workspaceId, progress) {
-    await db.workspace.update({
-        where: { id: workspaceId },
-        data: { analysisProgress: progress }
-    });
-    await PusherService.emitAnalysisProgress(workspaceId, progress);
-}
-const PIPELINE_STEPS = ['fileUpload', 'fileAnalysis', 'studyGuide', 'flashcards'];
-function buildProgressSteps(currentStep, currentStatus, config, overrides) {
-    const stepIndex = PIPELINE_STEPS.indexOf(currentStep);
-    const steps = {};
-    for (let i = 0; i < PIPELINE_STEPS.length; i++) {
-        const step = PIPELINE_STEPS[i];
-        let status;
-        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, filename, fileType, currentStep, currentStepStatus, config, extra) {
-    return {
-        status,
-        filename,
-        fileType,
-        startedAt: new Date().toISOString(),
-        steps: buildProgressSteps(currentStep, currentStepStatus, config, extra),
-        ...extra,
-    };
-}
-// Helper function to calculate search relevance score
-function calculateRelevance(query, ...texts) {
-    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,
-        };
-    }),
+        .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),
@@ -155,215 +18,30 @@ export const workspace = router({
         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);
-        return ws;
-    }),
+        .mutation(({ ctx, input }) => new WorkspaceService(ctx.db).create(ctx.session.user.id, input)),
     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,
-            },
-        });
-        await PusherService.emitLibraryUpdate(ctx.session.user.id);
-        return folder;
-    }),
+        .mutation(({ ctx, input }) => new WorkspaceService(ctx.db).createFolder(ctx.session.user.id, input)),
     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);
-        return folder;
-    }),
+        .mutation(({ ctx, input }) => new WorkspaceService(ctx.db).updateFolder(ctx.session.user.id, input)),
     deleteFolder: authedProcedure
-        .input(z.object({
-        id: z.string(),
-    }))
-        .mutation(async ({ ctx, input }) => {
-        const folder = await ctx.db.folder.delete({ where: { id: input.id } });
-        await PusherService.emitLibraryUpdate(ctx.session.user.id);
-        return folder;
-    }),
+        .input(z.object({ id: z.string() }))
+        .mutation(({ ctx, input }) => new WorkspaceService(ctx.db).deleteFolder(ctx.session.user.id, input.id)),
     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) => 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();
-        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 = [];
-        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));
-        }
-        // 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() } },
-        });
-        // 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 },
-        });
-        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,
-            },
-        };
-    }),
+        .input(z.object({ id: z.string() }))
+        .query(({ ctx, input }) => new WorkspaceService(ctx.db).get(ctx.session.user.id, input.id)),
+    getStats: authedProcedure.query(({ ctx }) => new WorkspaceService(ctx.db).getStats(ctx.session.user.id)),
+    getAccountSummary: authedProcedure.query(({ ctx }) => new WorkspaceService(ctx.db).getAccountSummary(ctx.session.user.id)),
+    getStudyAnalytics: authedProcedure.query(({ ctx }) => new WorkspaceAnalyticsService(ctx.db).getStudyAnalytics(ctx.session.user.id)),
     update: authedProcedure
         .input(z.object({
         id: z.string(),
@@ -372,202 +50,32 @@ export const workspace = router({
         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);
-        return updated;
-    }),
+        .mutation(({ ctx, input }) => new WorkspaceService(ctx.db).update(ctx.session.user.id, input)),
     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);
-        return true;
-    }),
+        .input(z.object({ id: z.string() }))
+        .mutation(({ ctx, input }) => new WorkspaceService(ctx.db).delete(ctx.session.user.id, input.id)),
     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 }) => {
-        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 };
-    }),
+        .input(z.object({ id: z.string() }))
+        .query(({ ctx, input }) => new WorkspaceService(ctx.db).getSharedWith(ctx.session.user.id, input.id)),
     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
+            size: z.number().min(1),
         })),
     }))
-        .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) => 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;
-    }),
+        .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) => {
-                    logger.error(`Error deleting file ${file.objectKey} from bucket ${file.bucket}:`, err);
-                });
-            }
-        }
-        await ctx.db.fileAsset.deleteMany({
-            where: {
-                id: { in: input.fileId },
-                workspaceId: input.id,
-                userId: ctx.session.user.id,
-            },
-        });
-        return true;
-    }),
+        .mutation(({ ctx, input }) => new WorkspaceService(ctx.db).deleteFiles(ctx.session.user.id, input)),
     getFileUploadUrl: authedProcedure
         .input(z.object({
         workspaceId: z.string(),
@@ -575,423 +83,22 @@ export const workspace = router({
         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) => 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.`
-            });
-        }
-        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,
-        };
-    }),
+        .query(({ ctx, input }) => new WorkspaceService(ctx.db).getFileUploadUrl(ctx.session.user.id, input)),
     uploadAndAnalyzeMedia: verifiedProcedure
         .input(z.object({
         workspaceId: z.string(),
-        files: z.array(z.object({
-            id: 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`);
-                    // 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: 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 }));
-                        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) => 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;
-        }
-    }),
+        .mutation(({ ctx, input }) => new MediaAnalysisService(ctx.db).uploadAndAnalyzeMedia(input, ctx.session.user.id)),
     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) => ({ ...w, type: 'workspace' })),
-            ...folders.map((f) => ({ ...f, type: 'folder', title: f.name })), // normalize name to title
-        ].sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime())
-            .slice(0, input.limit);
-        return results;
-    }),
-    // Members sub-router
+        .query(({ ctx, input }) => new WorkspaceService(ctx.db).search(ctx.session.user.id, input)),
     members,
 });