@goscribe/server 1.3.0 → 1.3.1

package/dist/routers/members.js

@@ -2,6 +2,9 @@ import { z } from 'zod';
 import { TRPCError } from '@trpc/server';
 import { router, publicProcedure, authedProcedure } from '../trpc.js';
 import { logger } from '../lib/logger.js';
+import { sendInvitationEmail } from '../lib/email.js';
+import PusherService from '../lib/pusher.js';
+import { notifyInviteAccepted, notifyInviteRecipient, notifyWorkspaceMembershipRemoved, notifyWorkspaceRoleChanged, } from '../lib/notification-service.js';
 /**
  * Members router for workspace member management
  *
@@ -72,8 +75,7 @@ export const members = router({
                 message: 'Workspace not found or access denied'
             });
         }
-        // Format members with roles
-        const members = [
+        const workspaceMembers = [
             {
                 id: workspace.owner.id,
                 name: workspace.owner.name || 'Unknown',
@@ -89,7 +91,10 @@ export const members = router({
                 joinedAt: membership.joinedAt,
             }))
         ];
-        return members;
+        logger.info(`👥 Fetched ${workspaceMembers.length} members for workspace ${input.workspaceId}`, 'WORKSPACE', {
+            memberEmails: workspaceMembers.map(m => m.email)
+        });
+        return workspaceMembers;
     }),
     /**
      * Get current user's role in a workspace
@@ -202,6 +207,21 @@ export const members = router({
                 }
             }
         });
+        const invitedExistingUser = await ctx.db.user.findUnique({
+            where: { email: input.email },
+            select: { id: true, name: true },
+        });
+        if (invitedExistingUser) {
+            await notifyInviteRecipient(ctx.db, {
+                invitedUserId: invitedExistingUser.id,
+                inviterUserId: ctx.session.user.id,
+                workspaceId: input.workspaceId,
+                workspaceTitle: invitation.workspace.title,
+                invitationId: invitation.id,
+                invitationToken: invitation.token,
+                inviterName: invitation.workspace.owner.name || invitation.workspace.owner.email,
+            });
+        }
         logger.info(`🎫 Invitation created for ${input.email} to workspace ${input.workspaceId} with role ${input.role}`, 'WORKSPACE', {
             invitationId: invitation.id,
             workspaceId: input.workspaceId,
@@ -209,8 +229,14 @@ export const members = router({
             role: input.role,
             invitedBy: ctx.session.user.id
         });
-        // TODO: Send email notification here
-        // await sendInvitationEmail(invitation);
+        // Send email notification
+        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,
@@ -251,6 +277,7 @@ export const members = router({
                     select: {
                         id: true,
                         title: true,
+                        ownerId: true,
                         owner: {
                             select: {
                                 name: true,
@@ -277,8 +304,10 @@ export const members = router({
         const user = await ctx.db.user.findFirst({ where: { id: ctx.session.user.id } });
         if (!user || !user.email)
             throw new TRPCError({ code: 'NOT_FOUND' });
-        // Check if the email matches the user's email
-        if (user.email !== invitation.email) {
+        logger.info(`🔍 Verification check for ${user.email} accepting invite for ${invitation.email}`, 'WORKSPACE');
+        // Check if the email matches the user's email (case-insensitive)
+        if (user.email.toLowerCase() !== invitation.email.toLowerCase()) {
+            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'
@@ -295,40 +324,81 @@ export const members = router({
             }
         });
         if (isAlreadyMember) {
+            logger.info(`ℹ️ User ${ctx.session.user.id} is already a member of workspace ${invitation.workspaceId}. Marking invite as accepted.`, 'WORKSPACE');
             // Mark invitation as accepted even if already a member
             await ctx.db.workspaceInvitation.update({
                 where: { id: invitation.id },
                 data: { acceptedAt: new Date() }
             });
-            throw new TRPCError({
-                code: 'BAD_REQUEST',
+            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'
+            };
+        }
+        // Add user to workspace with proper role.
+        // This can race if accept is triggered twice (e.g. redirects/retries),
+        // so treat duplicate membership as a successful, idempotent accept.
+        let memberAdded = false;
+        try {
+            await ctx.db.workspaceMember.create({
+                data: {
+                    workspaceId: invitation.workspaceId,
+                    userId: ctx.session.user.id,
+                    role: invitation.role,
+                }
             });
+            memberAdded = true;
         }
-        // Add user to workspace with proper role
-        await ctx.db.workspaceMember.create({
-            data: {
-                workspaceId: invitation.workspaceId,
-                userId: ctx.session.user.id,
-                role: invitation.role,
+        catch (error) {
+            if (error?.code !== 'P2002') {
+                throw error;
             }
-        });
+            logger.info(`ℹ️ Duplicate invite accept handled for user ${ctx.session.user.id} in workspace ${invitation.workspaceId}`, 'WORKSPACE');
+        }
         // Mark invitation as accepted
         await ctx.db.workspaceInvitation.update({
             where: { id: invitation.id },
             data: { acceptedAt: new Date() }
         });
-        logger.info(`✅ Invitation accepted by ${ctx.session.user.id} for workspace ${invitation.workspaceId}`, 'WORKSPACE', {
+        if (memberAdded) {
+            await notifyInviteAccepted(ctx.db, {
+                recipientUserIds: [invitation.invitedById, invitation.workspace.ownerId],
+                actorUserId: ctx.session.user.id,
+                workspaceId: invitation.workspaceId,
+                workspaceTitle: invitation.workspace.title,
+                memberName: user.name || user.email,
+                invitationId: invitation.id,
+            });
+        }
+        logger.info(`✅ Invitation accepted by ${ctx.session.user.id} (${user.email}) for workspace ${invitation.workspaceId}`, 'WORKSPACE', {
             invitationId: invitation.id,
             workspaceId: invitation.workspaceId,
             userId: ctx.session.user.id,
             email: invitation.email
         });
+        // Try to emit a Pusher event if possible
+        try {
+            if (memberAdded) {
+                await PusherService.emitMemberJoined(invitation.workspaceId, {
+                    id: ctx.session.user.id,
+                    name: user.name || 'Member',
+                    email: user.email,
+                    role: invitation.role,
+                });
+            }
+        }
+        catch (e) {
+            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' }),
         };
     }),
     /**
@@ -346,7 +416,8 @@ export const members = router({
             where: {
                 id: input.workspaceId,
                 ownerId: ctx.session.user.id
-            }
+            },
+            select: { id: true, title: true, ownerId: true },
         });
         if (!workspace) {
             throw new TRPCError({
@@ -394,6 +465,19 @@ export const members = router({
             newRole: input.role,
             changedBy: ctx.session.user.id
         });
+        const actor = await ctx.db.user.findUnique({
+            where: { id: ctx.session.user.id },
+            select: { name: true, email: true },
+        });
+        await notifyWorkspaceRoleChanged(ctx.db, {
+            memberUserId: input.memberId,
+            workspaceId: input.workspaceId,
+            workspaceTitle: workspace.title,
+            newRole: input.role,
+            oldRole: member.role,
+            actorUserId: ctx.session.user.id,
+            actorName: actor?.name || actor?.email || 'A workspace admin',
+        }).catch(() => { });
         return {
             memberId: input.memberId,
             role: input.role,
@@ -415,7 +499,8 @@ export const members = router({
             where: {
                 id: input.workspaceId,
                 ownerId: ctx.session.user.id
-            }
+            },
+            select: { id: true, title: true, ownerId: true },
         });
         if (!workspace) {
             throw new TRPCError({
@@ -451,6 +536,17 @@ export const members = router({
                 message: 'Member not found in this workspace'
             });
         }
+        const actor = await ctx.db.user.findUnique({
+            where: { id: ctx.session.user.id },
+            select: { name: true, email: true },
+        });
+        await notifyWorkspaceMembershipRemoved(ctx.db, {
+            memberUserId: input.memberId,
+            workspaceId: input.workspaceId,
+            workspaceTitle: workspace.title,
+            actorUserId: ctx.session.user.id,
+            actorName: actor?.name || actor?.email || 'A workspace admin',
+        }).catch(() => { });
         // Remove member from workspace
         await ctx.db.workspaceMember.delete({
             where: { id: member.id }
@@ -551,4 +647,89 @@ export const members = router({
             message: 'Invitation cancelled successfully'
         };
     }),
+    /**
+     * Resend a pending invitation (owner only)
+     */
+    resendInvitation: authedProcedure
+        .input(z.object({
+        invitationId: z.string(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        // Check if user is owner of the workspace and invitation is pending
+        const invitation = await ctx.db.workspaceInvitation.findFirst({
+            where: {
+                id: input.invitationId,
+                acceptedAt: null,
+                workspace: {
+                    ownerId: ctx.session.user.id
+                }
+            },
+            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'
+            });
+        }
+        // Check if expired and update expiry if needed
+        if (invitation.expiresAt < new Date()) {
+            const newExpiry = new Date();
+            newExpiry.setDate(newExpiry.getDate() + 7);
+            await ctx.db.workspaceInvitation.update({
+                where: { id: invitation.id },
+                data: { expiresAt: newExpiry }
+            });
+            invitation.expiresAt = newExpiry;
+        }
+        // Send email notification
+        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',
+        });
+        logger.info(`📧 Invitation resent to ${invitation.email} for workspace ${invitation.workspaceId}`, 'WORKSPACE', {
+            invitationId: invitation.id,
+            workspaceId: invitation.workspaceId,
+            email: invitation.email,
+            resentBy: ctx.session.user.id
+        });
+        return {
+            invitationId: invitation.id,
+            message: 'Invitation email resent successfully'
+        };
+    }),
+    /**
+     * DEBUG ONLY: Get all invitations for a workspace
+     */
+    getAllInvitationsDebug: authedProcedure
+        .input(z.object({
+        workspaceId: z.string(),
+    }))
+        .query(async ({ ctx, input }) => {
+        // Check if user is owner
+        const workspace = await ctx.db.workspace.findFirst({
+            where: { id: input.workspaceId, ownerId: ctx.session.user.id }
+        });
+        if (!workspace)
+            throw new TRPCError({ code: 'UNAUTHORIZED' });
+        return ctx.db.workspaceInvitation.findMany({
+            where: { workspaceId: input.workspaceId },
+            orderBy: { createdAt: 'desc' }
+        });
+    }),
 });

