/**

* Java Framework Resolver

*

* Handles Spring Boot and general Java patterns.

*/

import { Node } from '../../types';

import { FrameworkResolver, UnresolvedRef, ResolvedRef, ResolutionContext } from '../types';

import { stripCommentsForRegex } from '../strip-comments';

export const springResolver: FrameworkResolver = {

name: 'spring',

languages: ['java'],

detect(context: ResolutionContext): boolean {

// Check for pom.xml with Spring

const pomXml = context.readFile('pom.xml');

if (pomXml && (pomXml.includes('spring-boot') || pomXml.includes('springframework'))) {

return true;

}

// Check for build.gradle with Spring

const buildGradle = context.readFile('build.gradle');

if (buildGradle && (buildGradle.includes('spring-boot') || buildGradle.includes('springframework'))) {

return true;

}

const buildGradleKts = context.readFile('build.gradle.kts');

if (buildGradleKts && (buildGradleKts.includes('spring-boot') || buildGradleKts.includes('springframework'))) {

return true;

}

// Check for Spring annotations in Java files

const allFiles = context.getAllFiles();

for (const file of allFiles) {

if (file.endsWith('.java')) {

const content = context.readFile(file);

if (content && (

content.includes('@SpringBootApplication') ||

content.includes('@RestController') ||

content.includes('@Service') ||

content.includes('@Repository')

)) {

return true;

}

}

}

return false;

},

resolve(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null {

// Pattern 1: Service references (dependency injection)

if (ref.referenceName.endsWith('Service')) {

const result = resolveByNameAndKind(ref.referenceName, SERVICE_KINDS, SERVICE_DIRS, context);

if (result) {

return {

original: ref,

targetNodeId: result,

confidence: 0.85,

resolvedBy: 'framework',

};

}

}

// Pattern 2: Repository references

if (ref.referenceName.endsWith('Repository')) {

const result = resolveByNameAndKind(ref.referenceName, SERVICE_KINDS, REPO_DIRS, context);

if (result) {

return {

original: ref,

targetNodeId: result,

confidence: 0.85,

resolvedBy: 'framework',

};

}

}

// Pattern 3: Controller references

if (ref.referenceName.endsWith('Controller')) {

const result = resolveByNameAndKind(ref.referenceName, CLASS_KINDS, CONTROLLER_DIRS, context);

if (result) {

return {

original: ref,

targetNodeId: result,

confidence: 0.85,

resolvedBy: 'framework',

};

}

}

// Pattern 4: Entity/Model references

if (/^[A-Z][a-zA-Z]+$/.test(ref.referenceName)) {

const result = resolveByNameAndKind(ref.referenceName, CLASS_KINDS, ENTITY_DIRS, context);

if (result) {

return {

original: ref,

targetNodeId: result,

confidence: 0.7,

resolvedBy: 'framework',

};

}

}

// Pattern 5: Component references

if (ref.referenceName.endsWith('Component') || ref.referenceName.endsWith('Config')) {

const result = resolveByNameAndKind(ref.referenceName, CLASS_KINDS, COMPONENT_DIRS, context);

if (result) {

return {

original: ref,

targetNodeId: result,

confidence: 0.8,

resolvedBy: 'framework',

};

}

}

return null;

},

extract(filePath, content) {

if (!filePath.endsWith('.java')) return { nodes: [], references: [] };

const nodes: Node[] = [];

const references: UnresolvedRef[] = [];

const now = Date.now();

const safe = stripCommentsForRegex(content, 'java');

// @GetMapping("/path"), @PostMapping(value = "/path"), @RequestMapping("/path")

const mappingRegex = /@(GetMapping|PostMapping|PutMapping|PatchMapping|DeleteMapping|RequestMapping)\s*\(\s*(?:value\s*=\s*|path\s*=\s*)?["']([^"']+)["'][^)]*\)/g;

let match: RegExpExecArray | null;

while ((match = mappingRegex.exec(safe)) !== null) {

const [, mappingName, routePath] = match;

const line = safe.slice(0, match.index).split('\n').length;

const method =

mappingName === 'RequestMapping' ? 'ANY' : mappingName!.replace(/Mapping$/, '').toUpperCase();

const routeNode: Node = {

id: `route:${filePath}:${line}:${method}:${routePath}`,

kind: 'route',

name: `${method} ${routePath}`,

qualifiedName: `${filePath}::route:${routePath}`,

filePath,

startLine: line,

endLine: line,

startColumn: 0,

endColumn: match[0].length,

language: 'java',

updatedAt: now,

};

nodes.push(routeNode);

// Look for the next public/private/protected method after the annotation

const tail = safe.slice(match.index + match[0].length);

const methodMatch = tail.match(/\b(?:public|private|protected)\s+[^;{]*?\s+(\w+)\s*\(/);

if (methodMatch) {

references.push({

fromNodeId: routeNode.id,

referenceName: methodMatch[1]!,

referenceKind: 'references',

line,

column: 0,

filePath,

language: 'java',

});

}

}

return { nodes, references };

},

};

// Directory patterns

const SERVICE_DIRS = ['/service/', '/services/'];

const REPO_DIRS = ['/repository/', '/repositories/'];

const CONTROLLER_DIRS = ['/controller/', '/controllers/'];

const ENTITY_DIRS = ['/entity/', '/entities/', '/model/', '/models/', '/domain/'];

const COMPONENT_DIRS = ['/component/', '/components/', '/config/'];

const CLASS_KINDS = new Set(['class']);

const SERVICE_KINDS = new Set(['class', 'interface']);

/**

* Resolve a symbol by name using indexed queries instead of scanning all files.

*/

function resolveByNameAndKind(

name: string,

kinds: Set<string>,

preferredDirPatterns: string[],

context: ResolutionContext,

): string | null {

const candidates = context.getNodesByName(name);

if (candidates.length === 0) return null;

const kindFiltered = candidates.filter((n) => kinds.has(n.kind));

if (kindFiltered.length === 0) return null;

// Prefer candidates in framework-conventional directories

const preferred = kindFiltered.filter((n) =>

preferredDirPatterns.some((d) => n.filePath.includes(d))

);

if (preferred.length > 0) return preferred[0]!.id;

// Fall back to any match

return kindFiltered[0]!.id;

}