@goscribe/server 1.3.3 → 1.5.0

package/src/services/artifacts/annotation.service.ts

@@ -0,0 +1,189 @@
+import type { PrismaClient } from '@prisma/client';
+import { TRPCError } from '@trpc/server';
+import { BaseService } from '../base.service.js';
+import { notifyStudyGuideCommentAdded } from '../notifications/notification.service.js';
+
+export class AnnotationService extends BaseService {
+  constructor(db: PrismaClient) {
+    super(db);
+  }
+
+  listHighlights(artifactVersionId: string) {
+    return this.db.studyGuideHighlight.findMany({
+      where: { 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' },
+    });
+  }
+
+  async createHighlight(
+    userId: string,
+    input: {
+      artifactVersionId: string;
+      startOffset: number;
+      endOffset: number;
+      selectedText: string;
+      color?: string;
+    },
+  ) {
+    const version = await this.db.artifactVersion.findUnique({
+      where: { id: input.artifactVersionId },
+    });
+
+    if (!version) {
+      throw new TRPCError({ code: 'NOT_FOUND', message: 'Artifact version not found' });
+    }
+
+    return this.db.studyGuideHighlight.create({
+      data: {
+        artifactVersionId: input.artifactVersionId,
+        userId,
+        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 } },
+      },
+    });
+  }
+
+  async deleteHighlight(userId: string, highlightId: string) {
+    const highlight = await this.db.studyGuideHighlight.findUnique({
+      where: { id: highlightId },
+    });
+
+    if (!highlight) {
+      throw new TRPCError({ code: 'NOT_FOUND', message: 'Highlight not found' });
+    }
+
+    if (highlight.userId !== userId) {
+      throw new TRPCError({
+        code: 'FORBIDDEN',
+        message: 'You can only delete your own highlights',
+      });
+    }
+
+    await this.db.studyGuideHighlight.delete({ where: { id: highlightId } });
+
+    return { success: true };
+  }
+
+  async addComment(userId: string, input: { highlightId: string; content: string }) {
+    const highlight = await this.db.studyGuideHighlight.findUnique({
+      where: { id: input.highlightId },
+    });
+
+    if (!highlight) {
+      throw new TRPCError({ code: 'NOT_FOUND', message: 'Highlight not found' });
+    }
+
+    const comment = await this.db.studyGuideComment.create({
+      data: {
+        highlightId: input.highlightId,
+        userId,
+        content: input.content,
+      },
+      include: {
+        user: { select: { id: true, name: true, profilePicture: true } },
+      },
+    });
+
+    const after = await this.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 !== userId) {
+        recipientIds.add(after.userId);
+      }
+      for (const c of after.comments) {
+        if (c.userId !== userId) {
+          recipientIds.add(c.userId);
+        }
+      }
+      const authorName = comment.user.name?.trim() || 'Someone';
+      await notifyStudyGuideCommentAdded(this.db, {
+        authorUserId: userId,
+        authorName,
+        content: input.content,
+        highlightId: input.highlightId,
+        commentId: comment.id,
+        workspaceId: art.workspaceId,
+        artifactId: art.id,
+        artifactTitle: art.title,
+        recipientUserIds: [...recipientIds],
+      }).catch(() => {});
+    }
+
+    return comment;
+  }
+
+  async updateComment(userId: string, input: { commentId: string; content: string }) {
+    const comment = await this.db.studyGuideComment.findUnique({
+      where: { id: input.commentId },
+    });
+
+    if (!comment) {
+      throw new TRPCError({ code: 'NOT_FOUND', message: 'Comment not found' });
+    }
+
+    if (comment.userId !== userId) {
+      throw new TRPCError({
+        code: 'FORBIDDEN',
+        message: 'You can only edit your own comments',
+      });
+    }
+
+    return this.db.studyGuideComment.update({
+      where: { id: input.commentId },
+      data: { content: input.content },
+      include: {
+        user: { select: { id: true, name: true, profilePicture: true } },
+      },
+    });
+  }
+
+  async deleteComment(userId: string, commentId: string) {
+    const comment = await this.db.studyGuideComment.findUnique({
+      where: { id: commentId },
+    });
+
+    if (!comment) {
+      throw new TRPCError({ code: 'NOT_FOUND', message: 'Comment not found' });
+    }
+
+    if (comment.userId !== userId) {
+      throw new TRPCError({
+        code: 'FORBIDDEN',
+        message: 'You can only delete your own comments',
+      });
+    }
+
+    await this.db.studyGuideComment.delete({ where: { id: commentId } });
+
+    return { success: true };
+  }
+}

