gitnexus 1.6.6-rc.81 → 1.6.6-rc.83

package/dist/core/group/extractors/http-patterns/java.js

@@ -3,8 +3,11 @@ import { compilePatterns, runCompiledPatterns, unquoteLiteral, } from '../tree-s
 /**
  * Java HTTP plugin. Handles:
  *   - Spring `@RequestMapping` class prefixes + `@(Get|Post|...)Mapping` method annotations
- *   - Spring `RestTemplate.getForObject/...`, `WebClient.method(HttpMethod.X, ...)`
+ *   - Spring `RestTemplate.getForObject/...`, `exchange(...)`
+ *   - Spring `WebClient.method(HttpMethod.X, ...)`, `WebClient.get().uri(...)`
  *   - OkHttp `new Request.Builder().url("...")`
+ *   - OpenFeign interfaces with Spring MVC method annotations
+ *   - Java / Apache HttpClient literal request construction
  *
  * The plugin runs two pattern bundles: one to collect class-level
  * `@RequestMapping` prefixes keyed by the enclosing class node, and a
@@ -62,6 +65,52 @@ const SPRING_CLASS_PREFIX_PATTERNS = compilePatterns({
         },
     ],
 });
+// ─── Consumer: OpenFeign interface-level prefixes ───────────────────
+// Feign's `name`/`value` attributes identify a service, not an HTTP path,
+// so only `path` is used as a URL prefix. `@RequestMapping` on a Feign
+// interface is also common and does carry a path prefix.
+const FEIGN_INTERFACE_PREFIX_PATTERNS = compilePatterns({
+    name: 'java-feign-interface-prefix',
+    language: Java,
+    patterns: [
+        {
+            meta: {},
+            query: `
+        (interface_declaration
+          (modifiers
+            (annotation
+              name: (identifier) @ann (#eq? @ann "FeignClient")
+              arguments: (annotation_argument_list
+                (element_value_pair
+                  key: (identifier) @key (#eq? @key "path")
+                  value: (string_literal) @prefix))))) @interface
+      `,
+        },
+        {
+            meta: {},
+            query: `
+        (interface_declaration
+          (modifiers
+            (annotation
+              name: (identifier) @ann (#eq? @ann "RequestMapping")
+              arguments: (annotation_argument_list (string_literal) @prefix)))) @interface
+      `,
+        },
+        {
+            meta: {},
+            query: `
+        (interface_declaration
+          (modifiers
+            (annotation
+              name: (identifier) @ann (#eq? @ann "RequestMapping")
+              arguments: (annotation_argument_list
+                (element_value_pair
+                  key: (identifier) @key (#match? @key "^(path|value)$")
+                  value: (string_literal) @prefix))))) @interface
+      `,
+        },
+    ],
+});
 // ─── Provider: Spring @(Get|Post|...)Mapping method annotations ───────
 // Same dual-pattern approach: positional vs named argument. The named
 // pattern restricts the annotation member name to `path`/`value` to
@@ -104,6 +153,8 @@ const SPRING_METHOD_ROUTE_PATTERNS = compilePatterns({
 // RestTemplate.put → PUT
 // RestTemplate.delete → DELETE
 // RestTemplate.patchForObject → PATCH
+// Source-scan only: receiver must be named exactly `restTemplate`.
+// Fields, `this.restTemplate`, aliases, and other injection names are deferred.
 const REST_TEMPLATE_TO_HTTP = {
     getForObject: 'GET',
     getForEntity: 'GET',
@@ -128,22 +179,46 @@ const REST_TEMPLATE_PATTERNS = compilePatterns({
         },
     ],
 });
-// ─── Consumer: Spring WebClient — webClient.method(HttpMethod.X, "path") ─
-const WEB_CLIENT_PATTERNS = compilePatterns({
-    name: 'java-web-client',
+const REST_TEMPLATE_EXCHANGE_PATTERNS = compilePatterns({
+    name: 'java-rest-template-exchange',
     language: Java,
     patterns: [
         {
-            meta: {},
+            meta: { framework: 'spring-rest-template' },
             query: `
         (method_invocation
-          object: (identifier) @obj (#eq? @obj "webClient")
-          name: (identifier) @method (#eq? @method "method")
+          object: (identifier) @obj (#eq? @obj "restTemplate")
+          name: (identifier) @method (#eq? @method "exchange")
           arguments: (argument_list
+            . (string_literal) @path
             (field_access
               object: (identifier) @httpMethodCls (#eq? @httpMethodCls "HttpMethod")
-              field: (identifier) @http_method)
-            (string_literal) @path))
+              field: (identifier) @http_method)))
+      `,
+        },
+    ],
+});
+const WEB_CLIENT_SHORT_TO_HTTP = {
+    get: 'GET',
+    post: 'POST',
+    put: 'PUT',
+    delete: 'DELETE',
+    patch: 'PATCH',
+};
+const WEB_CLIENT_SHORT_FORM_PATTERNS = compilePatterns({
+    name: 'java-web-client-short-form',
+    language: Java,
+    patterns: [
+        {
+            meta: {},
+            query: `
+        (method_invocation
+          object: (method_invocation
+            object: (identifier) @obj (#eq? @obj "webClient")
+            name: (identifier) @verb (#match? @verb "^(get|post|put|delete|patch)$")
+            arguments: (argument_list))
+          name: (identifier) @uri_method (#eq? @uri_method "uri")
+          arguments: (argument_list . (string_literal) @path))
       `,
         },
     ],
@@ -168,6 +243,51 @@ const OK_HTTP_PATTERNS = compilePatterns({
         },
     ],
 });
+const JAVA_HTTP_CLIENT_PATTERNS = compilePatterns({
+    name: 'java-http-client',
+    language: Java,
+    patterns: [
+        {
+            meta: {},
+            query: `
+        (method_invocation
+          object: (method_invocation
+            object: (method_invocation
+              object: (identifier) @builderCls (#eq? @builderCls "HttpRequest")
+              name: (identifier) @newBuilder (#eq? @newBuilder "newBuilder")
+              arguments: (argument_list))
+            name: (identifier) @uri_method (#eq? @uri_method "uri")
+            arguments: (argument_list
+              (method_invocation
+                object: (identifier) @uriCls (#eq? @uriCls "URI")
+                name: (identifier) @create (#eq? @create "create")
+                arguments: (argument_list . (string_literal) @path))))
+          name: (identifier) @http_method (#match? @http_method "^(GET|POST|PUT|DELETE)$"))
+      `,
+        },
+    ],
+});
+const APACHE_HTTP_CLIENT_TO_HTTP = {
+    HttpGet: 'GET',
+    HttpPost: 'POST',
+    HttpPut: 'PUT',
+    HttpDelete: 'DELETE',
+    HttpPatch: 'PATCH',
+};
+const APACHE_HTTP_CLIENT_PATTERNS = compilePatterns({
+    name: 'java-apache-http-client',
+    language: Java,
+    patterns: [
+        {
+            meta: {},
+            query: `
+        (object_creation_expression
+          type: (type_identifier) @type (#match? @type "^Http(Get|Post|Put|Delete|Patch)$")
+          arguments: (argument_list . (string_literal) @path))
+      `,
+        },
+    ],
+});
 /**
  * Find the nearest enclosing class_declaration ancestor for a node, or
  * null if the node is top-level. Tree-sitter's SyntaxNode.parent walks
@@ -182,6 +302,32 @@ function findEnclosingClass(node) {
     }
     return null;
 }
+function findEnclosingInterface(node) {
+    let cur = node.parent;
+    while (cur) {
+        if (cur.type === 'interface_declaration')
+            return cur;
+        cur = cur.parent;
+    }
+    return null;
+}
+function hasAnnotation(node, annotationName) {
+    for (const child of node.namedChildren) {
+        if (child.type !== 'modifiers')
+            continue;
+        for (const modifier of child.namedChildren) {
+            if (modifier.type !== 'annotation')
+                continue;
+            const nameNode = modifier.childForFieldName('name');
+            if (!nameNode)
+                continue;
+            const simpleName = nameNode.text.split('.').pop();
+            if (nameNode.text === annotationName || simpleName === annotationName)
+                return true;
+        }
+    }
+    return false;
+}
 /**
  * Join a class-level prefix and a method-level path into a single URL
  * path. Mirrors the semantics of the original regex implementation:
@@ -211,6 +357,16 @@ export const JAVA_HTTP_PLUGIN = {
             if (prefix !== null)
                 prefixByClassId.set(classNode.id, prefix);
         }
+        const feignPrefixByInterfaceId = new Map();
+        for (const match of runCompiledPatterns(FEIGN_INTERFACE_PREFIX_PATTERNS, tree)) {
+            const prefixNode = match.captures.prefix;
+            const interfaceNode = match.captures.interface;
+            if (!prefixNode || !interfaceNode)
+                continue;
+            const prefix = unquoteLiteral(prefixNode.text);
+            if (prefix !== null && !feignPrefixByInterfaceId.has(interfaceNode.id))
+                feignPrefixByInterfaceId.set(interfaceNode.id, prefix);
+        }
         for (const match of runCompiledPatterns(SPRING_METHOD_ROUTE_PATTERNS, tree)) {
             const annNode = match.captures.ann;
             const pathNode = match.captures.path;
@@ -224,6 +380,20 @@ export const JAVA_HTTP_PLUGIN = {
             const rawPath = unquoteLiteral(pathNode.text);
             if (rawPath === null)
                 continue;
+            const enclosingInterface = findEnclosingInterface(methodNode);
+            if (enclosingInterface && hasAnnotation(enclosingInterface, 'FeignClient')) {
+                const prefix = feignPrefixByInterfaceId.get(enclosingInterface.id) ?? '';
+                const fullPath = joinPath(prefix, rawPath);
+                out.push({
+                    role: 'consumer',
+                    framework: 'openfeign',
+                    method: httpMethod,
+                    path: fullPath,
+                    name: nameNode?.text ?? null,
+                    confidence: 0.7,
+                });
+                continue;
+            }
             const enclosingClass = findEnclosingClass(methodNode);
             const prefix = enclosingClass ? (prefixByClassId.get(enclosingClass.id) ?? '') : '';
             const fullPath = joinPath(prefix, rawPath);
@@ -257,8 +427,7 @@ export const JAVA_HTTP_PLUGIN = {
                 confidence: 0.7,
             });
         }
-        // ─── Consumers: WebClient.method(HttpMethod.X, "path") ──────────
-        for (const match of runCompiledPatterns(WEB_CLIENT_PATTERNS, tree)) {
+        for (const match of runCompiledPatterns(REST_TEMPLATE_EXCHANGE_PATTERNS, tree)) {
             const httpMethodNode = match.captures.http_method;
             const pathNode = match.captures.path;
             if (!httpMethodNode || !pathNode)
@@ -268,13 +437,37 @@ export const JAVA_HTTP_PLUGIN = {
                 continue;
             out.push({
                 role: 'consumer',
-                framework: 'spring-web-client',
+                framework: 'spring-rest-template',
                 method: httpMethodNode.text.toUpperCase(),
                 path,
                 name: null,
                 confidence: 0.7,
             });
         }
+        // ─── Consumers: WebClient.get().uri("path") short form ─────────
+        // Source-scan only: receiver must be named exactly `webClient`.
+        // The real long-form chain `webClient.method(HttpMethod.X).uri("/x")`
+        // needs multi-hop chain analysis and is intentionally deferred.
+        for (const match of runCompiledPatterns(WEB_CLIENT_SHORT_FORM_PATTERNS, tree)) {
+            const verbNode = match.captures.verb;
+            const pathNode = match.captures.path;
+            if (!verbNode || !pathNode)
+                continue;
+            const httpMethod = WEB_CLIENT_SHORT_TO_HTTP[verbNode.text];
+            if (!httpMethod)
+                continue;
+            const path = unquoteLiteral(pathNode.text);
+            if (path === null)
+                continue;
+            out.push({
+                role: 'consumer',
+                framework: 'spring-web-client',
+                method: httpMethod,
+                path,
+                name: null,
+                confidence: 0.7,
+            });
+        }
         // ─── Consumers: OkHttp Request.Builder().url("path") ────────────
         for (const match of runCompiledPatterns(OK_HTTP_PATTERNS, tree)) {
             const pathNode = match.captures.path;
@@ -292,6 +485,47 @@ export const JAVA_HTTP_PLUGIN = {
                 confidence: 0.7,
             });
         }
+        // ─── Consumers: Java HttpClient request builder ─────────────────
+        // Java's builder exposes GET/POST/PUT/DELETE helpers. PATCH uses
+        // `.method("PATCH", body)`, which is intentionally deferred.
+        for (const match of runCompiledPatterns(JAVA_HTTP_CLIENT_PATTERNS, tree)) {
+            const httpMethodNode = match.captures.http_method;
+            const pathNode = match.captures.path;
+            if (!httpMethodNode || !pathNode)
+                continue;
+            const path = unquoteLiteral(pathNode.text);
+            if (path === null)
+                continue;
+            out.push({
+                role: 'consumer',
+                framework: 'java-http-client',
+                method: httpMethodNode.text.toUpperCase(),
+                path,
+                name: null,
+                confidence: 0.65,
+            });
+        }
+        // ─── Consumers: Apache HttpClient request constructors ──────────
+        for (const match of runCompiledPatterns(APACHE_HTTP_CLIENT_PATTERNS, tree)) {
+            const typeNode = match.captures.type;
+            const pathNode = match.captures.path;
+            if (!typeNode || !pathNode)
+                continue;
+            const httpMethod = APACHE_HTTP_CLIENT_TO_HTTP[typeNode.text];
+            if (!httpMethod)
+                continue;
+            const path = unquoteLiteral(pathNode.text);
+            if (path === null)
+                continue;
+            out.push({
+                role: 'consumer',
+                framework: 'apache-http-client',
+                method: httpMethod,
+                path,
+                name: null,
+                confidence: 0.65,
+            });
+        }
         return out;
     },
 };