@goscribe/server 1.3.4 → 1.6.0

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

@@ -0,0 +1,401 @@
+import { TRPCError } from '@trpc/server';
+import { BaseService } from '../base.service.js';
+import { supabaseClient } from '../../lib/storage.js';
+import PusherService from '../../lib/pusher.js';
+import { ai } from '../../lib/ai/index.js';
+import { workspaceKbService } from './workspace-kb.service.js';
+import { getAccountSummary, invalidateUserBillingCache, } from '../billing/usage.service.js';
+import { getUserStorageLimit } from '../billing/subscription.service.js';
+import { notifyWorkspaceDeleted } from '../notifications/notification.service.js';
+export class WorkspaceService extends BaseService {
+    constructor(db) {
+        super(db);
+    }
+    async list(userId, parentId) {
+        const workspaces = await this.db.workspace.findMany({
+            where: { ownerId: userId, folderId: parentId },
+            orderBy: { updatedAt: 'desc' },
+        });
+        const folders = await this.db.folder.findMany({
+            where: { ownerId: userId, parentId },
+        });
+        return { workspaces, folders };
+    }
+    async getTree(userId) {
+        const [allFolders, allWorkspaces] = await Promise.all([
+            this.db.folder.findMany({
+                where: { ownerId: userId },
+                select: {
+                    id: true,
+                    name: true,
+                    parentId: true,
+                    color: true,
+                    markerColor: true,
+                    updatedAt: true,
+                },
+                orderBy: { updatedAt: 'desc' },
+            }),
+            this.db.workspace.findMany({
+                where: { ownerId: userId },
+                select: {
+                    id: true,
+                    title: true,
+                    folderId: true,
+                    icon: true,
+                    color: true,
+                    markerColor: true,
+                    updatedAt: true,
+                    uploads: {
+                        select: {
+                            id: true,
+                            name: true,
+                            mimeType: true,
+                            createdAt: true,
+                        },
+                    },
+                },
+                orderBy: { updatedAt: 'desc' },
+            }),
+        ]);
+        return { folders: allFolders, workspaces: allWorkspaces };
+    }
+    async create(userId, input) {
+        const ws = await this.db.workspace.create({
+            data: {
+                title: input.name,
+                description: input.description,
+                ownerId: userId,
+                folderId: input.parentId ?? null,
+                ...(input.markerColor !== undefined ? { markerColor: input.markerColor } : {}),
+            },
+        });
+        void ai.backend.initSession(ws.id, userId).catch((err) => {
+            this.logger.error('Failed to init AI session on workspace creation:', err);
+        });
+        void workspaceKbService.ensureWorkspaceKb(ws.id, userId, input.name).catch((err) => {
+            this.logger.error('Failed to create workspace knowledge base:', err);
+        });
+        invalidateUserBillingCache(userId);
+        void PusherService.emitLibraryUpdate(userId);
+        return ws;
+    }
+    async createFolder(userId, input) {
+        const folder = await this.db.folder.create({
+            data: {
+                name: input.name,
+                ownerId: userId,
+                color: input.color ?? '#9D00FF',
+                parentId: input.parentId ?? null,
+            },
+        });
+        await PusherService.emitLibraryUpdate(userId);
+        return folder;
+    }
+    async updateFolder(userId, input) {
+        const folder = await this.db.folder.update({
+            where: { id: input.id },
+            data: { name: input.name, markerColor: input.markerColor },
+        });
+        await PusherService.emitLibraryUpdate(userId);
+        return folder;
+    }
+    async deleteFolder(userId, id) {
+        const folder = await this.db.folder.delete({ where: { id } });
+        await PusherService.emitLibraryUpdate(userId);
+        return folder;
+    }
+    async get(userId, id) {
+        const ws = await this.db.workspace.findFirst({
+            where: { id, ownerId: userId },
+            select: {
+                id: true,
+                title: true,
+                description: true,
+                icon: true,
+                color: true,
+                markerColor: true,
+                ownerId: true,
+                folderId: true,
+                fileBeingAnalyzed: true,
+                analysisProgress: true,
+                needsAnalysis: true,
+                createdAt: true,
+                updatedAt: true,
+                folder: { select: { id: true, name: true, color: true } },
+                uploads: {
+                    select: {
+                        id: true,
+                        name: true,
+                        mimeType: true,
+                        size: true,
+                        createdAt: true,
+                        objectKey: true,
+                    },
+                    orderBy: { createdAt: 'desc' },
+                },
+            },
+        });
+        if (!ws)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        return ws;
+    }
+    async getAccountSummary(userId) {
+        return getAccountSummary(userId);
+    }
+    async getStats(userId) {
+        const summary = await getAccountSummary(userId);
+        return summary.stats;
+    }
+    async update(userId, input) {
+        const existed = await this.db.workspace.findFirst({
+            where: { id: input.id, ownerId: userId },
+        });
+        if (!existed)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        const updated = await this.db.workspace.update({
+            where: { id: input.id },
+            data: {
+                title: input.name ?? existed.title,
+                description: input.description,
+                markerColor: input.markerColor !== undefined ? input.markerColor : existed.markerColor,
+                icon: input.icon ?? existed.icon,
+            },
+        });
+        await PusherService.emitLibraryUpdate(userId);
+        return updated;
+    }
+    async delete(userId, id) {
+        const workspaceToDelete = await this.db.workspace.findFirst({
+            where: { id, ownerId: userId },
+            select: {
+                id: true,
+                title: true,
+                ownerId: true,
+                members: { select: { userId: true } },
+            },
+        });
+        if (!workspaceToDelete)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        const actor = await this.db.user.findUnique({
+            where: { id: userId },
+            select: { name: true, email: true },
+        });
+        const actorName = actor?.name || actor?.email || 'A user';
+        await notifyWorkspaceDeleted(this.db, {
+            recipientUserIds: workspaceToDelete.members.map((m) => m.userId),
+            actorUserId: userId,
+            actorName,
+            workspaceId: workspaceToDelete.id,
+            workspaceTitle: workspaceToDelete.title,
+        });
+        const deleted = await this.db.workspace.deleteMany({
+            where: { id, ownerId: userId },
+        });
+        if (deleted.count === 0)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        await PusherService.emitLibraryUpdate(userId);
+        return true;
+    }
+    async getFolderInformation(userId, id) {
+        const folder = await this.db.folder.findFirst({
+            where: { id, ownerId: userId },
+        });
+        if (!folder)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        const parents = [];
+        let current = folder;
+        while (current.parentId) {
+            const parent = await this.db.folder.findFirst({
+                where: { id: current.parentId, ownerId: userId },
+            });
+            if (!parent)
+                break;
+            parents.push(parent);
+            current = parent;
+        }
+        return { folder, parents };
+    }
+    async getSharedWith(userId, id) {
+        const user = await this.db.user.findFirst({ where: { id: userId } });
+        if (!user || !user.email)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        const sharedWith = await this.db.workspace.findMany({
+            where: { members: { some: { userId } } },
+        });
+        const invitations = await this.db.workspaceInvitation.findMany({
+            where: { email: user.email, acceptedAt: null },
+            include: { workspace: true },
+        });
+        return { shared: sharedWith, invitations };
+    }
+    async uploadFiles(userId, input) {
+        const ws = await this.db.workspace.findFirst({
+            where: { id: input.id, ownerId: userId },
+        });
+        if (!ws)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        const workspaces = await this.db.workspace.findMany({
+            where: {
+                OR: [{ ownerId: userId }, { sharedWith: { some: { id: userId } } }],
+            },
+        });
+        const spaceUsed = await this.db.fileAsset.aggregate({
+            where: { workspaceId: { in: workspaces.map((w) => w.id) }, userId },
+            _sum: { size: true },
+        });
+        const storageLimit = await getUserStorageLimit(userId);
+        const totalSize = input.files.reduce((acc, file) => acc + file.size, 0);
+        if ((spaceUsed._sum?.size ?? 0) + totalSize > storageLimit) {
+            this.logger.warn(`Storage limit exceeded for user ${userId}. 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) {
+            const record = await this.db.fileAsset.create({
+                data: {
+                    userId,
+                    name: file.filename,
+                    mimeType: file.contentType,
+                    size: file.size,
+                    workspaceId: input.id,
+                },
+            });
+            const objectKey = `${userId}/${record.id}-${file.filename}`;
+            const { data: signedUrlData, error: signedUrlError } = await supabaseClient.storage
+                .from('media')
+                .createSignedUploadUrl(objectKey);
+            if (signedUrlError) {
+                throw new TRPCError({
+                    code: 'INTERNAL_SERVER_ERROR',
+                    message: `Failed to upload file`,
+                });
+            }
+            await this.db.fileAsset.update({
+                where: { id: record.id },
+                data: {
+                    bucket: 'media',
+                    objectKey,
+                },
+            });
+            results.push({
+                fileId: record.id,
+                uploadUrl: signedUrlData.signedUrl,
+            });
+        }
+        return results;
+    }
+    async deleteFiles(userId, input) {
+        const files = await this.db.fileAsset.findMany({
+            where: {
+                id: { in: input.fileId },
+                workspaceId: input.id,
+                userId,
+            },
+        });
+        for (const file of files) {
+            if (file.bucket && file.objectKey) {
+                supabaseClient.storage
+                    .from(file.bucket)
+                    .remove([file.objectKey])
+                    .catch((err) => {
+                    this.logger.error(`Error deleting file ${file.objectKey} from bucket ${file.bucket}:`, err);
+                });
+            }
+        }
+        await this.db.fileAsset.deleteMany({
+            where: {
+                id: { in: input.fileId },
+                workspaceId: input.id,
+                userId,
+            },
+        });
+        return true;
+    }
+    async getFileUploadUrl(userId, input) {
+        const workspaces = await this.db.workspace.findMany({
+            where: {
+                OR: [{ ownerId: userId }, { sharedWith: { some: { id: userId } } }],
+            },
+        });
+        const spaceUsed = await this.db.fileAsset.aggregate({
+            where: { workspaceId: { in: workspaces.map((w) => w.id) }, userId },
+            _sum: { size: true },
+        });
+        const storageLimit = await getUserStorageLimit(userId);
+        if ((spaceUsed._sum?.size ?? 0) + input.size > storageLimit) {
+            this.logger.warn(`Storage limit exceeded for user ${userId}. 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_${userId}/${input.workspaceId}-file_${input.filename}`;
+        const fileAsset = await this.db.fileAsset.create({
+            data: {
+                workspaceId: input.workspaceId,
+                name: input.filename,
+                mimeType: input.contentType,
+                size: input.size,
+                userId,
+                bucket: 'media',
+                objectKey,
+            },
+        });
+        const { data: signedUrlData, error: signedUrlError } = await supabaseClient.storage
+            .from('media')
+            .createSignedUploadUrl(objectKey, { upsert: true });
+        if (signedUrlError) {
+            this.logger.error('Signed upload URL error:', signedUrlError);
+            throw new TRPCError({
+                code: 'INTERNAL_SERVER_ERROR',
+                message: `Failed to create upload URL: ${signedUrlError.message}`,
+            });
+        }
+        await this.db.workspace.update({
+            where: { id: input.workspaceId },
+            data: { needsAnalysis: true },
+        });
+        return {
+            fileId: fileAsset.id,
+            uploadUrl: signedUrlData.signedUrl,
+        };
+    }
+    async search(userId, input) {
+        const { query, color } = input;
+        const workspaces = await this.db.workspace.findMany({
+            where: {
+                ownerId: userId,
+                markerColor: color || undefined,
+                ...(query
+                    ? {
+                        OR: [
+                            { title: { contains: query, mode: 'insensitive' } },
+                            { description: { contains: query, mode: 'insensitive' } },
+                        ],
+                    }
+                    : {}),
+            },
+            orderBy: { updatedAt: 'desc' },
+            take: input.limit,
+        });
+        const folders = await this.db.folder.findMany({
+            where: {
+                ownerId: userId,
+                markerColor: color || undefined,
+                ...(query ? { name: { contains: query, mode: 'insensitive' } } : {}),
+            },
+            orderBy: { updatedAt: 'desc' },
+            take: input.limit,
+        });
+        const results = [
+            ...workspaces.map((w) => ({ ...w, type: 'workspace' })),
+            ...folders.map((f) => ({ ...f, type: 'folder', title: f.name })),
+        ]
+            .sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime())
+            .slice(0, input.limit);
+        return results;
+    }
+}

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

@@ -0,0 +1,24 @@
+import type { PrismaClient } from '@prisma/client';
+import { BaseService } from './base.service.js';
+/**
+ * Study analytics: streaks, weekly activity, flashcard mastery, worksheet
+ * accuracy. Behavior-preserving extraction from `workspace.getStudyAnalytics`.
+ */
+export declare class WorkspaceAnalyticsService extends BaseService {
+    constructor(db: PrismaClient);
+    getStudyAnalytics(userId: string): Promise<{
+        streak: number;
+        totalStudyDays: number;
+        weeklyActivity: boolean[];
+        flashcards: {
+            total: number;
+            mastered: number;
+            dueForReview: number;
+        };
+        worksheets: {
+            completed: number;
+            correct: number;
+            accuracy: number;
+        };
+    }>;
+}

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

@@ -0,0 +1,95 @@
+import { BaseService } from './base.service.js';
+/**
+ * Study analytics: streaks, weekly activity, flashcard mastery, worksheet
+ * accuracy. Behavior-preserving extraction from `workspace.getStudyAnalytics`.
+ */
+export class WorkspaceAnalyticsService extends BaseService {
+    constructor(db) {
+        super(db);
+    }
+    async getStudyAnalytics(userId) {
+        const flashcardProgress = await this.db.flashcardProgress.findMany({
+            where: { userId },
+            select: { lastStudiedAt: true },
+        });
+        const worksheetProgress = await this.db.worksheetQuestionProgress.findMany({
+            where: { userId },
+            select: { updatedAt: true, completedAt: true },
+        });
+        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]);
+            }
+        }
+        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];
+            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;
+                    }
+                }
+            }
+        }
+        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));
+        }
+        const totalCards = await this.db.flashcardProgress.count({ where: { userId } });
+        const masteredCards = await this.db.flashcardProgress.count({
+            where: { userId, masteryLevel: { gte: 80 } },
+        });
+        const dueCards = await this.db.flashcardProgress.count({
+            where: { userId, nextReviewAt: { lte: new Date() } },
+        });
+        const completedQuestions = await this.db.worksheetQuestionProgress.count({
+            where: { userId, completedAt: { not: null } },
+        });
+        const correctQuestions = await this.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,
+            },
+        };
+    }
+}

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

@@ -0,0 +1,40 @@
+import type { PrismaClient } from '@prisma/client';
+import { BaseService } from './base.service.js';
+export interface WorkspaceKbMatch {
+    chunkId: string;
+    documentId: string;
+    documentName: string;
+    chunkIndex: number;
+    content: string;
+    score: number;
+}
+export declare class WorkspaceKbService extends BaseService {
+    constructor(db: PrismaClient);
+    /** Returns the single auto-managed KB for a workspace, creating it if needed. */
+    ensureWorkspaceKb(workspaceId: string, userId: string, title?: string): Promise<{
+        meta: import("@prisma/client/runtime/library").JsonValue | null;
+        name: string;
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        createdById: string | null;
+        description: string | null;
+        status: import("@prisma/client").$Enums.KnowledgeBaseStatus;
+        isCurated: boolean;
+        embeddingModel: string;
+        embeddingDim: number;
+    }>;
+    getWorkspaceKbId(workspaceId: string): Promise<string | null>;
+    indexText(workspaceId: string, userId: string, input: {
+        sourceType: string;
+        sourceId: string;
+        name: string;
+        text: string;
+    }): Promise<void>;
+    /** Fire-and-forget indexing — never blocks the caller. */
+    indexTextAsync(workspaceId: string, userId: string, input: Parameters<WorkspaceKbService['indexText']>[2]): void;
+    search(workspaceId: string, query: string, topK?: number): Promise<WorkspaceKbMatch[]>;
+    formatContext(matches: WorkspaceKbMatch[]): string;
+    retrieveContext(workspaceId: string, query: string, topK?: number): Promise<string>;
+}
+export declare const workspaceKbService: WorkspaceKbService;