20260513 mindmap优化01

wolai-frontend/convex/_utils/documentVisibility.ts

@@ -0,0 +1,117 @@
+export type DocumentVisibilityScope = "private" | "shared" | "public" | null | undefined;
+
+export type DocumentVisibilityRecord = {
+  id: string;
+  user_id?: string | null;
+  parent_id?: string | null;
+  access_scope?: DocumentVisibilityScope;
+  deleted_at?: string | null;
+};
+
+export type DocumentVisibilityShareRecord = {
+  document_id: string;
+  include_descendants?: boolean | null;
+};
+
+type BuildVisibleDocumentIdsInput = {
+  userId: string;
+  docs: readonly DocumentVisibilityRecord[];
+  directShares: readonly DocumentVisibilityShareRecord[];
+  directGroupShares: readonly DocumentVisibilityShareRecord[];
+  includeDeletedDocuments?: boolean;
+};
+
+function normalizeDocumentId(value: string | null | undefined): string | null {
+  const trimmed = String(value ?? "").trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+function buildInheritedShareMap(
+  shares: readonly DocumentVisibilityShareRecord[],
+): Map<string, { includeDescendants: boolean }> {
+  const result = new Map<string, { includeDescendants: boolean }>();
+  for (const share of shares) {
+    const documentId = normalizeDocumentId(share.document_id);
+    if (!documentId) continue;
+    const existing = result.get(documentId);
+    if (!existing) {
+      result.set(documentId, {
+        includeDescendants: Boolean(share.include_descendants),
+      });
+      continue;
+    }
+    existing.includeDescendants = existing.includeDescendants || Boolean(share.include_descendants);
+  }
+  return result;
+}
+
+function canAccessByInheritedShare(input: {
+  docId: string;
+  parentById: Map<string, string | null>;
+  directShareMap: Map<string, { includeDescendants: boolean }>;
+  cache: Map<string, boolean>;
+}): boolean {
+  const cached = input.cache.get(input.docId);
+  if (typeof cached === "boolean") return cached;
+  if (input.directShareMap.has(input.docId)) {
+    input.cache.set(input.docId, true);
+    return true;
+  }
+  let parentId = input.parentById.get(input.docId) ?? null;
+  for (let depth = 0; depth < 60 && parentId; depth += 1) {
+    const parentShare = input.directShareMap.get(parentId);
+    if (parentShare && parentShare.includeDescendants) {
+      input.cache.set(input.docId, true);
+      return true;
+    }
+    parentId = input.parentById.get(parentId) ?? null;
+  }
+  input.cache.set(input.docId, false);
+  return false;
+}
+
+export function buildVisibleDocumentIds(input: BuildVisibleDocumentIdsInput): Set<string> {
+  const candidateDocs = input.includeDeletedDocuments
+    ? [...input.docs]
+    : input.docs.filter((doc) => doc.deleted_at == null);
+
+  const parentById = new Map<string, string | null>();
+  for (const doc of candidateDocs) {
+    parentById.set(doc.id, normalizeDocumentId(doc.parent_id) ?? null);
+  }
+
+  const directShares = buildInheritedShareMap(input.directShares);
+  const directGroupShares = buildInheritedShareMap(input.directGroupShares);
+  const shareAccessCache = new Map<string, boolean>();
+  const groupAccessCache = new Map<string, boolean>();
+  const visible = new Set<string>();
+
+  for (const doc of candidateDocs) {
+    if (String(doc.user_id ?? "") === input.userId) {
+      visible.add(doc.id);
+      continue;
+    }
+    if (doc.access_scope === "public") {
+      visible.add(doc.id);
+      continue;
+    }
+    if (
+      canAccessByInheritedShare({
+        docId: doc.id,
+        parentById,
+        directShareMap: directShares,
+        cache: shareAccessCache,
+      }) ||
+      canAccessByInheritedShare({
+        docId: doc.id,
+        parentById,
+        directShareMap: directGroupShares,
+        cache: groupAccessCache,
+      })
+    ) {
+      visible.add(doc.id);
+    }
+  }
+
+  return visible;
+}