@goscribe/server 1.3.4 → 1.6.0

package/dist/services/workspace.service.js

@@ -0,0 +1,390 @@
+import { TRPCError } from '@trpc/server';
+import { BaseService } from './base.service.js';
+import { ArtifactType } from '../lib/constants.js';
+import { supabaseClient } from '../lib/storage.js';
+import PusherService from '../lib/pusher.js';
+import { aiSessionService } from './ai-session.service.js';
+import { getUserStorageLimit } from './subscription.service.js';
+import { notifyWorkspaceDeleted } from './notification.service.js';
+export class WorkspaceService extends BaseService {
+    constructor(db) {
+        super(db);
+    }
+    async list(userId, parentId) {
+        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) {
+        const allFolders = await this.db.folder.findMany({
+            where: { ownerId: userId },
+            orderBy: { updatedAt: 'desc' },
+        });
+        const allWorkspaces = await this.db.workspace.findMany({
+            where: { ownerId: userId },
+            include: {
+                uploads: {
+                    select: {
+                        id: true,
+                        name: true,
+                        mimeType: true,
+                        createdAt: true,
+                    },
+                },
+            },
+            orderBy: { updatedAt: 'desc' },
+        });
+        return { folders: allFolders, workspaces: allWorkspaces };
+    }
+    async create(userId, input) {
+        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 } : {}),
+                artifacts: {
+                    create: {
+                        type: ArtifactType.FLASHCARD_SET,
+                        title: 'New Flashcard Set',
+                    },
+                    createMany: {
+                        data: [
+                            { type: ArtifactType.WORKSHEET, title: 'Worksheet 1' },
+                            { type: ArtifactType.WORKSHEET, title: 'Worksheet 2' },
+                        ],
+                    },
+                },
+            },
+        });
+        await aiSessionService.initSession(ws.id, userId).catch((err) => {
+            this.logger.error('Failed to init AI session on workspace creation:', err);
+        });
+        await PusherService.emitLibraryUpdate(userId);
+        return ws;
+    }
+    async createFolder(userId, input) {
+        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, input) {
+        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, id) {
+        const folder = await this.db.folder.delete({ where: { id } });
+        await PusherService.emitLibraryUpdate(userId);
+        return folder;
+    }
+    async get(userId, id) {
+        const ws = await this.db.workspace.findFirst({
+            where: { id, ownerId: userId },
+            include: {
+                artifacts: true,
+                folder: true,
+                uploads: true,
+            },
+        });
+        if (!ws)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        return ws;
+    }
+    async getStats(userId) {
+        const workspaces = await this.db.workspace.findMany({
+            where: {
+                OR: [{ ownerId: userId }, { sharedWith: { some: { id: userId } } }],
+            },
+        });
+        const folders = await this.db.folder.findMany({
+            where: { OR: [{ ownerId: userId }] },
+        });
+        const lastUpdated = await this.db.workspace.findFirst({
+            where: {
+                OR: [{ ownerId: userId }, { sharedWith: { some: { id: userId } } }],
+            },
+            orderBy: { updatedAt: 'desc' },
+        });
+        const spaceLeft = await this.db.fileAsset.aggregate({
+            where: { workspaceId: { in: workspaces.map((ws) => ws.id) }, userId },
+            _sum: { size: true },
+        });
+        const storageLimit = await getUserStorageLimit(userId);
+        return {
+            workspaces: workspaces.length,
+            folders: folders.length,
+            lastUpdated: lastUpdated?.updatedAt,
+            spaceUsed: spaceLeft._sum?.size ?? 0,
+            spaceTotal: storageLimit,
+        };
+    }
+    async update(userId, input) {
+        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, id) {
+        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, id) {
+        const folder = await this.db.folder.findFirst({
+            where: { id, ownerId: userId },
+        });
+        if (!folder)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        const parents = [];
+        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, id) {
+        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, input) {
+        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) => 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 = [];
+        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, input) {
+        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) => {
+                    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, input) {
+        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) => 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, input) {
+        const { query, color } = input;
+        const workspaces = await this.db.workspace.findMany({
+            where: {
+                ownerId: userId,
+                markerColor: color || undefined,
+                ...(query
+                    ? {
+                        OR: [
+                            { title: { contains: query, mode: 'insensitive' } },
+                            { description: { contains: query, mode: 'insensitive' } },
+                        ],
+                    }
+                    : {}),
+            },
+            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' } } : {}),
+            },
+            orderBy: { updatedAt: 'desc' },
+            take: input.limit,
+        });
+        const results = [
+            ...workspaces.map((w) => ({ ...w, type: 'workspace' })),
+            ...folders.map((f) => ({ ...f, type: 'folder', title: f.name })),
+        ]
+            .sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime())
+            .slice(0, input.limit);
+        return results;
+    }
+}

