devlensio 0.4.2 → 0.4.4

package/dist/parser/index.test.js

@@ -296,24 +296,144 @@ describe("parseRepo", () => {
         expect(nodeModuleNode).toBeUndefined();
         deleteFakeRepo(repoPath);
     });
-    it("should ignore test files", () => {
+    it("should ignore config files", () => {
         const repoPath = createFakeRepo({
             "src/Button.tsx": `export function Button() { return <button />; }`,
-            "src/Button.test.tsx": `export function FakeButton() { return <button />; }`,
+            "next.config.ts": `export default {};`,
         });
         const result = parseRepo(repoPath);
-        const testNode = result.nodes.find((n) => n.filePath.includes(".test."));
-        expect(testNode).toBeUndefined();
+        const configNode = result.nodes.find((n) => n.filePath.includes(".config."));
+        expect(configNode).toBeUndefined();
         deleteFakeRepo(repoPath);
     });
-    it("should ignore config files", () => {
+    // ─── Object-literal Method Extraction ──────────────────────────────────────
+    it("should detect an arrow-function value in an object literal", () => {
         const repoPath = createFakeRepo({
-            "src/Button.tsx": `export function Button() { return <button />; }`,
-            "next.config.ts": `export default {};`,
+            "src/cfg.ts": `
+        export const cfg = {
+          load: () => doThing(),
+        };
+      `,
         });
         const result = parseRepo(repoPath);
-        const configNode = result.nodes.find((n) => n.filePath.includes(".config."));
-        expect(configNode).toBeUndefined();
+        const fn = result.nodes.find((n) => n.name === "cfg.load");
+        expect(fn).toBeDefined();
+        expect(fn?.type).toBe("FUNCTION");
+        expect(fn?.startLine).toBeGreaterThanOrEqual(1);
+        expect(fn?.endLine).toBeGreaterThanOrEqual(fn.startLine);
+        expect(fn?.metadata.calls).toContain("doThing");
+        deleteFakeRepo(repoPath);
+    });
+    it("should detect an async arrow value calling axios (nested object)", () => {
+        const repoPath = createFakeRepo({
+            "src/providersConfig.js": `
+        export const providersConfig = {
+          zoro: {
+            streamingData: async (episodeId) => {
+              const response = await axios.get('/api/v2/zoro/watch/' + episodeId);
+              return response.data;
+            },
+          },
+        };
+      `,
+        });
+        const result = parseRepo(repoPath);
+        const fn = result.nodes.find((n) => n.name === "providersConfig.zoro.streamingData");
+        expect(fn).toBeDefined();
+        expect(fn?.type).toBe("FUNCTION");
+        expect(fn?.metadata.isAsync).toBe(true);
+        expect((fn?.metadata.apiCalls).length).toBeGreaterThan(0);
+        deleteFakeRepo(repoPath);
+    });
+    it("should detect a function-expression value in an object literal", () => {
+        const repoPath = createFakeRepo({
+            "src/cfg.ts": `
+        export const cfg = {
+          run: function (x) { return helper(x); },
+        };
+      `,
+        });
+        const result = parseRepo(repoPath);
+        const fn = result.nodes.find((n) => n.name === "cfg.run");
+        expect(fn).toBeDefined();
+        expect(fn?.type).toBe("FUNCTION");
+        expect(fn?.metadata.params).toContain("x");
+        deleteFakeRepo(repoPath);
+    });
+    it("should detect a shorthand method in an object literal", () => {
+        const repoPath = createFakeRepo({
+            "src/cfg.ts": `
+        export const cfg = {
+          fetchData(url) { return fetch(url); },
+        };
+      `,
+        });
+        const result = parseRepo(repoPath);
+        const fn = result.nodes.find((n) => n.name === "cfg.fetchData");
+        expect(fn).toBeDefined();
+        expect(fn?.type).toBe("FUNCTION");
+        deleteFakeRepo(repoPath);
+    });
+    it("should detect a concise-body arrow value in an object literal", () => {
+        const repoPath = createFakeRepo({
+            "src/cfg.ts": `
+        export const cfg = {
+          pick: (u) => u.id,
+        };
+      `,
+        });
+        const result = parseRepo(repoPath);
+        const fn = result.nodes.find((n) => n.name === "cfg.pick");
+        expect(fn).toBeDefined();
+        expect(fn?.type).toBe("FUNCTION");
+        deleteFakeRepo(repoPath);
+    });
+    it("should detect a function in a two-level nested object", () => {
+        const repoPath = createFakeRepo({
+            "src/api.ts": `
+        export const api = {
+          v2: {
+            users: {
+              list: async () => fetch('/api/users'),
+            },
+          },
+        };
+      `,
+        });
+        const result = parseRepo(repoPath);
+        const fn = result.nodes.find((n) => n.name === "api.v2.users.list");
+        expect(fn).toBeDefined();
+        expect(fn?.type).toBe("FUNCTION");
+        deleteFakeRepo(repoPath);
+    });
+    it("should detect a function in an export-default object", () => {
+        const repoPath = createFakeRepo({
+            "src/handler.ts": `
+        export default {
+          handler: async () => fetch('/api/x'),
+        };
+      `,
+        });
+        const result = parseRepo(repoPath);
+        const fn = result.nodes.find((n) => n.name === "default.handler");
+        expect(fn).toBeDefined();
+        expect(fn?.type).toBe("FUNCTION");
+        deleteFakeRepo(repoPath);
+    });
+    it("should not double-extract or collide with top-level hooks", () => {
+        const repoPath = createFakeRepo({
+            "src/mix.ts": `
+        export const useThing = () => { return 1; };
+        export const cfg = {
+          a: () => doA(),
+        };
+      `,
+        });
+        const result = parseRepo(repoPath);
+        const objMethods = result.nodes.filter((n) => n.name === "cfg.a");
+        expect(objMethods.length).toBe(1);
+        const hook = result.nodes.find((n) => n.name === "useThing");
+        expect(hook?.type).toBe("HOOK");
         deleteFakeRepo(repoPath);
     });
 });

package/dist/pipeline/index.js

@@ -123,6 +123,32 @@ function routesToCodeNodes(routes, repoPath) {
                 },
             });
         }