package/dist/routers/notifications.d.ts

@@ -0,0 +1,99 @@
+export declare const notifications: import("@trpc/server").TRPCBuiltRouter<{
+    ctx: import("../context.js").Context;
+    meta: object;
+    errorShape: {
+        data: {
+            zodError: string | null;
+            code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
+            httpStatus: number;
+            path?: string;
+            stack?: string;
+        };
+        message: string;
+        code: import("@trpc/server").TRPC_ERROR_CODE_NUMBER;
+    };
+    transformer: true;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    list: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            cursor?: string | undefined;
+            limit?: number | undefined;
+            unreadOnly?: boolean | undefined;
+            types?: string[] | undefined;
+        };
+        output: {
+            items: ({
+                workspace: {
+                    id: string;
+                    title: string;
+                } | null;
+                actor: {
+                    name: string | null;
+                    id: string;
+                    email: string | null;
+                } | null;
+            } & {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                workspaceId: string | null;
+                type: string;
+                title: string;
+                content: string | null;
+                userId: string;
+                actorUserId: string | null;
+                body: string;
+                actionUrl: string | null;
+                metadata: import("@prisma/client/runtime/library").JsonValue | null;
+                priority: import("@prisma/client").$Enums.NotificationPriority;
+                sourceId: string | null;
+                read: boolean;
+                readAt: Date | null;
+                deliveredAt: Date | null;
+            })[];
+            nextCursor: string | undefined;
+        };
+        meta: object;
+    }>;
+    unreadCount: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            count: number;
+        };
+        meta: object;
+    }>;
+    markRead: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            id: string;
+        };
+        output: {
+            success: boolean;
+        };
+        meta: object;
+    }>;
+    markManyRead: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            ids: string[];
+        };
+        output: {
+            success: boolean;
+        };
+        meta: object;
+    }>;
+    markAllRead: import("@trpc/server").TRPCMutationProcedure<{
+        input: void;
+        output: {
+            success: boolean;
+        };
+        meta: object;
+    }>;
+    delete: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            id: string;
+        };
+        output: {
+            success: boolean;
+        };
+        meta: object;
+    }>;
+}>>;

