cgraphx 2.0.2 → 2.0.3

package/dist/core/code/engine/core/ingestion/languages/java/spring-aop.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attachJavaSpringAopMetadata = void 0;
+exports.captureJavaSpringAopFacts = captureJavaSpringAopFacts;
+const index_js_1 = require("../../../../../shared/index.js");
+const aop_js_1 = require("../../frameworks/spring/aop.js");
+const ast_helpers_js_1 = require("../../utils/ast-helpers.js");
+const capture_side_channel_js_1 = require("./capture-side-channel.js");
+const package_siblings_js_1 = require("./package-siblings.js");
+const spring_di_js_1 = require("./spring-di.js");
+function scopeId(filePath, node, kind) {
+    return (0, index_js_1.makeScopeId)({
+        filePath,
+        range: (0, ast_helpers_js_1.nodeToCapture)('@spring-aop.owner', node).range,
+        kind,
+    });
+}
+/**
+ * Capture Spring AOP syntax while Java's existing class traversal already has
+ * the AST node in hand. Import/FQN resolution and pointcut matching remain in
+ * the shared post-resolution layer.
+ */
+function captureJavaSpringAopFacts(classNode, filePath) {
+    const facts = [];
+    const classAnnotations = (0, spring_di_js_1.javaSpringAnnotationFacts)(classNode);
+    if ((0, aop_js_1.hasSpringAopRelevantAnnotation)(classAnnotations)) {
+        facts.push({
+            ownerScopeId: scopeId(filePath, classNode, 'Class'),
+            ownerKind: 'class',
+            annotations: classAnnotations,
+        });
+    }
+    const body = classNode.childForFieldName('body');
+    if (body === null)
+        return facts;
+    for (const member of body.namedChildren) {
+        if (member.type !== 'method_declaration')
+            continue;
+        const annotations = (0, spring_di_js_1.javaSpringAnnotationFacts)(member);
+        if (!(0, aop_js_1.hasSpringAopRelevantAnnotation)(annotations))
+            continue;
+        facts.push({
+            ownerScopeId: scopeId(filePath, member, 'Function'),
+            ownerKind: 'callable',
+            annotations,
+        });
+    }
+    return facts;
+}
+exports.attachJavaSpringAopMetadata = (0, aop_js_1.createSpringAopMetadataAttacher)({
+    getFacts: capture_side_channel_js_1.getJavaSpringAopFacts,
+    isPackageVisibilityIncomplete: package_siblings_js_1.isJavaPackageSiblingVisibilityIncomplete,
+});

package/dist/core/code/engine/core/ingestion/languages/java/spring-bean-metadata.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attachSpringBeanCandidateMetadata = void 0;
+const bean_candidates_js_1 = require("../../frameworks/spring/bean-candidates.js");
+const capture_side_channel_js_1 = require("./capture-side-channel.js");
+const package_siblings_js_1 = require("./package-siblings.js");
+/** Java wiring for the language-neutral Spring candidate engine. */
+exports.attachSpringBeanCandidateMetadata = (0, bean_candidates_js_1.createSpringBeanCandidateAttacher)({
+    getClassAnnotationFacts: capture_side_channel_js_1.getJavaClassAnnotationFacts,
+    isPackageVisibilityIncomplete: package_siblings_js_1.isJavaPackageSiblingVisibilityIncomplete,
+});

package/dist/core/code/engine/core/ingestion/languages/java/spring-conditionals.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attachJavaSpringConditionalMetadata = void 0;
+exports.captureJavaSpringConditionalFacts = captureJavaSpringConditionalFacts;
+const index_js_1 = require("../../../../../shared/index.js");
+const conditionals_js_1 = require("../../frameworks/spring/conditionals.js");
+const ast_helpers_js_1 = require("../../utils/ast-helpers.js");
+const capture_side_channel_js_1 = require("./capture-side-channel.js");
+const package_siblings_js_1 = require("./package-siblings.js");
+const spring_di_js_1 = require("./spring-di.js");
+function scopeId(filePath, node, kind) {
+    return (0, index_js_1.makeScopeId)({
+        filePath,
+        range: (0, ast_helpers_js_1.nodeToCapture)('@spring-condition.owner', node).range,
+        kind,
+    });
+}
+/**
+ * Capture Spring condition syntax while Java's existing class traversal already
+ * has the AST node in hand. Framework/FQN semantics are resolved later.
+ */
+function captureJavaSpringConditionalFacts(classNode, filePath) {
+    const facts = [];
+    const classAnnotations = (0, spring_di_js_1.javaSpringAnnotationFacts)(classNode);
+    if ((0, conditionals_js_1.hasSpringConditionalRelevantAnnotation)(classAnnotations)) {
+        facts.push({
+            ownerScopeId: scopeId(filePath, classNode, 'Class'),
+            ownerKind: 'class',
+            annotations: classAnnotations,
+        });
+    }
+    const body = classNode.childForFieldName('body');
+    if (body === null)
+        return facts;
+    for (const member of body.namedChildren) {
+        if (member.type !== 'method_declaration')
+            continue;
+        const annotations = (0, spring_di_js_1.javaSpringAnnotationFacts)(member);
+        if (!(0, conditionals_js_1.hasSpringConditionalRelevantAnnotation)(annotations))
+            continue;
+        facts.push({
+            ownerScopeId: scopeId(filePath, member, 'Function'),
+            ownerKind: 'callable',
+            annotations,
+        });
+    }
+    return facts;
+}
+exports.attachJavaSpringConditionalMetadata = (0, conditionals_js_1.createSpringConditionalMetadataAttacher)({
+    getFacts: capture_side_channel_js_1.getJavaSpringConditionalFacts,
+    isPackageVisibilityIncomplete: package_siblings_js_1.isJavaPackageSiblingVisibilityIncomplete,
+});

