@goscribe/server 1.3.4 → 1.6.0

package/src/services/workspace/workspace.service.ts

@@ -0,0 +1,488 @@
+import type { PrismaClient } from '@prisma/client';
+import { TRPCError } from '@trpc/server';
+import { BaseService } from '../base.service.js';
+import { supabaseClient } from '../../lib/storage.js';
+import PusherService from '../../lib/pusher.js';
+import { ai } from '../../lib/ai/index.js';
+import { workspaceKbService } from './workspace-kb.service.js';
+import {
+  getAccountSummary,
+  invalidateUserBillingCache,
+} from '../billing/usage.service.js';
+import { getUserStorageLimit } from '../billing/subscription.service.js';
+import { notifyWorkspaceDeleted } from '../notifications/notification.service.js';
+
+export class WorkspaceService extends BaseService {
+  constructor(db: PrismaClient) {
+    super(db);
+  }
+
+  async list(userId: string, parentId: string | null) {
+    const workspaces = await this.db.workspace.findMany({
+      where: { ownerId: userId, folderId: parentId },
+      orderBy: { updatedAt: 'desc' },
+    });
+    const folders = await this.db.folder.findMany({
+      where: { ownerId: userId, parentId },
+    });
+    return { workspaces, folders };
+  }
+
+  async getTree(userId: string) {
+    const [allFolders, allWorkspaces] = await Promise.all([
+      this.db.folder.findMany({
+        where: { ownerId: userId },
+        select: {
+          id: true,
+          name: true,
+          parentId: true,
+          color: true,
+          markerColor: true,
+          updatedAt: true,
+        },
+        orderBy: { updatedAt: 'desc' },
+      }),
+      this.db.workspace.findMany({
+        where: { ownerId: userId },
+        select: {
+          id: true,
+          title: true,
+          folderId: true,
+          icon: true,
+          color: true,
+          markerColor: true,
+          updatedAt: true,
+          uploads: {
+            select: {
+              id: true,
+              name: true,
+              mimeType: true,
+              createdAt: true,
+            },
+          },
+        },
+        orderBy: { updatedAt: 'desc' },
+      }),
+    ]);
+
+    return { folders: allFolders, workspaces: allWorkspaces };
+  }
+
+  async create(
+    userId: string,
+    input: {
+      name: string;
+      description?: string;
+      parentId?: string;
+      markerColor?: string | null;
+    },
+  ) {
+    const ws = await this.db.workspace.create({
+      data: {
+        title: input.name,
+        description: input.description,
+        ownerId: userId,
+        folderId: input.parentId ?? null,
+        ...(input.markerColor !== undefined ? { markerColor: input.markerColor } : {}),
+      },
+    });
+
+    void ai.backend.initSession(ws.id, userId).catch((err) => {
+      this.logger.error('Failed to init AI session on workspace creation:', err);
+    });
+
+    void workspaceKbService.ensureWorkspaceKb(ws.id, userId, input.name).catch((err) => {
+      this.logger.error('Failed to create workspace knowledge base:', err);
+    });
+
+    invalidateUserBillingCache(userId);
+    void PusherService.emitLibraryUpdate(userId);
+
+    return ws;
+  }
+
+  async createFolder(
+    userId: string,
+    input: { name: string; color?: string; parentId?: string },
+  ) {
+    const folder = await this.db.folder.create({
+      data: {
+        name: input.name,
+        ownerId: userId,
+        color: input.color ?? '#9D00FF',
+        parentId: input.parentId ?? null,
+      },
+    });
+    await PusherService.emitLibraryUpdate(userId);
+    return folder;
+  }
+
+  async updateFolder(
+    userId: string,
+    input: { id: string; name?: string; markerColor?: string | null },
+  ) {
+    const folder = await this.db.folder.update({
+      where: { id: input.id },
+      data: { name: input.name, markerColor: input.markerColor },
+    });
+    await PusherService.emitLibraryUpdate(userId);
+    return folder;
+  }
+
+  async deleteFolder(userId: string, id: string) {
+    const folder = await this.db.folder.delete({ where: { id } });
+    await PusherService.emitLibraryUpdate(userId);
+    return folder;
+  }
+
+  async get(userId: string, id: string) {
+    const ws = await this.db.workspace.findFirst({
+      where: { id, ownerId: userId },
+      select: {
+        id: true,
+        title: true,
+        description: true,
+        icon: true,
+        color: true,
+        markerColor: true,
+        ownerId: true,
+        folderId: true,
+        fileBeingAnalyzed: true,
+        analysisProgress: true,
+        needsAnalysis: true,
+        createdAt: true,
+        updatedAt: true,
+        folder: { select: { id: true, name: true, color: true } },
+        uploads: {
+          select: {
+            id: true,
+            name: true,
+            mimeType: true,
+            size: true,
+            createdAt: true,
+            objectKey: true,
+          },
+          orderBy: { createdAt: 'desc' },
+        },
+      },
+    });
+    if (!ws) throw new TRPCError({ code: 'NOT_FOUND' });
+    return ws;
+  }
+
+  async getAccountSummary(userId: string) {
+    return getAccountSummary(userId);
+  }
+
+  async getStats(userId: string) {
+    const summary = await getAccountSummary(userId);
+    return summary.stats;
+  }
+
+  async update(
+    userId: string,
+    input: {
+      id: string;
+      name?: string;
+      description?: string;
+      markerColor?: string | null;
+      icon?: string;
+    },
+  ) {
+    const existed = await this.db.workspace.findFirst({
+      where: { id: input.id, ownerId: userId },
+    });
+    if (!existed) throw new TRPCError({ code: 'NOT_FOUND' });
+    const updated = await this.db.workspace.update({
+      where: { id: input.id },
+      data: {
+        title: input.name ?? existed.title,
+        description: input.description,
+        markerColor: input.markerColor !== undefined ? input.markerColor : existed.markerColor,
+        icon: input.icon ?? existed.icon,
+      },
+    });
+
+    await PusherService.emitLibraryUpdate(userId);
+    return updated;
+  }
+
+  async delete(userId: string, id: string) {
+    const workspaceToDelete = await this.db.workspace.findFirst({
+      where: { id, ownerId: userId },
+      select: {
+        id: true,
+        title: true,
+        ownerId: true,
+        members: { select: { userId: true } },
+      },
+    });
+
+    if (!workspaceToDelete) throw new TRPCError({ code: 'NOT_FOUND' });
+
+    const actor = await this.db.user.findUnique({
+      where: { id: userId },
+      select: { name: true, email: true },
+    });
+    const actorName = actor?.name || actor?.email || 'A user';
+
+    await notifyWorkspaceDeleted(this.db, {
+      recipientUserIds: workspaceToDelete.members.map((m) => m.userId),
+      actorUserId: userId,
+      actorName,
+      workspaceId: workspaceToDelete.id,
+      workspaceTitle: workspaceToDelete.title,
+    });
+
+    const deleted = await this.db.workspace.deleteMany({
+      where: { id, ownerId: userId },
+    });
+    if (deleted.count === 0) throw new TRPCError({ code: 'NOT_FOUND' });
+
+    await PusherService.emitLibraryUpdate(userId);
+    return true;
+  }
+
+  async getFolderInformation(userId: string, id: string) {
+    const folder = await this.db.folder.findFirst({
+      where: { id, ownerId: userId },
+    });
+    if (!folder) throw new TRPCError({ code: 'NOT_FOUND' });
+
+    const parents: typeof folder[] = [];
+    let current = folder;
+    while (current.parentId) {
+      const parent = await this.db.folder.findFirst({
+        where: { id: current.parentId, ownerId: userId },
+      });
+      if (!parent) break;
+      parents.push(parent);
+      current = parent;
+    }
+
+    return { folder, parents };
+  }
+
+  async getSharedWith(userId: string, id: string) {
+    const user = await this.db.user.findFirst({ where: { id: userId } });
+    if (!user || !user.email) throw new TRPCError({ code: 'NOT_FOUND' });
+    const sharedWith = await this.db.workspace.findMany({
+      where: { members: { some: { userId } } },
+    });
+    const invitations = await this.db.workspaceInvitation.findMany({
+      where: { email: user.email, acceptedAt: null },
+      include: { workspace: true },
+    });
+    return { shared: sharedWith, invitations };
+  }
+
+  async uploadFiles(
+    userId: string,
+    input: {
+      id: string;
+      files: Array<{ filename: string; contentType: string; size: number }>;
+    },
+  ) {
+    const ws = await this.db.workspace.findFirst({
+      where: { id: input.id, ownerId: userId },
+    });
+    if (!ws) throw new TRPCError({ code: 'NOT_FOUND' });
+
+    const workspaces = await this.db.workspace.findMany({
+      where: {
+        OR: [{ ownerId: userId }, { sharedWith: { some: { id: userId } } }],
+      },
+    });
+    const spaceUsed = await this.db.fileAsset.aggregate({
+      where: { workspaceId: { in: workspaces.map((w: any) => w.id) }, userId },
+      _sum: { size: true },
+    });
+    const storageLimit = await getUserStorageLimit(userId);
+    const totalSize = input.files.reduce((acc, file) => acc + file.size, 0);
+    if ((spaceUsed._sum?.size ?? 0) + totalSize > storageLimit) {
+      this.logger.warn(
+        `Storage limit exceeded for user ${userId}. Used: ${spaceUsed._sum?.size}, Tried to upload: ${totalSize}, Limit: ${storageLimit}`,
+      );
+      throw new TRPCError({
+        code: 'FORBIDDEN',
+        message: `Storage limit exceeded. Maximum allowed storage is ${(storageLimit / (1024 * 1024 * 1024)).toFixed(1)}GB.`,
+      });
+    }
+
+    const results: Array<{ fileId: string; uploadUrl: string }> = [];
+
+    for (const file of input.files) {
+      const record = await this.db.fileAsset.create({
+        data: {
+          userId,
+          name: file.filename,
+          mimeType: file.contentType,
+          size: file.size,
+          workspaceId: input.id,
+        },
+      });
+
+      const objectKey = `${userId}/${record.id}-${file.filename}`;
+      const { data: signedUrlData, error: signedUrlError } = await supabaseClient.storage
+        .from('media')
+        .createSignedUploadUrl(objectKey);
+
+      if (signedUrlError) {
+        throw new TRPCError({
+          code: 'INTERNAL_SERVER_ERROR',
+          message: `Failed to upload file`,
+        });
+      }
+
+      await this.db.fileAsset.update({
+        where: { id: record.id },
+        data: {
+          bucket: 'media',
+          objectKey,
+        },
+      });
+
+      results.push({
+        fileId: record.id,
+        uploadUrl: signedUrlData.signedUrl,
+      });
+    }
+
+    return results;
+  }
+
+  async deleteFiles(userId: string, input: { fileId: string[]; id: string }) {
+    const files = await this.db.fileAsset.findMany({
+      where: {
+        id: { in: input.fileId },
+        workspaceId: input.id,
+        userId,
+      },
+    });
+    for (const file of files) {
+      if (file.bucket && file.objectKey) {
+        supabaseClient.storage
+          .from(file.bucket)
+          .remove([file.objectKey])
+          .catch((err: unknown) => {
+            this.logger.error(
+              `Error deleting file ${file.objectKey} from bucket ${file.bucket}:`,
+              err,
+            );
+          });
+      }
+    }
+
+    await this.db.fileAsset.deleteMany({
+      where: {
+        id: { in: input.fileId },
+        workspaceId: input.id,
+        userId,
+      },
+    });
+    return true;
+  }
+
+  async getFileUploadUrl(
+    userId: string,
+    input: {
+      workspaceId: string;
+      filename: string;
+      contentType: string;
+      size: number;
+    },
+  ) {
+    const workspaces = await this.db.workspace.findMany({
+      where: {
+        OR: [{ ownerId: userId }, { sharedWith: { some: { id: userId } } }],
+      },
+    });
+    const spaceUsed = await this.db.fileAsset.aggregate({
+      where: { workspaceId: { in: workspaces.map((w: any) => w.id) }, userId },
+      _sum: { size: true },
+    });
+    const storageLimit = await getUserStorageLimit(userId);
+    if ((spaceUsed._sum?.size ?? 0) + input.size > storageLimit) {
+      this.logger.warn(
+        `Storage limit exceeded for user ${userId}. Used: ${spaceUsed._sum?.size}, Tried to upload: ${input.size}, Limit: ${storageLimit}`,
+      );
+      throw new TRPCError({
+        code: 'FORBIDDEN',
+        message: `Storage limit exceeded. Maximum allowed storage is ${(storageLimit / (1024 * 1024 * 1024)).toFixed(1)}GB.`,
+      });
+    }
+
+    const objectKey = `workspace_${userId}/${input.workspaceId}-file_${input.filename}`;
+    const fileAsset = await this.db.fileAsset.create({
+      data: {
+        workspaceId: input.workspaceId,
+        name: input.filename,
+        mimeType: input.contentType,
+        size: input.size,
+        userId,
+        bucket: 'media',
+        objectKey,
+      },
+    });
+    const { data: signedUrlData, error: signedUrlError } = await supabaseClient.storage
+      .from('media')
+      .createSignedUploadUrl(objectKey, { upsert: true });
+    if (signedUrlError) {
+      this.logger.error('Signed upload URL error:', signedUrlError);
+      throw new TRPCError({
+        code: 'INTERNAL_SERVER_ERROR',
+        message: `Failed to create upload URL: ${signedUrlError.message}`,
+      });
+    }
+
+    await this.db.workspace.update({
+      where: { id: input.workspaceId },
+      data: { needsAnalysis: true },
+    });
+
+    return {
+      fileId: fileAsset.id,
+      uploadUrl: signedUrlData.signedUrl,
+    };
+  }
+
+  async search(userId: string, input: { query: string; color?: string; limit: number }) {
+    const { query, color } = input;
+
+    const workspaces = await this.db.workspace.findMany({
+      where: {
+        ownerId: userId,
+        markerColor: color || undefined,
+        ...(query
+          ? {
+              OR: [
+                { title: { contains: query, mode: 'insensitive' as const } },
+                { description: { contains: query, mode: 'insensitive' as const } },
+              ],
+            }
+          : {}),
+      },
+      orderBy: { updatedAt: 'desc' },
+      take: input.limit,
+    });
+
+    const folders = await this.db.folder.findMany({
+      where: {
+        ownerId: userId,
+        markerColor: color || undefined,
+        ...(query ? { name: { contains: query, mode: 'insensitive' as const } } : {}),
+      },
+      orderBy: { updatedAt: 'desc' },
+      take: input.limit,
+    });
+
+    const results = [
+      ...workspaces.map((w: any) => ({ ...w, type: 'workspace' as const })),
+      ...folders.map((f: any) => ({ ...f, type: 'folder' as const, title: f.name })),
+    ]
+      .sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime())
+      .slice(0, input.limit);
+
+    return results;
+  }
+}

