@goscribe/server 1.6.0 → 1.7.0

package/dist/src/routers/knowledgeBase.d.ts

@@ -0,0 +1,421 @@
+/**
+ * Knowledge Base router.
+ *
+ * Read paths and "attach to my workspace" are user-facing. Creating, deleting,
+ * uploading documents, and toggling curation are gated behind the System
+ * Admin role under the nested `admin.*` namespace.
+ */
+export declare const knowledgeBase: import("@trpc/server").TRPCBuiltRouter<{
+    ctx: import("../context.js").Context;
+    meta: object;
+    errorShape: {
+        data: {
+            zodError: string | null;
+            code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
+            httpStatus: number;
+            path?: string;
+            stack?: string;
+        };
+        message: string;
+        code: import("@trpc/server").TRPC_ERROR_CODE_NUMBER;
+    };
+    transformer: true;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    /** KBs already attached to a workspace ("the workspace's library"). */
+    listForWorkspace: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            workspaceId: string;
+        };
+        output: {
+            attachmentId: string;
+            attachedAt: Date;
+            attachedById: string | null;
+            _count: {
+                documents: number;
+            };
+            id: string;
+            name: string;
+            createdAt: Date;
+            updatedAt: Date;
+            description: string | null;
+            createdById: string | null;
+            status: import("../../generated/prisma/enums.js").KnowledgeBaseStatus;
+            meta: import("@prisma/client/runtime/client").JsonValue | null;
+            isCurated: boolean;
+            embeddingModel: string;
+            embeddingDim: number;
+        }[];
+        meta: object;
+    }>;
+    /** Search the curated catalog. Pass workspaceId to flag already-attached KBs. */
+    searchCatalog: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            query?: string | undefined;
+            workspaceId?: string | undefined;
+            limit?: number | undefined;
+        };
+        output: {
+            attached: boolean;
+            _count: {
+                documents: number;
+            };
+            id: string;
+            name: string;
+            createdAt: Date;
+            updatedAt: Date;
+            description: string | null;
+            createdById: string | null;
+            status: import("../../generated/prisma/enums.js").KnowledgeBaseStatus;
+            meta: import("@prisma/client/runtime/client").JsonValue | null;
+            isCurated: boolean;
+            embeddingModel: string;
+            embeddingDim: number;
+        }[];
+        meta: object;
+    }>;
+    get: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            id: string;
+        };
+        output: {
+            documents: {
+                id: string;
+                name: string;
+                createdAt: Date;
+                updatedAt: Date;
+                size: number;
+                status: import("../../generated/prisma/enums.js").KnowledgeBaseDocumentStatus;
+                objectKey: string | null;
+                mimeType: string;
+                bucket: string | null;
+                meta: import("@prisma/client/runtime/client").JsonValue | null;
+                knowledgeBaseId: string;
+                errorMessage: string | null;
+                numChunks: number;
+                numPages: number | null;
+            }[];
+            id: string;
+            name: string;
+            createdAt: Date;
+            updatedAt: Date;
+            description: string | null;
+            createdById: string | null;
+            status: import("../../generated/prisma/enums.js").KnowledgeBaseStatus;
+            meta: import("@prisma/client/runtime/client").JsonValue | null;
+            isCurated: boolean;
+            embeddingModel: string;
+            embeddingDim: number;
+        };
+        meta: object;
+    }>;
+    listDocuments: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            knowledgeBaseId: string;
+        };
+        output: {
+            id: string;
+            name: string;
+            createdAt: Date;
+            updatedAt: Date;
+            size: number;
+            status: import("../../generated/prisma/enums.js").KnowledgeBaseDocumentStatus;
+            objectKey: string | null;
+            mimeType: string;
+            bucket: string | null;
+            meta: import("@prisma/client/runtime/client").JsonValue | null;
+            knowledgeBaseId: string;
+            errorMessage: string | null;
+            numChunks: number;
+            numPages: number | null;
+        }[];
+        meta: object;
+    }>;
+    addToWorkspace: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            workspaceId: string;
+            knowledgeBaseId: string;
+        };
+        output: {
+            id: string;
+            createdAt: Date;
+            workspaceId: string;
+            knowledgeBaseId: string;
+            addedById: string | null;
+        };
+        meta: object;
+    }>;
+    removeFromWorkspace: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            workspaceId: string;
+            knowledgeBaseId: string;
+        };
+        output: boolean;
+        meta: object;
+    }>;
+    query: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            knowledgeBaseId: string;
+            query: string;
+            topK?: number | undefined;
+            generateAnswer?: boolean | undefined;
+        };
+        output: {
+            matches: {
+                chunkId: string;
+                documentId: string;
+                documentName: string;
+                chunkIndex: number;
+                content: string;
+                score: number;
+            }[];
+            answer: string | null;
+        };
+        meta: object;
+    }>;
+    admin: import("@trpc/server").TRPCBuiltRouter<{
+        ctx: import("../context.js").Context;
+        meta: object;
+        errorShape: {
+            data: {
+                zodError: string | null;
+                code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
+                httpStatus: number;
+                path?: string;
+                stack?: string;
+            };
+            message: string;
+            code: import("@trpc/server").TRPC_ERROR_CODE_NUMBER;
+        };
+        transformer: true;
+    }, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+        listAll: import("@trpc/server").TRPCQueryProcedure<{
+            input: void;
+            output: ({
+                _count: {
+                    workspaces: number;
+                    documents: number;
+                };
+            } & {
+                id: string;
+                name: string;
+                createdAt: Date;
+                updatedAt: Date;
+                description: string | null;
+                createdById: string | null;
+                status: import("../../generated/prisma/enums.js").KnowledgeBaseStatus;
+                meta: import("@prisma/client/runtime/client").JsonValue | null;
+                isCurated: boolean;
+                embeddingModel: string;
+                embeddingDim: number;
+            })[];
+            meta: object;
+        }>;
+        get: import("@trpc/server").TRPCQueryProcedure<{
+            input: {
+                id: string;
+            };
+            output: {
+                documents: {
+                    id: string;
+                    name: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    size: number;
+                    status: import("../../generated/prisma/enums.js").KnowledgeBaseDocumentStatus;
+                    objectKey: string | null;
+                    mimeType: string;
+                    bucket: string | null;
+                    meta: import("@prisma/client/runtime/client").JsonValue | null;
+                    knowledgeBaseId: string;
+                    errorMessage: string | null;
+                    numChunks: number;
+                    numPages: number | null;
+                }[];
+                workspaces: ({
+                    workspace: {
+                        id: string;
+                        title: string;
+                        icon: string;
+                    };
+                } & {
+                    id: string;
+                    createdAt: Date;
+                    workspaceId: string;
+                    knowledgeBaseId: string;
+                    addedById: string | null;
+                })[];
+                id: string;
+                name: string;
+                createdAt: Date;
+                updatedAt: Date;
+                description: string | null;
+                createdById: string | null;
+                status: import("../../generated/prisma/enums.js").KnowledgeBaseStatus;
+                meta: import("@prisma/client/runtime/client").JsonValue | null;
+                isCurated: boolean;
+                embeddingModel: string;
+                embeddingDim: number;
+            };
+            meta: object;
+        }>;
+        listDocuments: import("@trpc/server").TRPCQueryProcedure<{
+            input: {
+                knowledgeBaseId: string;
+            };
+            output: {
+                id: string;
+                name: string;
+                createdAt: Date;
+                updatedAt: Date;
+                size: number;
+                status: import("../../generated/prisma/enums.js").KnowledgeBaseDocumentStatus;
+                objectKey: string | null;
+                mimeType: string;
+                bucket: string | null;
+                meta: import("@prisma/client/runtime/client").JsonValue | null;
+                knowledgeBaseId: string;
+                errorMessage: string | null;
+                numChunks: number;
+                numPages: number | null;
+            }[];
+            meta: object;
+        }>;
+        create: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                name: string;
+                description?: string | undefined;
+                isCurated?: boolean | undefined;
+            };
+            output: {
+                id: string;
+                name: string;
+                createdAt: Date;
+                updatedAt: Date;
+                description: string | null;
+                createdById: string | null;
+                status: import("../../generated/prisma/enums.js").KnowledgeBaseStatus;
+                meta: import("@prisma/client/runtime/client").JsonValue | null;
+                isCurated: boolean;
+                embeddingModel: string;
+                embeddingDim: number;
+            };
+            meta: object;
+        }>;
+        update: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                id: string;
+                name?: string | undefined;
+                description?: string | null | undefined;
+                isCurated?: boolean | undefined;
+            };
+            output: {
+                id: string;
+                name: string;
+                createdAt: Date;
+                updatedAt: Date;
+                description: string | null;
+                createdById: string | null;
+                status: import("../../generated/prisma/enums.js").KnowledgeBaseStatus;
+                meta: import("@prisma/client/runtime/client").JsonValue | null;
+                isCurated: boolean;
+                embeddingModel: string;
+                embeddingDim: number;
+            };
+            meta: object;
+        }>;
+        delete: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                id: string;
+            };
+            output: boolean;
+            meta: object;
+        }>;
+        attachToWorkspace: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                workspaceId: string;
+                knowledgeBaseId: string;
+            };
+            output: {
+                id: string;
+                createdAt: Date;
+                workspaceId: string;
+                knowledgeBaseId: string;
+                addedById: string | null;
+            };
+            meta: object;
+        }>;
+        detachFromWorkspace: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                workspaceId: string;
+                knowledgeBaseId: string;
+            };
+            output: boolean;
+            meta: object;
+        }>;
+        requestDocumentUploadUrl: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                knowledgeBaseId: string;
+                filename: string;
+                contentType: string;
+                size: number;
+            };
+            output: {
+                documentId: string;
+                uploadUrl: string;
+                bucket: string;
+                objectKey: string;
+            };
+            meta: object;
+        }>;
+        processDocument: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                knowledgeBaseId: string;
+                documentId: string;
+            };
+            output: {
+                id: string;
+                name: string;
+                createdAt: Date;
+                updatedAt: Date;
+                size: number;
+                status: import("../../generated/prisma/enums.js").KnowledgeBaseDocumentStatus;
+                objectKey: string | null;
+                mimeType: string;
+                bucket: string | null;
+                meta: import("@prisma/client/runtime/client").JsonValue | null;
+                knowledgeBaseId: string;
+                errorMessage: string | null;
+                numChunks: number;
+                numPages: number | null;
+            } | null;
+            meta: object;
+        }>;
+        deleteDocument: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                documentId: string;
+            };
+            output: boolean;
+            meta: object;
+        }>;
+        query: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                knowledgeBaseId: string;
+                query: string;
+                topK?: number | undefined;
+                generateAnswer?: boolean | undefined;
+            };
+            output: {
+                matches: {
+                    chunkId: string;
+                    documentId: string;
+                    documentName: string;
+                    chunkIndex: number;
+                    content: string;
+                    score: number;
+                }[];
+                answer: string | null;
+            };
+            meta: object;
+        }>;
+    }>>;
+}>>;

