Composio powers 1000+ toolkits, tool search, context management, authentication, and a sandboxed workbench to help you build AI agents that turn intent into action.

next
ts 138 lines 4.86 KB
Raw
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 }