package/src/trpc.ts

@@ -4,13 +4,13 @@ import { ActivityLogStatus } from "@prisma/client";
 import type { Context } from "./context.js";
 import { logger } from "./lib/logger.js";
 import { toTRPCError } from "./lib/errors.js";
-import { getUserUsage, getUserPlanLimits } from "./lib/usage_service.js";
+import { getUserUsage, getUserPlanLimits } from "./services/billing/usage.service.js";
 import {
   getClientIp,
   isActivityLogEnabled,
   scheduleRecordActivity,
   truncateUserAgent,
-} from "./lib/activity_log_service.js";
+} from "./services/activity/activity-log.service.js";
 
 /** Avoid logging the log viewers themselves (noise when browsing activity). */
 const SKIP_ACTIVITY_TRPC_PATHS = new Set([
@@ -95,12 +95,8 @@ const errorHandler = middleware(async ({ next }) => {
 /**
  * Middleware that enforces email verification
  */
-const isVerified = middleware(async ({ ctx, next }) => {
-  const user = await ctx.db.user.findUnique({
-    where: { id: (ctx.session as any).user.id },
-    select: { emailVerified: true },
-  });
-
+const isVerified = middleware(({ ctx, next }) => {
+  const user = (ctx.session as { user?: { emailVerified?: boolean } })?.user;
   if (!user?.emailVerified) {
     throw new TRPCError({
       code: "FORBIDDEN",
@@ -168,13 +164,9 @@ const checkUsageLimit = middleware(async ({ ctx, next, path }) => {
 /**
  * Middleware that enforces system admin role
  */
-const isAdmin = middleware(async ({ ctx, next }) => {
-  const user = await ctx.db.user.findUnique({
-    where: { id: (ctx.session as any).user.id },
-    include: { role: true },
-  });
-
-  if (user?.role?.name !== 'System Admin') {
+const isAdmin = middleware(({ ctx, next }) => {
+  const user = (ctx.session as { user?: { isSystemAdmin?: boolean } })?.user;
+  if (!user?.isSystemAdmin) {
     throw new TRPCError({
       code: "FORBIDDEN",
       message: "You do not have permission to access this resource",