cgraphx 2.0.1 → 2.0.3

package/dist/core/code/engine/core/ingestion/frameworks/spring/bean-candidates.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createClassAnnotationFactStore = createClassAnnotationFactStore;
+exports.recordClassAnnotationCapture = recordClassAnnotationCapture;
+exports.materializeClassAnnotationFacts = materializeClassAnnotationFacts;
+exports.createSpringAnnotationNameResolver = createSpringAnnotationNameResolver;
+exports.createSpringBeanCandidateAttacher = createSpringBeanCandidateAttacher;
+const index_js_1 = require("../../../../../shared/index.js");
+const ids_js_1 = require("../../scope-resolution/graph-bridge/ids.js");
+const walkers_js_1 = require("../../scope-resolution/scope/walkers.js");
+const bean_catalog_js_1 = require("./bean-catalog.js");
+/** Per-language store for capture facts that cross the worker boundary. */
+function createClassAnnotationFactStore() {
+    const factsByFile = new Map();
+    return {
+        clear: () => factsByFile.clear(),
+        set: (filePath, facts) => {
+            if (facts.length === 0)
+                factsByFile.delete(filePath);
+            else
+                factsByFile.set(filePath, facts);
+        },
+        get: (filePath) => factsByFile.get(filePath) ?? [],
+    };
+}
+/** Record one annotation from the language's existing scope-query traversal. */
+function recordClassAnnotationCapture(facts, filePath, classCapture, annotationName) {
+    const classScopeId = (0, index_js_1.makeScopeId)({ filePath, range: classCapture.range, kind: 'Class' });
+    const names = facts.get(classScopeId) ?? new Set();
+    names.add(annotationName.trim());
+    facts.set(classScopeId, names);
+}
+function materializeClassAnnotationFacts(facts) {
+    return [...facts].map(([classScopeId, annotationNames]) => ({
+        classScopeId,
+        annotationNames: [...annotationNames],
+    }));
+}
+function simpleNameOf(def) {
+    const qualifiedName = def.qualifiedName;
+    if (qualifiedName === undefined)
+        return undefined;
+    const separator = qualifiedName.lastIndexOf('.');
+    return separator === -1 ? qualifiedName : qualifiedName.slice(separator + 1);
+}
+function buildOwnedTypeNamesByOwner(indexes) {
+    const namesByOwner = new Map();
+    for (const def of indexes.defs.byId.values()) {
+        if (def.ownerId === undefined)
+            continue;
+        if (!(0, walkers_js_1.isClassLike)(def.type) && def.type !== 'Annotation')
+            continue;
+        const simpleName = simpleNameOf(def);
+        if (simpleName === undefined)
+            continue;
+        const names = namesByOwner.get(def.ownerId) ?? new Set();
+        names.add(simpleName);
+        namesByOwner.set(def.ownerId, names);
+    }
+    return namesByOwner;
+}
+function hasLexicalTypeDeclaration(startScope, simpleName, indexes) {
+    let scopeId = startScope;
+    const visited = new Set();
+    while (scopeId !== null && !visited.has(scopeId)) {
+        visited.add(scopeId);
+        const scope = indexes.scopeTree.getScope(scopeId);
+        if (scope === undefined)
+            return false;
+        const locals = scope.bindings.get(simpleName);
+        if (locals?.some(({ def }) => (0, walkers_js_1.isClassLike)(def.type) || def.type === 'Annotation'))
+            return true;
+        scopeId = scope.parent;
+    }
+    return false;
+}
+function explicitImportTargets(parsed, simpleName) {
+    const targets = new Set();
+    for (const entry of parsed.parsedImports) {
+        if (entry.kind !== 'named' && entry.kind !== 'alias')
+            continue;
+        if (entry.localName !== simpleName)
+            continue;
+        targets.add(entry.targetRaw);
+    }
+    return targets;
+}
+function hasInheritedTypeDeclaration(startScope, simpleName, indexes, ownedTypeNamesByOwner) {
+    let scopeId = startScope;
+    const visited = new Set();
+    while (scopeId !== null && !visited.has(scopeId)) {
+        visited.add(scopeId);
+        const scope = indexes.scopeTree.getScope(scopeId);
+        if (scope === undefined)
+            return false;
+        if (scope.kind === 'Class') {
+            const classDef = scope.ownedDefs.find((def) => (0, walkers_js_1.isClassLike)(def.type));
+            if (classDef !== undefined) {
+                for (const ancestorId of indexes.methodDispatch.mroFor(classDef.nodeId)) {
+                    if (ownedTypeNamesByOwner.get(ancestorId)?.has(simpleName) === true)
+                        return true;
+                }
+            }
+        }
+        scopeId = scope.parent;
+    }
+    return false;
+}
+function hasVisibleTypeBinding(startScope, simpleName, indexes) {
+    let scopeId = startScope;
+    const visited = new Set();
+    while (scopeId !== null && !visited.has(scopeId)) {
+        visited.add(scopeId);
+        const scope = indexes.scopeTree.getScope(scopeId);
+        if (scope === undefined)
+            return false;
+        const visible = (0, walkers_js_1.lookupBindingsAt)(scopeId, simpleName, indexes);
+        if (visible.some(({ def }) => (0, walkers_js_1.isClassLike)(def.type) || def.type === 'Annotation'))
+            return true;
+        scopeId = scope.parent;
+    }
+    return false;
+}
+function wildcardImportTarget(parsed, simpleName, recognizedAnnotations) {
+    const wildcardPackages = new Set(parsed.parsedImports
+        .filter((entry) => entry.kind === 'wildcard')
+        .map((entry) => entry.targetRaw.replace(/\.\*$/, '')));
+    if (wildcardPackages.size !== 1)
+        return undefined;
+    const [packageName] = wildcardPackages;
+    const target = `${packageName}.${simpleName}`;
+    return recognizedAnnotations.has(target) ? target : undefined;
+}
+/** Build a scope-aware Spring annotation resolver shared by framework hooks. */
+function createSpringAnnotationNameResolver(indexes) {
+    const ownedTypeNamesByOwner = buildOwnedTypeNamesByOwner(indexes);
+    return (rawName, parsed, enclosingScope, recognizedAnnotations, isPackageVisibilityIncomplete) => {
+        if (rawName.includes('.')) {
+            return recognizedAnnotations.has(rawName) ? rawName : undefined;
+        }
+        if (hasLexicalTypeDeclaration(enclosingScope, rawName, indexes))
+            return undefined;
+        if (hasInheritedTypeDeclaration(enclosingScope, rawName, indexes, ownedTypeNamesByOwner)) {
+            return undefined;
+        }
+        const explicitImports = explicitImportTargets(parsed, rawName);
+        if (explicitImports.size > 0) {
+            if (explicitImports.size !== 1)
+                return undefined;
+            const [imported] = explicitImports;
+            return recognizedAnnotations.has(imported) ? imported : undefined;
+        }
+        const wildcardTarget = wildcardImportTarget(parsed, rawName, recognizedAnnotations);
+        if (wildcardTarget === undefined || isPackageVisibilityIncomplete)
+            return undefined;
+        return hasVisibleTypeBinding(enclosingScope, rawName, indexes) ? undefined : wildcardTarget;
+    };
+}
+/** Build a language hook that enriches Class nodes after scope resolution. */
+function createSpringBeanCandidateAttacher(adapter) {
+    return (graph, parsedFiles, nodeLookup, indexes) => {
+        const resolveSpringAnnotation = createSpringAnnotationNameResolver(indexes);
+        for (const parsed of parsedFiles) {
+            for (const fact of adapter.getClassAnnotationFacts(parsed.filePath)) {
+                const classScope = indexes.scopeTree.getScope(fact.classScopeId);
+                if (classScope === undefined || classScope.kind !== 'Class')
+                    continue;
+                const classDef = classScope.ownedDefs.find((def) => def.type === 'Class');
+                if (classDef === undefined)
+                    continue;
+                const graphId = (0, ids_js_1.resolveDefGraphId)(parsed.filePath, classDef, nodeLookup);
+                if (graphId === undefined)
+                    continue;
+                const classNode = graph.getNode(graphId);
+                if (classNode === undefined || classNode.label !== 'Class')
+                    continue;
+                const recognized = new Set();
+                for (const rawName of fact.annotationNames) {
+                    const annotation = resolveSpringAnnotation(rawName, parsed, classScope.parent, bean_catalog_js_1.SPRING_BEAN_STEREOTYPES, adapter.isPackageVisibilityIncomplete(parsed.filePath));
+                    if (annotation !== undefined)
+                        recognized.add(annotation);
+                }
+                if (recognized.size === 1) {
+                    classNode.properties.frameworkAnnotations = [...recognized];
+                }
+            }
+        }
+    };
+}