+        else if (route.type === "REACT_ROUTER_ROUTE") {
+            // React Router / TanStack / wouter route — a single ROUTE node, no method.
+            const name = route.urlPath;
+            const id = `${relativeFilePath}::${name}`;
+            nodes.push({
+                id,
+                name,
+                type: "ROUTE",
+                filePath: relativeFilePath,
+                startLine: 1,
+                endLine: 1,
+                parentFile: `file::${relativeFilePath}`,
+                metadata: {
+                    urlPath: route.urlPath,
+                    httpMethod: null,
+                    isDynamic: route.isDynamic,
+                    isCatchAll: route.isCatchAll,
+                    isGroupRoute: route.isGroupRoute,
+                    params: route.params ?? [],
+                    routeNodeType: "REACT_ROUTER_ROUTE",
+                    framework: "react-router",
+                    routeKind: "react-router",
+                    rendersComponent: route.rendersComponent, // resolved to a HANDLES edge in routeEdge.ts
+                },
+            });
+        }
         else {
             // Next.js RouteNode — one node per HTTP method for API routes,
             // one node for page/layout/etc.

package/dist/types.d.ts

@@ -17,7 +17,7 @@ export interface ProjectFingerprint {
     databases: DatabaseLibrary[];
     rawDependencies: Record<string, string>;
 }
-export type RouteNodeType = "PAGE" | "LAYOUT" | "API_ROUTE" | "LOADING" | "ERROR" | "MIDDLEWARE" | "NOT_FOUND";
+export type RouteNodeType = "PAGE" | "LAYOUT" | "API_ROUTE" | "LOADING" | "ERROR" | "MIDDLEWARE" | "NOT_FOUND" | "REACT_ROUTER_ROUTE";
 export interface RouteNode {
     type: RouteNodeType;
     nodeId?: string;
@@ -29,6 +29,7 @@ export interface RouteNode {
     layoutPath?: string;
     params?: string[];
     httpMethods?: string[];
+    rendersComponent?: string;
 }
 export interface BackendRouteNode {
     type: "BACKEND_ROUTE";
@@ -69,7 +70,7 @@ export interface CodeNode {
     score?: Number;
     metadata: Record<string, unknown>;
 }
-export type EdgeType = "CALLS" | "IMPORTS" | "READS_FROM" | "WRITES_TO" | "PROP_PASS" | "EMITS" | "LISTENS" | "WRAPPED_BY" | "GUARDS" | "HANDLES" | "TESTS" | "USES" | "NEXTJS_API_CALL";
+export type EdgeType = "CALLS" | "IMPORTS" | "READS_FROM" | "WRITES_TO" | "PROP_PASS" | "EMITS" | "LISTENS" | "WRAPPED_BY" | "GUARDS" | "HANDLES" | "TESTS" | "USES" | "NEXTJS_API_CALL" | "NAVIGATES_TO";
 export interface CodeEdge {
     from: string;
     to: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devlensio",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "description": "Codebase intelligence engine for TypeScript/JavaScript/Reactjs/Nextjs repositories.",
   "type": "module",
   "main": "./dist/index.js",