fix: fetch missing Notion descendants after normalizing nested shape

notion-client's getPage walks the raw recordMap to find missing
descendants, but Notion's API now wraps blocks in an extra value.value
layer — so the walk reads block.value.content (undefined) and stops at
the root. Toggle children and other nested blocks were never fetched,
which is why toggles expanded to empty content.

Extract a fetchNotionPage helper that disables the broken traversal,
normalizes the shape, then manually walks the tree and fetches missing
ids via getBlocks until complete.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: hkirat

apps/web/app/pdf/[...pdfId]/page.tsx

@@ -6,6 +6,7 @@ import { getProblem, getTrack } from "../../../components/utils";
 import { LessonView } from "../../../components/LessonView";
 import { getServerSession } from "next-auth";
 import { authOptions } from "../../../lib/auth";
+import { fetchNotionPage } from "../../../lib/notion";
 
 const notion = new NotionAPI();
 
@@ -24,10 +25,9 @@ export default async function TrackComponent({ params }: { params: { pdfId: stri
   }
 
   if (problemDetails?.notionDocId && trackDetails?.problems) {
-    // notionRecordMaps = await notion.getPage(problemDetails.notionDocId);
     notionRecordMaps = await Promise.all(
       trackDetails.problems.map(
-        async (problem: any) => await notion.getPage((await getProblem(problem.id))?.notionDocId!)
+        async (problem: any) => fetchNotionPage(notion, (await getProblem(problem.id))?.notionDocId!)
       )
     );
   }

apps/web/app/tracks/[...trackIds]/page.tsx

@@ -3,28 +3,11 @@ import { NotionAPI } from "notion-client";
 import { redirect, notFound } from "next/navigation";
 import { getProblem, getTrack } from "../../../components/utils";
 import { LessonView } from "../../../components/LessonView";
+import { fetchNotionPage } from "../../../lib/notion";
 
 const notion = new NotionAPI();
 export const dynamic = "force-dynamic";
 
-// Normalize Notion record map to handle nested value.value structure
-// and remove blocks with no actual data (role-only entries)
-function normalizeRecordMap(recordMap: any) {
-  if (!recordMap?.block) return recordMap;
-  const normalizedBlock: any = {};
-  for (const [key, block] of Object.entries(recordMap.block) as any) {
-    if (block?.value?.value) {
-      // Fix double-nested value.value structure
-      normalizedBlock[key] = { ...block, value: block.value.value };
-    } else if (block?.value?.type) {
-      // Normal block with type - keep as is
-      normalizedBlock[key] = block;
-    }
-    // Skip blocks with no type (role-only entries like { value: { role: "none" } })
-  }
-  return { ...recordMap, block: normalizedBlock };
-}
-
 // Dynamic Metadata
 export async function generateMetadata({ params }: { params: { trackIds: string[] } }) {
   const trackId = params.trackIds[0] || "";
@@ -78,8 +61,7 @@ export default async function TrackComponent({ params }: { params: { trackIds: s
   }
 
   if (problemDetails?.notionDocId) {
-    const rawRecordMap = await notion.getPage(problemDetails.notionDocId);
-    notionRecordMap = normalizeRecordMap(rawRecordMap);
+    notionRecordMap = await fetchNotionPage(notion, problemDetails.notionDocId);
   }
 
   if (trackDetails && problemDetails) {

apps/web/lib/notion.ts

@@ -0,0 +1,58 @@
+import { NotionAPI } from "notion-client";
+
+function normalizeRecordMap(recordMap: any) {
+  if (!recordMap?.block) return recordMap;
+  const normalizedBlock: any = {};
+  for (const [key, block] of Object.entries(recordMap.block) as any) {
+    if (!block?.value) continue;
+    const value = block.value;
+    if (!value.type && value.value?.type) {
+      normalizedBlock[key] = { ...block, value: value.value };
+    } else if (value.type) {
+      normalizedBlock[key] = block;
+    }
+  }
+  return { ...recordMap, block: normalizedBlock };
+}
+
+function collectContentBlockIds(recordMap: any): string[] {
+  const blocks = recordMap?.block;
+  if (!blocks) return [];
+  const rootId = Object.keys(blocks)[0];
+  if (!rootId) return [];
+
+  const seen = new Set<string>();
+  const walk = (id: string) => {
+    if (seen.has(id)) return;
+    seen.add(id);
+    const value = blocks[id]?.value;
+    if (!value) return;
+    if (id !== rootId && (value.type === "page" || value.type === "collection_view_page")) return;
+    if (Array.isArray(value.content)) {
+      for (const childId of value.content) walk(childId);
+    }
+    const refId = value.format?.transclusion_reference_pointer?.id;
+    if (refId) walk(refId);
+  };
+  walk(rootId);
+  return Array.from(seen);
+}
+
+// Notion's API now returns blocks in a nested `value.value` shape. notion-client's
+// built-in missing-block traversal walks the raw map and can't see past that nesting,
+// so toggle children (and other nested descendants) never get fetched. We disable its
+// traversal, normalize the shape, then manually fetch descendants until the tree is
+// complete.
+export async function fetchNotionPage(notion: NotionAPI, pageId: string): Promise<any> {
+  let recordMap: any = await notion.getPage(pageId, { fetchMissingBlocks: false });
+  recordMap = normalizeRecordMap(recordMap);
+
+  for (let i = 0; i < 10; i++) {
+    const missing = collectContentBlockIds(recordMap).filter((id) => !recordMap.block[id]);
+    if (!missing.length) break;
+    const fetched = await notion.getBlocks(missing).then((r: any) => r.recordMap.block);
+    recordMap = normalizeRecordMap({ ...recordMap, block: { ...recordMap.block, ...fetched } });
+  }
+
+  return recordMap;
+}