@opengeni/api-router 0.11.1 → 0.11.8

package/src/routes/documents.ts

@@ -1,5 +1,6 @@
 import {
   AddDocumentRequest,
+  CreateKnowledgeDropRequest,
   CreateKnowledgeMemoryRequest,
   CreateDocumentBaseRequest,
   Document,
@@ -7,11 +8,14 @@ import {
   DocumentSearchRequest,
   KnowledgeMemory,
   KnowledgeMemorySearchRequest,
+  MoveDocumentRequest,
   UpdateKnowledgeMemoryRequest,
   WorkspaceMemorySearchRequest,
   WorkspaceMemorySearchResponse,
 } from "@opengeni/contracts";
 import {
+  completeFileUpload,
+  createFileUpload,
   createKnowledgeMemory,
   getKnowledgeMemory,
   listKnowledgeMemories,
@@ -23,10 +27,12 @@ import {
   addDocumentToBase,
   createDocumentBase,
   deleteDocumentFromBase,
+  ensureDefaultBase,
   getDocument,
   getDocumentBase,
   listDocumentBases,
   listDocuments,
+  moveDocumentToBase,
   queueDocumentForReindex,
   searchDocuments,
 } from "@opengeni/documents";
@@ -37,6 +43,7 @@ import { requireAccessGrant } from "@opengeni/core";
 import { recordWorkspaceUsage, requireLimit } from "@opengeni/core";
 import type { ApiRouteDeps } from "@opengeni/core";
 import { buildDocumentsMcpServer } from "../mcp/documents";
+import { sanitizeFilename } from "./files";
 
 export function registerDocumentRoutes(app: Hono, deps: ApiRouteDeps): void {
   const { db, objectStorage, documentIndexer, getDocumentServices } = deps;
@@ -90,6 +97,8 @@ export function registerDocumentRoutes(app: Hono, deps: ApiRouteDeps): void {
         accountId: grant.accountId,
         workspaceId,
         baseId: c.req.param("baseId"),
+        createdBy: grant.subjectId,
+        access: { viewerSubjectId: grant.subjectId },
       });
       const wasCreated =
         document.status === "queued" && document.chunkCount === 0 && document.error === null;
@@ -122,11 +131,13 @@ export function registerDocumentRoutes(app: Hono, deps: ApiRouteDeps): void {
 
   app.get("/v1/workspaces/:workspaceId/document-bases/:baseId/documents", async (c) => {
     const workspaceId = c.req.param("workspaceId");
-    await requireAccessGrant(c, deps, workspaceId, "documents:search");
+    const grant = await requireAccessGrant(c, deps, workspaceId, "documents:search");
     return c.json(
-      (await listDocuments(db, workspaceId, c.req.param("baseId"))).map((document) =>
-        Document.parse(document),
-      ),
+      (
+        await listDocuments(db, workspaceId, c.req.param("baseId"), {
+          viewerSubjectId: grant.subjectId,
+        })
+      ).map((document) => Document.parse(document)),
     );
   });
 
@@ -141,9 +152,13 @@ export function registerDocumentRoutes(app: Hono, deps: ApiRouteDeps): void {
           workspaceId,
           baseId: c.req.param("baseId"),
           documentId: c.req.param("documentId"),
+          access: { viewerSubjectId: grant.subjectId },
         });
         return c.body(null, 204);
       } catch (error) {
+        if (error instanceof HTTPException) {
+          throw error;
+        }
         throw documentHttpException(error);
       }
     },
