@opengeni/documents 0.2.7 → 0.2.9

package/dist/index.js

@@ -56,8 +56,6 @@ var RecursiveTextChunker = class {
       throw new Error("document chunk overlap must be smaller than chunk size");
     }
   }
-  maxChars;
-  overlapChars;
   chunk(parsed, file) {
     return chunkText(parsed.text, this.maxChars, this.overlapChars).map((text, index) => ({
       text,
@@ -127,8 +125,6 @@ var DeterministicEmbeddingProvider = class {
     this.dimensions = dimensions;
     this.model = model;
   }
-  dimensions;
-  model;
   async embedMany(texts) {
     return texts.map((text) => deterministicEmbedding(text, this.dimensions));
   }
@@ -190,16 +186,20 @@ function azureOpenAIDefaultQuery(settings, baseURL) {
   return { "api-version": settings.azureOpenaiApiVersion };
 }
 async function createDocumentBase(db, input) {
-  return await withRlsContext(db, { accountId: input.accountId, workspaceId: input.workspaceId }, async (scopedDb) => {
-    const [row] = await scopedDb.insert(schema.documentBases).values({
-      accountId: input.accountId,
-      workspaceId: input.workspaceId,
-      name: input.name.trim(),
-      description: input.description?.trim() || null
-    }).returning();
-    if (!row) throw new Error("Failed to create document base");
-    return mapDocumentBase(row);
-  });
+  return await withRlsContext(
+    db,
+    { accountId: input.accountId, workspaceId: input.workspaceId },
+    async (scopedDb) => {
+      const [row] = await scopedDb.insert(schema.documentBases).values({
+        accountId: input.accountId,
+        workspaceId: input.workspaceId,
+        name: input.name.trim(),
+        description: input.description?.trim() || null
+      }).returning();
+      if (!row) throw new Error("Failed to create document base");
+      return mapDocumentBase(row);
+    }
+  );
 }
 async function listDocumentBases(db, workspaceId) {
   return await withWorkspaceRls(db, workspaceId, async (scopedDb) => {
@@ -209,77 +209,112 @@ async function listDocumentBases(db, workspaceId) {
 }
 async function getDocumentBase(db, workspaceId, baseId) {
   return await withWorkspaceRls(db, workspaceId, async (scopedDb) => {
-    const [row] = await scopedDb.select().from(schema.documentBases).where(and(eq(schema.documentBases.workspaceId, workspaceId), eq(schema.documentBases.id, baseId))).limit(1);
+    const [row] = await scopedDb.select().from(schema.documentBases).where(
+      and(eq(schema.documentBases.workspaceId, workspaceId), eq(schema.documentBases.id, baseId))
+    ).limit(1);
     return row ? mapDocumentBase(row) : null;
   });
 }
 async function addDocumentToBase(db, input) {
-  return await withRlsContext(db, { accountId: input.accountId, workspaceId: input.workspaceId }, async (scopedDb) => {
-    const base = await getDocumentBase(scopedDb, input.workspaceId, input.baseId);
-    if (!base) throw new Error(`Document base not found: ${input.baseId}`);
-    const file = await requireReadyFile(scopedDb, input.workspaceId, input.fileId);
-    const now = /* @__PURE__ */ new Date();
-    const [existing] = await scopedDb.select().from(schema.documents).where(and(eq(schema.documents.workspaceId, input.workspaceId), eq(schema.documents.baseId, input.baseId), eq(schema.documents.fileId, input.fileId))).limit(1);
-    if (existing) {
-      const [updated] = await scopedDb.update(schema.documents).set({
-        title: cleanString(input.title) ?? cleanString(input.sourceTitle) ?? existing.title,
-        ...input.sourceKind !== void 0 ? { sourceKind: input.sourceKind } : {},
-        sourceUri: cleanString(input.sourceUri) ?? existing.sourceUri,
-        sourceExternalId: cleanString(input.sourceExternalId) ?? existing.sourceExternalId,
-        sourceTitle: cleanString(input.sourceTitle) ?? existing.sourceTitle,
-        sourceAuthor: cleanString(input.sourceAuthor) ?? existing.sourceAuthor,
-        sourceCreatedAt: parseOptionalDate(input.sourceCreatedAt) ?? existing.sourceCreatedAt,
-        sourceUpdatedAt: parseOptionalDate(input.sourceUpdatedAt) ?? existing.sourceUpdatedAt,
-        sourceVersion: cleanString(input.sourceVersion) ?? existing.sourceVersion,
-        ...input.aclTags !== void 0 ? { aclTags: cleanStringArray(input.aclTags) } : {},
+  return await withRlsContext(
+    db,
+    { accountId: input.accountId, workspaceId: input.workspaceId },
+    async (scopedDb) => {
+      const base = await getDocumentBase(scopedDb, input.workspaceId, input.baseId);
+      if (!base) throw new Error(`Document base not found: ${input.baseId}`);
+      const file = await requireReadyFile(scopedDb, input.workspaceId, input.fileId);
+      const now = /* @__PURE__ */ new Date();
+      const [existing] = await scopedDb.select().from(schema.documents).where(
+        and(
+          eq(schema.documents.workspaceId, input.workspaceId),
+          eq(schema.documents.baseId, input.baseId),
+          eq(schema.documents.fileId, input.fileId)
+        )
+      ).limit(1);
+      if (existing) {
+        const [updated] = await scopedDb.update(schema.documents).set({
+          title: cleanString(input.title) ?? cleanString(input.sourceTitle) ?? existing.title,
+          ...input.sourceKind !== void 0 ? { sourceKind: input.sourceKind } : {},
+          sourceUri: cleanString(input.sourceUri) ?? existing.sourceUri,
+          sourceExternalId: cleanString(input.sourceExternalId) ?? existing.sourceExternalId,
+          sourceTitle: cleanString(input.sourceTitle) ?? existing.sourceTitle,
+          sourceAuthor: cleanString(input.sourceAuthor) ?? existing.sourceAuthor,
+          sourceCreatedAt: parseOptionalDate(input.sourceCreatedAt) ?? existing.sourceCreatedAt,
+          sourceUpdatedAt: parseOptionalDate(input.sourceUpdatedAt) ?? existing.sourceUpdatedAt,
+          sourceVersion: cleanString(input.sourceVersion) ?? existing.sourceVersion,
+          ...input.aclTags !== void 0 ? { aclTags: cleanStringArray(input.aclTags) } : {},
+          updatedAt: now
+        }).where(
+          and(
+            eq(schema.documents.workspaceId, input.workspaceId),
+            eq(schema.documents.id, existing.id)
+          )
+        ).returning();
+        return mapDocument(updated ?? existing);
+      }
+      const [row] = await scopedDb.insert(schema.documents).values({
+        accountId: input.accountId,
+        workspaceId: input.workspaceId,
+        baseId: input.baseId,
+        fileId: input.fileId,
+        status: "queued",
+        title: cleanString(input.title) ?? cleanString(input.sourceTitle) ?? file.filename,
+        parser: DEFAULT_DOCUMENT_PARSER,
+        sourceKind: input.sourceKind ?? "manual_upload",
+        sourceUri: cleanString(input.sourceUri) ?? null,
+        sourceExternalId: cleanString(input.sourceExternalId) ?? null,
+        sourceTitle: cleanString(input.sourceTitle) ?? null,
+        sourceAuthor: cleanString(input.sourceAuthor) ?? null,
+        sourceCreatedAt: parseOptionalDate(input.sourceCreatedAt),
+        sourceUpdatedAt: parseOptionalDate(input.sourceUpdatedAt),
+        sourceVersion: cleanString(input.sourceVersion) ?? null,
+        aclTags: cleanStringArray(input.aclTags),
         updatedAt: now
-      }).where(and(eq(schema.documents.workspaceId, input.workspaceId), eq(schema.documents.id, existing.id))).returning();
-      return mapDocument(updated ?? existing);
+      }).returning();
+      if (!row) throw new Error("Failed to create document");
+      return mapDocument(row);
     }
-    const [row] = await scopedDb.insert(schema.documents).values({
-      accountId: input.accountId,
-      workspaceId: input.workspaceId,
-      baseId: input.baseId,
-      fileId: input.fileId,
-      status: "queued",
-      title: cleanString(input.title) ?? cleanString(input.sourceTitle) ?? file.filename,
-      parser: DEFAULT_DOCUMENT_PARSER,
-      sourceKind: input.sourceKind ?? "manual_upload",
-      sourceUri: cleanString(input.sourceUri) ?? null,
-      sourceExternalId: cleanString(input.sourceExternalId) ?? null,
-      sourceTitle: cleanString(input.sourceTitle) ?? null,
-      sourceAuthor: cleanString(input.sourceAuthor) ?? null,
-      sourceCreatedAt: parseOptionalDate(input.sourceCreatedAt),
-      sourceUpdatedAt: parseOptionalDate(input.sourceUpdatedAt),
-      sourceVersion: cleanString(input.sourceVersion) ?? null,
-      aclTags: cleanStringArray(input.aclTags),
-      updatedAt: now
-    }).returning();
-    if (!row) throw new Error("Failed to create document");
-    return mapDocument(row);
-  });
+  );
 }
 async function deleteDocumentFromBase(db, input) {
-  await withRlsContext(db, { accountId: input.accountId, workspaceId: input.workspaceId }, async (scopedDb) => {
-    const [document] = await scopedDb.select().from(schema.documents).where(and(eq(schema.documents.workspaceId, input.workspaceId), eq(schema.documents.id, input.documentId))).limit(1);
-    if (!document) {
-      throw new Error(`Document not found: ${input.documentId}`);
-    }
-    if (document.baseId !== input.baseId) {
-      throw new Error(`Document not found: ${input.documentId}`);
+  await withRlsContext(
+    db,
+    { accountId: input.accountId, workspaceId: input.workspaceId },
+    async (scopedDb) => {
+      const [document] = await scopedDb.select().from(schema.documents).where(
+        and(
+          eq(schema.documents.workspaceId, input.workspaceId),
+          eq(schema.documents.id, input.documentId)
+        )
+      ).limit(1);
+      if (!document) {
+        throw new Error(`Document not found: ${input.documentId}`);
+      }
+      if (document.baseId !== input.baseId) {
+        throw new Error(`Document not found: ${input.documentId}`);
+      }
+      await scopedDb.delete(schema.documents).where(
+        and(
+          eq(schema.documents.workspaceId, input.workspaceId),
+          eq(schema.documents.id, input.documentId)
+        )
+      );
     }
-    await scopedDb.delete(schema.documents).where(and(eq(schema.documents.workspaceId, input.workspaceId), eq(schema.documents.id, input.documentId)));
-  });
+  );
 }
 async function listDocuments(db, workspaceId, baseId) {
   return await withWorkspaceRls(db, workspaceId, async (scopedDb) => {
-    const rows = await scopedDb.select().from(schema.documents).where(and(eq(schema.documents.workspaceId, workspaceId), eq(schema.documents.baseId, baseId))).orderBy(asc(schema.documents.createdAt));
+    const rows = await scopedDb.select().from(schema.documents).where(
+      and(eq(schema.documents.workspaceId, workspaceId), eq(schema.documents.baseId, baseId))
+    ).orderBy(asc(schema.documents.createdAt));
     return rows.map(mapDocument);
   });
 }
 async function getDocument(db, workspaceId, documentId) {
   return await withWorkspaceRls(db, workspaceId, async (scopedDb) => {
-    const [row] = await scopedDb.select().from(schema.documents).where(and(eq(schema.documents.workspaceId, workspaceId), eq(schema.documents.id, documentId))).limit(1);
+    const [row] = await scopedDb.select().from(schema.documents).where(
+      and(eq(schema.documents.workspaceId, workspaceId), eq(schema.documents.id, documentId))
+    ).limit(1);
     return row ? mapDocument(row) : null;
   });
 }
@@ -289,7 +324,9 @@ async function queueDocumentForReindex(db, workspaceId, documentId) {
       status: "queued",
       error: null,
       updatedAt: /* @__PURE__ */ new Date()
-    }).where(and(eq(schema.documents.workspaceId, workspaceId), eq(schema.documents.id, documentId))).returning();
+    }).where(
+      and(eq(schema.documents.workspaceId, workspaceId), eq(schema.documents.id, documentId))
+    ).returning();
     if (!row) throw new Error(`Document not found: ${documentId}`);
     return mapDocument(row);
   });
@@ -298,7 +335,9 @@ async function indexDocumentNow(db, objectStorage, workspaceId, documentId, serv
   const [document] = await withWorkspaceRls(
     db,
     workspaceId,
-    async (scopedDb) => await scopedDb.select().from(schema.documents).where(and(eq(schema.documents.workspaceId, workspaceId), eq(schema.documents.id, documentId))).limit(1)
+    async (scopedDb) => await scopedDb.select().from(schema.documents).where(
+      and(eq(schema.documents.workspaceId, workspaceId), eq(schema.documents.id, documentId))
+    ).limit(1)
   );
   if (!document) throw new Error(`Document not found: ${documentId}`);
   const file = await requireReadyFile(db, workspaceId, document.fileId);
@@ -308,7 +347,9 @@ async function indexDocumentNow(db, objectStorage, workspaceId, documentId, serv
       parser: services.parser.name,
       error: null,
       updatedAt: /* @__PURE__ */ new Date()
-    }).where(and(eq(schema.documents.workspaceId, workspaceId), eq(schema.documents.id, documentId)));
+    }).where(
+      and(eq(schema.documents.workspaceId, workspaceId), eq(schema.documents.id, documentId))
+    );
   });
   try {
     const bytes = await objectStorage.getFileBytes(file);
@@ -322,44 +363,66 @@ async function indexDocumentNow(db, objectStorage, workspaceId, documentId, serv
     });
     const embeddings = await services.embedder.embedMany(chunks.map((chunk) => chunk.text));
     if (embeddings.length !== chunks.length) {
-      throw new Error(`Embedding provider returned ${embeddings.length} embeddings for ${chunks.length} chunks`);
+      throw new Error(
+        `Embedding provider returned ${embeddings.length} embeddings for ${chunks.length} chunks`
+      );
     }
