@goscribe/server 1.3.4 → 1.5.0

package/dist/services/invitation.service.js

@@ -0,0 +1,348 @@
+import { TRPCError } from '@trpc/server';
+import { BaseService } from './base.service.js';
+import { sendInvitationEmail } from '../lib/email.js';
+import PusherService from '../lib/pusher.js';
+import { notifyInviteAccepted, notifyInviteRecipient, } from './notification.service.js';
+export class InvitationService extends BaseService {
+    constructor(db) {
+        super(db);
+    }
+    async inviteMember(userId, input) {
+        const workspace = await this.db.workspace.findFirst({
+            where: { id: input.workspaceId, ownerId: userId },
+        });
+        if (!workspace) {
+            throw new TRPCError({
+                code: 'NOT_FOUND',
+                message: 'Workspace not found or insufficient permissions',
+            });
+        }
+        const existingMember = await this.db.user.findFirst({
+            where: {
+                email: input.email,
+                OR: [
+                    { id: workspace.ownerId },
+                    { workspaceMemberships: { some: { workspaceId: input.workspaceId } } },
+                ],
+            },
+        });
+        if (existingMember) {
+            throw new TRPCError({
+                code: 'BAD_REQUEST',
+                message: 'User is already a member of this workspace',
+            });
+        }
+        const existingInvitation = await this.db.workspaceInvitation.findFirst({
+            where: {
+                workspaceId: input.workspaceId,
+                email: input.email,
+                acceptedAt: null,
+                expiresAt: { gt: new Date() },
+            },
+        });
+        if (existingInvitation) {
+            throw new TRPCError({
+                code: 'BAD_REQUEST',
+                message: 'Invitation already sent to this email',
+            });
+        }
+        const invitation = await this.db.workspaceInvitation.create({
+            data: {
+                workspaceId: input.workspaceId,
+                email: input.email,
+                role: input.role,
+                invitedById: userId,
+            },
+            include: {
+                workspace: {
+                    select: {
+                        title: true,
+                        owner: { select: { name: true, email: true } },
+                    },
+                },
+            },
+        });
+        const invitedExistingUser = await this.db.user.findUnique({
+            where: { email: input.email },
+            select: { id: true, name: true },
+        });
+        if (invitedExistingUser) {
+            await notifyInviteRecipient(this.db, {
+                invitedUserId: invitedExistingUser.id,
+                inviterUserId: userId,
+                workspaceId: input.workspaceId,
+                workspaceTitle: invitation.workspace.title,
+                invitationId: invitation.id,
+                invitationToken: invitation.token,
+                inviterName: invitation.workspace.owner.name || invitation.workspace.owner.email,
+            });
+        }
+        this.logger.info(`🎫 Invitation created for ${input.email} to workspace ${input.workspaceId} with role ${input.role}`, 'WORKSPACE', {
+            invitationId: invitation.id,
+            workspaceId: input.workspaceId,
+            email: input.email,
+            role: input.role,
+            invitedBy: userId,
+        });
+        await sendInvitationEmail({
+            email: invitation.email,
+            token: invitation.token,
+            role: invitation.role,
+            workspaceTitle: invitation.workspace.title,
+            invitedByName: invitation.workspace.owner.name || invitation.workspace.owner.email || 'Someone',
+        });
+        return {
+            invitationId: invitation.id,
+            token: invitation.token,
+            email: invitation.email,
+            role: invitation.role,
+            expiresAt: invitation.expiresAt,
+            workspaceTitle: invitation.workspace.title,
+            invitedByName: invitation.workspace.owner.name || invitation.workspace.owner.email,
+        };
+    }
+    async getInvitations(workspaceId) {
+        return this.db.workspaceInvitation.findMany({
+            where: { workspaceId },
+        });
+    }
+    async acceptInvite(sessionUserId, token) {
+        const invitation = await this.db.workspaceInvitation.findFirst({
+            where: {
+                token,
+                acceptedAt: null,
+                expiresAt: { gt: new Date() },
+            },
+            include: {
+                workspace: {
+                    select: {
+                        id: true,
+                        title: true,
+                        ownerId: true,
+                        owner: { select: { name: true, email: true } },
+                    },
+                },
+            },
+        });
+        if (!invitation) {
+            throw new TRPCError({
+                code: 'NOT_FOUND',
+                message: 'Invalid or expired invitation',
+            });
+        }
+        if (!sessionUserId) {
+            throw new TRPCError({
+                code: 'UNAUTHORIZED',
+                message: 'Please log in to accept this invitation',
+            });
+        }
+        const user = await this.db.user.findFirst({ where: { id: sessionUserId } });
+        if (!user || !user.email)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        this.logger.info(`🔍 Verification check for ${user.email} accepting invite for ${invitation.email}`, 'WORKSPACE');
+        if (user.email.toLowerCase() !== invitation.email.toLowerCase()) {
+            this.logger.warn(`❌ Invitation email mismatch: user ${user.email} vs invite ${invitation.email}`, 'WORKSPACE');
+            throw new TRPCError({
+                code: 'BAD_REQUEST',
+                message: 'This invitation was sent to a different email address',
+            });
+        }
+        const isAlreadyMember = await this.db.workspace.findFirst({
+            where: {
+                id: invitation.workspaceId,
+                OR: [
+                    { ownerId: sessionUserId },
+                    { members: { some: { userId: sessionUserId } } },
+                ],
+            },
+        });
+        if (isAlreadyMember) {
+            this.logger.info(`ℹ️ User ${sessionUserId} is already a member of workspace ${invitation.workspaceId}. Marking invite as accepted.`, 'WORKSPACE');
+            await this.db.workspaceInvitation.update({
+                where: { id: invitation.id },
+                data: { acceptedAt: new Date() },
+            });
+            return {
+                workspaceId: invitation.workspaceId,
+                workspaceTitle: invitation.workspace.title,
+                role: invitation.role,
+                ownerName: invitation.workspace.owner.name || invitation.workspace.owner.email,
+                message: 'You are already a member of this workspace',
+            };
+        }
+        let memberAdded = false;
+        try {
+            await this.db.workspaceMember.create({
+                data: {
+                    workspaceId: invitation.workspaceId,
+                    userId: sessionUserId,
+                    role: invitation.role,
+                },
+            });
+            memberAdded = true;
+        }
+        catch (error) {
+            if (error?.code !== 'P2002') {
+                throw error;
+            }
+            this.logger.info(`ℹ️ Duplicate invite accept handled for user ${sessionUserId} in workspace ${invitation.workspaceId}`, 'WORKSPACE');
+        }
+        await this.db.workspaceInvitation.update({
+            where: { id: invitation.id },
+            data: { acceptedAt: new Date() },
+        });
+        if (memberAdded) {
+            await notifyInviteAccepted(this.db, {
+                recipientUserIds: [invitation.invitedById, invitation.workspace.ownerId],
+                actorUserId: sessionUserId,
+                workspaceId: invitation.workspaceId,
+                workspaceTitle: invitation.workspace.title,
+                memberName: user.name || user.email,
+                invitationId: invitation.id,
+            });
+        }
+        this.logger.info(`✅ Invitation accepted by ${sessionUserId} (${user.email}) for workspace ${invitation.workspaceId}`, 'WORKSPACE', {
+            invitationId: invitation.id,
+            workspaceId: invitation.workspaceId,
+            userId: sessionUserId,
+            email: invitation.email,
+        });
+        try {
+            if (memberAdded) {
+                await PusherService.emitMemberJoined(invitation.workspaceId, {
+                    id: sessionUserId,
+                    name: user.name || 'Member',
+                    email: user.email,
+                    role: invitation.role,
+                });
+            }
+        }
+        catch (e) {
+            this.logger.error('Failed to emit member joined event', e);
+        }
+        return {
+            workspaceId: invitation.workspaceId,
+            workspaceTitle: invitation.workspace.title,
+            role: invitation.role,
+            ownerName: invitation.workspace.owner.name || invitation.workspace.owner.email,
+            ...(memberAdded ? {} : { message: 'You are already a member of this workspace' }),
+        };
+    }
+    async getPendingInvitations(userId, workspaceId) {
+        const workspace = await this.db.workspace.findFirst({
+            where: { id: workspaceId, ownerId: userId },
+        });
+        if (!workspace) {
+            throw new TRPCError({
+                code: 'NOT_FOUND',
+                message: 'Workspace not found or insufficient permissions',
+            });
+        }
+        const invitations = await this.db.workspaceInvitation.findMany({
+            where: {
+                workspaceId,
+                acceptedAt: null,
+                expiresAt: { gt: new Date() },
+            },
+            include: {
+                invitedBy: { select: { name: true, email: true } },
+            },
+            orderBy: { createdAt: 'desc' },
+        });
+        return invitations.map((invitation) => ({
+            id: invitation.id,
+            email: invitation.email,
+            role: invitation.role,
+            token: invitation.token,
+            expiresAt: invitation.expiresAt,
+            createdAt: invitation.createdAt,
+            invitedByName: invitation.invitedBy.name || invitation.invitedBy.email,
+        }));
+    }
+    async cancelInvitation(userId, invitationId) {
+        const invitation = await this.db.workspaceInvitation.findFirst({
+            where: {
+                id: invitationId,
+                acceptedAt: null,
+                workspace: { ownerId: userId },
+            },
+        });
+        if (!invitation) {
+            throw new TRPCError({
+                code: 'NOT_FOUND',
+                message: 'Invitation not found or insufficient permissions',
+            });
+        }
+        await this.db.workspaceInvitation.delete({ where: { id: invitationId } });
+        this.logger.info(`❌ Invitation cancelled for ${invitation.email} to workspace ${invitation.workspaceId}`, 'WORKSPACE', {
+            invitationId,
+            workspaceId: invitation.workspaceId,
+            email: invitation.email,
+            cancelledBy: userId,
+        });
+        return {
+            invitationId,
+            message: 'Invitation cancelled successfully',
+        };
+    }
+    async resendInvitation(userId, invitationId) {
+        const invitation = await this.db.workspaceInvitation.findFirst({
+            where: {
+                id: invitationId,
+                acceptedAt: null,
+                workspace: { ownerId: userId },
+            },
+            include: {
+                workspace: {
+                    select: {
+                        title: true,
+                        owner: { select: { name: true, email: true } },
+                    },
+                },
+            },
+        });
+        if (!invitation) {
+            throw new TRPCError({
+                code: 'NOT_FOUND',
+                message: 'Invitation not found or insufficient permissions',
+            });
+        }
+        if (invitation.expiresAt < new Date()) {
+            const newExpiry = new Date();
+            newExpiry.setDate(newExpiry.getDate() + 7);
+            await this.db.workspaceInvitation.update({
+                where: { id: invitation.id },
+                data: { expiresAt: newExpiry },
+            });
+            invitation.expiresAt = newExpiry;
+        }
+        await sendInvitationEmail({
+            email: invitation.email,
+            token: invitation.token,
+            role: invitation.role,
+            workspaceTitle: invitation.workspace.title,
+            invitedByName: invitation.workspace.owner.name || invitation.workspace.owner.email || 'Someone',
+        });
+        this.logger.info(`📧 Invitation resent to ${invitation.email} for workspace ${invitation.workspaceId}`, 'WORKSPACE', {
+            invitationId: invitation.id,
+            workspaceId: invitation.workspaceId,
+            email: invitation.email,
+            resentBy: userId,
+        });
+        return {
+            invitationId: invitation.id,
+            message: 'Invitation email resent successfully',
+        };
+    }
+    async getAllInvitationsDebug(userId, workspaceId) {
+        const workspace = await this.db.workspace.findFirst({
+            where: { id: workspaceId, ownerId: userId },
+        });
+        if (!workspace)
+            throw new TRPCError({ code: 'UNAUTHORIZED' });
+        return this.db.workspaceInvitation.findMany({
+            where: { workspaceId },
+            orderBy: { createdAt: 'desc' },
+        });
+    }
+}