package/dist/trpc.d.ts

@@ -20,7 +20,9 @@ export declare const publicProcedure: import("@trpc/server").TRPCProcedureBuilde
 /** Exported procedures with middleware */
 export declare const authedProcedure: import("@trpc/server").TRPCProcedureBuilder<Context, object, {
     userId: any;
-    session: any;
+    session: {
+        user: import("./context.js").SessionUser;
+    };
     req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
     res: import("express").Response<any, Record<string, any>>;
     db: import("@prisma/client").PrismaClient<import("@prisma/client").Prisma.PrismaClientOptions, never, import("@prisma/client/runtime/library").DefaultArgs>;
@@ -28,7 +30,9 @@ export declare const authedProcedure: import("@trpc/server").TRPCProcedureBuilde
 }, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, false>;
 export declare const verifiedProcedure: import("@trpc/server").TRPCProcedureBuilder<Context, object, {
     userId: any;
-    session: any;
+    session: {
+        user: import("./context.js").SessionUser;
+    };
     req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
     res: import("express").Response<any, Record<string, any>>;
     db: import("@prisma/client").PrismaClient<import("@prisma/client").Prisma.PrismaClientOptions, never, import("@prisma/client/runtime/library").DefaultArgs>;
@@ -36,7 +40,9 @@ export declare const verifiedProcedure: import("@trpc/server").TRPCProcedureBuil
 }, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, false>;
 export declare const adminProcedure: import("@trpc/server").TRPCProcedureBuilder<Context, object, {
     userId: any;
-    session: any;
+    session: {
+        user: import("./context.js").SessionUser;
+    };
     req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
     res: import("express").Response<any, Record<string, any>>;
     db: import("@prisma/client").PrismaClient<import("@prisma/client").Prisma.PrismaClientOptions, never, import("@prisma/client/runtime/library").DefaultArgs>;
@@ -44,7 +50,9 @@ export declare const adminProcedure: import("@trpc/server").TRPCProcedureBuilder
 }, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, false>;
 export declare const limitedProcedure: import("@trpc/server").TRPCProcedureBuilder<Context, object, {
     userId: any;
-    session: any;
+    session: {
+        user: import("./context.js").SessionUser;
+    };
     req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
     res: import("express").Response<any, Record<string, any>>;
     db: import("@prisma/client").PrismaClient<import("@prisma/client").Prisma.PrismaClientOptions, never, import("@prisma/client/runtime/library").DefaultArgs>;

package/dist/trpc.js

@@ -3,8 +3,8 @@ import superjson from "superjson";
 import { ActivityLogStatus } from "@prisma/client";
 import { logger } from "./lib/logger.js";
 import { toTRPCError } from "./lib/errors.js";
-import { getUserUsage, getUserPlanLimits } from "./lib/usage_service.js";
-import { getClientIp, isActivityLogEnabled, scheduleRecordActivity, truncateUserAgent, } from "./lib/activity_log_service.js";
+import { getUserUsage, getUserPlanLimits } from "./services/billing/usage.service.js";
+import { getClientIp, isActivityLogEnabled, scheduleRecordActivity, truncateUserAgent, } from "./services/activity/activity-log.service.js";
 /** Avoid logging the log viewers themselves (noise when browsing activity). */
 const SKIP_ACTIVITY_TRPC_PATHS = new Set([
     "admin.activityList",
@@ -79,11 +79,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.user.id },
-        select: { emailVerified: true },
-    });
+const isVerified = middleware(({ ctx, next }) => {
+    const user = ctx.session?.user;
     if (!user?.emailVerified) {
         throw new TRPCError({
             code: "FORBIDDEN",
@@ -139,12 +136,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.user.id },
-        include: { role: true },
-    });
-    if (user?.role?.name !== 'System Admin') {
+const isAdmin = middleware(({ ctx, next }) => {
+    const user = ctx.session?.user;
+    if (!user?.isSystemAdmin) {
         throw new TRPCError({
             code: "FORBIDDEN",
             message: "You do not have permission to access this resource",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goscribe/server",
-  "version": "1.3.4",
+  "version": "1.6.0",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -15,8 +15,8 @@
     "dev": "tsx watch src/server.ts",
     "build": "npx prisma generate && tsc -p .",
     "start": "node --experimental-specifier-resolution=node dist/server.js",
-    "test": "tsx --test src/lib/worksheet-generation.test.ts",
-    "test:activity": "tsx --test src/lib/activity_log_service.test.ts src/lib/activity_human_description.test.ts",
+    "test": "tsx --test \"src/**/*.test.ts\"",
+    "test:activity": "tsx --test src/services/activity/activity-log.service.test.ts src/services/activity/activity-human-description.service.test.ts",
     "generate": "npx prisma generate",
     "prepublishOnly": "npm run generate && npm run build"
   },
@@ -42,8 +42,8 @@
     "express": "^5.1.0",
     "helmet": "^8.1.0",
     "morgan": "^1.10.1",
-    "nodemailer": "^8.0.1",
     "openai": "^6.3.0",
+    "pdf-parse": "^1.1.4",
     "prisma": "^6.14.0",
     "pusher": "^5.2.0",
     "pusher-js": "^8.4.0",
@@ -61,7 +61,6 @@
     "@types/express": "^5.0.3",
     "@types/morgan": "^1.9.10",
     "@types/node": "^24.3.0",
-    "@types/nodemailer": "^7.0.11",
     "ts-node": "^10.9.2",
     "ts-node-dev": "^2.0.0",
     "tsc-alias": "^1.8.16",
@@ -70,4 +69,4 @@
     "typescript": "^5.9.2",
     "typescript-transform-paths": "^3.5.5"
   }
-}
+}

package/prisma/migrations/20260509000001_add_knowledge_base/migration.sql

@@ -0,0 +1,99 @@
+-- Knowledge Base feature: requires the pgvector extension for embedding storage.
+-- See https://github.com/pgvector/pgvector
+CREATE EXTENSION IF NOT EXISTS vector;
+
+-- CreateEnum
+CREATE TYPE "KnowledgeBaseStatus" AS ENUM ('READY', 'INDEXING', 'ERROR');
+
+-- CreateEnum
+CREATE TYPE "KnowledgeBaseDocumentStatus" AS ENUM ('PENDING', 'PROCESSING', 'READY', 'FAILED');
+
+-- CreateTable
+CREATE TABLE "KnowledgeBase" (
+    "id" TEXT NOT NULL,
+    "workspaceId" TEXT NOT NULL,
+    "createdById" TEXT,
+    "name" TEXT NOT NULL,
+    "description" TEXT,
+    "status" "KnowledgeBaseStatus" NOT NULL DEFAULT 'READY',
+    "embeddingModel" TEXT NOT NULL DEFAULT 'text-embedding-3-small',
+    "embeddingDim" INTEGER NOT NULL DEFAULT 1536,
+    "meta" JSONB,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+
+    CONSTRAINT "KnowledgeBase_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "KnowledgeBaseDocument" (
+    "id" TEXT NOT NULL,
+    "knowledgeBaseId" TEXT NOT NULL,
+    "name" TEXT NOT NULL,
+    "mimeType" TEXT NOT NULL,
+    "size" INTEGER NOT NULL,
+    "bucket" TEXT,
+    "objectKey" TEXT,
+    "status" "KnowledgeBaseDocumentStatus" NOT NULL DEFAULT 'PENDING',
+    "errorMessage" TEXT,
+    "numChunks" INTEGER NOT NULL DEFAULT 0,
+    "numPages" INTEGER,
+    "meta" JSONB,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+
+    CONSTRAINT "KnowledgeBaseDocument_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "KnowledgeBaseChunk" (
+    "id" TEXT NOT NULL,
+    "documentId" TEXT NOT NULL,
+    "knowledgeBaseId" TEXT NOT NULL,
+    "chunkIndex" INTEGER NOT NULL,
+    "pageNumber" INTEGER,
+    "content" TEXT NOT NULL,
+    "tokenCount" INTEGER,
+    "embedding" vector(1536),
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "KnowledgeBaseChunk_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE INDEX "KnowledgeBase_workspaceId_idx" ON "KnowledgeBase"("workspaceId");
+
+-- CreateIndex
+CREATE INDEX "KnowledgeBase_workspaceId_updatedAt_idx" ON "KnowledgeBase"("workspaceId", "updatedAt" DESC);
+
+-- CreateIndex
+CREATE INDEX "KnowledgeBaseDocument_knowledgeBaseId_idx" ON "KnowledgeBaseDocument"("knowledgeBaseId");
+
+-- CreateIndex
+CREATE INDEX "KnowledgeBaseDocument_knowledgeBaseId_createdAt_idx" ON "KnowledgeBaseDocument"("knowledgeBaseId", "createdAt" DESC);
+
+-- CreateIndex
+CREATE INDEX "KnowledgeBaseChunk_knowledgeBaseId_idx" ON "KnowledgeBaseChunk"("knowledgeBaseId");
+
+-- CreateIndex
+CREATE INDEX "KnowledgeBaseChunk_documentId_chunkIndex_idx" ON "KnowledgeBaseChunk"("documentId", "chunkIndex");
+
+-- AddForeignKey
+ALTER TABLE "KnowledgeBase" ADD CONSTRAINT "KnowledgeBase_workspaceId_fkey" FOREIGN KEY ("workspaceId") REFERENCES "Workspace"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "KnowledgeBase" ADD CONSTRAINT "KnowledgeBase_createdById_fkey" FOREIGN KEY ("createdById") REFERENCES "User"("id") ON DELETE SET NULL ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "KnowledgeBaseDocument" ADD CONSTRAINT "KnowledgeBaseDocument_knowledgeBaseId_fkey" FOREIGN KEY ("knowledgeBaseId") REFERENCES "KnowledgeBase"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "KnowledgeBaseChunk" ADD CONSTRAINT "KnowledgeBaseChunk_documentId_fkey" FOREIGN KEY ("documentId") REFERENCES "KnowledgeBaseDocument"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- ANN index for cosine similarity search across chunks (IVFFlat).
+-- The number of lists (100) is a reasonable default for tens of thousands of
+-- rows; tune via `SET ivfflat.probes` or recreate as the corpus grows.
+CREATE INDEX IF NOT EXISTS "KnowledgeBaseChunk_embedding_cosine_idx"
+    ON "KnowledgeBaseChunk"
+    USING ivfflat ("embedding" vector_cosine_ops)
+    WITH (lists = 100);

package/prisma/migrations/20260509000002_curate_knowledge_base/migration.sql

@@ -0,0 +1,52 @@
+-- Knowledge bases move from "owned by one workspace" to a global catalog
+-- where workspaces opt-in via a join table. Curated KBs are discoverable
+-- by users in the catalog search; non-curated ones are only attachable by
+-- a System Admin.
+
+-- 1. Drop the workspace-owns-KB relationship.
+ALTER TABLE "KnowledgeBase" DROP CONSTRAINT IF EXISTS "KnowledgeBase_workspaceId_fkey";
+DROP INDEX IF EXISTS "KnowledgeBase_workspaceId_idx";
+DROP INDEX IF EXISTS "KnowledgeBase_workspaceId_updatedAt_idx";
+ALTER TABLE "KnowledgeBase" DROP COLUMN IF EXISTS "workspaceId";
+
+-- 2. Add the curated flag.
+ALTER TABLE "KnowledgeBase"
+    ADD COLUMN IF NOT EXISTS "isCurated" BOOLEAN NOT NULL DEFAULT false;
+
+CREATE INDEX IF NOT EXISTS "KnowledgeBase_isCurated_updatedAt_idx"
+    ON "KnowledgeBase" ("isCurated", "updatedAt" DESC);
+
+-- 3. Create the workspace ↔ knowledge base join table.
+CREATE TABLE IF NOT EXISTS "WorkspaceKnowledgeBase" (
+    "id" TEXT NOT NULL,
+    "workspaceId" TEXT NOT NULL,
+    "knowledgeBaseId" TEXT NOT NULL,
+    "addedById" TEXT,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "WorkspaceKnowledgeBase_pkey" PRIMARY KEY ("id")
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS "WorkspaceKnowledgeBase_workspaceId_knowledgeBaseId_key"
+    ON "WorkspaceKnowledgeBase" ("workspaceId", "knowledgeBaseId");
+
+CREATE INDEX IF NOT EXISTS "WorkspaceKnowledgeBase_workspaceId_idx"
+    ON "WorkspaceKnowledgeBase" ("workspaceId");
+
+CREATE INDEX IF NOT EXISTS "WorkspaceKnowledgeBase_knowledgeBaseId_idx"
+    ON "WorkspaceKnowledgeBase" ("knowledgeBaseId");
+
+ALTER TABLE "WorkspaceKnowledgeBase"
+    ADD CONSTRAINT "WorkspaceKnowledgeBase_workspaceId_fkey"
+    FOREIGN KEY ("workspaceId") REFERENCES "Workspace"("id")
+    ON DELETE CASCADE ON UPDATE CASCADE;
+
+ALTER TABLE "WorkspaceKnowledgeBase"
+    ADD CONSTRAINT "WorkspaceKnowledgeBase_knowledgeBaseId_fkey"
+    FOREIGN KEY ("knowledgeBaseId") REFERENCES "KnowledgeBase"("id")
+    ON DELETE CASCADE ON UPDATE CASCADE;
+
+ALTER TABLE "WorkspaceKnowledgeBase"
+    ADD CONSTRAINT "WorkspaceKnowledgeBase_addedById_fkey"
+    FOREIGN KEY ("addedById") REFERENCES "User"("id")
+    ON DELETE SET NULL ON UPDATE CASCADE;