package/dist/routers/notifications.js

@@ -0,0 +1,127 @@
+import { z } from 'zod';
+import { authedProcedure, router } from '../trpc.js';
+import PusherService from '../lib/pusher.js';
+const listInputSchema = z.object({
+    cursor: z.string().optional(),
+    limit: z.number().min(1).max(50).default(20),
+    unreadOnly: z.boolean().optional(),
+    types: z.array(z.string()).optional(),
+});
+export const notifications = router({
+    list: authedProcedure
+        .input(listInputSchema)
+        .query(async ({ ctx, input }) => {
+        const { cursor, limit, unreadOnly, types } = input;
+        const userId = ctx.userId;
+        const items = await ctx.db.notification.findMany({
+            where: {
+                userId,
+                ...(unreadOnly ? { read: false } : {}),
+                ...(types?.length ? { type: { in: types } } : {}),
+            },
+            include: {
+                actor: {
+                    select: {
+                        id: true,
+                        name: true,
+                        email: true,
+                    },
+                },
+                workspace: {
+                    select: {
+                        id: true,
+                        title: true,
+                    },
+                },
+            },
+            orderBy: [{ createdAt: 'desc' }, { id: 'desc' }],
+            take: limit + 1,
+            ...(cursor ? { cursor: { id: cursor }, skip: 1 } : {}),
+        });
+        let nextCursor;
+        if (items.length > limit) {
+            const next = items.pop();
+            nextCursor = next?.id;
+        }
+        return {
+            items,
+            nextCursor,
+        };
+    }),
+    unreadCount: authedProcedure.query(async ({ ctx }) => {
+        const count = await ctx.db.notification.count({
+            where: {
+                userId: ctx.userId,
+                read: false,
+            },
+        });
+        return { count };
+    }),
+    markRead: authedProcedure
+        .input(z.object({ id: z.string() }))
+        .mutation(async ({ ctx, input }) => {
+        const now = new Date();
+        await ctx.db.notification.updateMany({
+            where: {
+                id: input.id,
+                userId: ctx.userId,
+            },
+            data: {
+                read: true,
+                readAt: now,
+            },
+        });
+        const unreadCount = await ctx.db.notification.count({
+            where: { userId: ctx.userId, read: false },
+        });
+        await PusherService.emitNotificationReadState(ctx.userId, { unreadCount });
+        return { success: true };
+    }),
+    markManyRead: authedProcedure
+        .input(z.object({ ids: z.array(z.string()).min(1) }))
+        .mutation(async ({ ctx, input }) => {
+        const now = new Date();
+        await ctx.db.notification.updateMany({
+            where: {
+                id: { in: input.ids },
+                userId: ctx.userId,
+            },
+            data: {
+                read: true,
+                readAt: now,
+            },
+        });
+        const unreadCount = await ctx.db.notification.count({
+            where: { userId: ctx.userId, read: false },
+        });
+        await PusherService.emitNotificationReadState(ctx.userId, { unreadCount });
+        return { success: true };
+    }),
+    markAllRead: authedProcedure
+        .mutation(async ({ ctx }) => {
+        const now = new Date();
+        await ctx.db.notification.updateMany({
+            where: {
+                userId: ctx.userId,
+                read: false,
+            },
+            data: {
+                read: true,
+                readAt: now,
+            },
+        });
+        await PusherService.emitNotificationReadState(ctx.userId, { unreadCount: 0 });
+        return { success: true };
+    }),
+    delete: authedProcedure
+        .input(z.object({ id: z.string() }))
+        .mutation(async ({ ctx, input }) => {
+        await ctx.db.notification.deleteMany({
+            where: {
+                id: input.id,
+                userId: ctx.userId,
+            },
+        });
+        return { success: true };
+    }),
+});

