Composio powers 1000+ toolkits, tool search, context management, authentication, and a sandboxed workbench to help you build AI agents that turn intent into action.
| 1 | /** |
| 2 | * Filters the combined page tree to show only the selected API version. |
| 3 | * v3.1 pages are at /reference/{page} and /reference/api-reference/{tag}/{op} |
| 4 | * v3.0 pages are at /reference/v3/{page} and /reference/v3/api-reference/{tag}/{op} |
| 5 | * |
| 6 | * For v3.1: hide the V3 folder entirely. |
| 7 | * For v3.0: lift V3 folder contents to the top, hide v3.1-only nodes. |
| 8 | */ |
| 9 | |
| 10 | interface PageTreeNode { |
| 11 | type: 'page' | 'folder' | 'separator'; |
| 12 | name?: unknown; |
| 13 | url?: string; |
| 14 | children?: PageTreeNode[]; |
| 15 | index?: PageTreeNode; |
| 16 | } |
| 17 | |
| 18 | interface PageTreeRoot { |
| 19 | name: unknown; |
| 20 | children: PageTreeNode[]; |
| 21 | } |
| 22 | |
| 23 | /** |
| 24 | * API-reference tags that we intentionally hide on our side even though the |
| 25 | * upstream OpenAPI spec (from hermes) still includes them. Matched by tag slug. |
| 26 | * |
| 27 | * Hiding happens in two places that must stay in sync: |
| 28 | * - `scripts/generate-api-index.ts` skips generating (and deletes) their |
| 29 | * `index.mdx` overview pages. |
| 30 | * - `filterHiddenTags` (below) drops their folders/pages from the reference |
| 31 | * page tree so the fumadocs-openapi operation pages disappear from the |
| 32 | * sidebar, llms.txt walk, and search. |
| 33 | */ |
| 34 | export const HIDDEN_API_TAGS: ReadonlySet<string> = new Set([ |
| 35 | 'consumer', |
| 36 | 'invite-codes', |
| 37 | 'authentication', |
| 38 | ]); |
| 39 | |
| 40 | /** True if a URL points at a hidden tag's pages (v3.1 or v3.0). */ |
| 41 | export function isHiddenApiTagUrl(url: string): boolean { |
| 42 | for (const tag of HIDDEN_API_TAGS) { |
| 43 | if ( |
| 44 | url.startsWith(`/reference/api-reference/${tag}/`) || |
| 45 | url === `/reference/api-reference/${tag}` || |
| 46 | url.startsWith(`/reference/v3/api-reference/${tag}/`) || |
| 47 | url === `/reference/v3/api-reference/${tag}` |
| 48 | ) { |
| 49 | return true; |
| 50 | } |
| 51 | } |
| 52 | return false; |
| 53 | } |
| 54 | |
| 55 | /** True if a node (page or folder) belongs entirely to a hidden tag. */ |
| 56 | function isHiddenTagNode(node: PageTreeNode): boolean { |
| 57 | if (node.type === 'page' && typeof node.url === 'string') { |
| 58 | return isHiddenApiTagUrl(node.url); |
| 59 | } |
| 60 | if (node.type === 'folder') { |
| 61 | if (node.index && isHiddenTagNode(node.index)) return true; |
| 62 | // A folder whose every child is hidden (and has at least one) is itself hidden. |
| 63 | const children = node.children ?? []; |
| 64 | if (children.length > 0 && children.every(isHiddenTagNode)) return true; |
| 65 | } |
| 66 | return false; |
| 67 | } |
| 68 | |
| 69 | /** Recursively drops folders/pages whose tag slug is in HIDDEN_API_TAGS. */ |
| 70 | function filterHiddenTags(nodes: PageTreeNode[]): PageTreeNode[] { |
| 71 | return nodes |
| 72 | .filter(node => !isHiddenTagNode(node)) |
| 73 | .map(node => |
| 74 | node.type === 'folder' && node.children |
| 75 | ? { ...node, children: filterHiddenTags(node.children) } |
| 76 | : node |
| 77 | ); |
| 78 | } |
| 79 | |
| 80 | function isV3Node(node: PageTreeNode): boolean { |
| 81 | if (node.type === 'page' && typeof node.url === 'string') { |
| 82 | return node.url.startsWith('/reference/v3/') || node.url === '/reference/v3'; |
| 83 | } |
| 84 | if (node.type === 'folder') { |
| 85 | if (node.index && isV3Node(node.index)) return true; |
| 86 | return node.children?.some(isV3Node) ?? false; |
| 87 | } |
| 88 | return false; |
| 89 | } |
| 90 | |
| 91 | /** Checks if a folder contains v3.1 API reference pages (URLs under /reference/api-reference/). */ |
| 92 | function isV31ApiFolder(node: PageTreeNode): boolean { |
| 93 | if (node.type !== 'folder') return false; |
| 94 | const hasV31ApiPage = (n: PageTreeNode): boolean => { |
| 95 | if (n.type === 'page' && typeof n.url === 'string') { |
| 96 | return n.url.startsWith('/reference/api-reference/'); |
| 97 | } |
| 98 | if (n.type === 'folder') { |
| 99 | if (n.index && hasV31ApiPage(n.index)) return true; |
| 100 | return n.children?.some(hasV31ApiPage) ?? false; |
| 101 | } |
| 102 | return false; |
| 103 | }; |
| 104 | if (node.index && hasV31ApiPage(node.index)) return true; |
| 105 | return node.children?.some(hasV31ApiPage) ?? false; |
| 106 | } |
| 107 | |
| 108 | export function prepareTree<T extends PageTreeRoot>(tree: T, version: string): T { |
| 109 | // Drop intentionally-hidden tags (consumer, invite-codes) from the whole tree |
| 110 | // first, so neither version surfaces their operation pages. |
| 111 | const children = filterHiddenTags(tree.children as PageTreeNode[]); |
| 112 | |
| 113 | if (version === '3.1') { |
| 114 | // Just hide the V3 folder |
| 115 | return { |
| 116 | ...tree, |
| 117 | children: children.filter(node => !isV3Node(node)), |
| 118 | }; |
| 119 | } |
| 120 | |
| 121 | // v3.0: lift V3 folder contents, keep version-independent folders (SDK Reference, Meta Tools) |
| 122 | const v3Folder = children.find(node => node.type === 'folder' && isV3Node(node)); |
| 123 | |
| 124 | // Nodes that should appear in both versions (exclude v3 nodes, v3.1 API Reference folder, |
| 125 | // and top-level pages which are version-specific — both versions have their own copies) |
| 126 | const sharedNodes = children.filter( |
| 127 | node => node.type !== 'page' && !isV3Node(node) && !isV31ApiFolder(node) |
| 128 | ); |
| 129 | |
| 130 | if (v3Folder?.children) { |
| 131 | // Include the folder's index page (v3/index.mdx → overview) which fumadocs |
| 132 | // stores in .index rather than .children |
| 133 | const indexPage = v3Folder.index ? [v3Folder.index] : []; |
| 134 | return { ...tree, children: [...indexPage, ...v3Folder.children, ...sharedNodes] }; |
| 135 | } |
| 136 | |
| 137 | return { ...tree, children: [...children.filter(isV3Node), ...sharedNodes] }; |
| 138 | } |