@opengeni/documents 0.6.9-canary.0 → 0.8.2-canary.0

package/dist/index.d.ts

@@ -117,6 +117,14 @@ export type RunDocumentDefaultCollectionBackfillInput = RunDocumentDefaultCollec
     actorSubjectId: string;
     accountAdminAuthorization: DocumentAccountAdminAuthorization;
 };
+export type DocumentMigrationAuditInput = {
+    accountId: string;
+    workspaceId: string;
+    actorSubjectId: string;
+    accountAdminAuthorization: DocumentAccountAdminAuthorization;
+    limit?: number | undefined;
+    cursor?: string | undefined;
+};
 export type AgentDocumentAuthorityContext = {
     sessionId: string;
     attemptId: string;
@@ -158,6 +166,7 @@ export type DocumentSearchInput = {
     limit?: number | undefined;
     mode?: DocumentSearchMode | undefined;
     sourceKinds?: KnowledgeSourceKind[] | undefined;
+    authorityKinds?: DocumentAuthorityKind[] | undefined;
     aclTags?: string[] | undefined;
     access?: DocumentAccessFilter | undefined;
 };
@@ -321,6 +330,87 @@ export declare function runDocumentDefaultCollectionBackfill(db: Database, input
     adoptedCount: number;
     completedAt: string | null;
 }>;
+export declare function listDocumentDefaultCollectionBackfillRuns(db: Database, input: DocumentMigrationAuditInput): Promise<{
+    runs: {
+        runId: string;
+        status: "completed" | "running";
+        lastWorkspaceId: string | null;
+        processedCount: number;
+        createdCount: number;
+        adoptedCount: number;
+        completedAt: string | null;
+        actorSubjectId: string;
+        startedAt: string;
+        updatedAt: string;
+    }[];
+    hasMore: boolean;
+    nextCursor: string | null;
+}>;
+export declare function getDocumentDefaultCollectionBackfillAudit(db: Database, input: DocumentMigrationAuditInput & {
+    runId: string;
+    operationCursor?: string | undefined;
+    receiptCursor?: string | undefined;
+}): Promise<{
+    run: {
+        runId: string;
+        status: "completed" | "running";
+        lastWorkspaceId: string | null;
+        processedCount: number;
+        createdCount: number;
+        adoptedCount: number;
+        completedAt: string | null;
+        actorSubjectId: string;
+        startedAt: string;
+        updatedAt: string;
+    };
+    operations: {
+        operationId: string;
+        result: {
+            runId: string;
+            operationId: string;
+            status: "completed" | "running";
+            lastWorkspaceId: string | null;
+            processedCount: number;
+            createdCount: number;
+            adoptedCount: number;
+            completedAt: string | null;
+        };
+        createdAt: string;
+    }[];
+    receipts: {
+        workspaceId: string;
+        baseId: string;
+        outcome: "adopted" | "created";
+        createdAt: string;
+    }[];
+    operationsHasMore: boolean;
+    operationsNextCursor: string | null;
+    receiptsHasMore: boolean;
+    receiptsNextCursor: string | null;
+}>;
+export declare function listOrganizationDocumentAuthorityReclassifications(db: Database, input: DocumentMigrationAuditInput): Promise<{
+    receipts: {
+        operationId: string;
+        documentId: string;
+        previousAuthority: {
+            kind: "organization" | "personal" | "workspace";
+            workspaceId: string | null;
+            subjectId: string | null;
+            authorityId: string | null;
+        };
+        authority: {
+            kind: "organization" | "personal" | "workspace";
+            workspaceId: string | null;
+            subjectId: string | null;
+            authorityId: string | null;
+        };
+        createdAt: string;
+        actorSubjectId: string;
+        requestWorkspaceId: string;
+    }[];
+    hasMore: boolean;
+    nextCursor: string | null;
+}>;
 export declare function reclassifyDocumentAuthority(db: Database, input: ReclassifyDocumentAuthorityInput): Promise<{
     operationId: string;
     documentId: string;

package/dist/index.js

@@ -3,7 +3,14 @@ import {
   KnowledgeProviderCitation,
   DocumentAuthorityReclassification,
   ListDocumentAuthorityReclassificationsResponse,
-  DocumentDefaultCollectionBackfill
+  DocumentDefaultCollectionBackfill,
+  DocumentDefaultCollectionBackfillAudit,
+  DocumentDefaultCollectionBackfillOperationAudit,
+  DocumentDefaultCollectionBackfillReceiptAudit,
+  DocumentDefaultCollectionBackfillRunAudit,
+  ListDocumentDefaultCollectionBackfillRunsResponse,
+  ListOrganizationDocumentAuthorityReclassificationsResponse,
+  OrganizationDocumentAuthorityReclassification
 } from "@opengeni/contracts";
 import {
   createPersonalDocumentAuthority,
@@ -740,6 +747,203 @@ async function runDocumentDefaultCollectionBackfill(db, input) {
     }
   );
 }
+async function listDocumentDefaultCollectionBackfillRuns(db, input) {
+  const limit = validateDocumentMigrationAuditLimit(input.limit);
+  const cursor = input.cursor ? decodeDocumentMigrationAuditCursor(input.cursor, ["backfill-runs", input.accountId], true) : null;
+  return await withDocumentAccountRls(
+    db,
+    input.accountId,
+    input.workspaceId,
+    { viewerSubjectId: input.actorSubjectId },
+    async (scopedDb) => {
+      const command = {
+        accountId: input.accountId,
+        workspaceId: input.workspaceId,
+        actorSubjectId: input.actorSubjectId,
+        accountAdminAuthorization: input.accountAdminAuthorization,
+        limit: limit + 1,
+        beforeStartedAt: cursor?.timestamp ?? null,
+        beforeRunId: cursor?.id ?? null
+      };
+      const rows = await scopedDb.execute(sql`
+        SELECT list_document_default_collection_backfill_runs(
+          ${JSON.stringify(command)}::jsonb
+        ) AS result
+      `);
+      const parsed = rows.map((row) => DocumentDefaultCollectionBackfillRunAudit.parse(row.result));
+      const hasMore = parsed.length > limit;
+      const runs = parsed.slice(0, limit);
+      const tail = hasMore ? runs.at(-1) : null;
+      return ListDocumentDefaultCollectionBackfillRunsResponse.parse({
+        runs,
+        hasMore,
+        nextCursor: tail ? encodeDocumentMigrationAuditCursor(["backfill-runs", input.accountId], {
+          timestamp: tail.startedAt,
+          id: tail.runId
+        }) : null
+      });
+    }
+  );
+}
+async function getDocumentDefaultCollectionBackfillAudit(db, input) {
+  const limit = validateDocumentMigrationAuditLimit(input.limit);
+  const operationCursor = input.operationCursor ? decodeDocumentMigrationAuditCursor(
+    input.operationCursor,
+    ["backfill-operations", input.accountId, input.runId],
+    true
+  ) : null;
+  const receiptCursor = input.receiptCursor ? decodeDocumentMigrationAuditCursor(
+    input.receiptCursor,
+    ["backfill-receipts", input.accountId, input.runId],
+    false
+  ) : null;
+  return await withDocumentAccountRls(
+    db,
+    input.accountId,
+    input.workspaceId,
+    { viewerSubjectId: input.actorSubjectId },
+    async (scopedDb) => {
+      const command = {
+        accountId: input.accountId,
+        workspaceId: input.workspaceId,
+        actorSubjectId: input.actorSubjectId,
+        accountAdminAuthorization: input.accountAdminAuthorization,
+        runId: input.runId,
+        limit,
+        operationBeforeCreatedAt: operationCursor?.timestamp ?? null,
+        operationBeforeId: operationCursor?.id ?? null,
+        receiptAfterWorkspaceId: receiptCursor?.id ?? null
+      };
+      const rows = await scopedDb.execute(sql`
+        SELECT get_document_default_collection_backfill_audit(
+          ${JSON.stringify(command)}::jsonb
+        ) AS result
+      `);
+      const raw = rows[0]?.result;
+      if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        throw new Error("document Default collection backfill audit returned no result");
+      }
+      const value = raw;
+      const run = DocumentDefaultCollectionBackfillRunAudit.parse(value.run);
+      const operations = Array.isArray(value.operations) ? value.operations.map(
+        (operation) => DocumentDefaultCollectionBackfillOperationAudit.parse(operation)
+      ) : [];
+      const receipts = Array.isArray(value.receipts) ? value.receipts.map(
+        (receipt) => DocumentDefaultCollectionBackfillReceiptAudit.parse(receipt)
+      ) : [];
+      const operationsHasMore = operations.length > limit;
+      const receiptsHasMore = receipts.length > limit;
+      const operationPage = operations.slice(0, limit);
+      const receiptPage = receipts.slice(0, limit);
+      const operationTail = operationsHasMore ? operationPage.at(-1) : null;
+      const receiptTail = receiptsHasMore ? receiptPage.at(-1) : null;
+      return DocumentDefaultCollectionBackfillAudit.parse({
+        run,
+        operations: operationPage,
+        receipts: receiptPage,
+        operationsHasMore,
+        operationsNextCursor: operationTail ? encodeDocumentMigrationAuditCursor(
+          ["backfill-operations", input.accountId, input.runId],
+          {
+            timestamp: operationTail.createdAt,
+            id: operationTail.operationId
+          }
+        ) : null,
+        receiptsHasMore,
+        receiptsNextCursor: receiptTail ? encodeDocumentMigrationAuditCursor(
+          ["backfill-receipts", input.accountId, input.runId],
+          { timestamp: null, id: receiptTail.workspaceId }
+        ) : null
+      });
+    }
+  );
+}
+async function listOrganizationDocumentAuthorityReclassifications(db, input) {
+  const limit = validateDocumentMigrationAuditLimit(input.limit);
+  const cursor = input.cursor ? decodeDocumentMigrationAuditCursor(
+    input.cursor,
+    ["organization-reclassifications", input.accountId],
+    true
+  ) : null;
+  return await withDocumentAccountRls(
+    db,
+    input.accountId,
+    input.workspaceId,
+    { viewerSubjectId: input.actorSubjectId },
+    async (scopedDb) => {
+      const command = {
+        accountId: input.accountId,
+        workspaceId: input.workspaceId,
+        actorSubjectId: input.actorSubjectId,
+        accountAdminAuthorization: input.accountAdminAuthorization,
+        limit: limit + 1,
+        beforeCreatedAt: cursor?.timestamp ?? null,
+        beforeOperationId: cursor?.id ?? null
+      };
+      const rows = await scopedDb.execute(sql`
+        SELECT list_organization_document_authority_reclassifications(
+          ${JSON.stringify(command)}::jsonb
+        ) AS result
+      `);
+      const parsed = rows.map(
+        (row) => OrganizationDocumentAuthorityReclassification.parse(row.result)
+      );
+      const hasMore = parsed.length > limit;
+      const receipts = parsed.slice(0, limit);
+      const tail = hasMore ? receipts.at(-1) : null;
+      return ListOrganizationDocumentAuthorityReclassificationsResponse.parse({
+        receipts,
+        hasMore,
+        nextCursor: tail ? encodeDocumentMigrationAuditCursor(
+          ["organization-reclassifications", input.accountId],
+          { timestamp: tail.createdAt, id: tail.operationId }
+        ) : null
+      });
+    }
+  );
+}
+function validateDocumentMigrationAuditLimit(value) {
+  const limit = value ?? 50;
+  if (!Number.isInteger(limit) || limit < 1 || limit > 100) {
+    throw new Error("document migration audit limit must be between 1 and 100");
+  }
+  return limit;
+}
+function documentMigrationAuditCursorScope(parts) {
+  return createHash("sha256").update(JSON.stringify(["document-migration-audit", 1, ...parts]), "utf8").digest("hex").slice(0, 32);
+}
+function encodeDocumentMigrationAuditCursor(parts, cursor) {
+  return Buffer.from(
+    JSON.stringify({
+      v: 1,
+      s: documentMigrationAuditCursorScope(parts),
+      t: cursor.timestamp,
+      i: cursor.id
+    }),
+    "utf8"
+  ).toString("base64url");
+}
+function decodeDocumentMigrationAuditCursor(value, parts, requireTimestamp) {
+  try {
+    if (!value || value.length > 1024) throw new Error("cursor length");
+    const bytes = Buffer.from(value, "base64url");
+    if (bytes.toString("base64url") !== value) throw new Error("cursor encoding");
+    const parsed = JSON.parse(bytes.toString("utf8"));
+    if (Object.keys(parsed).sort().join(",") !== "i,s,t,v" || parsed.v !== 1 || parsed.s !== documentMigrationAuditCursorScope(parts) || typeof parsed.i !== "string" || !/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu.test(
+      parsed.i
+    ) || (requireTimestamp ? typeof parsed.t !== "string" || !Number.isFinite(new Date(parsed.t).getTime()) : parsed.t !== null)) {
+      throw new Error("cursor payload");
+    }
+    return {
+      timestamp: typeof parsed.t === "string" ? parsed.t : null,
+      id: parsed.i
+    };
+  } catch (error) {
+    throw new Error("invalid document migration audit cursor", {
+      cause: error
+    });
+  }
+}
 async function reclassifyDocumentAuthority(db, input) {
   return await withDocumentAccountRls(
     db,
@@ -839,7 +1043,9 @@ function decodeDocumentAuthorityReclassificationCursor(value, scope) {
     }
     return { createdAt: parsed.t, operationId: parsed.i };
   } catch (error) {
-    throw new Error("invalid document authority receipt cursor", { cause: error });
+    throw new Error("invalid document authority receipt cursor", {
+      cause: error
+    });
   }
 }
 async function addDocumentToBase(db, input) {
@@ -1380,7 +1586,11 @@ async function curateDroppedDocument(db, services, document, parsed, file) {
     return updated2 ?? document;
   }
   const bases = await listDocumentBases(db, document.workspaceId);
-  const candidates = bases.filter((base) => base.id !== document.baseId).map((base) => ({ id: base.id, name: base.name, description: base.description }));
+  const candidates = bases.filter((base) => base.id !== document.baseId).map((base) => ({
+    id: base.id,
+    name: base.name,
+    description: base.description
+  }));
   const input = {
     text: parsed.text.slice(0, DOCUMENT_CURATION_MAX_INPUT_CHARS),
     filename: file.filename,
@@ -1519,6 +1729,7 @@ async function searchEffectiveDocuments(db, input, services = createDocumentServ
       limit: input.limit,
       mode: input.mode,
       sourceKinds: input.sourceKinds,
+      authorityKinds: input.authorityKinds,
       aclTags: input.aclTags,
       // Construct the lower-level access filter here instead of spreading the
       // caller input, so an untyped/legacy access override is always ignored.
@@ -1548,6 +1759,7 @@ async function searchEffectiveKnowledge(db, input, services = createDocumentServ
       ...input.baseIds ? { baseIds: input.baseIds } : {},
       ...input.mode ? { mode: input.mode } : {},
       ...input.sourceKinds ? { sourceKinds: input.sourceKinds } : {},
+      ...input.authorityKinds ? { authorityKinds: input.authorityKinds } : {},
       ...input.aclTags ? { aclTags: input.aclTags } : {},
       access
     },
@@ -1586,6 +1798,7 @@ async function searchEffectiveKnowledge(db, input, services = createDocumentServ
           ranked.map((result) => result.chunkId)
         ),
         eq(schema.documents.status, "ready"),
+        ...input.authorityKinds?.length ? [inArray(schema.documents.authorityKind, input.authorityKinds)] : [],
         ...documentAccessConditions(input.workspaceId, access)
       )
     )
@@ -1986,7 +2199,10 @@ async function browseEffectiveKnowledge(db, input) {
     access,
     async (scopedDb) => {
       if (parent) {
-        const [authorizedParent] = await scopedDb.select({ id: schema.documents.id, indexSequence: schema.documents.indexSequence }).from(schema.documents).where(
+        const [authorizedParent] = await scopedDb.select({
+          id: schema.documents.id,
+          indexSequence: schema.documents.indexSequence
+        }).from(schema.documents).where(
           and(
             eq(schema.documents.accountId, input.accountId),
             eq(schema.documents.id, parent.id),
@@ -1995,7 +2211,10 @@ async function browseEffectiveKnowledge(db, input) {
           )
         ).limit(1);
         if (!authorizedParent) {
-          return selectKnowledgeBrowseRecords({ entries: [], hasMoreAfterEntries: false });
+          return selectKnowledgeBrowseRecords({
+            entries: [],
+            hasMoreAfterEntries: false
+          });
         }
         if (authorizedParent.indexSequence === null) {
           throw new Error("ready knowledge document is missing its index revision");
@@ -2083,7 +2302,11 @@ function encodeKnowledgeBrowseCursor(scope, position) {
   if (position < 0n) throw new Error("knowledge browse cursor position is invalid");
   const version = knowledgeBrowseCursorVersion(scope);
   return Buffer.from(
-    JSON.stringify({ v: version, s: knowledgeBrowseCursorScope(scope), q: position.toString() }),
+    JSON.stringify({
+      v: version,
+      s: knowledgeBrowseCursorScope(scope),
+      q: position.toString()
+    }),
     "utf8"
   ).toString("base64url");
 }
@@ -2130,7 +2353,10 @@ function parseKnowledgeRecordId(value) {
     value
   );
   if (!match) throw new Error("invalid knowledge record id");
-  return { kind: match[1], id: match[2].toLowerCase() };
+  return {
+    kind: match[1],
+    id: match[2].toLowerCase()
+  };
 }
 function knowledgeDocumentRecord(document, citation = null, firstChunkId = null) {
   if (!document.indexedAt) throw new Error(`Ready document is missing indexed_at: ${document.id}`);
@@ -2547,6 +2773,9 @@ function documentSearchConditions(input, embeddingModel) {
   if (input.sourceKinds?.length) {
     conditions.push(inArray(schema.documents.sourceKind, input.sourceKinds));
   }
+  if (input.authorityKinds?.length) {
+    conditions.push(inArray(schema.documents.authorityKind, input.authorityKinds));
+  }
   const aclTags = cleanStringArray(input.aclTags);
   if (aclTags.length > 0) {
     conditions.push(sql`${schema.documents.aclTags} @> ${JSON.stringify(aclTags)}::jsonb`);
@@ -2909,6 +3138,7 @@ export {
   getDocument,
   getDocumentBase,
   getDocumentChunk,
+  getDocumentDefaultCollectionBackfillAudit,
   getDocumentForIndexing,
   getDocumentInventory,
   getDocumentOriginalFile,
@@ -2919,8 +3149,10 @@ export {
   listDocumentAuthorityReclassifications,
   listDocumentBases,
   listDocumentBasesEnsuringDefault,
+  listDocumentDefaultCollectionBackfillRuns,
   listDocuments,
   listEffectiveIndexedDocuments,
+  listOrganizationDocumentAuthorityReclassifications,
   moveDocumentToBase,
   parseCurationOutcome,
   parseDocumentBytes,