package/dist/core/code/engine/core/ingestion/frameworks/spring/bean-catalog.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SPRING_BEAN_STEREOTYPES = void 0;
+exports.deriveSpringBeanMetadata = deriveSpringBeanMetadata;
+exports.isSpringBeanCandidateSourceFile = isSpringBeanCandidateSourceFile;
+exports.SPRING_BEAN_STEREOTYPES = new Map([
+    ['org.springframework.stereotype.Component', { role: 'component' }],
+    ['org.springframework.stereotype.Service', { role: 'service' }],
+    ['org.springframework.stereotype.Repository', { role: 'repository' }],
+    ['org.springframework.stereotype.Controller', { role: 'controller' }],
+    ['org.springframework.web.bind.annotation.RestController', { role: 'rest-controller' }],
+    ['org.springframework.context.annotation.Configuration', { role: 'configuration' }],
+    ['org.springframework.boot.autoconfigure.AutoConfiguration', { role: 'auto-configuration' }],
+]);
+function deriveSpringBeanMetadata(frameworkAnnotations) {
+    const recognized = [
+        ...new Set(frameworkAnnotations.filter((annotation) => exports.SPRING_BEAN_STEREOTYPES.has(annotation))),
+    ];
+    if (recognized.length !== 1)
+        return undefined;
+    const annotation = recognized[0];
+    const stereotype = exports.SPRING_BEAN_STEREOTYPES.get(annotation);
+    if (!stereotype)
+        return undefined;
+    return { framework: 'spring', role: stereotype.role, annotation };
+}
+const SPRING_BEAN_SOURCE_EXTENSIONS = ['.java', '.kt', '.kts'];
+/** Whether a source change can alter Spring Bean candidate metadata. */
+function isSpringBeanCandidateSourceFile(filePath) {
+    const normalized = filePath.toLowerCase();
+    return SPRING_BEAN_SOURCE_EXTENSIONS.some((extension) => normalized.endsWith(extension));
+}