package/src/services/artifacts/artifact-version.service.ts

@@ -0,0 +1,151 @@
+import type { PrismaClient } from '@prisma/client';
+import { TRPCError } from '@trpc/server';
+import { BaseService } from '../base.service.js';
+import { workspaceAccessWhere } from '../../repositories/workspace.repository.js';
+
+export class ArtifactVersionService extends BaseService {
+  constructor(db: PrismaClient) {
+    super(db);
+  }
+
+  private async assertArtifactAccess(userId: string, artifactId: string) {
+    const artifact = await this.db.artifact.findFirst({
+      where: {
+        id: artifactId,
+        workspace: workspaceAccessWhere(userId),
+      },
+      select: { id: true, workspaceId: true },
+    });
+
+    if (!artifact) {
+      throw new TRPCError({
+        code: 'NOT_FOUND',
+        message: 'Artifact not found or access denied',
+      });
+    }
+
+    return artifact;
+  }
+
+  private async assertVersionAccess(userId: string, artifactVersionId: string) {
+    const version = await this.db.artifactVersion.findUnique({
+      where: { id: artifactVersionId },
+      include: {
+        artifact: {
+          select: { id: true, workspaceId: true, workspace: { select: { id: true } } },
+        },
+      },
+    });
+
+    if (!version) {
+      throw new TRPCError({ code: 'NOT_FOUND', message: 'Version not found' });
+    }
+
+    const hasAccess = await this.db.workspace.findFirst({
+      where: {
+        id: version.artifact.workspaceId,
+        ...workspaceAccessWhere(userId),
+      },
+      select: { id: true },
+    });
+
+    if (!hasAccess) {
+      throw new TRPCError({ code: 'FORBIDDEN', message: 'Access denied' });
+    }
+
+    return version;
+  }
+
+  async listVersions(userId: string, artifactId: string) {
+    await this.assertArtifactAccess(userId, artifactId);
+
+    const versions = await this.db.artifactVersion.findMany({
+      where: { artifactId },
+      orderBy: { version: 'desc' },
+      select: {
+        id: true,
+        version: true,
+        createdAt: true,
+        data: true,
+        createdBy: {
+          select: { id: true, name: true },
+        },
+      },
+    });
+
+    const latestId = versions[0]?.id ?? null;
+
+    return versions.map((v) => ({
+      id: v.id,
+      version: v.version,
+      createdAt: v.createdAt,
+      isCurrent: v.id === latestId,
+      label: this.versionLabel(v.data),
+      createdBy: v.createdBy,
+    }));
+  }
+
+  async getVersion(userId: string, artifactVersionId: string) {
+    const version = await this.assertVersionAccess(userId, artifactVersionId);
+
+    const latest = await this.db.artifactVersion.findFirst({
+      where: { artifactId: version.artifactId },
+      orderBy: { version: 'desc' },
+      select: { id: true },
+    });
+
+    return {
+      id: version.id,
+      artifactId: version.artifactId,
+      version: version.version,
+      content: version.content,
+      data: version.data,
+      createdAt: version.createdAt,
+      isCurrent: version.id === latest?.id,
+      createdBy: version.createdById,
+    };
+  }
+
+  async restoreVersion(userId: string, artifactVersionId: string) {
+    const source = await this.assertVersionAccess(userId, artifactVersionId);
+
+    const latest = await this.db.artifactVersion.findFirst({
+      where: { artifactId: source.artifactId },
+      orderBy: { version: 'desc' },
+    });
+
+    if (latest?.id === source.id) {
+      throw new TRPCError({
+        code: 'BAD_REQUEST',
+        message: 'This is already the current version',
+      });
+    }
+
+    const nextVersion = (latest?.version ?? 0) + 1;
+
+    const restored = await this.db.artifactVersion.create({
+      data: {
+        artifactId: source.artifactId,
+        version: nextVersion,
+        content: source.content,
+        data: source.data ?? undefined,
+        createdById: userId,
+      },
+    });
+
+    await this.db.artifact.update({
+      where: { id: source.artifactId },
+      data: { updatedAt: new Date() },
+    });
+
+    return restored;
+  }
+
+  private versionLabel(data: unknown): string | null {
+    if (!data || typeof data !== 'object') return null;
+    const record = data as Record<string, unknown>;
+    if (typeof record.title === 'string') return record.title;
+    if (typeof record.description === 'string') return record.description;
+    return null;
+  }
+}