@@ -164,7 +179,9 @@ export function registerDocumentRoutes(app: Hono, deps: ApiRouteDeps): void {
         quantity: 0,
       });
       try {
-        const document = await getDocument(db, workspaceId, c.req.param("documentId"));
+        const document = await getDocument(db, workspaceId, c.req.param("documentId"), {
+          viewerSubjectId: grant.subjectId,
+        });
         if (!document) {
           throw new HTTPException(404, { message: "document not found" });
         }
@@ -174,7 +191,9 @@ export function registerDocumentRoutes(app: Hono, deps: ApiRouteDeps): void {
         if (document.baseId !== c.req.param("baseId")) {
           throw new HTTPException(404, { message: "document not found" });
         }
-        const queued = await queueDocumentForReindex(db, workspaceId, document.id);
+        const queued = await queueDocumentForReindex(db, workspaceId, document.id, {
+          viewerSubjectId: grant.subjectId,
+        });
         const indexed =
           (await documentIndexer.indexDocument({
             accountId: grant.accountId,
@@ -206,7 +225,7 @@ export function registerDocumentRoutes(app: Hono, deps: ApiRouteDeps): void {
 
   app.post("/v1/workspaces/:workspaceId/document-bases/:baseId/search", async (c) => {
     const workspaceId = c.req.param("workspaceId");
-    await requireAccessGrant(c, deps, workspaceId, "documents:search");
+    const grant = await requireAccessGrant(c, deps, workspaceId, "documents:search");
     const payload = DocumentSearchRequest.parse(await c.req.json());
     const base = await getDocumentBase(db, workspaceId, c.req.param("baseId"));
     if (!base) {
@@ -223,6 +242,7 @@ export function registerDocumentRoutes(app: Hono, deps: ApiRouteDeps): void {
           mode: payload.mode,
           sourceKinds: payload.sourceKinds,
           aclTags: payload.aclTags,
+          access: { viewerSubjectId: grant.subjectId },
         },
         getDocumentServices(),
       ),
@@ -231,7 +251,7 @@ export function registerDocumentRoutes(app: Hono, deps: ApiRouteDeps): void {
 
   app.post("/v1/workspaces/:workspaceId/knowledge/search", async (c) => {
     const workspaceId = c.req.param("workspaceId");
-    await requireAccessGrant(c, deps, workspaceId, "documents:search");
+    const grant = await requireAccessGrant(c, deps, workspaceId, "documents:search");
     const payload = DocumentSearchRequest.parse(await c.req.json());
     return c.json({
       results: await searchDocuments(
@@ -244,12 +264,162 @@ export function registerDocumentRoutes(app: Hono, deps: ApiRouteDeps): void {
           mode: payload.mode,
           sourceKinds: payload.sourceKinds,
           aclTags: payload.aclTags,
+          access: { viewerSubjectId: grant.subjectId },
         },
         getDocumentServices(),
       ),
     });
   });
 
+  // Knowledge drop: raw text or an uploaded file, no metadata required. Lands
+  // in the workspace Default base with curationStatus 'pending'; indexing then
+  // applies the configured curation provider, or leaves it as 'none' when
+  // curation is disabled.
+  app.post("/v1/workspaces/:workspaceId/knowledge/drops", async (c) => {
+    const workspaceId = c.req.param("workspaceId");
+    const grant = await requireAccessGrant(c, deps, workspaceId, "documents:manage");
+    if (!objectStorage) {
+      throw new HTTPException(503, { message: "object storage is not configured" });
+    }
+    await requireLimit(deps, {
+      accountId: grant.accountId,
+      workspaceId,
+      action: "document:index",
+      quantity: 0,
+    });
+    const payload = CreateKnowledgeDropRequest.parse(await c.req.json());
+    try {
+      let fileId: string;
+      if (payload.text !== undefined) {
+        const bytes = new TextEncoder().encode(payload.text);
+        await requireLimit(deps, {
+          accountId: grant.accountId,
+          workspaceId,
+          action: "file:upload",
+          quantity: bytes.length,
+        });
+        if (bytes.length > objectStorage.maxSinglePutSizeBytes) {
+          throw new HTTPException(413, {
+            message: `drop exceeds single PUT limit of ${objectStorage.maxSinglePutSizeBytes} bytes`,
+          });
+        }
+        const filename = dropFilename(payload.filename ?? payload.title);
+        const newFileId = crypto.randomUUID();
+        const safeFilename = sanitizeFilename(filename);
+        const objectKey = `workspaces/${workspaceId}/files/${newFileId}/original/${safeFilename}`;
+        const upload = await createFileUpload(db, {
+          accountId: grant.accountId,
+          workspaceId,
+          fileId: newFileId,
+          filename,
+          safeFilename,
+          contentType: "text/plain; charset=utf-8",
+          sizeBytes: bytes.length,
+          sha256: null,
+          bucket: objectStorage.bucket,
+          objectKey,
+          expiresAt: new Date(Date.now() + 15 * 60 * 1000),
+        });
+        await objectStorage.putObject({
+          key: objectKey,
+          contentType: "text/plain; charset=utf-8",
+          body: bytes,
+        });
+        const file = await completeFileUpload(db, workspaceId, upload.uploadId);
+        await recordWorkspaceUsage(deps, {
+          accountId: grant.accountId,
+          workspaceId,
+          subjectId: grant.subjectId,
+          eventType: "file.uploaded",
+          quantity: file.sizeBytes,
+          unit: "byte",
+          sourceResourceType: "file",
+          sourceResourceId: file.id,
+          idempotencyKey: `file.uploaded:${workspaceId}:${file.id}`,
+        });
+        fileId = file.id;
+      } else {
+        fileId = payload.fileId as string;
+      }
+      const defaultBase = await ensureDefaultBase(db, {
+        accountId: grant.accountId,
+        workspaceId,
+      });
+      const document = await addDocumentToBase(db, {
+        fileId,
+        ...(payload.title ? { title: payload.title } : {}),
+        ...(payload.visibility ? { visibility: payload.visibility } : {}),
+        ...(payload.agentAccess !== undefined ? { agentAccess: payload.agentAccess } : {}),
+        accountId: grant.accountId,
+        workspaceId,
+        baseId: defaultBase.id,
+        createdBy: grant.subjectId,
+        curationStatus: "pending",
+        access: { viewerSubjectId: grant.subjectId },
+      });
+      const wasCreated =
+        document.status === "queued" && document.chunkCount === 0 && document.error === null;
+      const indexed =
+        document.status === "ready"
+          ? document
+          : ((await documentIndexer.indexDocument({
+              accountId: grant.accountId,
+              workspaceId,
+              documentId: document.id,
+            })) ?? document);
+      if (indexed.status === "ready") {
+        await recordWorkspaceUsage(deps, {
+          accountId: grant.accountId,
+          workspaceId,
+          subjectId: grant.subjectId,
+          eventType: "document.indexed",
+          quantity: indexed.chunkCount,
+          unit: "chunk",
+          sourceResourceType: "document",
+          sourceResourceId: indexed.id,
+          idempotencyKey: `document.indexed:${workspaceId}:${indexed.id}:${indexed.updatedAt}`,
+        });
+      }
+      return c.json(Document.parse(indexed), wasCreated ? 201 : 200);
+    } catch (error) {
+      if (error instanceof HTTPException) {
+        throw error;
+      }
+      throw documentHttpException(error);
+    }
+  });
+
+  // Apply a curation suggestion (no body target) or move to an explicit base.
+  app.post("/v1/workspaces/:workspaceId/documents/:documentId/move", async (c) => {
+    const workspaceId = c.req.param("workspaceId");
+    const grant = await requireAccessGrant(c, deps, workspaceId, "documents:manage");
+    const payload = MoveDocumentRequest.parse(await c.req.json().catch(() => ({})));
+    try {
+      const document = await getDocument(db, workspaceId, c.req.param("documentId"), {
+        viewerSubjectId: grant.subjectId,
+      });
+      if (!document) {
+        throw new HTTPException(404, { message: "document not found" });
+      }
+      return c.json(
+        Document.parse(
+          await moveDocumentToBase(db, {
+            accountId: grant.accountId,
+            workspaceId,
+            documentId: document.id,
+            targetBaseId: payload.targetBaseId ?? null,
+            access: { viewerSubjectId: grant.subjectId },
+          }),
+        ),
+      );
+    } catch (error) {
+      if (error instanceof HTTPException) {
+        throw error;
+      }
+      throw documentHttpException(error);
+    }
+  });
+
   app.get("/v1/workspaces/:workspaceId/knowledge/memories", async (c) => {
     const workspaceId = c.req.param("workspaceId");
     await requireAccessGrant(c, deps, workspaceId, "documents:search");
@@ -390,18 +560,30 @@ export function registerDocumentRoutes(app: Hono, deps: ApiRouteDeps): void {
       grant.accountId,
       workspaceId,
       getDocumentServices(),
-      { createdBySessionId: sessionId },
+      { createdBySessionId: sessionId, viewerSubjectId: grant.subjectId },
     );
     await server.connect(transport);
     return await transport.handleRequest(c.req.raw);
   });
 }
 
+/** Derive a .txt filename for a raw-text drop from its optional title/filename. */
+function dropFilename(preferred: string | undefined): string {
+  const stem = (preferred ?? "").trim() || `note-${new Date().toISOString().slice(0, 10)}`;
+  return /\.[A-Za-z0-9]{1,8}$/.test(stem) ? stem : `${stem}.txt`;
+}
+
 function documentHttpException(error: unknown): HTTPException {
   const message = error instanceof Error ? error.message : String(error);
   if (message.includes("not found")) {
     return new HTTPException(404, { message });
   }
+  if (message.includes("already exists")) {
+    return new HTTPException(409, { message });
+  }
+  if (message.includes("no suggested base")) {
+    return new HTTPException(422, { message });
+  }
   if (message.includes("pending") || message.includes("failed") || message.includes("deleted")) {
     return new HTTPException(422, { message });
   }

package/src/routes/files.ts

@@ -351,7 +351,7 @@ export function registerFileRoutes(app: Hono, deps: ApiRouteDeps): void {
   });
 }
 
-function sanitizeFilename(filename: string): string {
+export function sanitizeFilename(filename: string): string {
   const trimmed = filename.trim().replace(/[/\\]/g, "_");
   const safe = trimmed
     .replace(/[^A-Za-z0-9._ -]+/g, "_")