@goscribe/server 1.1.7 → 1.3.0

package/src/routers/annotations.ts

@@ -0,0 +1,227 @@
+import { z } from 'zod';
+import { TRPCError } from '@trpc/server';
+import { router, authedProcedure } from '../trpc.js';
+import { notifyStudyGuideCommentAdded } from '../lib/notification-service.js';
+
+export const annotations = router({
+  // List all highlights (with nested comments) for an artifact version
+  listHighlights: authedProcedure
+    .input(
+      z.object({
+        artifactVersionId: z.string(),
+      })
+    )
+    .query(async ({ ctx, input }) => {
+      const highlights = await ctx.db.studyGuideHighlight.findMany({
+        where: { artifactVersionId: input.artifactVersionId },
+        include: {
+          comments: {
+            include: {
+              user: { select: { id: true, name: true, profilePicture: true } },
+            },
+            orderBy: { createdAt: 'asc' },
+          },
+          user: { select: { id: true, name: true, profilePicture: true } },
+        },
+        orderBy: { startOffset: 'asc' },
+      });
+
+      return highlights;
+    }),
+
+  // Create a new highlight
+  createHighlight: authedProcedure
+    .input(
+      z.object({
+        artifactVersionId: z.string(),
+        startOffset: z.number().int().min(0),
+        endOffset: z.number().int().min(0),
+        selectedText: z.string().min(1),
+        color: z.string().optional(),
+      })
+    )
+    .mutation(async ({ ctx, input }) => {
+      // Verify the artifact version exists
+      const version = await ctx.db.artifactVersion.findUnique({
+        where: { id: input.artifactVersionId },
+      });
+
+      if (!version) {
+        throw new TRPCError({ code: 'NOT_FOUND', message: 'Artifact version not found' });
+      }
+
+      const highlight = await ctx.db.studyGuideHighlight.create({
+        data: {
+          artifactVersionId: input.artifactVersionId,
+          userId: ctx.session.user.id,
+          startOffset: input.startOffset,
+          endOffset: input.endOffset,
+          selectedText: input.selectedText,
+          ...(input.color && { color: input.color }),
+        },
+        include: {
+          comments: true,
+          user: { select: { id: true, name: true, profilePicture: true } },
+        },
+      });
+
+      return highlight;
+    }),
+
+  // Delete a highlight (and its comments via cascade)
+  deleteHighlight: authedProcedure
+    .input(
+      z.object({
+        highlightId: z.string(),
+      })
+    )
+    .mutation(async ({ ctx, input }) => {
+      const highlight = await ctx.db.studyGuideHighlight.findUnique({
+        where: { id: input.highlightId },
+      });
+
+      if (!highlight) {
+        throw new TRPCError({ code: 'NOT_FOUND', message: 'Highlight not found' });
+      }
+
+      if (highlight.userId !== ctx.session.user.id) {
+        throw new TRPCError({ code: 'FORBIDDEN', message: 'You can only delete your own highlights' });
+      }
+
+      await ctx.db.studyGuideHighlight.delete({
+        where: { id: input.highlightId },
+      });
+
+      return { success: true };
+    }),
+
+  // Add a comment to a highlight
+  addComment: authedProcedure
+    .input(
+      z.object({
+        highlightId: z.string(),
+        content: z.string().min(1),
+      })
+    )
+    .mutation(async ({ ctx, input }) => {
+      const highlight = await ctx.db.studyGuideHighlight.findUnique({
+        where: { id: input.highlightId },
+      });
+
+      if (!highlight) {
+        throw new TRPCError({ code: 'NOT_FOUND', message: 'Highlight not found' });
+      }
+
+      const comment = await ctx.db.studyGuideComment.create({
+        data: {
+          highlightId: input.highlightId,
+          userId: ctx.session.user.id,
+          content: input.content,
+        },
+        include: {
+          user: { select: { id: true, name: true, profilePicture: true } },
+        },
+      });
+
+      const after = await ctx.db.studyGuideHighlight.findUnique({
+        where: { id: input.highlightId },
+        include: {
+          comments: { select: { userId: true } },
+          artifactVersion: {
+            include: {
+              artifact: {
+                select: { id: true, title: true, workspaceId: true, type: true },
+              },
+            },
+          },
+        },
+      });
+
+      if (after?.artifactVersion?.artifact) {
+        const art = after.artifactVersion.artifact;
+        const recipientIds = new Set<string>();
+        if (after.userId !== ctx.session.user.id) {
+          recipientIds.add(after.userId);
+        }
+        for (const c of after.comments) {
+          if (c.userId !== ctx.session.user.id) {
+            recipientIds.add(c.userId);
+          }
+        }
+        const authorName =
+          comment.user.name?.trim() || 'Someone';
+        await notifyStudyGuideCommentAdded(ctx.db, {
+          authorUserId: ctx.session.user.id,
+          authorName,
+          content: input.content,
+          highlightId: input.highlightId,
+          commentId: comment.id,
+          workspaceId: art.workspaceId,
+          artifactId: art.id,
+          artifactTitle: art.title,
+          recipientUserIds: [...recipientIds],
+        }).catch(() => {});
+      }
+
+      return comment;
+    }),
+
+  // Update a comment
+  updateComment: authedProcedure
+    .input(
+      z.object({
+        commentId: z.string(),
+        content: z.string().min(1),
+      })
+    )
+    .mutation(async ({ ctx, input }) => {
+      const comment = await ctx.db.studyGuideComment.findUnique({
+        where: { id: input.commentId },
+      });
+
+      if (!comment) {
+        throw new TRPCError({ code: 'NOT_FOUND', message: 'Comment not found' });
+      }
+
+      if (comment.userId !== ctx.session.user.id) {
+        throw new TRPCError({ code: 'FORBIDDEN', message: 'You can only edit your own comments' });
+      }
+
+      const updated = await ctx.db.studyGuideComment.update({
+        where: { id: input.commentId },
+        data: { content: input.content },
+        include: {
+          user: { select: { id: true, name: true, profilePicture: true } },
+        },
+      });
+
+      return updated;
+    }),
+
+  // Delete a comment
+  deleteComment: authedProcedure
+    .input(
+      z.object({
+        commentId: z.string(),
+      })
+    )
+    .mutation(async ({ ctx, input }) => {
+      const comment = await ctx.db.studyGuideComment.findUnique({
+        where: { id: input.commentId },
+      });
+
+      if (!comment) {
+        throw new TRPCError({ code: 'NOT_FOUND', message: 'Comment not found' });
+      }
+
+      if (comment.userId !== ctx.session.user.id) {
+        throw new TRPCError({ code: 'FORBIDDEN', message: 'You can only delete your own comments' });
+      }
+
+      await ctx.db.studyGuideComment.delete({
+        where: { id: input.commentId },
+      });
+
+      return { success: true };
+    }),
+});