package/src/services/artifacts/chat.service.ts

@@ -0,0 +1,197 @@
+import type { PrismaClient } from '@prisma/client';
+import { TRPCError } from '@trpc/server';
+import { BaseService } from '../base.service.js';
+import PusherService from '../../lib/pusher.js';
+
+/**
+ * NOTE: These procedures currently do not verify that the caller belongs to
+ * the target workspace or channel. That's pre-existing behavior and is
+ * listed in REFACTOR_NOTES.md as a follow-up.
+ */
+export class ChatService extends BaseService {
+  constructor(db: PrismaClient) {
+    super(db);
+  }
+
+  async getChannels(workspaceId: string) {
+    const channels = await this.db.channel.findMany({
+      where: { workspaceId },
+      include: {
+        chats: {
+          include: {
+            user: {
+              select: {
+                id: true,
+                name: true,
+                profilePicture: {
+                  select: { id: true, name: true, url: true },
+                },
+              },
+            },
+          },
+        },
+      },
+    });
+    if (!channels) {
+      const defaultChannel = await this.db.channel.create({
+        data: { workspaceId, name: 'General' },
+      });
+      return [defaultChannel];
+    }
+    return channels;
+  }
+
+  async getChannel(input: { workspaceId?: string; channelId?: string }) {
+    if (!input.channelId && input.workspaceId) {
+      const defaultChannel = await this.db.channel.create({
+        data: { workspaceId: input.workspaceId, name: 'General' },
+        include: {
+          chats: {
+            include: {
+              user: { select: { id: true, name: true } },
+            },
+          },
+        },
+      });
+
+      await PusherService.emitTaskComplete(input.workspaceId, 'new_channel', {
+        channelId: defaultChannel.id,
+        workspaceId: input.workspaceId,
+        name: 'General',
+        createdAt: defaultChannel.createdAt,
+      });
+
+      return defaultChannel;
+    }
+
+    const channel = await this.db.channel.findUnique({
+      where: { id: input.channelId },
+      include: {
+        chats: {
+          include: {
+            user: { select: { id: true, name: true } },
+          },
+        },
+      },
+    });
+
+    if (!channel) {
+      throw new TRPCError({ code: 'NOT_FOUND', message: 'Channel not found' });
+    }
+
+    return channel;
+  }
+
+  async removeChannel(input: { workspaceId: string; channelId: string }) {
+    await this.db.channel.delete({ where: { id: input.channelId } });
+    await PusherService.emitTaskComplete(input.workspaceId, 'remove_channel', {
+      channelId: input.channelId,
+      deletedAt: new Date().toISOString(),
+    });
+    return { success: true };
+  }
+
+  async editChannel(input: { workspaceId: string; channelId: string; name: string }) {
+    const channel = await this.db.channel.update({
+      where: { id: input.channelId },
+      data: { name: input.name },
+      include: {
+        chats: {
+          include: {
+            user: { select: { id: true, name: true } },
+          },
+        },
+      },
+    });
+    await PusherService.emitTaskComplete(input.workspaceId, 'edit_channel', {
+      channelId: input.channelId,
+      workspaceId: input.workspaceId,
+      name: input.name,
+    });
+    return channel;
+  }
+
+  async createChannel(input: { workspaceId: string; name: string }) {
+    const channel = await this.db.channel.create({
+      data: { workspaceId: input.workspaceId, name: input.name },
+      include: {
+        chats: {
+          include: {
+            user: { select: { id: true, name: true } },
+          },
+        },
+      },
+    });
+    await PusherService.emitTaskComplete(input.workspaceId, 'new_channel', {
+      channelId: channel.id,
+      workspaceId: input.workspaceId,
+      name: input.name,
+      createdAt: channel.createdAt,
+    });
+    return channel;
+  }
+
+  async postMessage(userId: string, input: { channelId: string; message: string }) {
+    const channel = await this.db.channel.findUnique({
+      where: { id: input.channelId },
+      include: {
+        chats: {
+          include: {
+            user: { select: { id: true, name: true } },
+          },
+        },
+      },
+    });
+    if (!channel) {
+      throw new TRPCError({ code: 'NOT_FOUND', message: 'Channel not found' });
+    }
+    const chat = await this.db.chat.create({
+      data: {
+        channelId: input.channelId,
+        userId,
+        message: input.message,
+      },
+      include: {
+        user: { select: { id: true, name: true } },
+      },
+    });
+    await PusherService.emitChannelEvent(input.channelId, 'new_message', chat);
+    return chat;
+  }
+
+  async editMessage(userId: string, input: { chatId: string; message: string }) {
+    const chat = await this.db.chat.findUnique({
+      where: { id: input.chatId },
+      include: { user: { select: { id: true, name: true } } },
+    });
+    if (!chat) {
+      throw new TRPCError({ code: 'NOT_FOUND', message: 'Chat message not found' });
+    }
+    if (chat.userId !== userId) {
+      throw new TRPCError({ code: 'FORBIDDEN', message: 'Not your message to edit' });
+    }
+    const updatedChat = await this.db.chat.update({
+      where: { id: input.chatId },
+      data: { message: input.message },
+      include: { user: { select: { id: true, name: true } } },
+    });
+    await PusherService.emitChannelEvent(chat.channelId, 'edit_message', updatedChat);
+    return updatedChat;
+  }
+
+  async deleteMessage(userId: string, chatId: string) {
+    const chat = await this.db.chat.findUnique({
+      where: { id: chatId },
+      include: { user: { select: { id: true, name: true } } },
+    });
+    if (!chat) {
+      throw new TRPCError({ code: 'NOT_FOUND', message: 'Chat message not found' });
+    }
+    if (chat.userId !== userId) {
+      throw new TRPCError({ code: 'FORBIDDEN', message: 'Not your message to delete' });
+    }
+    await this.db.chat.delete({ where: { id: chatId } });
+    await PusherService.emitChannelEvent(chat.channelId, 'delete_message', chat);
+    return { success: true };
+  }
+}

