no tree brnahc isolation, run splitting on the whole tree

Author: florianbgt

packages/app/src/components/MethodBadge.tsx

@@ -5,7 +5,7 @@ export default function MethodBadge(props: { method: string }) {
   const [color, setColor] = useState<BadgeProps["color"]>("gray");
 
   useEffect(() => {
-    switch (props.method.toLocaleLowerCase()) {
+    switch (props.method.toLowerCase()) {
       case "get":
         setColor("green");
         break;

packages/cli/src/api/split.ts

@@ -12,39 +12,38 @@ import { z } from "zod";
 import { GroupMap } from "../helper/types";
 
 export function split(payload: z.infer<typeof splitSchema>) {
-  let groupIndex = 0;
+  console.time("split command");
   const groupMap: GroupMap = {};
 
   // Get the dependency tree
   const tree = getDependencyTree(payload.entrypointPath);
 
-  payload.outputDir = payload.outputDir || path.dirname(payload.entrypointPath);
+  const outputDir = payload.outputDir || path.dirname(payload.entrypointPath);
 
   // Clean up and prepare the output directory
-  cleanupOutputDir(payload.outputDir);
-  createOutputDir(payload.outputDir);
+  cleanupOutputDir(outputDir);
+  createOutputDir(outputDir);
 
   // Iterate over the tree and get endpoints
   const endpoints = getEndpontsFromTree(tree);
 
   // Get groups from the endpoints
   const groups = getGroupsFromEndpoints(endpoints);
 
-  // Process each endpoint for splitting
-  for (const group of groups) {
-    createSplit(
-      group,
-      payload.outputDir,
-      payload.entrypointPath,
-      groupMap,
-      groupIndex,
-    );
-    groupIndex++;
-  }
+  // Process each group for splitting
+  groups.forEach((group, index) => {
+    // Clone the tree to avoid mutation of the original tree
+    const treeClone = structuredClone(tree);
+    createSplit(treeClone, group, outputDir, payload.entrypointPath, index);
+  });
 
   // Store the processed annotations in the output directory
-  const annotationFilePath = path.join(payload.outputDir, "annotations.json");
+  groups.forEach((group, index) => {
+    groupMap[index] = group;
+  });
+  const annotationFilePath = path.join(outputDir, "annotations.json");
   fs.writeFileSync(annotationFilePath, JSON.stringify(groupMap, null, 2));
 
+  console.timeEnd("split command");
   return { groups, success: true };
 }

packages/cli/src/api/sync.ts

@@ -2,8 +2,8 @@ import { z } from "zod";
 import { syncSchema } from "./helpers/validation";
 import fs from "fs";
 import {
-  getNanoApiAnnotationFromCommentValue,
-  replaceCommentFromAnnotation,
+  parseNanoApiAnnotation,
+  updateCommentFromAnnotation,
 } from "../helper/annotations";
 import {
   getDependencyTree,
@@ -12,6 +12,7 @@ import {
 import Parser from "tree-sitter";
 import { getParserLanguageFromFile } from "../helper/treeSitter";
 import { replaceIndexesFromSourceCode } from "../helper/cleanup";
+import { getAnnotationNodes } from "../helper/languages/javascript/annotations";
 
 export function sync(payload: z.infer<typeof syncSchema>) {
   const tree = getDependencyTree(payload.entrypointPath);
@@ -48,35 +49,26 @@ export function sync(payload: z.infer<typeof syncSchema>) {
       text: string;
     }[] = [];
 
-    function traverse(node: Parser.SyntaxNode) {
-      if (node.type === "comment") {
-        const comment = node.text;
-
-        const annotation = getNanoApiAnnotationFromCommentValue(comment);
-
-        if (annotation) {
-          if (
-            annotation.path === endpoint.path &&
-            annotation.method === endpoint.method
-          ) {
-            annotation.group = endpoint.group;
-            const updatedComment = replaceCommentFromAnnotation(
-              comment,
-              annotation,
-            );
-
-            indexesToReplace.push({
-              startIndex: node.startIndex,
-              endIndex: node.endIndex,
-              text: updatedComment,
-            });
-          }
-        }
+    const annotationNodes = getAnnotationNodes(parser, tree.rootNode);
+    annotationNodes.forEach((node) => {
+      const annotation = parseNanoApiAnnotation(node.text);
+      if (
+        annotation.path === endpoint.path &&
+        annotation.method === endpoint.method
+      ) {
+        annotation.group = endpoint.group;
+        const updatedComment = updateCommentFromAnnotation(
+          node.text,
+          annotation,
+        );
+
+        indexesToReplace.push({
+          startIndex: node.startIndex,
+          endIndex: node.endIndex,
+          text: updatedComment,
+        });
       }
-      node.children.forEach((child) => traverse(child));
-    }
-
-    traverse(tree.rootNode);
+    });
 
     sourceCode = replaceIndexesFromSourceCode(sourceCode, indexesToReplace);
 

packages/cli/src/commands/split.ts

@@ -13,7 +13,6 @@ export default function splitCommandHandler(
   entrypointPath: string, // Path to the entrypoint file
   outputDir: string, // Path to the output directory
 ) {
-  let groupIndex = 0;
   const groupMap: GroupMap = {};
 
   const tree = getDependencyTree(entrypointPath);
@@ -27,13 +26,17 @@ export default function splitCommandHandler(
   // Get groups from the endpoints
   const groups = getGroupsFromEndpoints(endpoints);
 
-  // Process each endpoint for splitting
-  for (const group of groups) {
-    createSplit(group, outputDir, entrypointPath, groupMap, groupIndex);
-    groupIndex++;
-  }
+  // Process each group for splitting
+  groups.forEach((group, index) => {
+    // Clone the tree to avoid mutation of the original tree
+    const treeClone = structuredClone(tree);
+    createSplit(treeClone, group, outputDir, entrypointPath, index);
+  });
 
   // Store the processed annotations in the output directory
+  groups.forEach((group, index) => {
+    groupMap[index] = group;
+  });
   const annotationFilePath = path.join(outputDir, "annotations.json");
   fs.writeFileSync(annotationFilePath, JSON.stringify(groupMap, null, 2));
 }

packages/cli/src/helper/annotations.ts

@@ -1,8 +1,8 @@
-import { NanoAPIAnnotation } from "./types";
+import { Group, NanoAPIAnnotation } from "./types";
 
-export function getNanoApiAnnotationFromCommentValue(comment: string) {
+export function parseNanoApiAnnotation(value: string) {
   const nanoapiRegex = /@nanoapi|((method|path|group):([^ ]+))/g;
-  const matches = comment.match(nanoapiRegex);
+  const matches = value.match(nanoapiRegex);
   // remove first match, which is the @nanoapi identifier
   matches?.shift();
 
@@ -16,10 +16,41 @@ export function getNanoApiAnnotationFromCommentValue(comment: string) {
     }, {} as NanoAPIAnnotation);
   }
 
-  return null;
+  throw new Error("Could not parse annotation");
 }
 
-export function replaceCommentFromAnnotation(
+export function isAnnotationInGroup(
+  group: Group,
+  annotation: NanoAPIAnnotation,
+) {
+  // check if annotation has a method (actual endpoint)
+  if (annotation.method) {
+    const endpoint = group.endpoints.find(
+      (endpoint) =>
+        endpoint.method === annotation.method &&
+        endpoint.path === annotation.path,
+    );
+
+    if (endpoint) {
+      return true;
+    }
+
+    return false;
+  }
+
+  // if annotation has no method, we treat it as a module that contains other endpoints
+  const endpoints = group.endpoints.filter((endpoint) =>
+    endpoint.path.startsWith(annotation.path),
+  );
+
+  if (endpoints.length > 0) {
+    return true;
+  }
+
+  return false;
+}
+
+export function updateCommentFromAnnotation(
   comment: string,
   annotation: NanoAPIAnnotation,
 ) {