package/dist/services/knowledge/knowledge-base.service.d.ts

@@ -0,0 +1,316 @@
+import type { PrismaClient } from '@prisma/client';
+import { BaseService } from '../base.service.js';
+interface AdminCreateInput {
+    name: string;
+    description?: string;
+    isCurated?: boolean;
+}
+interface AdminUpdateInput {
+    id: string;
+    name?: string;
+    description?: string | null;
+    isCurated?: boolean;
+}
+interface RequestUploadUrlInput {
+    knowledgeBaseId: string;
+    filename: string;
+    contentType: string;
+    size: number;
+}
+interface ProcessDocumentInput {
+    knowledgeBaseId: string;
+    documentId: string;
+}
+interface QueryInput {
+    knowledgeBaseId: string;
+    query: string;
+    topK?: number;
+    generateAnswer?: boolean;
+}
+export declare class KnowledgeBaseService extends BaseService {
+    constructor(db: PrismaClient);
+    private assertWorkspaceAccess;
+    /**
+     * Loads a knowledge base only if it's reachable to the calling user, i.e.
+     * either curated (visible in catalog) or attached to one of their accessible
+     * workspaces.
+     */
+    private loadKbForUser;
+    /** Admin-only: load by id without membership/curation checks. */
+    private loadKbAsAdmin;
+    /**
+     * KBs attached to a given workspace (the user's "library" for that
+     * workspace).
+     */
+    listForWorkspace(userId: string, workspaceId: string): Promise<{
+        attachmentId: string;
+        attachedAt: Date;
+        attachedById: string | null;
+        _count: {
+            documents: number;
+        };
+        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;
+    }[]>;
+    /**
+     * Search the curated catalog. Optionally pass a workspaceId to also tag
+     * each result with whether the workspace already has it attached.
+     */
+    searchCatalog(userId: string, input: {
+        query?: string;
+        workspaceId?: string;
+        limit?: number;
+    }): Promise<{
+        attached: boolean;
+        _count: {
+            documents: number;
+        };
+        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;
+    }[]>;
+    get(userId: string, id: string): Promise<{
+        documents: {
+            meta: import("@prisma/client/runtime/library").JsonValue | null;
+            name: string;
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            mimeType: string;
+            size: number;
+            bucket: string | null;
+            objectKey: string | null;
+            status: import("@prisma/client").$Enums.KnowledgeBaseDocumentStatus;
+            knowledgeBaseId: string;
+            errorMessage: string | null;
+            numChunks: number;
+            numPages: number | null;
+        }[];
+        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;
+    }>;
+    listDocuments(userId: string, knowledgeBaseId: string): Promise<{
+        meta: import("@prisma/client/runtime/library").JsonValue | null;
+        name: string;
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        mimeType: string;
+        size: number;
+        bucket: string | null;
+        objectKey: string | null;
+        status: import("@prisma/client").$Enums.KnowledgeBaseDocumentStatus;
+        knowledgeBaseId: string;
+        errorMessage: string | null;
+        numChunks: number;
+        numPages: number | null;
+    }[]>;
+    /** Attach a curated KB to one of the user's workspaces. */
+    addToWorkspace(userId: string, input: {
+        workspaceId: string;
+        knowledgeBaseId: string;
+    }): Promise<{
+        id: string;
+        createdAt: Date;
+        workspaceId: string;
+        knowledgeBaseId: string;
+        addedById: string | null;
+    }>;
+    /** Detach a KB from one of the user's workspaces. */
+    removeFromWorkspace(userId: string, input: {
+        workspaceId: string;
+        knowledgeBaseId: string;
+    }): Promise<boolean>;
+    query(userId: string, input: QueryInput): Promise<{
+        matches: {
+            chunkId: string;
+            documentId: string;
+            documentName: string;
+            chunkIndex: number;
+            content: string;
+            score: number;
+        }[];
+        answer: string | null;
+    }>;
+    private queryForKb;
+    private processDocumentForKb;
+    adminListAll(): Promise<({
+        _count: {
+            workspaces: number;
+            documents: number;
+        };
+    } & {
+        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;
+    })[]>;
+    adminGet(id: string): Promise<{
+        documents: {
+            meta: import("@prisma/client/runtime/library").JsonValue | null;
+            name: string;
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            mimeType: string;
+            size: number;
+            bucket: string | null;
+            objectKey: string | null;
+            status: import("@prisma/client").$Enums.KnowledgeBaseDocumentStatus;
+            knowledgeBaseId: string;
+            errorMessage: string | null;
+            numChunks: number;
+            numPages: number | null;
+        }[];
+        workspaces: ({
+            workspace: {
+                id: string;
+                title: string;
+                icon: string;
+            };
+        } & {
+            id: string;
+            createdAt: Date;
+            workspaceId: string;
+            knowledgeBaseId: string;
+            addedById: string | null;
+        })[];
+        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;
+    }>;
+    adminListDocuments(knowledgeBaseId: string): Promise<{
+        meta: import("@prisma/client/runtime/library").JsonValue | null;
+        name: string;
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        mimeType: string;
+        size: number;
+        bucket: string | null;
+        objectKey: string | null;
+        status: import("@prisma/client").$Enums.KnowledgeBaseDocumentStatus;
+        knowledgeBaseId: string;
+        errorMessage: string | null;
+        numChunks: number;
+        numPages: number | null;
+    }[]>;
+    adminCreate(actorUserId: string, input: AdminCreateInput): 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;
+    }>;
+    adminUpdate(input: AdminUpdateInput): 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;
+    }>;
+    adminDelete(id: string): Promise<boolean>;
+    /** Admin-only: attach a KB to a workspace (curated or not). */
+    adminAttachToWorkspace(actorUserId: string, input: {
+        workspaceId: string;
+        knowledgeBaseId: string;
+    }): Promise<{
+        id: string;
+        createdAt: Date;
+        workspaceId: string;
+        knowledgeBaseId: string;
+        addedById: string | null;
+    }>;
+    adminDetachFromWorkspace(input: {
+        workspaceId: string;
+        knowledgeBaseId: string;
+    }): Promise<boolean>;
+    adminRequestUploadUrl(input: RequestUploadUrlInput): Promise<{
+        documentId: string;
+        uploadUrl: string;
+        bucket: string;
+        objectKey: string;
+    }>;
+    adminProcessDocument(input: ProcessDocumentInput): Promise<{
+        meta: import("@prisma/client/runtime/library").JsonValue | null;
+        name: string;
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        mimeType: string;
+        size: number;
+        bucket: string | null;
+        objectKey: string | null;
+        status: import("@prisma/client").$Enums.KnowledgeBaseDocumentStatus;
+        knowledgeBaseId: string;
+        errorMessage: string | null;
+        numChunks: number;
+        numPages: number | null;
+    } | null>;
+    adminDeleteDocument(documentId: string): Promise<boolean>;
+    adminQuery(input: QueryInput): Promise<{
+        matches: {
+            chunkId: string;
+            documentId: string;
+            documentName: string;
+            chunkIndex: number;
+            content: string;
+            score: number;
+        }[];
+        answer: string | null;
+    }>;
+}
+export {};