package/dist/core/code/engine/core/ingestion/languages/java/spring-config-bindings.js

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseValuePlaceholderKeys = parseValuePlaceholderKeys;
+exports.parseConfigurationPropertiesPrefix = parseConfigurationPropertiesPrefix;
+exports.captureJavaSpringConfigConsumerFacts = captureJavaSpringConfigConsumerFacts;
+exports.extractJavaSpringConfigConsumers = extractJavaSpringConfigConsumers;
+exports.attachJavaSpringConfigBindings = attachJavaSpringConfigBindings;
+const index_js_1 = require("../../../../../shared/index.js");
+const config_bindings_js_1 = require("../../frameworks/spring/config-bindings.js");
+const bean_candidates_js_1 = require("../../frameworks/spring/bean-candidates.js");
+const safe_parse_js_1 = require("../../../tree-sitter/safe-parse.js");
+const ast_helpers_js_1 = require("../../utils/ast-helpers.js");
+const query_js_1 = require("./query.js");
+const capture_side_channel_js_1 = require("./capture-side-channel.js");
+const package_siblings_js_1 = require("./package-siblings.js");
+const VALUE_ANNOTATION = 'org.springframework.beans.factory.annotation.Value';
+const CONFIGURATION_PROPERTIES_ANNOTATION = 'org.springframework.boot.context.properties.ConfigurationProperties';
+function collectJavaImports(root) {
+    const exact = new Set();
+    const wildcard = new Set();
+    const localTypes = new Set();
+    for (const node of root.descendantsOfType('import_declaration')) {
+        const imported = node.text
+            .replace(/^\s*import\s+(?:static\s+)?/, '')
+            .replace(/;\s*$/, '')
+            .trim();
+        if (imported.endsWith('.*'))
+            wildcard.add(imported.slice(0, -2));
+        else
+            exact.add(imported);
+    }
+    for (const type of [
+        'class_declaration',
+        'interface_declaration',
+        'enum_declaration',
+        'record_declaration',
+        'annotation_type_declaration',
+    ]) {
+        for (const node of root.descendantsOfType(type)) {
+            const name = node.childForFieldName('name')?.text;
+            if (name)
+                localTypes.add(name);
+        }
+    }
+    return { exact, wildcard, localTypes };
+}
+function annotationsOn(node) {
+    const modifiers = node.namedChildren.find((child) => child.type === 'modifiers');
+    if (modifiers === undefined)
+        return [];
+    const annotations = [];
+    for (const child of modifiers.namedChildren) {
+        if (child.type !== 'annotation' && child.type !== 'marker_annotation')
+            continue;
+        const name = child.childForFieldName('name')?.text ?? child.firstNamedChild?.text;
+        if (name)
+            annotations.push({ name, node: child });
+    }
+    return annotations;
+}
+function resolvesToAnnotation(rawName, canonicalName, imports) {
+    if (rawName.includes('.'))
+        return rawName === canonicalName;
+    if (imports.localTypes.has(rawName))
+        return false;
+    if (imports.exact.has(canonicalName))
+        return true;
+    const packageName = canonicalName.slice(0, canonicalName.lastIndexOf('.'));
+    return imports.wildcard.has(packageName);
+}
+function decodeJavaStringLiteral(literal) {
+    const delimiterLength = literal.startsWith('"""') && literal.endsWith('"""') ? 3 : 1;
+    return literal
+        .slice(delimiterLength, -delimiterLength)
+        .replace(/\\u([0-9a-fA-F]{4})/g, (_match, hex) => String.fromCharCode(Number.parseInt(hex, 16)))
+        .replace(/\\(["'\\btnfr])/g, (_match, escaped) => {
+        const controls = {
+            b: '\b',
+            t: '\t',
+            n: '\n',
+            f: '\f',
+            r: '\r',
+        };
+        return controls[escaped] ?? escaped;
+    });
+}
+function javaStringLiterals(annotation) {
+    return annotation
+        .descendantsOfType('string_literal')
+        .map((literal) => decodeJavaStringLiteral(literal.text));
+}
+/** Extract statically readable Spring placeholder keys from a Java annotation. */
+function parseValuePlaceholderKeys(annotation) {
+    const keys = new Set();
+    for (const literal of javaStringLiterals(annotation)) {
+        for (const match of literal.matchAll(/\$\{([^{}]+)\}/g)) {
+            const key = match[1].split(':', 1)[0].trim();
+            if (/^[A-Za-z0-9_.-]+$/.test(key))
+                keys.add(key);
+        }
+    }
+    return [...keys];
+}
+/** Extract `prefix`/`value` (or the positional value) from the annotation. */
+function parseConfigurationPropertiesPrefix(annotation) {
+    const named = annotation.descendantsOfType('element_value_pair').find((pair) => {
+        const key = pair.childForFieldName('key')?.text;
+        return key === 'prefix' || key === 'value';
+    });
+    const namedValue = named?.childForFieldName('value');
+    const argumentsNode = annotation.childForFieldName('arguments');
+    const literalNode = (namedValue?.type === 'string_literal'
+        ? namedValue
+        : namedValue?.descendantsOfType('string_literal')[0]) ??
+        (named === undefined
+            ? argumentsNode?.namedChildren.find((child) => child.type === 'string_literal')
+            : undefined);
+    if (literalNode === undefined)
+        return null;
+    const prefix = decodeJavaStringLiteral(literalNode.text)
+        .trim()
+        .replace(/^\.+|\.+$/g, '');
+    return /^[A-Za-z0-9_.-]+$/.test(prefix) ? prefix : null;
+}
+function classScopeId(filePath, declaration) {
+    return (0, index_js_1.makeScopeId)({
+        filePath,
+        range: (0, ast_helpers_js_1.nodeToCapture)('@scope.class', declaration).range,
+        kind: 'Class',
+    });
+}
+function enclosingClass(node) {
+    let current = node.parent;
+    while (current !== null) {
+        if (current.type === 'class_declaration' || current.type === 'record_declaration') {
+            return current;
+        }
+        current = current.parent;
+    }
+    return undefined;
+}
+/** Collect config facts from the Java parser's existing AST (no reparse). */
+function captureJavaSpringConfigConsumerFacts(root, filePath) {
+    const imports = collectJavaImports(root);
+    const facts = [];
+    for (const field of root.descendantsOfType('field_declaration')) {
+        const annotations = annotationsOn(field).filter((annotation) => resolvesToAnnotation(annotation.name, VALUE_ANNOTATION, imports));
+        if (annotations.length === 0)
+            continue;
+        const owner = enclosingClass(field);
+        if (owner === undefined)
+            continue;
+        for (const declarator of field.namedChildren.filter((child) => child.type === 'variable_declarator')) {
+            const fieldName = declarator.childForFieldName('name')?.text;
+            if (!fieldName)
+                continue;
+            for (const annotation of annotations) {
+                const keys = parseValuePlaceholderKeys(annotation.node);
+                if (keys.length > 0) {
+                    facts.push({
+                        consumer: { kind: 'value', fieldName, line: field.startPosition.row + 1, keys },
+                        annotationName: annotation.name,
+                        classScopeId: classScopeId(filePath, owner),
+                    });
+                }
+            }
+        }
+    }
+    for (const type of ['class_declaration', 'record_declaration']) {
+        for (const declaration of root.descendantsOfType(type)) {
+            const className = declaration.childForFieldName('name')?.text;
+            if (!className)
+                continue;
+            for (const annotation of annotationsOn(declaration)) {
+                if (!resolvesToAnnotation(annotation.name, CONFIGURATION_PROPERTIES_ANNOTATION, imports)) {
+                    continue;
+                }
+                const prefix = parseConfigurationPropertiesPrefix(annotation.node);
+                if (prefix !== null) {
+                    facts.push({
+                        consumer: {
+                            kind: 'configuration-properties',
+                            className,
+                            line: declaration.startPosition.row + 1,
+                            prefix,
+                        },
+                        annotationName: annotation.name,
+                        classScopeId: classScopeId(filePath, declaration),
+                    });
+                }
+            }
+        }
+    }
+    return facts;
+}
+/** Parse Java consumers for focused unit tests; production reuses the worker AST. */
+function extractJavaSpringConfigConsumers(source) {
+    const tree = (0, safe_parse_js_1.parseSourceSafe)((0, query_js_1.getJavaParser)(), source);
+    return captureJavaSpringConfigConsumerFacts(tree.rootNode, '<memory>').map((fact) => fact.consumer);
+}
+/** Java ScopeResolver post-resolution hook for Spring configuration consumers. */
+function attachJavaSpringConfigBindings(graph, parsedFiles, _nodeLookup, indexes, _ctx) {
+    const resolveAnnotation = (0, bean_candidates_js_1.createSpringAnnotationNameResolver)(indexes);
+    const recognizedAnnotations = new Set([VALUE_ANNOTATION, CONFIGURATION_PROPERTIES_ANNOTATION]);
+    const batches = [];
+    for (const parsed of parsedFiles) {
+        const consumers = [];
+        for (const fact of (0, capture_side_channel_js_1.getJavaSpringConfigConsumerFacts)(parsed.filePath)) {
+            const classScope = indexes.scopeTree.getScope(fact.classScopeId);
+            if (classScope === undefined || classScope.kind !== 'Class')
+                continue;
+            const expectedAnnotation = fact.consumer.kind === 'value' ? VALUE_ANNOTATION : CONFIGURATION_PROPERTIES_ANNOTATION;
+            const enclosingScope = fact.consumer.kind === 'value' ? classScope.id : classScope.parent;
+            const resolved = resolveAnnotation(fact.annotationName, parsed, enclosingScope, recognizedAnnotations, (0, package_siblings_js_1.isJavaPackageSiblingVisibilityIncomplete)(parsed.filePath));
+            if (resolved === expectedAnnotation)
+                consumers.push(fact.consumer);
+        }
+        if (consumers.length > 0)
+            batches.push({ filePath: parsed.filePath, consumers });
+    }
+    (0, config_bindings_js_1.bindSpringConfigConsumers)(graph, batches);
+}

package/dist/core/code/engine/core/ingestion/languages/java/spring-di.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attachJavaSpringDiMetadata = void 0;
+exports.javaSpringAnnotationFacts = javaSpringAnnotationFacts;
+exports.captureJavaSpringDiClassFact = captureJavaSpringDiClassFact;
+const index_js_1 = require("../../../../../shared/index.js");
+const di_metadata_js_1 = require("../../frameworks/spring/di-metadata.js");
+const bean_factories_js_1 = require("../../frameworks/spring/bean-factories.js");
+const spring_js_1 = require("../../di-extractors/spring.js");
+const ast_helpers_js_1 = require("../../utils/ast-helpers.js");
+const package_siblings_js_1 = require("./package-siblings.js");
+const capture_side_channel_js_1 = require("./capture-side-channel.js");
+function javaSpringAnnotationFacts(node) {
+    const facts = [];
+    for (const child of node.namedChildren) {
+        if (child.type !== 'modifiers')
+            continue;
+        for (const modifier of child.namedChildren) {
+            if (modifier.type !== 'marker_annotation' && modifier.type !== 'annotation')
+                continue;
+            const nameNode = modifier.childForFieldName('name') ?? modifier.firstNamedChild;
+            if (nameNode === null)
+                continue;
+            facts.push({
+                name: nameNode.text.trim(),
+                text: modifier.text.trim(),
+                line: modifier.startPosition.row + 1,
+            });
+        }
+    }
+    return facts;
+}
+function dependenciesOf(callable) {
+    const parameters = callable.childForFieldName('parameters');
+    if (parameters === null)
+        return [];
+    const dependencies = [];
+    for (const parameter of parameters.namedChildren) {
+        if (parameter.type !== 'formal_parameter' && parameter.type !== 'spread_parameter')
+            continue;
+        const nameNode = parameter.childForFieldName('name');
+        const typeNode = parameter.childForFieldName('type');
+        if (nameNode === null || typeNode === null)
+            continue;
+        dependencies.push({
+            name: nameNode.text.trim(),
+            rawType: typeNode.text.trim(),
+            annotations: javaSpringAnnotationFacts(parameter),
+        });
+    }
+    return dependencies;
+}
+/**
+ * Capture one class already surfaced by Java's scope query.
+ *
+ * `captures.ts` calls this from its existing query-match traversal, so Spring
+ * DI does not perform a second recursive walk from the AST root.
+ */
+function captureJavaSpringDiClassFact(classNode, filePath) {
+    const body = classNode.childForFieldName('body');
+    if (body === null)
+        return null;
+    const classAnnotations = javaSpringAnnotationFacts(classNode);
+    const injectionSites = [];
+    const beanFactoryMethods = [];
+    const constructors = body.namedChildren.filter((child) => child.type === 'constructor_declaration');
+    for (const constructor of constructors) {
+        const annotations = javaSpringAnnotationFacts(constructor);
+        const implicitConstructor = constructors.length === 1 &&
+            (0, di_metadata_js_1.hasSpringStereotypeSyntax)(classAnnotations) &&
+            !(0, di_metadata_js_1.hasSpringDiRelevantAnnotation)(annotations);
+        if (!implicitConstructor && !(0, di_metadata_js_1.hasSpringDiRelevantAnnotation)(annotations))
+            continue;
+        injectionSites.push({
+            kind: 'constructor',
+            memberName: constructor.childForFieldName('name')?.text.trim() ?? '<constructor>',
+            implicitConstructor,
+            annotations,
+            dependencies: dependenciesOf(constructor),
+        });
+    }
+    for (const member of body.namedChildren) {
+        if (member.type === 'field_declaration') {
+            const annotations = javaSpringAnnotationFacts(member);
+            if (!(0, di_metadata_js_1.hasSpringDiRelevantAnnotation)(annotations))
+                continue;
+            const typeNode = member.childForFieldName('type');
+            if (typeNode === null)
+                continue;
+            for (const declarator of member.namedChildren) {
+                if (declarator.type !== 'variable_declarator')
+                    continue;
+                const nameNode = declarator.childForFieldName('name');
+                if (nameNode === null)
+                    continue;
+                injectionSites.push({
+                    kind: 'field',
+                    memberName: nameNode.text.trim(),
+                    implicitConstructor: false,
+                    annotations,
+                    dependencies: [
+                        {
+                            name: nameNode.text.trim(),
+                            rawType: typeNode.text.trim(),
+                            annotations,
+                        },
+                    ],
+                });
+            }
+        }
+        else if (member.type === 'method_declaration') {
+            const annotations = javaSpringAnnotationFacts(member);
+            const memberName = member.childForFieldName('name')?.text.trim() ?? '<method>';
+            const beanFactory = (0, bean_factories_js_1.hasSpringBeanFactorySyntax)(annotations);
+            if (beanFactory) {
+                const callableCapture = (0, ast_helpers_js_1.nodeToCapture)('@spring-bean.factory', member);
+                const returnType = member.childForFieldName('type')?.text.trim();
+                beanFactoryMethods.push({
+                    callableScopeId: (0, index_js_1.makeScopeId)({
+                        filePath,
+                        range: callableCapture.range,
+                        kind: 'Function',
+                    }),
+                    methodName: memberName,
+                    ...(returnType === undefined ? {} : { returnType }),
+                    annotations,
+                    dependencies: dependenciesOf(member),
+                });
+            }
+            // @Bean parameters are already represented on the factory Method. Do not
+            // also attach them to the owning configuration Class when the method has
+            // an otherwise relevant annotation such as @Autowired or @Qualifier.
+            if (beanFactory)
+                continue;
+            if (!(0, di_metadata_js_1.hasSpringDiRelevantAnnotation)(annotations))
+                continue;
+            injectionSites.push({
+                kind: 'method',
+                memberName,
+                implicitConstructor: false,
+                annotations,
+                dependencies: dependenciesOf(member),
+            });
+        }
+    }
+    if (injectionSites.length === 0 &&
+        beanFactoryMethods.length === 0 &&
+        !(0, di_metadata_js_1.hasSpringDiRelevantAnnotation)(classAnnotations)) {
+        return null;
+    }
+    const classCapture = (0, ast_helpers_js_1.nodeToCapture)('@spring-di.class', classNode);
+    return {
+        classScopeId: (0, index_js_1.makeScopeId)({ filePath, range: classCapture.range, kind: 'Class' }),
+        classAnnotations,
+        injectionSites,
+        ...(beanFactoryMethods.length === 0 ? {} : { beanFactoryMethods }),
+    };
+}
+/** Attach resolved, framework-private DI metadata to Class nodes. */
+exports.attachJavaSpringDiMetadata = (0, di_metadata_js_1.createSpringDiMetadataAttacher)({
+    getFacts: capture_side_channel_js_1.getJavaSpringDiFacts,
+    isPackageVisibilityIncomplete: package_siblings_js_1.isJavaPackageSiblingVisibilityIncomplete,
+    parseInjectionType: spring_js_1.parseSpringInjectionType,
+    capturedMemberKind: 'field',
+});