package/src/services/artifacts/study-guide.service.ts

@@ -0,0 +1,72 @@
+import type { PrismaClient } from '@prisma/client';
+import { TRPCError } from '@trpc/server';
+import { BaseService } from '../base.service.js';
+import { ArtifactType } from '../../lib/constants.js';
+import { getUserUsage, getUserPlanLimits } from '../billing/usage.service.js';
+import { workspaceAccessWhere } from '../../repositories/workspace.repository.js';
+
+const initializeEditorJsEmptyBlock = () => ({
+  time: Date.now(),
+  blocks: [
+    {
+      id: 'initial',
+      type: 'paragraph',
+      data: { text: 'Upload some files to begin creating your revision workspace...' },
+    },
+  ],
+  version: '2.27.0',
+});
+
+export class StudyGuideService extends BaseService {
+  constructor(db: PrismaClient) {
+    super(db);
+  }
+
+  async get(userId: string, workspaceId: string) {
+    let artifact = await this.db.artifact.findFirst({
+      where: {
+        workspaceId,
+        type: ArtifactType.STUDY_GUIDE,
+        workspace: workspaceAccessWhere(userId),
+      },
+      include: {
+        versions: { orderBy: { version: 'desc' }, take: 1 },
+      },
+    });
+
+    if (!artifact) {
+      const [usage, limits] = await Promise.all([
+        getUserUsage(userId),
+        getUserPlanLimits(userId),
+      ]);
+      if (limits && usage.studyGuides >= limits.maxStudyGuides) {
+        throw new TRPCError({
+          code: 'FORBIDDEN',
+          message:
+            'Study Guide limit reached. Please upgrade your plan to create more workspaces with study guides.',
+        });
+      }
+
+      artifact = await this.db.artifact.create({
+        data: {
+          workspaceId,
+          type: ArtifactType.STUDY_GUIDE,
+          title: 'Study Guide',
+          createdById: userId,
+          versions: {
+            create: {
+              content: `${JSON.stringify(initializeEditorJsEmptyBlock())}`,
+              version: 1,
+              createdById: userId,
+            },
+          },
+        },
+        include: {
+          versions: { orderBy: { version: 'desc' }, take: 1 },
+        },
+      });
+    }
+    const latestVersion = artifact.versions[0] ?? null;
+    return { artifactId: artifact.id, title: artifact.title, latestVersion };
+  }
+}