package/dist/src/routers/knowledgeBase.js

@@ -0,0 +1,118 @@
+import { z } from 'zod';
+import { router, authedProcedure, adminProcedure } from '../trpc.js';
+import { KnowledgeBaseService } from '../services/knowledge/knowledge-base.service.js';
+/**
+ * Knowledge Base router.
+ *
+ * Read paths and "attach to my workspace" are user-facing. Creating, deleting,
+ * uploading documents, and toggling curation are gated behind the System
+ * Admin role under the nested `admin.*` namespace.
+ */
+export const knowledgeBase = router({
+    // ── User-facing reads ────────────────────────────────────────────────
+    /** KBs already attached to a workspace ("the workspace's library"). */
+    listForWorkspace: authedProcedure
+        .input(z.object({ workspaceId: z.string() }))
+        .query(({ ctx, input }) => new KnowledgeBaseService(ctx.db).listForWorkspace(ctx.session.user.id, input.workspaceId)),
+    /** Search the curated catalog. Pass workspaceId to flag already-attached KBs. */
+    searchCatalog: authedProcedure
+        .input(z.object({
+        query: z.string().max(200).optional(),
+        workspaceId: z.string().optional(),
+        limit: z.number().int().min(1).max(100).optional(),
+    }))
+        .query(({ ctx, input }) => new KnowledgeBaseService(ctx.db).searchCatalog(ctx.session.user.id, input)),
+    get: authedProcedure
+        .input(z.object({ id: z.string() }))
+        .query(({ ctx, input }) => new KnowledgeBaseService(ctx.db).get(ctx.session.user.id, input.id)),
+    listDocuments: authedProcedure
+        .input(z.object({ knowledgeBaseId: z.string() }))
+        .query(({ ctx, input }) => new KnowledgeBaseService(ctx.db).listDocuments(ctx.session.user.id, input.knowledgeBaseId)),
+    // ── User-facing writes (limited to attaching/detaching curated KBs) ──
+    addToWorkspace: authedProcedure
+        .input(z.object({
+        workspaceId: z.string(),
+        knowledgeBaseId: z.string(),
+    }))
+        .mutation(({ ctx, input }) => new KnowledgeBaseService(ctx.db).addToWorkspace(ctx.session.user.id, input)),
+    removeFromWorkspace: authedProcedure
+        .input(z.object({
+        workspaceId: z.string(),
+        knowledgeBaseId: z.string(),
+    }))
+        .mutation(({ ctx, input }) => new KnowledgeBaseService(ctx.db).removeFromWorkspace(ctx.session.user.id, input)),
+    // ── Retrieval ────────────────────────────────────────────────────────
+    query: authedProcedure
+        .input(z.object({
+        knowledgeBaseId: z.string(),
+        query: z.string().min(1).max(2000),
+        topK: z.number().int().min(1).max(20).optional(),
+        generateAnswer: z.boolean().optional(),
+    }))
+        .mutation(({ ctx, input }) => new KnowledgeBaseService(ctx.db).query(ctx.session.user.id, input)),
+    // ── Admin-only ───────────────────────────────────────────────────────
+    admin: router({
+        listAll: adminProcedure.query(({ ctx }) => new KnowledgeBaseService(ctx.db).adminListAll()),
+        get: adminProcedure
+            .input(z.object({ id: z.string() }))
+            .query(({ ctx, input }) => new KnowledgeBaseService(ctx.db).adminGet(input.id)),
+        listDocuments: adminProcedure
+            .input(z.object({ knowledgeBaseId: z.string() }))
+            .query(({ ctx, input }) => new KnowledgeBaseService(ctx.db).adminListDocuments(input.knowledgeBaseId)),
+        create: adminProcedure
+            .input(z.object({
+            name: z.string().min(1).max(120),
+            description: z.string().max(500).optional(),
+            isCurated: z.boolean().optional(),
+        }))
+            .mutation(({ ctx, input }) => new KnowledgeBaseService(ctx.db).adminCreate(ctx.session.user.id, input)),
+        update: adminProcedure
+            .input(z.object({
+            id: z.string(),
+            name: z.string().min(1).max(120).optional(),
+            description: z.string().max(500).nullable().optional(),
+            isCurated: z.boolean().optional(),
+        }))
+            .mutation(({ ctx, input }) => new KnowledgeBaseService(ctx.db).adminUpdate(input)),
+        delete: adminProcedure
+            .input(z.object({ id: z.string() }))
+            .mutation(({ ctx, input }) => new KnowledgeBaseService(ctx.db).adminDelete(input.id)),
+        attachToWorkspace: adminProcedure
+            .input(z.object({
+            workspaceId: z.string(),
+            knowledgeBaseId: z.string(),
+        }))
+            .mutation(({ ctx, input }) => new KnowledgeBaseService(ctx.db).adminAttachToWorkspace(ctx.session.user.id, input)),
+        detachFromWorkspace: adminProcedure
+            .input(z.object({
+            workspaceId: z.string(),
+            knowledgeBaseId: z.string(),
+        }))
+            .mutation(({ ctx, input }) => new KnowledgeBaseService(ctx.db).adminDetachFromWorkspace(input)),
+        requestDocumentUploadUrl: adminProcedure
+            .input(z.object({
+            knowledgeBaseId: z.string(),
+            filename: z.string().min(1).max(255),
+            contentType: z.string().min(1).max(100),
+            size: z.number().int().min(1),
+        }))
+            .mutation(({ ctx, input }) => new KnowledgeBaseService(ctx.db).adminRequestUploadUrl(input)),
+        processDocument: adminProcedure
+            .input(z.object({
+            knowledgeBaseId: z.string(),
+            documentId: z.string(),
+        }))
+            .mutation(({ ctx, input }) => new KnowledgeBaseService(ctx.db).adminProcessDocument(input)),
+        deleteDocument: adminProcedure
+            .input(z.object({ documentId: z.string() }))
+            .mutation(({ ctx, input }) => new KnowledgeBaseService(ctx.db).adminDeleteDocument(input.documentId)),
+        query: adminProcedure
+            .input(z.object({
+            knowledgeBaseId: z.string(),
+            query: z.string().min(1).max(2000),
+            topK: z.number().int().min(1).max(20).optional(),
+            generateAnswer: z.boolean().optional(),
+        }))
+            .mutation(({ ctx, input }) => new KnowledgeBaseService(ctx.db).adminQuery(input)),
+    }),
+});

