@goscribe/server 1.3.4 → 1.5.0

package/dist/services/media-analysis.service.js

@@ -0,0 +1,384 @@
+import { TRPCError } from '@trpc/server';
+import { BaseService } from './base.service.js';
+import { ArtifactType } from '../lib/constants.js';
+import { supabaseClient } from '../lib/storage.js';
+import PusherService from '../lib/pusher.js';
+import { aiSessionService } from './ai-session.service.js';
+import { getUserUsage, getUserPlanLimits } from './usage.service.js';
+import { notifyArtifactFailed, notifyArtifactReady } from './notification.service.js';
+const PIPELINE_STEPS = ['fileUpload', 'fileAnalysis', 'studyGuide', 'flashcards'];
+const PROGRESS_FILENAME_MAX_CHARS = 20;
+function truncateProgressFilename(value, maxChars = PROGRESS_FILENAME_MAX_CHARS) {
+    if (value.length <= maxChars)
+        return value;
+    return `${value.slice(0, Math.max(0, maxChars - 3))}...`;
+}
+function buildCombinedFilenameLabel(fileNames) {
+    return truncateProgressFilename(fileNames.join(', '));
+}
+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 {
+            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,
+    };
+}
+export class MediaAnalysisService extends BaseService {
+    constructor(db) {
+        super(db);
+    }
+    async updateAnalysisProgress(workspaceId, progress) {
+        await this.db.workspace.update({
+            where: { id: workspaceId },
+            data: { analysisProgress: progress },
+        });
+        await PusherService.emitAnalysisProgress(workspaceId, progress);
+    }
+    async uploadAndAnalyzeMedia(input, userId) {
+        const workspace = await this.db.workspace.findFirst({
+            where: { id: input.workspaceId, ownerId: userId },
+        });
+        if (!workspace) {
+            this.logger.error('Workspace not found', { workspaceId: input.workspaceId, userId });
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        }
+        if (workspace.fileBeingAnalyzed) {
+            throw new TRPCError({
+                code: 'CONFLICT',
+                message: 'File analysis is already in progress for this workspace. Please wait for it to complete.',
+            });
+        }
+        const files = await this.db.fileAsset.findMany({
+            where: {
+                id: { in: input.files.map((file) => file.id) },
+                workspaceId: input.workspaceId,
+                userId,
+            },
+        });
+        if (files.length === 0) {
+            throw new TRPCError({
+                code: 'NOT_FOUND',
+                message: 'No files found with the provided IDs',
+            });
+        }
+        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`,
+                });
+            }
+        }
+        const primaryFile = files[0];
+        const fileType = primaryFile.mimeType.startsWith('image/') ? 'image' : 'pdf';
+        const combinedFilenameLabel = buildCombinedFilenameLabel(files.map((file) => file.name));
+        try {
+            await this.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 this.updateAnalysisProgress(input.workspaceId, buildProgress('starting', primaryFile.name, fileType, 'fileUpload', 'pending', genConfig));
+            }
+            catch (error) {
+                this.logger.error('Failed to update analysis progress:', error);
+                await this.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 this.updateAnalysisProgress(input.workspaceId, buildProgress('uploading', primaryFile.name, fileType, 'fileUpload', 'in_progress', genConfig));
+            for (const [fileIndex, file] of files.entries()) {
+                if (!file.bucket || !file.objectKey) {
+                    continue;
+                }
+                const currentFileType = file.mimeType.startsWith('image/') ? 'image' : 'pdf';
+                const currentFileLabel = truncateProgressFilename(file.name);
+                await this.updateAnalysisProgress(input.workspaceId, buildProgress('uploading', currentFileLabel, currentFileType, 'fileUpload', 'in_progress', genConfig, {
+                    currentFileIndex: fileIndex + 1,
+                    totalFiles: files.length,
+                }));
+                const { data: signedUrlData, error: signedUrlError } = await supabaseClient.storage
+                    .from(file.bucket)
+                    .createSignedUrl(file.objectKey, 24 * 60 * 60);
+                if (signedUrlError) {
+                    await this.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 maxPages = currentFileType === 'pdf' && file.size && file.size > 50 ? 50 : undefined;
+                const processResult = await aiSessionService.processFile(input.workspaceId, userId, fileUrl, currentFileType, maxPages);
+                if (processResult.status === 'error') {
+                    this.logger.error(`Failed to process file ${file.name}:`, processResult.error);
+                }
+                else {
+                    this.logger.info(`Successfully processed file ${file.name}: ${processResult.pageCount} pages`);
+                    await this.db.fileAsset.update({
+                        where: { id: file.id },
+                        data: {
+                            aiTranscription: {
+                                comprehensiveDescription: processResult.comprehensiveDescription,
+                                textContent: processResult.textContent,
+                                imageDescriptions: processResult.imageDescriptions,
+                            },
+                        },
+                    });
+                }
+            }
+            await this.updateAnalysisProgress(input.workspaceId, buildProgress('analyzing', combinedFilenameLabel, fileType, 'fileAnalysis', 'in_progress', genConfig));
+            try {
+                await this.updateAnalysisProgress(input.workspaceId, buildProgress('generating_artifacts', combinedFilenameLabel, fileType, 'studyGuide', 'pending', genConfig));
+            }
+            catch (error) {
+                this.logger.error('Failed to analyze files:', error);
+                await this.updateAnalysisProgress(input.workspaceId, buildProgress('error', combinedFilenameLabel, fileType, 'fileAnalysis', 'error', genConfig, {
+                    error: `Failed to analyze ${fileType}: ${error}`,
+                    studyGuide: 'skipped',
+                    flashcards: 'skipped',
+                }));
+                await this.db.workspace.update({
+                    where: { id: input.workspaceId },
+                    data: { fileBeingAnalyzed: false },
+                });
+                throw error;
+            }
+            const results = {
+                filename: primaryFile.name,
+                artifacts: {
+                    studyGuide: null,
+                    flashcards: null,
+                    worksheet: null,
+                },
+            };
+            try {
+                await aiSessionService.initSession(input.workspaceId, userId);
+            }
+            catch (initError) {
+                this.logger.error('Failed to init AI session (continuing with workspace context):', initError);
+            }
+            const [usage, limits] = await Promise.all([
+                getUserUsage(userId),
+                getUserPlanLimits(userId),
+            ]);
+            if (input.generateStudyGuide) {
+                if (limits && usage.studyGuides >= limits.maxStudyGuides) {
+                    await this.updateAnalysisProgress(input.workspaceId, buildProgress('skipped', combinedFilenameLabel, fileType, 'studyGuide', 'skipped', genConfig));
+                    await PusherService.emitError(input.workspaceId, 'Study guide skipped: Limit reached.', 'study_guide');
+                    await notifyArtifactFailed(this.db, {
+                        userId,
+                        workspaceId: input.workspaceId,
+                        artifactType: ArtifactType.STUDY_GUIDE,
+                        message: 'Study guide was skipped because your plan limit was reached.',
+                    }).catch(() => { });
+                }
+                else {
+                    try {
+                        await this.updateAnalysisProgress(input.workspaceId, buildProgress('generating_study_guide', combinedFilenameLabel, fileType, 'studyGuide', 'in_progress', genConfig));
+                        const content = await aiSessionService.generateStudyGuide(input.workspaceId, userId);
+                        let artifact = await this.db.artifact.findFirst({
+                            where: { workspaceId: input.workspaceId, type: ArtifactType.STUDY_GUIDE },
+                        });
+                        if (!artifact) {
+                            artifact = await this.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: userId,
+                                },
+                            });
+                        }
+                        const lastVersion = await this.db.artifactVersion.findFirst({
+                            where: { artifact: { workspaceId: input.workspaceId, type: ArtifactType.STUDY_GUIDE } },
+                            orderBy: { version: 'desc' },
+                        });
+                        await this.db.artifactVersion.create({
+                            data: {
+                                artifactId: artifact.id,
+                                version: lastVersion ? lastVersion.version + 1 : 1,
+                                content: content,
+                                createdById: userId,
+                            },
+                        });
+                        results.artifacts.studyGuide = artifact;
+                        await PusherService.emitStudyGuideComplete(input.workspaceId, artifact);
+                        await notifyArtifactReady(this.db, {
+                            userId,
+                            workspaceId: input.workspaceId,
+                            artifactId: artifact.id,
+                            artifactType: ArtifactType.STUDY_GUIDE,
+                            title: artifact.title,
+                        }).catch(() => { });
+                    }
+                    catch (sgError) {
+                        this.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(this.db, {
+                            userId,
+                            workspaceId: input.workspaceId,
+                            artifactType: ArtifactType.STUDY_GUIDE,
+                            message: 'Study guide generation failed. Please try regenerating later.',
+                        }).catch(() => { });
+                    }
+                }
+            }
+            if (input.generateFlashcards) {
+                if (limits && usage.flashcards >= limits.maxFlashcards) {
+                    await this.updateAnalysisProgress(input.workspaceId, buildProgress('skipped', combinedFilenameLabel, fileType, 'flashcards', 'skipped', genConfig));
+                    await PusherService.emitError(input.workspaceId, 'Flashcards skipped: Limit reached.', 'flashcards');
+                    await notifyArtifactFailed(this.db, {
+                        userId,
+                        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 this.updateAnalysisProgress(input.workspaceId, buildProgress('generating_flashcards', combinedFilenameLabel, fileType, 'flashcards', 'in_progress', genConfig, {
+                            studyGuide: sgStatus,
+                        }));
+                        const content = await aiSessionService.generateFlashcardQuestions(input.workspaceId, userId, 10, 'medium');
+                        const artifact = await this.db.artifact.create({
+                            data: {
+                                workspaceId: input.workspaceId,
+                                type: ArtifactType.FLASHCARD_SET,
+                                title: files.length === 1
+                                    ? `Flashcards - ${primaryFile.name}`
+                                    : `Flashcards - ${files.length} files`,
+                                createdById: userId,
+                            },
+                        });
+                        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 this.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);
+                            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 this.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(this.db, {
+                            userId,
+                            workspaceId: input.workspaceId,
+                            artifactId: artifact.id,
+                            artifactType: ArtifactType.FLASHCARD_SET,
+                            title: artifact.title,
+                        }).catch(() => { });
+                    }
+                    catch (fcError) {
+                        this.logger.error('Flashcard generation failed after retries:', fcError);
+                        await PusherService.emitError(input.workspaceId, 'Flashcard generation failed. Please try regenerating later.', 'flashcards');
+                        await notifyArtifactFailed(this.db, {
+                            userId,
+                            workspaceId: input.workspaceId,
+                            artifactType: ArtifactType.FLASHCARD_SET,
+                            message: 'Flashcard generation failed. Please try regenerating later.',
+                        }).catch(() => { });
+                    }
+                }
+            }
+            await this.db.workspace.update({
+                where: { id: input.workspaceId },
+                data: { fileBeingAnalyzed: false },
+            });
+            await this.updateAnalysisProgress(input.workspaceId, {
+                ...buildProgress('completed', combinedFilenameLabel, fileType, 'flashcards', 'completed', genConfig),
+                completedAt: new Date().toISOString(),
+            });
+            return results;
+        }
+        catch (error) {
+            this.logger.error('Failed to update analysis progress:', error);
+            await this.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;
+        }
+    }
+}

package/dist/services/member.service.d.ts

@@ -0,0 +1,36 @@
+import type { PrismaClient } from '@prisma/client';
+import { BaseService } from './base.service.js';
+export declare class MemberService extends BaseService {
+    constructor(db: PrismaClient);
+    getMembers(userId: string, workspaceId: string): Promise<({
+        id: string;
+        name: string;
+        email: string;
+        role: "admin" | "member";
+        joinedAt: Date;
+    } | {
+        id: string;
+        name: string;
+        email: string;
+        role: "owner";
+        joinedAt: Date;
+    })[]>;
+    getCurrentUserRole(userId: string, workspaceId: string): Promise<"admin" | "member" | "owner">;
+    changeMemberRole(userId: string, input: {
+        workspaceId: string;
+        memberId: string;
+        role: 'admin' | 'member';
+    }): Promise<{
+        memberId: string;
+        role: "admin" | "member";
+        memberName: string | null;
+        message: string;
+    }>;
+    removeMember(userId: string, input: {
+        workspaceId: string;
+        memberId: string;
+    }): Promise<{
+        memberId: string;
+        message: string;
+    }>;
+}

package/dist/services/member.service.js

@@ -0,0 +1,193 @@
+import { TRPCError } from '@trpc/server';
+import { BaseService } from './base.service.js';
+import { notifyWorkspaceMembershipRemoved, notifyWorkspaceRoleChanged, } from './notification.service.js';
+export class MemberService extends BaseService {
+    constructor(db) {
+        super(db);
+    }
+    async getMembers(userId, workspaceId) {
+        const workspace = await this.db.workspace.findFirst({
+            where: {
+                id: workspaceId,
+                OR: [{ ownerId: userId }, { members: { some: { userId } } }],
+            },
+            include: {
+                owner: {
+                    select: {
+                        id: true,
+                        name: true,
+                        email: true,
+                        profilePicture: { select: { id: true, name: true, url: true } },
+                    },
+                },
+                members: {
+                    include: {
+                        user: {
+                            select: {
+                                id: true,
+                                name: true,
+                                email: true,
+                                profilePicture: { select: { id: true, name: true, url: true } },
+                            },
+                        },
+                    },
+                },
+            },
+        });
+        if (!workspace) {
+            throw new TRPCError({
+                code: 'NOT_FOUND',
+                message: 'Workspace not found or access denied',
+            });
+        }
+        const workspaceMembers = [
+            {
+                id: workspace.owner.id,
+                name: workspace.owner.name || 'Unknown',
+                email: workspace.owner.email || '',
+                role: 'owner',
+                joinedAt: workspace.createdAt,
+            },
+            ...workspace.members.map((membership) => ({
+                id: membership.user.id,
+                name: membership.user.name || 'Unknown',
+                email: membership.user.email || '',
+                role: membership.role,
+                joinedAt: membership.joinedAt,
+            })),
+        ];
+        this.logger.info(`👥 Fetched ${workspaceMembers.length} members for workspace ${workspaceId}`, 'WORKSPACE', { memberEmails: workspaceMembers.map((m) => m.email) });
+        return workspaceMembers;
+    }
+    async getCurrentUserRole(userId, workspaceId) {
+        const workspace = await this.db.workspace.findFirst({
+            where: { id: workspaceId },
+            select: {
+                ownerId: true,
+                members: { where: { userId }, select: { role: true } },
+            },
+        });
+        if (!workspace) {
+            throw new TRPCError({ code: 'NOT_FOUND', message: 'Workspace not found' });
+        }
+        if (workspace.ownerId === userId) {
+            return 'owner';
+        }
+        if (workspace.members.length > 0) {
+            return workspace.members[0].role;
+        }
+        throw new TRPCError({
+            code: 'FORBIDDEN',
+            message: 'Access denied to this workspace',
+        });
+    }
+    async changeMemberRole(userId, input) {
+        const workspace = await this.db.workspace.findFirst({
+            where: { id: input.workspaceId, ownerId: userId },
+            select: { id: true, title: true, ownerId: true },
+        });
+        if (!workspace) {
+            throw new TRPCError({
+                code: 'NOT_FOUND',
+                message: 'Workspace not found or insufficient permissions',
+            });
+        }
+        if (input.memberId === workspace.ownerId) {
+            throw new TRPCError({
+                code: 'BAD_REQUEST',
+                message: 'Cannot change owner role',
+            });
+        }
+        const member = await this.db.workspaceMember.findFirst({
+            where: { workspaceId: input.workspaceId, userId: input.memberId },
+        });
+        if (!member) {
+            throw new TRPCError({
+                code: 'NOT_FOUND',
+                message: 'Member not found in this workspace',
+            });
+        }
+        const updatedMember = await this.db.workspaceMember.update({
+            where: { id: member.id },
+            data: { role: input.role },
+            include: {
+                user: { select: { id: true, name: true, email: true } },
+            },
+        });
+        this.logger.info(`🔄 Member role changed for ${input.memberId} from ${member.role} to ${input.role} in workspace ${input.workspaceId}`, 'WORKSPACE', {
+            workspaceId: input.workspaceId,
+            memberId: input.memberId,
+            oldRole: member.role,
+            newRole: input.role,
+            changedBy: userId,
+        });
+        const actor = await this.db.user.findUnique({
+            where: { id: userId },
+            select: { name: true, email: true },
+        });
+        await notifyWorkspaceRoleChanged(this.db, {
+            memberUserId: input.memberId,
+            workspaceId: input.workspaceId,
+            workspaceTitle: workspace.title,
+            newRole: input.role,
+            oldRole: member.role,
+            actorUserId: userId,
+            actorName: actor?.name || actor?.email || 'A workspace admin',
+        }).catch(() => { });
+        return {
+            memberId: input.memberId,
+            role: input.role,
+            memberName: updatedMember.user.name || updatedMember.user.email,
+            message: 'Role changed successfully',
+        };
+    }
+    async removeMember(userId, input) {
+        const workspace = await this.db.workspace.findFirst({
+            where: { id: input.workspaceId, ownerId: userId },
+            select: { id: true, title: true, ownerId: true },
+        });
+        if (!workspace) {
+            throw new TRPCError({
+                code: 'NOT_FOUND',
+                message: 'Workspace not found or insufficient permissions',
+            });
+        }
+        if (input.memberId === workspace.ownerId) {
+            throw new TRPCError({
+                code: 'BAD_REQUEST',
+                message: 'Cannot remove workspace owner',
+            });
+        }
+        const member = await this.db.workspaceMember.findFirst({
+            where: { workspaceId: input.workspaceId, userId: input.memberId },
+            include: { user: { select: { name: true, email: true } } },
+        });
+        if (!member) {
+            throw new TRPCError({
+                code: 'NOT_FOUND',
+                message: 'Member not found in this workspace',
+            });
+        }
+        const actor = await this.db.user.findUnique({
+            where: { id: userId },
+            select: { name: true, email: true },
+        });
+        await notifyWorkspaceMembershipRemoved(this.db, {
+            memberUserId: input.memberId,
+            workspaceId: input.workspaceId,
+            workspaceTitle: workspace.title,
+            actorUserId: userId,
+            actorName: actor?.name || actor?.email || 'A workspace admin',
+        }).catch(() => { });
+        await this.db.workspaceMember.delete({ where: { id: member.id } });
+        this.logger.info(`🗑️ Member ${input.memberId} removed from workspace ${input.workspaceId}`, 'WORKSPACE', {
+            workspaceId: input.workspaceId,
+            memberId: input.memberId,
+            removedBy: userId,
+        });
+        return {
+            memberId: input.memberId,
+            message: 'Member removed successfully',
+        };
+    }
+}

package/dist/services/members/invitation.service.d.ts

@@ -0,0 +1,66 @@
+import type { PrismaClient } from '@prisma/client';
+import { BaseService } from '../base.service.js';
+export declare class InvitationService extends BaseService {
+    constructor(db: PrismaClient);
+    inviteMember(userId: string, input: {
+        workspaceId: string;
+        email: string;
+        role: 'admin' | 'member';
+    }): Promise<{
+        invitationId: string;
+        token: string;
+        email: string;
+        role: string;
+        expiresAt: Date;
+        workspaceTitle: string;
+        invitedByName: string | null;
+    }>;
+    getInvitations(workspaceId: string): Promise<{
+        id: string;
+        email: string;
+        createdAt: Date;
+        updatedAt: Date;
+        workspaceId: string;
+        role: string;
+        token: string;
+        invitedById: string;
+        acceptedAt: Date | null;
+        expiresAt: Date;
+    }[]>;
+    acceptInvite(sessionUserId: string | undefined, token: string): Promise<{
+        message?: string | undefined;
+        workspaceId: string;
+        workspaceTitle: string;
+        role: string;
+        ownerName: string | null;
+    }>;
+    getPendingInvitations(userId: string, workspaceId: string): Promise<{
+        id: string;
+        email: string;
+        role: string;
+        token: string;
+        expiresAt: Date;
+        createdAt: Date;
+        invitedByName: string | null;
+    }[]>;
+    cancelInvitation(userId: string, invitationId: string): Promise<{
+        invitationId: string;
+        message: string;
+    }>;
+    resendInvitation(userId: string, invitationId: string): Promise<{
+        invitationId: string;
+        message: string;
+    }>;
+    getAllInvitationsDebug(userId: string, workspaceId: string): Promise<{
+        id: string;
+        email: string;
+        createdAt: Date;
+        updatedAt: Date;
+        workspaceId: string;
+        role: string;
+        token: string;
+        invitedById: string;
+        acceptedAt: Date | null;
+        expiresAt: Date;
+    }[]>;
+}