@goscribe/server 1.3.4 → 1.6.0

package/src/services/members/invitation.service.ts

@@ -0,0 +1,427 @@
+import type { PrismaClient } from '@prisma/client';
+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: PrismaClient) {
+    super(db);
+  }
+
+  async inviteMember(
+    userId: string,
+    input: { workspaceId: string; email: string; role: 'admin' | 'member' },
+  ) {
+    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: string) {
+    return this.db.workspaceInvitation.findMany({
+      where: { workspaceId },
+    });
+  }
+
+  async acceptInvite(sessionUserId: string | undefined, token: string) {
+    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: any) {
+      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: string, workspaceId: string) {
+    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: string, invitationId: string) {
+    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: string, invitationId: string) {
+    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: string, workspaceId: string) {
+    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/src/services/members/member.service.ts

@@ -0,0 +1,241 @@
+import type { PrismaClient } from '@prisma/client';
+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: PrismaClient) {
+    super(db);
+  }
+
+  async getMembers(userId: string, workspaceId: string) {
+    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' as const,
+        joinedAt: workspace.createdAt,
+      },
+      ...workspace.members.map((membership) => ({
+        id: membership.user.id,
+        name: membership.user.name || 'Unknown',
+        email: membership.user.email || '',
+        role: membership.role as 'admin' | 'member',
+        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: string, workspaceId: string) {
+    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 as 'admin' | 'member';
+    }
+
+    throw new TRPCError({
+      code: 'FORBIDDEN',
+      message: 'Access denied to this workspace',
+    });
+  }
+
+  async changeMemberRole(
+    userId: string,
+    input: { workspaceId: string; memberId: string; role: 'admin' | 'member' },
+  ) {
+    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: string, input: { workspaceId: string; memberId: string }) {
+    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/src/{lib/notification-service.test.ts → services/notifications/notification.service.test.ts}

@@ -1,7 +1,7 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
-import PusherService from './pusher.js';
-import { NotificationType, createNotification } from './notification-service.js';
+import PusherService from '../../lib/pusher.js';
+import { NotificationType, createNotification } from './notification.service.js';
 
 type FakeNotification = {
   id: string;