@goscribe/server 1.3.4 → 1.6.0

package/dist/services/billing/usage.service.js

@@ -0,0 +1,149 @@
+import { prisma } from '../../lib/prisma.js';
+import { workspaceAccessWhere } from '../../repositories/workspace.repository.js';
+const FALLBACK_PLAN_LIMITS = {
+    id: 'fallback-free',
+    planId: 'fallback-free',
+    maxStorageBytes: BigInt(1024 * 1024 * 1024), // 1GB
+    maxWorksheets: 3,
+    maxFlashcards: 20,
+    maxPodcasts: 0,
+    maxStudyGuides: 1,
+};
+const CACHE_TTL_MS = 30000;
+const usageCache = new Map();
+const limitsCache = new Map();
+const accountSummaryCache = new Map();
+function readCache(map, userId) {
+    const entry = map.get(userId);
+    if (!entry || entry.expiresAt <= Date.now()) {
+        map.delete(userId);
+        return null;
+    }
+    return entry.value;
+}
+function writeCache(map, userId, value) {
+    map.set(userId, { value, expiresAt: Date.now() + CACHE_TTL_MS });
+}
+/** Bust cached usage/limit reads after creates, deletes, or billing changes. */
+export function invalidateUserBillingCache(userId) {
+    usageCache.delete(userId);
+    limitsCache.delete(userId);
+    accountSummaryCache.delete(userId);
+}
+function workspaceAccessFilter(userId) {
+    return workspaceAccessWhere(userId);
+}
+/**
+ * Counts all resources consumed by a user across the platform.
+ */
+export async function getUserUsage(userId) {
+    const cached = readCache(usageCache, userId);
+    if (cached)
+        return cached;
+    const [flashcards, worksheets, studyGuides, podcasts, storageResult] = await Promise.all([
+        prisma.artifact.count({ where: { createdById: userId, type: 'FLASHCARD_SET' } }),
+        prisma.artifact.count({ where: { createdById: userId, type: 'WORKSHEET' } }),
+        prisma.artifact.count({ where: { createdById: userId, type: 'STUDY_GUIDE' } }),
+        prisma.artifact.count({ where: { createdById: userId, type: 'PODCAST_EPISODE' } }),
+        prisma.fileAsset.aggregate({
+            _sum: { size: true },
+            where: { userId },
+        }),
+    ]);
+    const usage = {
+        flashcards,
+        worksheets,
+        studyGuides,
+        podcasts,
+        storageBytes: Number(storageResult._sum.size || 0),
+    };
+    writeCache(usageCache, userId, usage);
+    return usage;
+}
+/**
+ * Retrieves the specific plan limits for a user based on their active subscription
+ * PLUS any extra credits purchased.
+ */
+export async function getUserPlanLimits(userId) {
+    const cached = readCache(limitsCache, userId);
+    if (cached)
+        return cached;
+    const [activeSub, freePlan, userCredits] = await Promise.all([
+        prisma.subscription.findFirst({
+            where: { userId, status: 'active' },
+            include: { plan: { include: { limit: true } } },
+            orderBy: { createdAt: 'desc' },
+        }),
+        prisma.plan.findFirst({
+            where: {
+                active: true,
+                price: 0,
+                limit: { isNot: null },
+            },
+            include: { limit: true },
+            orderBy: { createdAt: 'asc' },
+        }),
+        prisma.userCredit.groupBy({
+            by: ['resourceType'],
+            where: { userId },
+            _sum: { amount: true },
+        }),
+    ]);
+    const baseLimit = activeSub?.plan?.limit ?? freePlan?.limit;
+    const base = baseLimit ?? FALLBACK_PLAN_LIMITS;
+    const getCreditSum = (type) => userCredits.find((c) => c.resourceType === type)?._sum.amount || 0;
+    const limits = {
+        id: base.id,
+        planId: base.planId,
+        maxStorageBytes: BigInt(Number(base.maxStorageBytes) + getCreditSum('STORAGE') * 1024 * 1024),
+        maxWorksheets: base.maxWorksheets + getCreditSum('WORKSHEET'),
+        maxFlashcards: base.maxFlashcards + getCreditSum('FLASHCARD_SET'),
+        maxPodcasts: base.maxPodcasts + getCreditSum('PODCAST_EPISODE'),
+        maxStudyGuides: base.maxStudyGuides + getCreditSum('STUDY_GUIDE'),
+        createdAt: baseLimit?.createdAt || new Date(),
+        updatedAt: baseLimit?.updatedAt || new Date(),
+        isFallbackPlan: !baseLimit,
+    };
+    writeCache(limitsCache, userId, limits);
+    return limits;
+}
+/**
+ * Sidebar/dashboard summary: stats + usage + limits in one parallel DB round-trip batch.
+ */
+export async function getAccountSummary(userId) {
+    const cached = readCache(accountSummaryCache, userId);
+    if (cached)
+        return cached;
+    const workspaceWhere = workspaceAccessFilter(userId);
+    const [workspaceMeta, folderCount, usage, limits, storageUsed] = await Promise.all([
+        prisma.workspace.aggregate({
+            where: workspaceWhere,
+            _count: { _all: true },
+            _max: { updatedAt: true },
+        }),
+        prisma.folder.count({ where: { ownerId: userId } }),
+        getUserUsage(userId),
+        getUserPlanLimits(userId),
+        prisma.fileAsset.aggregate({
+            where: {
+                userId,
+                workspace: workspaceWhere,
+            },
+            _sum: { size: true },
+        }),
+    ]);
+    const summary = {
+        stats: {
+            workspaces: workspaceMeta._count._all,
+            folders: folderCount,
+            lastUpdated: workspaceMeta._max.updatedAt,
+            spaceUsed: Number(storageUsed._sum.size ?? 0),
+            spaceTotal: Number(limits.maxStorageBytes),
+        },
+        usage,
+        limits,
+        hasActivePlan: !limits.isFallbackPlan,
+    };
+    writeCache(accountSummaryCache, userId, summary);
+    return summary;
+}

