@goscribe/server 1.6.0 → 1.7.0

package/dist/src/services/artifacts/annotation.service.js

@@ -0,0 +1,154 @@
+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) {
+        super(db);
+    }
+    listHighlights(artifactVersionId) {
+        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, input) {
+        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, highlightId) {
+        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, input) {
+        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();
+            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, input) {
+        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, commentId) {
+        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/dist/src/services/artifacts/artifact-version.service.d.ts

@@ -0,0 +1,38 @@
+import type { PrismaClient } from '@prisma/client';
+import { BaseService } from '../base.service.js';
+export declare class ArtifactVersionService extends BaseService {
+    constructor(db: PrismaClient);
+    private assertArtifactAccess;
+    private assertVersionAccess;
+    listVersions(userId: string, artifactId: string): Promise<{
+        id: string;
+        version: number;
+        createdAt: Date;
+        isCurrent: boolean;
+        label: string | null;
+        createdBy: {
+            id: string;
+            name: string | null;
+        } | null;
+    }[]>;
+    getVersion(userId: string, artifactVersionId: string): Promise<{
+        id: string;
+        artifactId: string;
+        version: number;
+        content: string;
+        data: import("@prisma/client/runtime/client").JsonValue;
+        createdAt: Date;
+        isCurrent: boolean;
+        createdBy: string | null;
+    }>;
+    restoreVersion(userId: string, artifactVersionId: string): Promise<{
+        id: string;
+        createdAt: Date;
+        data: import("@prisma/client/runtime/client").JsonValue | null;
+        createdById: string | null;
+        artifactId: string;
+        content: string;
+        version: number;
+    }>;
+    private versionLabel;
+}

package/dist/src/services/artifacts/artifact-version.service.js

@@ -0,0 +1,129 @@
+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) {
+        super(db);
+    }
+    async assertArtifactAccess(userId, artifactId) {
+        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;
+    }
+    async assertVersionAccess(userId, artifactVersionId) {
+        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, artifactId) {
+        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, artifactVersionId) {
+        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, artifactVersionId) {
+        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;
+    }
+    versionLabel(data) {
+        if (!data || typeof data !== 'object')
+            return null;
+        const record = data;
+        if (typeof record.title === 'string')
+            return record.title;
+        if (typeof record.description === 'string')
+            return record.description;
+        return null;
+    }
+}

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

@@ -0,0 +1,127 @@
+import type { PrismaClient } from '@prisma/client';
+import { BaseService } from '../base.service.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 declare class ChatService extends BaseService {
+    constructor(db: PrismaClient);
+    getChannels(workspaceId: string): Promise<{
+        id: string;
+        name: string;
+        createdAt: Date;
+        workspaceId: string;
+    }[]>;
+    getChannel(input: {
+        workspaceId?: string;
+        channelId?: string;
+    }): Promise<{
+        chats: ({
+            user: {
+                id: string;
+                name: string | null;
+            } | null;
+        } & {
+            userId: string | null;
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            message: string;
+            channelId: string;
+        })[];
+    } & {
+        id: string;
+        name: string;
+        createdAt: Date;
+        workspaceId: string;
+    }>;
+    removeChannel(input: {
+        workspaceId: string;
+        channelId: string;
+    }): Promise<{
+        success: boolean;
+    }>;
+    editChannel(input: {
+        workspaceId: string;
+        channelId: string;
+        name: string;
+    }): Promise<{
+        chats: ({
+            user: {
+                id: string;
+                name: string | null;
+            } | null;
+        } & {
+            userId: string | null;
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            message: string;
+            channelId: string;
+        })[];
+    } & {
+        id: string;
+        name: string;
+        createdAt: Date;
+        workspaceId: string;
+    }>;
+    createChannel(input: {
+        workspaceId: string;
+        name: string;
+    }): Promise<{
+        chats: ({
+            user: {
+                id: string;
+                name: string | null;
+            } | null;
+        } & {
+            userId: string | null;
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            message: string;
+            channelId: string;
+        })[];
+    } & {
+        id: string;
+        name: string;
+        createdAt: Date;
+        workspaceId: string;
+    }>;
+    postMessage(userId: string, input: {
+        channelId: string;
+        message: string;
+    }): Promise<{
+        user: {
+            id: string;
+            name: string | null;
+        } | null;
+    } & {
+        userId: string | null;
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        message: string;
+        channelId: string;
+    }>;
+    editMessage(userId: string, input: {
+        chatId: string;
+        message: string;
+    }): Promise<{
+        user: {
+            id: string;
+            name: string | null;
+        } | null;
+    } & {
+        userId: string | null;
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        message: string;
+        channelId: string;
+    }>;
+    deleteMessage(userId: string, chatId: string): Promise<{
+        success: boolean;
+    }>;
+}

package/dist/src/services/artifacts/chat.service.js

@@ -0,0 +1,182 @@
+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) {
+        super(db);
+    }
+    async getChannels(workspaceId) {
+        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) {
+        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) {
+        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) {
+        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) {
+        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, input) {
+        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, input) {
+        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, chatId) {
+        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/dist/src/services/artifacts/study-guide.service.d.ts

@@ -0,0 +1,18 @@
+import type { PrismaClient } from '@prisma/client';
+import { BaseService } from '../base.service.js';
+export declare class StudyGuideService extends BaseService {
+    constructor(db: PrismaClient);
+    get(userId: string, workspaceId: string): Promise<{
+        artifactId: string;
+        title: string;
+        latestVersion: {
+            id: string;
+            createdAt: Date;
+            data: import("@prisma/client/runtime/client").JsonValue | null;
+            createdById: string | null;
+            artifactId: string;
+            content: string;
+            version: number;
+        };
+    }>;
+}