package/dist/core/code/engine/core/ingestion/frameworks/spring/bean-factories.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SPRING_BEAN_FACTORY_REASON_PREFIX = exports.SPRING_BEAN_DECLARATION_ID_PREFIX = exports.SPRING_BEAN_ANNOTATION = void 0;
+exports.hasSpringBeanFactorySyntax = hasSpringBeanFactorySyntax;
+exports.springBeanNames = springBeanNames;
+exports.encodeSpringBeanFactoryReason = encodeSpringBeanFactoryReason;
+exports.decodeSpringBeanFactoryReason = decodeSpringBeanFactoryReason;
+exports.isSpringBeanFactoryDeclaration = isSpringBeanFactoryDeclaration;
+const annotation_arguments_js_1 = require("./annotation-arguments.js");
+exports.SPRING_BEAN_ANNOTATION = 'org.springframework.context.annotation.Bean';
+exports.SPRING_BEAN_DECLARATION_ID_PREFIX = 'CodeElement:spring-bean:';
+exports.SPRING_BEAN_FACTORY_REASON_PREFIX = 'spring-bean-factory:';
+function simpleName(name) {
+    const separator = name.lastIndexOf('.');
+    return separator === -1 ? name : name.slice(separator + 1);
+}
+function hasSpringBeanFactorySyntax(annotations) {
+    return annotations.some((annotation) => simpleName(annotation.name) === 'Bean');
+}
+/** Resolve statically readable Bean names; dynamic constants remain explicitly unknown. */
+function springBeanNames(annotationText, defaultMethodName) {
+    const argumentsList = (0, annotation_arguments_js_1.parseSpringAnnotationArguments)(annotationText);
+    if (argumentsList === null)
+        return { names: [], namesKnown: false };
+    const nameArguments = argumentsList.filter((argument) => argument.name === undefined || argument.name === 'name' || argument.name === 'value');
+    if (nameArguments.length === 0)
+        return { names: [defaultMethodName], namesKnown: true };
+    const names = new Set();
+    for (const argument of nameArguments) {
+        const values = (0, annotation_arguments_js_1.parseStaticStringValues)(argument.value);
+        if (values === null)
+            return { names: [], namesKnown: false };
+        for (const value of values) {
+            if (value.length > 0)
+                names.add(value);
+        }
+    }
+    return {
+        names: names.size === 0 ? [defaultMethodName] : [...names],
+        namesKnown: true,
+    };
+}
+function encodeSpringBeanFactoryReason(declaration) {
+    return `${exports.SPRING_BEAN_FACTORY_REASON_PREFIX}${JSON.stringify(declaration)}`;
+}
+function decodeSpringBeanFactoryReason(reason) {
+    if (typeof reason !== 'string' || !reason.startsWith(exports.SPRING_BEAN_FACTORY_REASON_PREFIX)) {
+        return undefined;
+    }
+    try {
+        const value = JSON.parse(reason.slice(exports.SPRING_BEAN_FACTORY_REASON_PREFIX.length));
+        if (!Array.isArray(value.names) ||
+            !value.names.every((name) => typeof name === 'string') ||
+            typeof value.namesKnown !== 'boolean' ||
+            (value.providedType !== undefined && typeof value.providedType !== 'string')) {
+            return undefined;
+        }
+        return {
+            framework: 'spring',
+            role: 'factory-method',
+            annotation: exports.SPRING_BEAN_ANNOTATION,
+            names: value.names,
+            ...(value.providedType === undefined ? {} : { providedType: value.providedType }),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function isSpringBeanFactoryDeclaration(relationship) {
+    return (relationship.type === 'DECLARES' &&
+        relationship.reason.startsWith(exports.SPRING_BEAN_FACTORY_REASON_PREFIX));
+}

package/dist/core/code/engine/core/ingestion/frameworks/spring/conditionals.js

@@ -0,0 +1,323 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasSpringConditionalRelevantAnnotation = hasSpringConditionalRelevantAnnotation;
+exports.createSpringConditionalMetadataAttacher = createSpringConditionalMetadataAttacher;
+const utils_js_1 = require("../../../../lib/utils.js");
+const ids_js_1 = require("../../scope-resolution/graph-bridge/ids.js");
+const ast_helpers_js_1 = require("../../utils/ast-helpers.js");
+const bean_candidates_js_1 = require("./bean-candidates.js");
+const config_bindings_js_1 = require("./config-bindings.js");
+const PROFILE_ANNOTATION = 'org.springframework.context.annotation.Profile';
+const CONDITIONAL_ANNOTATION = 'org.springframework.context.annotation.Conditional';
+const AUTO_CONFIGURATION_ANNOTATION = 'org.springframework.boot.autoconfigure.AutoConfiguration';
+const BOOT_CONDITIONAL_ANNOTATIONS = [
+    'ConditionalOnBean',
+    'ConditionalOnBooleanProperty',
+    'ConditionalOnClass',
+    'ConditionalOnCloudPlatform',
+    'ConditionalOnExpression',
+    'ConditionalOnJava',
+    'ConditionalOnJndi',
+    'ConditionalOnMissingBean',
+    'ConditionalOnMissingClass',
+    'ConditionalOnNotWebApplication',
+    'ConditionalOnProperty',
+    'ConditionalOnResource',
+    'ConditionalOnSingleCandidate',
+    'ConditionalOnThreading',
+    'ConditionalOnWarDeployment',
+    'ConditionalOnWebApplication',
+];
+const CONDITIONAL_ANNOTATIONS = new Set([
+    PROFILE_ANNOTATION,
+    CONDITIONAL_ANNOTATION,
+    ...BOOT_CONDITIONAL_ANNOTATIONS.map((name) => `org.springframework.boot.autoconfigure.condition.${name}`),
+]);
+const PROPERTY_CONDITIONAL_ANNOTATIONS = new Set([
+    'org.springframework.boot.autoconfigure.condition.ConditionalOnProperty',
+    'org.springframework.boot.autoconfigure.condition.ConditionalOnBooleanProperty',
+]);
+const RESOLVABLE_SPRING_CONDITIONAL_ANNOTATIONS = new Set([
+    ...CONDITIONAL_ANNOTATIONS,
+    AUTO_CONFIGURATION_ANNOTATION,
+]);
+const CAPTURE_RELEVANT_SIMPLE_NAMES = new Set([
+    'Profile',
+    'Conditional',
+    'AutoConfiguration',
+    ...BOOT_CONDITIONAL_ANNOTATIONS,
+]);
+function simpleName(name) {
+    const separator = name.lastIndexOf('.');
+    return separator === -1 ? name : name.slice(separator + 1);
+}
+function hasSpringConditionalRelevantAnnotation(annotations) {
+    return annotations.some((annotation) => CAPTURE_RELEVANT_SIMPLE_NAMES.has(simpleName(annotation.name)));
+}
+function annotationArguments(text) {
+    const start = text.indexOf('(');
+    const end = text.lastIndexOf(')');
+    if (start === -1 || end <= start)
+        return undefined;
+    const args = text.slice(start + 1, end).trim();
+    return args.length === 0 ? undefined : args;
+}
+function splitTopLevelArguments(value) {
+    const parts = [];
+    let start = 0;
+    let quote = null;
+    let escaped = false;
+    let round = 0;
+    let square = 0;
+    let curly = 0;
+    for (let index = 0; index < value.length; index++) {
+        const char = value.charAt(index);
+        if (quote !== null) {
+            if (escaped)
+                escaped = false;
+            else if (char === '\\')
+                escaped = true;
+            else if (char === quote)
+                quote = null;
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            quote = char;
+            continue;
+        }
+        if (char === '(')
+            round++;
+        else if (char === ')')
+            round = Math.max(0, round - 1);
+        else if (char === '[')
+            square++;
+        else if (char === ']')
+            square = Math.max(0, square - 1);
+        else if (char === '{')
+            curly++;
+        else if (char === '}')
+            curly = Math.max(0, curly - 1);
+        else if (char === ',' && round === 0 && square === 0 && curly === 0) {
+            parts.push(value.slice(start, index).trim());
+            start = index + 1;
+        }
+    }
+    parts.push(value.slice(start).trim());
+    return parts.filter((part) => part.length > 0);
+}
+function parseArguments(text) {
+    const positional = [];
+    const named = new Map();
+    const args = annotationArguments(text);
+    if (args === undefined)
+        return { positional, named };
+    for (const part of splitTopLevelArguments(args)) {
+        const assignment = /^([A-Za-z_][A-Za-z0-9_]*)\s*=\s*([\s\S]+)$/.exec(part);
+        if (assignment === null)
+            positional.push(part);
+        else {
+            const [, name, value] = assignment;
+            if (name !== undefined && value !== undefined)
+                named.set(name, value.trim());
+        }
+    }
+    return { positional, named };
+}
+function decodeStaticString(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+}
+function staticStrings(value) {
+    if (value === undefined)
+        return [];
+    const values = [];
+    for (let index = 0; index < value.length;) {
+        if (value.startsWith('"""', index)) {
+            const end = value.indexOf('"""', index + 3);
+            if (end === -1)
+                break;
+            const decoded = value.slice(index + 3, end);
+            if (!decoded.includes('${'))
+                values.push(decoded);
+            index = end + 3;
+            continue;
+        }
+        if (value.charAt(index) !== '"') {
+            index++;
+            continue;
+        }
+        let end = index + 1;
+        let escaped = false;
+        for (; end < value.length; end++) {
+            const char = value.charAt(end);
+            if (escaped)
+                escaped = false;
+            else if (char === '\\')
+                escaped = true;
+            else if (char === '"')
+                break;
+        }
+        if (end >= value.length)
+            break;
+        const decoded = decodeStaticString(value.slice(index, end + 1));
+        if (decoded !== undefined)
+            values.push(decoded);
+        index = end + 1;
+    }
+    return values;
+}
+function propertyConditionKeys(annotationText) {
+    const args = parseArguments(annotationText);
+    const prefix = staticStrings(args.named.get('prefix'))[0]?.trim().replace(/\.+$/, '') ?? '';
+    const names = staticStrings(args.named.get('name') ??
+        args.named.get('value') ??
+        (args.positional.length > 0 ? args.positional.join(',') : undefined));
+    return [
+        ...new Set(names
+            .map((name) => name.replace(/^\.+/, '').trim())
+            .filter((name) => name.length > 0)
+            .map((name) => (prefix.length > 0 ? `${prefix}.${name}` : name))),
+    ];
+}
+function conditionDescription(resolvedName, annotationText) {
+    const args = annotationArguments(annotationText);
+    const renderedArgs = args === undefined ? '' : `(${args.replace(/\s+/g, ' ').trim().slice(0, 1000)})`;
+    return (0, ast_helpers_js_1.stripBidiAndZeroWidth)(`Spring condition @${simpleName(resolvedName)}${renderedArgs}; activation unknown`);
+}
+function ownerGraphNode(fact, indexes, nodeLookup, graph) {
+    const ownerScope = indexes.scopeTree.getScope(fact.ownerScopeId);
+    if (ownerScope === undefined)
+        return undefined;
+    let ownerId;
+    if (fact.ownerKind === 'class') {
+        const classDef = ownerScope.ownedDefs.find((definition) => definition.type === 'Class' || definition.type === 'Record');
+        if (classDef !== undefined) {
+            ownerId = (0, ids_js_1.resolveDefGraphId)(classDef.filePath, classDef, nodeLookup);
+        }
+    }
+    else {
+        ownerId = (0, ids_js_1.resolveCallerGraphId)(fact.ownerScopeId, indexes, nodeLookup, {
+            startLine: fact.annotations[0]?.line ?? ownerScope.range.startLine,
+            startCol: 0,
+        });
+    }
+    if (ownerId === undefined)
+        return undefined;
+    const owner = graph.getNode(ownerId);
+    if (owner === undefined || owner.label === 'File')
+        return undefined;
+    return owner;
+}
+function addConditionNode(graph, owner, annotation, resolvedName) {
+    const description = conditionDescription(resolvedName, annotation.text);
+    const nodeId = (0, utils_js_1.generateId)('Annotation', `spring-condition:${owner.id}:${annotation.line}:${resolvedName}:${description}`);
+    const conditionNode = {
+        id: nodeId,
+        label: 'Annotation',
+        properties: {
+            name: `@${simpleName(resolvedName)}`,
+            filePath: owner.properties.filePath,
+            startLine: annotation.line,
+            endLine: annotation.line,
+            description,
+        },
+    };
+    graph.addNode(conditionNode);
+    const fileId = (0, utils_js_1.generateId)('File', owner.properties.filePath);
+    if (graph.getNode(fileId) !== undefined) {
+        graph.addRelationship({
+            id: (0, utils_js_1.generateId)('DEFINES', `${fileId}->${nodeId}`),
+            sourceId: fileId,
+            targetId: nodeId,
+            type: 'DEFINES',
+            confidence: 1,
+            reason: 'spring-condition:annotation',
+        });
+    }
+    return conditionNode;
+}
+function addConditionalRelationship(graph, owner, target, annotation, resolvedName, detail) {
+    const reason = (0, ast_helpers_js_1.stripBidiAndZeroWidth)([`spring-condition:@${simpleName(resolvedName)}`, detail, 'activation=unknown']
+        .filter((part) => part !== undefined && part.length > 0)
+        .join(' '));
+    graph.addRelationship({
+        id: (0, utils_js_1.generateId)('CONDITIONAL_ON', `${owner.id}->${target.id}:${annotation.line}:${resolvedName}:${detail ?? ''}`),
+        sourceId: owner.id,
+        targetId: target.id,
+        type: 'CONDITIONAL_ON',
+        confidence: 1,
+        reason,
+    });
+}
+const configNodesByGraph = new WeakMap();
+function configNodesByKey(graph) {
+    const cached = configNodesByGraph.get(graph);
+    if (cached !== undefined)
+        return cached;
+    const byKey = new Map();
+    for (const node of graph.iterNodes()) {
+        if (node.label !== 'Property' ||
+            typeof node.properties.description !== 'string' ||
+            !node.properties.description.startsWith(config_bindings_js_1.SPRING_CONFIG_DESCRIPTION)) {
+            continue;
+        }
+        const key = String(node.properties.name);
+        const bucket = byKey.get(key) ?? [];
+        bucket.push(node);
+        byKey.set(key, bucket);
+    }
+    configNodesByGraph.set(graph, byKey);
+    return byKey;
+}
+/**
+ * Build a post-resolution Spring conditional attacher shared by language
+ * adapters. Adapters capture syntax and package-visibility facts; this module
+ * owns framework annotation semantics and graph representation.
+ */
+function createSpringConditionalMetadataAttacher(adapter) {
+    return (graph, parsedFiles, nodeLookup, indexes) => {
+        const resolveAnnotation = (0, bean_candidates_js_1.createSpringAnnotationNameResolver)(indexes);
+        let propertyNodes;
+        for (const parsed of parsedFiles) {
+            const incomplete = adapter.isPackageVisibilityIncomplete(parsed.filePath);
+            const resolvedAnnotations = new Map();
+            for (const fact of adapter.getFacts(parsed.filePath)) {
+                const owner = ownerGraphNode(fact, indexes, nodeLookup, graph);
+                const ownerScope = indexes.scopeTree.getScope(fact.ownerScopeId);
+                if (owner === undefined || ownerScope === undefined)
+                    continue;
+                for (const annotation of fact.annotations) {
+                    const cacheKey = `${ownerScope.parent ?? '<root>'}\0${annotation.name}`;
+                    let resolved = resolvedAnnotations.get(cacheKey);
+                    if (!resolvedAnnotations.has(cacheKey)) {
+                        resolved = resolveAnnotation(annotation.name, parsed, ownerScope.parent, RESOLVABLE_SPRING_CONDITIONAL_ANNOTATIONS, incomplete);
+                        resolvedAnnotations.set(cacheKey, resolved);
+                    }
+                    if (resolved === undefined)
+                        continue;
+                    if (!CONDITIONAL_ANNOTATIONS.has(resolved))
+                        continue;
+                    if (PROPERTY_CONDITIONAL_ANNOTATIONS.has(resolved)) {
+                        const keys = propertyConditionKeys(annotation.text);
+                        propertyNodes ??= configNodesByKey(graph);
+                        let matched = false;
+                        for (const key of keys) {
+                            for (const property of propertyNodes.get(key) ?? []) {
+                                matched = true;
+                                addConditionalRelationship(graph, owner, property, annotation, resolved, `key=${key}`);
+                            }
+                        }
+                        if (matched)
+                            continue;
+                    }
+                    const conditionNode = addConditionNode(graph, owner, annotation, resolved);
+                    addConditionalRelationship(graph, owner, conditionNode, annotation, resolved);
+                }
+            }
+        }
+    };
+}