package/dist/services/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<{
+        name: string;
+        id: string;
+        createdAt: Date;
+        workspaceId: string;
+    }[]>;
+    getChannel(input: {
+        workspaceId?: string;
+        channelId?: string;
+    }): Promise<{
+        chats: ({
+            user: {
+                name: string | null;
+                id: string;
+            } | null;
+        } & {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            channelId: string;
+            userId: string | null;
+            message: string;
+        })[];
+    } & {
+        name: string;
+        id: 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: {
+                name: string | null;
+                id: string;
+            } | null;
+        } & {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            channelId: string;
+            userId: string | null;
+            message: string;
+        })[];
+    } & {
+        name: string;
+        id: string;
+        createdAt: Date;
+        workspaceId: string;
+    }>;
+    createChannel(input: {
+        workspaceId: string;
+        name: string;
+    }): Promise<{
+        chats: ({
+            user: {
+                name: string | null;
+                id: string;
+            } | null;
+        } & {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            channelId: string;
+            userId: string | null;
+            message: string;
+        })[];
+    } & {
+        name: string;
+        id: string;
+        createdAt: Date;
+        workspaceId: string;
+    }>;
+    postMessage(userId: string, input: {
+        channelId: string;
+        message: string;
+    }): Promise<{
+        user: {
+            name: string | null;
+            id: string;
+        } | null;
+    } & {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        channelId: string;
+        userId: string | null;
+        message: string;
+    }>;
+    editMessage(userId: string, input: {
+        chatId: string;
+        message: string;
+    }): Promise<{
+        user: {
+            name: string | null;
+            id: string;
+        } | null;
+    } & {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        channelId: string;
+        userId: string | null;
+        message: string;
+    }>;
+    deleteMessage(userId: string, chatId: string): Promise<{
+        success: boolean;
+    }>;
+}

package/dist/services/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/services/content/copilot.service.d.ts

@@ -0,0 +1,113 @@
+import type { PrismaClient } from '@prisma/client';
+import { z } from 'zod';
+import { BaseService } from '../base.service.js';
+export declare const copilotArtifactType: z.ZodEnum<{
+    flashcards: "flashcards";
+    worksheet: "worksheet";
+    "study-guide": "study-guide";
+}>;
+export declare const copilotContextSchema: z.ZodObject<{
+    workspaceId: z.ZodString;
+    artifactId: z.ZodString;
+    artifactType: z.ZodEnum<{
+        flashcards: "flashcards";
+        worksheet: "worksheet";
+        "study-guide": "study-guide";
+    }>;
+    documentContent: z.ZodString;
+    documentPlainText: z.ZodOptional<z.ZodString>;
+    selectedText: z.ZodOptional<z.ZodString>;
+    viewportText: z.ZodOptional<z.ZodString>;
+    cursorPosition: z.ZodOptional<z.ZodObject<{
+        start: z.ZodNumber;
+        end: z.ZodNumber;
+    }, z.core.$strip>>;
+    metadata: z.ZodOptional<z.ZodObject<{
+        flashcardId: z.ZodOptional<z.ZodString>;
+        questionId: z.ZodOptional<z.ZodString>;
+        documentId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type CopilotContextInput = z.infer<typeof copilotContextSchema>;
+export declare class CopilotService extends BaseService {
+    constructor(db: PrismaClient);
+    private assertWorkspaceAccess;
+    private assertConversationAccess;
+    private loadHistory;
+    private persistConversationExchange;
+    listConversations(userId: string, workspaceId: string): Promise<{
+        id: string;
+        title: string;
+        updatedAt: Date;
+        preview: string;
+    }[]>;
+    getConversation(userId: string, workspaceId: string, conversationId: string): Promise<{
+        id: string;
+        title: string;
+        messages: {
+            id: string;
+            role: string;
+            content: string;
+            createdAt: Date;
+        }[];
+    }>;
+    createConversation(userId: string, input: {
+        workspaceId: string;
+        title?: string;
+    }): Promise<{
+        id: string;
+        title: string;
+        updatedAt: Date;
+    }>;
+    deleteConversation(userId: string, workspaceId: string, conversationId: string): Promise<{
+        success: boolean;
+    }>;
+    ask(userId: string, input: {
+        context: CopilotContextInput;
+        message: string;
+        conversationId?: string;
+    }): Promise<{
+        answer: string;
+        highlights: {
+            text: string;
+            label?: string;
+        }[];
+    }>;
+    explainSelection(userId: string, input: {
+        context: CopilotContextInput;
+        message?: string;
+        conversationId?: string;
+    }): Promise<{
+        answer: string;
+    }>;
+    suggestHighlights(userId: string, input: {
+        context: CopilotContextInput;
+        message?: string;
+        conversationId?: string;
+    }): Promise<{
+        answer: string;
+        highlights: {
+            text: string;
+            label?: string;
+        }[];
+    }>;
+    generateFlashcards(userId: string, input: {
+        context: CopilotContextInput;
+        message?: string;
+        numCards: number;
+        conversationId?: string;
+    }): Promise<{
+        answer: string;
+        artifactId: string;
+        flashcards: {
+            id: string;
+            createdAt: Date;
+            artifactId: string;
+            tags: string[];
+            order: number;
+            front: string;
+            back: string;
+            acceptedAnswers: string[];
+        }[];
+    }>;
+}