package/dist/routers/payment.d.ts

@@ -0,0 +1,89 @@
+export declare const paymentRouter: import("@trpc/server").TRPCBuiltRouter<{
+    ctx: import("../context.js").Context;
+    meta: object;
+    errorShape: {
+        data: {
+            zodError: string | null;
+            code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
+            httpStatus: number;
+            path?: string;
+            stack?: string;
+        };
+        message: string;
+        code: import("@trpc/server").TRPC_ERROR_CODE_NUMBER;
+    };
+    transformer: true;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    getPlans: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: any[];
+        meta: object;
+    }>;
+    createCheckoutSession: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            planId: string;
+        };
+        output: {
+            url: any;
+        };
+        meta: object;
+    }>;
+    confirmCheckoutSuccess: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            sessionId: string;
+        };
+        output: {
+            confirmed: boolean;
+            reason: string;
+            kind?: undefined;
+        } | {
+            confirmed: boolean;
+            kind: "payment";
+            reason?: undefined;
+        } | {
+            confirmed: boolean;
+            kind: "subscription";
+            reason?: undefined;
+        };
+        meta: object;
+    }>;
+    createResourcePurchaseSession: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            resourceType: "STUDY_GUIDE" | "FLASHCARD_SET" | "WORKSHEET" | "MEETING_SUMMARY" | "PODCAST_EPISODE" | "STORAGE";
+            quantity?: number | undefined;
+        };
+        output: {
+            url: any;
+        };
+        meta: object;
+    }>;
+    getUsageOverview: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            usage: import("../lib/usage_service.js").UserUsage;
+            limits: {
+                id: string;
+                planId: string;
+                maxStorageBytes: bigint;
+                maxWorksheets: number;
+                maxFlashcards: number;
+                maxPodcasts: number;
+                maxStudyGuides: number;
+                createdAt: Date;
+                updatedAt: Date;
+            } | null;
+            hasActivePlan: boolean;
+        };
+        meta: object;
+    }>;
+    getResourcePrices: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            id: string;
+            updatedAt: Date;
+            resourceType: import("@prisma/client").$Enums.ArtifactType;
+            priceCents: number;
+        }[];
+        meta: object;
+    }>;
+}>>;