-    await withWorkspaceRls(db, workspaceId, async (scopedDb) => await scopedDb.transaction(async (tx) => {
-      await tx.delete(schema.documentChunks).where(and(eq(schema.documentChunks.workspaceId, workspaceId), eq(schema.documentChunks.documentId, documentId)));
-      if (chunks.length > 0) {
-        await tx.insert(schema.documentChunks).values(chunks.map((chunk, index) => ({
-          accountId: document.accountId,
-          workspaceId: document.workspaceId,
-          documentId,
-          baseId: document.baseId,
-          fileId: file.id,
-          chunkIndex: index,
-          text: chunk.text,
-          metadata: {
-            ...chunk.metadata,
-            documentTitle: document.title,
-            sourceKind: document.sourceKind,
-            sourceUri: document.sourceUri,
-            sourceExternalId: document.sourceExternalId,
-            sourceTitle: document.sourceTitle,
-            sourceAuthor: document.sourceAuthor,
-            sourceCreatedAt: document.sourceCreatedAt?.toISOString() ?? null,
-            sourceUpdatedAt: document.sourceUpdatedAt?.toISOString() ?? null,
-            sourceVersion: document.sourceVersion,
-            aclTags: document.aclTags
-          },
-          embedding: validateEmbedding(embeddings[index] ?? [], services.embedder.dimensions, services.embedder.model),
-          embeddingModel: services.embedder.model
-        })));
-      }
-      await tx.update(schema.documents).set({
-        status: "ready",
-        parser: services.parser.name,
-        chunkCount: chunks.length,
-        error: null,
-        updatedAt: /* @__PURE__ */ new Date()
-      }).where(and(eq(schema.documents.workspaceId, workspaceId), eq(schema.documents.id, documentId)));
-    }));
+    await withWorkspaceRls(
+      db,
+      workspaceId,
+      async (scopedDb) => await scopedDb.transaction(async (tx) => {
+        await tx.delete(schema.documentChunks).where(
+          and(
+            eq(schema.documentChunks.workspaceId, workspaceId),
+            eq(schema.documentChunks.documentId, documentId)
+          )
+        );
+        if (chunks.length > 0) {
+          await tx.insert(schema.documentChunks).values(
+            chunks.map((chunk, index) => ({
+              accountId: document.accountId,
+              workspaceId: document.workspaceId,
+              documentId,
+              baseId: document.baseId,
+              fileId: file.id,
+              chunkIndex: index,
+              text: chunk.text,
+              metadata: {
+                ...chunk.metadata,
+                documentTitle: document.title,
+                sourceKind: document.sourceKind,
+                sourceUri: document.sourceUri,
+                sourceExternalId: document.sourceExternalId,
+                sourceTitle: document.sourceTitle,
+                sourceAuthor: document.sourceAuthor,
+                sourceCreatedAt: document.sourceCreatedAt?.toISOString() ?? null,
+                sourceUpdatedAt: document.sourceUpdatedAt?.toISOString() ?? null,
+                sourceVersion: document.sourceVersion,
+                aclTags: document.aclTags
+              },
+              embedding: validateEmbedding(
+                embeddings[index] ?? [],
+                services.embedder.dimensions,
+                services.embedder.model
+              ),
+              embeddingModel: services.embedder.model
+            }))
+          );
+        }
+        await tx.update(schema.documents).set({
+          status: "ready",
+          parser: services.parser.name,
+          chunkCount: chunks.length,
+          error: null,
+          updatedAt: /* @__PURE__ */ new Date()
+        }).where(
+          and(
+            eq(schema.documents.workspaceId, workspaceId),
+            eq(schema.documents.id, documentId)
+          )
+        );
+      })
+    );
   } catch (error) {
     const [failed] = await withWorkspaceRls(
       db,
@@ -368,7 +431,9 @@ async function indexDocumentNow(db, objectStorage, workspaceId, documentId, serv
         status: "failed",
         error: error instanceof Error ? error.message : String(error),
         updatedAt: /* @__PURE__ */ new Date()
-      }).where(and(eq(schema.documents.workspaceId, workspaceId), eq(schema.documents.id, documentId))).returning()
+      }).where(
+        and(eq(schema.documents.workspaceId, workspaceId), eq(schema.documents.id, documentId))
+      ).returning()
     );
     if (!failed) throw error;
     return mapDocument(failed);