package/dist/src/routers/members.d.ts

@@ -0,0 +1,169 @@
+export declare const members: import("@trpc/server").TRPCBuiltRouter<{
+    ctx: import("../context.js").Context;
+    meta: object;
+    errorShape: {
+        data: {
+            zodError: string | null;
+            code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
+            httpStatus: number;
+            path?: string;
+            stack?: string;
+        };
+        message: string;
+        code: import("@trpc/server").TRPC_ERROR_CODE_NUMBER;
+    };
+    transformer: true;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    getMembers: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            workspaceId: string;
+        };
+        output: ({
+            id: string;
+            name: string;
+            email: string;
+            role: "admin" | "member";
+            joinedAt: Date;
+        } | {
+            id: string;
+            name: string;
+            email: string;
+            role: "owner";
+            joinedAt: Date;
+        })[];
+        meta: object;
+    }>;
+    getCurrentUserRole: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            workspaceId: string;
+        };
+        output: "admin" | "member" | "owner";
+        meta: object;
+    }>;
+    inviteMember: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            workspaceId: string;
+            email: string;
+            role?: "admin" | "member" | undefined;
+        };
+        output: {
+            invitationId: string;
+            token: string;
+            email: string;
+            role: string;
+            expiresAt: Date;
+            workspaceTitle: string;
+            invitedByName: string | null;
+        };
+        meta: object;
+    }>;
+    getInvitations: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            workspaceId: string;
+        };
+        output: {
+            id: string;
+            email: string;
+            createdAt: Date;
+            updatedAt: Date;
+            role: string;
+            token: string;
+            workspaceId: string;
+            invitedById: string;
+            acceptedAt: Date | null;
+            expiresAt: Date;
+        }[];
+        meta: object;
+    }>;
+    acceptInvite: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            token: string;
+        };
+        output: {
+            message?: string | undefined;
+            workspaceId: string;
+            workspaceTitle: string;
+            role: string;
+            ownerName: string | null;
+        };
+        meta: object;
+    }>;
+    changeMemberRole: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            workspaceId: string;
+            memberId: string;
+            role: "admin" | "member";
+        };
+        output: {
+            memberId: string;
+            role: "admin" | "member";
+            memberName: string | null;
+            message: string;
+        };
+        meta: object;
+    }>;
+    removeMember: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            workspaceId: string;
+            memberId: string;
+        };
+        output: {
+            memberId: string;
+            message: string;
+        };
+        meta: object;
+    }>;
+    getPendingInvitations: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            workspaceId: string;
+        };
+        output: {
+            id: string;
+            email: string;
+            role: string;
+            token: string;
+            expiresAt: Date;
+            createdAt: Date;
+            invitedByName: string | null;
+        }[];
+        meta: object;
+    }>;
+    cancelInvitation: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            invitationId: string;
+        };
+        output: {
+            invitationId: string;
+            message: string;
+        };
+        meta: object;
+    }>;
+    resendInvitation: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            invitationId: string;
+        };
+        output: {
+            invitationId: string;
+            message: string;
+        };
+        meta: object;
+    }>;
+    getAllInvitationsDebug: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            workspaceId: string;
+        };
+        output: {
+            id: string;
+            email: string;
+            createdAt: Date;
+            updatedAt: Date;
+            role: string;
+            token: string;
+            workspaceId: string;
+            invitedById: string;
+            acceptedAt: Date | null;
+            expiresAt: Date;
+        }[];
+        meta: object;
+    }>;
+}>>;