@goscribe/server 1.3.4 → 1.6.0

package/dist/services/annotation.service.d.ts

@@ -0,0 +1,177 @@
+import type { PrismaClient } from '@prisma/client';
+import { BaseService } from './base.service.js';
+export declare class AnnotationService extends BaseService {
+    constructor(db: PrismaClient);
+    listHighlights(artifactVersionId: string): import("@prisma/client").Prisma.PrismaPromise<({
+        user: {
+            name: string | null;
+            id: string;
+            profilePicture: {
+                meta: import("@prisma/client/runtime/library").JsonValue | null;
+                name: string;
+                id: string;
+                createdAt: Date;
+                workspaceId: string | null;
+                userId: string | null;
+                mimeType: string;
+                size: number;
+                bucket: string | null;
+                objectKey: string | null;
+                url: string | null;
+                checksum: string | null;
+                aiTranscription: import("@prisma/client/runtime/library").JsonValue | null;
+            } | null;
+        };
+        comments: ({
+            user: {
+                name: string | null;
+                id: string;
+                profilePicture: {
+                    meta: import("@prisma/client/runtime/library").JsonValue | null;
+                    name: string;
+                    id: string;
+                    createdAt: Date;
+                    workspaceId: string | null;
+                    userId: string | null;
+                    mimeType: string;
+                    size: number;
+                    bucket: string | null;
+                    objectKey: string | null;
+                    url: string | null;
+                    checksum: string | null;
+                    aiTranscription: import("@prisma/client/runtime/library").JsonValue | null;
+                } | null;
+            };
+        } & {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            content: string;
+            userId: string;
+            highlightId: string;
+        })[];
+    } & {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        userId: string;
+        color: string;
+        artifactVersionId: string;
+        startOffset: number;
+        endOffset: number;
+        selectedText: string;
+    })[]>;
+    createHighlight(userId: string, input: {
+        artifactVersionId: string;
+        startOffset: number;
+        endOffset: number;
+        selectedText: string;
+        color?: string;
+    }): Promise<{
+        user: {
+            name: string | null;
+            id: string;
+            profilePicture: {
+                meta: import("@prisma/client/runtime/library").JsonValue | null;
+                name: string;
+                id: string;
+                createdAt: Date;
+                workspaceId: string | null;
+                userId: string | null;
+                mimeType: string;
+                size: number;
+                bucket: string | null;
+                objectKey: string | null;
+                url: string | null;
+                checksum: string | null;
+                aiTranscription: import("@prisma/client/runtime/library").JsonValue | null;
+            } | null;
+        };
+        comments: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            content: string;
+            userId: string;
+            highlightId: string;
+        }[];
+    } & {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        userId: string;
+        color: string;
+        artifactVersionId: string;
+        startOffset: number;
+        endOffset: number;
+        selectedText: string;
+    }>;
+    deleteHighlight(userId: string, highlightId: string): Promise<{
+        success: boolean;
+    }>;
+    addComment(userId: string, input: {
+        highlightId: string;
+        content: string;
+    }): Promise<{
+        user: {
+            name: string | null;
+            id: string;
+            profilePicture: {
+                meta: import("@prisma/client/runtime/library").JsonValue | null;
+                name: string;
+                id: string;
+                createdAt: Date;
+                workspaceId: string | null;
+                userId: string | null;
+                mimeType: string;
+                size: number;
+                bucket: string | null;
+                objectKey: string | null;
+                url: string | null;
+                checksum: string | null;
+                aiTranscription: import("@prisma/client/runtime/library").JsonValue | null;
+            } | null;
+        };
+    } & {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        content: string;
+        userId: string;
+        highlightId: string;
+    }>;
+    updateComment(userId: string, input: {
+        commentId: string;
+        content: string;
+    }): Promise<{
+        user: {
+            name: string | null;
+            id: string;
+            profilePicture: {
+                meta: import("@prisma/client/runtime/library").JsonValue | null;
+                name: string;
+                id: string;
+                createdAt: Date;
+                workspaceId: string | null;
+                userId: string | null;
+                mimeType: string;
+                size: number;
+                bucket: string | null;
+                objectKey: string | null;
+                url: string | null;
+                checksum: string | null;
+                aiTranscription: import("@prisma/client/runtime/library").JsonValue | null;
+            } | null;
+        };
+    } & {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        content: string;
+        userId: string;
+        highlightId: string;
+    }>;
+    deleteComment(userId: string, commentId: string): Promise<{
+        success: boolean;
+    }>;
+}

package/dist/services/annotation.service.js

@@ -0,0 +1,154 @@
+import { TRPCError } from '@trpc/server';
+import { BaseService } from './base.service.js';
+import { notifyStudyGuideCommentAdded } from './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/services/artifact-notification.service.d.ts

@@ -0,0 +1,14 @@
+import type { PrismaClient } from '@prisma/client';
+import { notifyArtifactFailed, notifyArtifactReady, notifyWorkspaceDeleted } from '../lib/notification-service.js';
+/**
+ * Cross-cutting notification adapter for MVC services. Centralizes the
+ * emission surface so workflows don't import lib/notification-service
+ * directly.
+ */
+export declare class ArtifactNotificationService {
+    private readonly db;
+    constructor(db: PrismaClient);
+    emitArtifactReady(payload: Parameters<typeof notifyArtifactReady>[1]): Promise<void>;
+    emitArtifactFailed(payload: Parameters<typeof notifyArtifactFailed>[1]): Promise<void>;
+    emitWorkspaceDeleted(payload: Parameters<typeof notifyWorkspaceDeleted>[1]): Promise<void>;
+}

package/dist/services/artifact-notification.service.js

@@ -0,0 +1,20 @@
+import { notifyArtifactFailed, notifyArtifactReady, notifyWorkspaceDeleted, } from '../lib/notification-service.js';
+/**
+ * Cross-cutting notification adapter for MVC services. Centralizes the
+ * emission surface so workflows don't import lib/notification-service
+ * directly.
+ */
+export class ArtifactNotificationService {
+    constructor(db) {
+        this.db = db;
+    }
+    async emitArtifactReady(payload) {
+        await notifyArtifactReady(this.db, payload).catch(() => { });
+    }
+    async emitArtifactFailed(payload) {
+        await notifyArtifactFailed(this.db, payload).catch(() => { });
+    }
+    async emitWorkspaceDeleted(payload) {
+        await notifyWorkspaceDeleted(this.db, payload).catch(() => { });
+    }
+}

package/dist/services/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: {
+            name: string | null;
+            id: string;
+        } | null;
+    }[]>;
+    getVersion(userId: string, artifactVersionId: string): Promise<{
+        id: string;
+        artifactId: string;
+        version: number;
+        content: string;
+        data: import("@prisma/client/runtime/library").JsonValue;
+        createdAt: Date;
+        isCurrent: boolean;
+        createdBy: string | null;
+    }>;
+    restoreVersion(userId: string, artifactVersionId: string): Promise<{
+        id: string;
+        createdAt: Date;
+        createdById: string | null;
+        artifactId: string;
+        content: string;
+        data: import("@prisma/client/runtime/library").JsonValue | null;
+        version: number;
+    }>;
+    private versionLabel;
+}

package/dist/services/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;
+    }
+}