@goscribe/server 1.3.4 → 1.5.0

package/src/routers/annotations.ts

@@ -1,35 +1,14 @@
 import { z } from 'zod';
-import { TRPCError } from '@trpc/server';
 import { router, authedProcedure } from '../trpc.js';
-import { notifyStudyGuideCommentAdded } from '../lib/notification-service.js';
+import { AnnotationService } from '../services/artifacts/annotation.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;
-    }),
+    .input(z.object({ artifactVersionId: z.string() }))
+    .query(({ ctx, input }) =>
+      new AnnotationService(ctx.db).listHighlights(input.artifactVersionId),
+    ),
 
-  // Create a new highlight
   createHighlight: authedProcedure
     .input(
       z.object({
@@ -38,190 +17,33 @@ export const annotations = router({
         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 },
-      });
+    .mutation(({ ctx, input }) =>
+      new AnnotationService(ctx.db).createHighlight(ctx.session.user.id, input),
+    ),
 
-      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 };
-    }),
+    .input(z.object({ highlightId: z.string() }))
+    .mutation(({ ctx, input }) =>
+      new AnnotationService(ctx.db).deleteHighlight(ctx.session.user.id, input.highlightId),
+    ),
 
-  // 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' });
-      }
+    .input(z.object({ highlightId: z.string(), content: z.string().min(1) }))
+    .mutation(({ ctx, input }) =>
+      new AnnotationService(ctx.db).addComment(ctx.session.user.id, input),
+    ),
 
-      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' });
-      }
+    .input(z.object({ commentId: z.string(), content: z.string().min(1) }))
+    .mutation(({ ctx, input }) =>
+      new AnnotationService(ctx.db).updateComment(ctx.session.user.id, input),
+    ),
 
-      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 };
-    }),
+    .input(z.object({ commentId: z.string() }))
+    .mutation(({ ctx, input }) =>
+      new AnnotationService(ctx.db).deleteComment(ctx.session.user.id, input.commentId),
+    ),
 });

package/src/routers/artifactVersions.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import { router, authedProcedure } from '../trpc.js';
+import { ArtifactVersionService } from '../services/artifacts/artifact-version.service.js';
+
+export const artifactVersions = router({
+  list: authedProcedure
+    .input(z.object({ artifactId: z.string() }))
+    .query(({ ctx, input }) =>
+      new ArtifactVersionService(ctx.db).listVersions(
+        ctx.session.user.id,
+        input.artifactId,
+      ),
+    ),
+
+  get: authedProcedure
+    .input(z.object({ artifactVersionId: z.string() }))
+    .query(({ ctx, input }) =>
+      new ArtifactVersionService(ctx.db).getVersion(
+        ctx.session.user.id,
+        input.artifactVersionId,
+      ),
+    ),
+
+  restore: authedProcedure
+    .input(z.object({ artifactVersionId: z.string() }))
+    .mutation(({ ctx, input }) =>
+      new ArtifactVersionService(ctx.db).restoreVersion(
+        ctx.session.user.id,
+        input.artifactVersionId,
+      ),
+    ),
+});