@@ -389,10 +454,13 @@ async function searchDocuments(db, input, services = createDocumentServices()) {
       if (mode === "vector") {
         throw error;
       }
-      console.warn("document hybrid search vector component failed; falling back to keyword search", {
-        workspaceId: input.workspaceId,
-        error: error instanceof Error ? error.message : String(error)
-      });
+      console.warn(
+        "document hybrid search vector component failed; falling back to keyword search",
+        {
+          workspaceId: input.workspaceId,
+          error: error instanceof Error ? error.message : String(error)
+        }
+      );
     }
   }
   if (mode === "keyword" || mode === "hybrid") {
@@ -458,10 +526,12 @@ async function keywordSearchDocuments(db, input, limit) {
       sourceVersion: schema.documents.sourceVersion,
       aclTags: schema.documents.aclTags,
       rank
-    }).from(schema.documentChunks).innerJoin(schema.documents, eq(schema.documentChunks.documentId, schema.documents.id)).where(and(
-      ...documentSearchConditions(input),
-      sql`to_tsvector('simple', ${schema.documentChunks.text}) @@ plainto_tsquery('simple', ${input.query})`
-    )).orderBy(desc(rank)).limit(limit)
+    }).from(schema.documentChunks).innerJoin(schema.documents, eq(schema.documentChunks.documentId, schema.documents.id)).where(
+      and(
+        ...documentSearchConditions(input),
+        sql`to_tsvector('simple', ${schema.documentChunks.text}) @@ plainto_tsquery('simple', ${input.query})`
+      )
+    ).orderBy(desc(rank)).limit(limit)
   );
   return rows.map((row) => ({
     ...mapSearchRowBase(row, input.workspaceId),
@@ -491,7 +561,13 @@ async function getDocumentChunk(db, workspaceId, chunkId) {
       sourceUpdatedAt: schema.documents.sourceUpdatedAt,
       sourceVersion: schema.documents.sourceVersion,
       aclTags: schema.documents.aclTags
-    }).from(schema.documentChunks).innerJoin(schema.documents, eq(schema.documentChunks.documentId, schema.documents.id)).where(and(eq(schema.documentChunks.workspaceId, workspaceId), eq(schema.documentChunks.id, chunkId), eq(schema.documents.status, "ready"))).limit(1)
+    }).from(schema.documentChunks).innerJoin(schema.documents, eq(schema.documentChunks.documentId, schema.documents.id)).where(
+      and(
+        eq(schema.documentChunks.workspaceId, workspaceId),
+        eq(schema.documentChunks.id, chunkId),
+        eq(schema.documents.status, "ready")
+      )
+    ).limit(1)
   );
   if (!row) return null;
   return {
@@ -576,7 +652,9 @@ function combinedSearchScore(mode, vectorScore, keywordScore, matchType) {
   const keyword = keywordScore ?? 0;
   if (mode === "vector") return roundScore(vector);
   if (mode === "keyword") return roundScore(keyword);
-  return roundScore(Math.min(1, 0.65 * vector + 0.35 * keyword + (matchType === "hybrid" ? 0.1 : 0)));
+  return roundScore(
+    Math.min(1, 0.65 * vector + 0.35 * keyword + (matchType === "hybrid" ? 0.1 : 0))
+  );
 }
 function normalizeKeywordScore(rank) {
   if (!Number.isFinite(rank) || rank <= 0) {
@@ -637,7 +715,9 @@ async function requireReadyFile(db, workspaceId, fileId) {
 }
 function validateEmbedding(values, dimensions, model) {
   if (values.length !== dimensions) {
-    throw new Error(`Embedding model ${model} returned ${values.length} dimensions; expected ${dimensions}`);
+    throw new Error(
+      `Embedding model ${model} returned ${values.length} dimensions; expected ${dimensions}`
+    );
   }
   if (values.some((value) => !Number.isFinite(value))) {
     throw new Error(`Embedding model ${model} returned non-finite values`);