@goscribe/server 1.5.0 → 1.7.0

package/dist/src/services/members/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 '../notifications/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/src/services/members/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/src/services/members/member.service.js

@@ -0,0 +1,193 @@
+import { TRPCError } from '@trpc/server';
+import { BaseService } from '../base.service.js';
+import { notifyWorkspaceMembershipRemoved, notifyWorkspaceRoleChanged, } from '../notifications/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',
+        };
+    }
+}