cgraphx 2.0.2 → 2.0.3

package/dist/core/code/engine/core/ingestion/frameworks/spring/annotation-arguments.js

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSpringAnnotationArguments = parseSpringAnnotationArguments;
+exports.parseStaticStringLiteral = parseStaticStringLiteral;
+exports.parseStaticStringValues = parseStaticStringValues;
+exports.parseStaticClassLiteral = parseStaticClassLiteral;
+exports.normalizeSpringBeanType = normalizeSpringBeanType;
+function splitTopLevel(value, separator) {
+    const parts = [];
+    const stack = [];
+    let quote = null;
+    let escaped = false;
+    let start = 0;
+    // Angle brackets are deliberate: Java/Kotlin generic expressions may contain
+    // commas that are not annotation-argument separators. Ambiguous comparison
+    // expressions remain unsupported and fail closed instead of being mis-split.
+    const closing = new Map([
+        ['(', ')'],
+        ['[', ']'],
+        ['{', '}'],
+        ['<', '>'],
+    ]);
+    for (let index = 0; index < value.length; index++) {
+        const char = value[index];
+        if (quote === '"""') {
+            if (value.startsWith('"""', index)) {
+                quote = null;
+                index += 2;
+            }
+            continue;
+        }
+        if (quote !== null) {
+            if (escaped)
+                escaped = false;
+            else if (char === '\\')
+                escaped = true;
+            else if (char === quote)
+                quote = null;
+            continue;
+        }
+        if (value.startsWith('"""', index)) {
+            quote = '"""';
+            index += 2;
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            quote = char;
+            continue;
+        }
+        const closingChar = closing.get(char);
+        if (closingChar !== undefined) {
+            stack.push(closingChar);
+            continue;
+        }
+        if (stack[stack.length - 1] === char) {
+            stack.pop();
+            continue;
+        }
+        if (char === separator && stack.length === 0) {
+            parts.push(value.slice(start, index).trim());
+            start = index + 1;
+        }
+    }
+    if (quote !== null || stack.length > 0)
+        return null;
+    parts.push(value.slice(start).trim());
+    return parts;
+}
+function topLevelAssignment(argument) {
+    const stack = [];
+    let quote = null;
+    let escaped = false;
+    // Keep the same deliberate generic-delimiter policy as splitTopLevel.
+    const closing = new Map([
+        ['(', ')'],
+        ['[', ']'],
+        ['{', '}'],
+        ['<', '>'],
+    ]);
+    for (let index = 0; index < argument.length; index++) {
+        const char = argument[index];
+        if (quote === '"""') {
+            if (argument.startsWith('"""', index)) {
+                quote = null;
+                index += 2;
+            }
+            continue;
+        }
+        if (quote !== null) {
+            if (escaped)
+                escaped = false;
+            else if (char === '\\')
+                escaped = true;
+            else if (char === quote)
+                quote = null;
+            continue;
+        }
+        if (argument.startsWith('"""', index)) {
+            quote = '"""';
+            index += 2;
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            quote = char;
+            continue;
+        }
+        const closingChar = closing.get(char);
+        if (closingChar !== undefined) {
+            stack.push(closingChar);
+            continue;
+        }
+        if (stack[stack.length - 1] === char) {
+            stack.pop();
+            continue;
+        }
+        if (char === '=' && stack.length === 0)
+            return index;
+    }
+    return -1;
+}
+/** Parse Java/Kotlin annotation arguments without evaluating constants. */
+function parseSpringAnnotationArguments(annotationText) {
+    const open = annotationText.indexOf('(');
+    if (open === -1)
+        return [];
+    const close = annotationText.lastIndexOf(')');
+    if (close < open || annotationText.slice(close + 1).trim().length > 0)
+        return null;
+    const body = annotationText.slice(open + 1, close).trim();
+    if (body.length === 0)
+        return [];
+    const rawArguments = splitTopLevel(body, ',');
+    if (rawArguments === null || rawArguments.some((argument) => argument.length === 0))
+        return null;
+    const parsed = [];
+    for (const raw of rawArguments) {
+        const assignment = topLevelAssignment(raw);
+        if (assignment === -1) {
+            parsed.push({ value: raw });
+            continue;
+        }
+        const name = raw.slice(0, assignment).trim();
+        const value = raw.slice(assignment + 1).trim();
+        if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name) || value.length === 0)
+            return null;
+        parsed.push({ name, value });
+    }
+    return parsed;
+}
+function parseStaticStringLiteral(value) {
+    const trimmed = value.trim();
+    if (trimmed.startsWith('"""')) {
+        if (trimmed.length < 6 || !trimmed.endsWith('"""'))
+            return null;
+        const raw = trimmed.slice(3, -3);
+        if (raw.includes('"""') || /\$(?:\{|[A-Za-z_])/.test(raw))
+            return null;
+        return raw;
+    }
+    const match = /^"((?:\\.|[^"\\])*)"$/s.exec(trimmed);
+    if (match === null)
+        return null;
+    if (/(^|[^\\])\$(?:\{|[A-Za-z_])/.test(match[1]))
+        return null;
+    try {
+        return JSON.parse(`"${match[1]}"`);
+    }
+    catch {
+        return null;
+    }
+}
+/** Parse one string literal or a Java/Kotlin annotation string array. */
+function parseStaticStringValues(value) {
+    const trimmed = value.trim();
+    const pair = (trimmed.startsWith('{') && trimmed.endsWith('}')) ||
+        (trimmed.startsWith('[') && trimmed.endsWith(']'));
+    const body = pair ? trimmed.slice(1, -1).trim() : trimmed;
+    if (body.length === 0)
+        return [];
+    const parts = pair ? splitTopLevel(body, ',') : [body];
+    if (parts === null)
+        return null;
+    const strings = [];
+    for (const part of parts) {
+        const parsed = parseStaticStringLiteral(part);
+        if (parsed === null)
+            return null;
+        strings.push(parsed);
+    }
+    return strings;
+}
+/** Parse `Foo.class` or `Foo::class`; an Object/Any default returns an empty string. */
+function parseStaticClassLiteral(value) {
+    const compact = value.replace(/\s+/g, '');
+    const match = /^([A-Za-z_$][A-Za-z0-9_$.]*)(?:\.class|::class)$/.exec(compact);
+    if (match === null)
+        return null;
+    const typeName = match[1];
+    if (typeName === 'Object' ||
+        typeName === 'java.lang.Object' ||
+        typeName === 'Any' ||
+        typeName === 'kotlin.Any') {
+        return '';
+    }
+    return typeName;
+}
+/** Normalize a declared bean type to the graph's simple/qualified raw type key. */
+function normalizeSpringBeanType(rawType) {
+    // Projection keywords are tokens only when separated from the following
+    // type. Strip them before whitespace compaction so valid lowercase type
+    // aliases such as `outputStream` and `inside.Type` remain intact.
+    let normalized = rawType
+        .replace(/^(?:out|in)\s+/, '')
+        .replace(/([<,])\s*(?:out|in)\s+/g, '$1')
+        .replace(/\s+/g, '')
+        .replace(/^kotlin\.collections\.Mutable(List|Set|Collection|Map)(?=<|$)/, 'kotlin.collections.$1')
+        .replace(/^Mutable(List|Set|Collection|Map)(?=<|$)/, '$1')
+        .replace(/\?$/, '');
+    const generic = normalized.indexOf('<');
+    if (generic !== -1) {
+        if (!normalized.endsWith('>'))
+            return null;
+        normalized = normalized.slice(0, generic);
+    }
+    if (normalized === 'void' ||
+        normalized === 'Void' ||
+        normalized === 'Unit' ||
+        normalized === 'kotlin.Unit') {
+        return null;
+    }
+    return /^[A-Za-z_$][A-Za-z0-9_$]*(?:\.[A-Za-z_$][A-Za-z0-9_$]*)*$/.test(normalized)
+        ? normalized
+        : null;
+}

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

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSpringAopCandidateIndex = createSpringAopCandidateIndex;
+function ownerPatternLiteralPrefix(pattern) {
+    const wildcardIndex = pattern.indexOf('*');
+    const descendantIndex = pattern.indexOf('..');
+    const firstDynamicIndex = [wildcardIndex, descendantIndex]
+        .filter((index) => index >= 0)
+        .reduce((first, index) => Math.min(first, index), pattern.length);
+    return pattern.slice(0, firstDynamicIndex);
+}
+function lowerBoundByQualifiedName(buckets, prefix) {
+    let low = 0;
+    let high = buckets.length;
+    while (low < high) {
+        const middle = low + Math.floor((high - low) / 2);
+        if ((buckets[middle]?.qualifiedName ?? '') < prefix)
+            low = middle + 1;
+        else
+            high = middle;
+    }
+    return low;
+}
+function compareStrings(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+/**
+ * Build immutable candidate lists once per pipeline run. The pointcut matcher
+ * remains the final authority; this index only returns safe supersets.
+ */
+function createSpringAopCandidateIndex(candidates, methodAnnotations) {
+    const allCandidates = [...candidates];
+    const candidatesByAnnotation = new Map();
+    const candidatesByExactOwner = new Map();
+    const ownerBucketsById = new Map();
+    for (const candidate of allCandidates) {
+        for (const annotation of methodAnnotations.get(candidate.method.id) ?? []) {
+            const annotated = candidatesByAnnotation.get(annotation) ?? [];
+            annotated.push(candidate);
+            candidatesByAnnotation.set(annotation, annotated);
+        }
+        const qualifiedName = candidate.owner.properties.qualifiedName;
+        if (typeof qualifiedName !== 'string' || qualifiedName.length === 0)
+            continue;
+        const exactOwnerCandidates = candidatesByExactOwner.get(qualifiedName) ?? [];
+        exactOwnerCandidates.push(candidate);
+        candidatesByExactOwner.set(qualifiedName, exactOwnerCandidates);
+        let bucket = ownerBucketsById.get(candidate.owner.id);
+        if (bucket === undefined) {
+            bucket = { id: candidate.owner.id, qualifiedName, candidates: [] };
+            ownerBucketsById.set(candidate.owner.id, bucket);
+        }
+        bucket.candidates.push(candidate);
+    }
+    const ownerBuckets = [...ownerBucketsById.values()].sort((left, right) => compareStrings(left.qualifiedName, right.qualifiedName) || compareStrings(left.id, right.id));
+    const candidatesByOwnerPattern = new Map();
+    return {
+        totalCandidates: allCandidates.length,
+        candidatesFor(pointcut) {
+            if (pointcut.kind === 'annotation') {
+                return candidatesByAnnotation.get(pointcut.annotation) ?? [];
+            }
+            if (!pointcut.ownerPattern.includes('*') && !pointcut.ownerPattern.includes('..')) {
+                return candidatesByExactOwner.get(pointcut.ownerPattern) ?? [];
+            }
+            // Unqualified wildcard patterns (for example `*Service` or `Order*`)
+            // match the owner simple name. The qualified-name prefix index cannot
+            // safely narrow those, so preserve the full candidate superset.
+            if (!pointcut.ownerPattern.includes('.'))
+                return allCandidates;
+            const prefix = ownerPatternLiteralPrefix(pointcut.ownerPattern);
+            if (prefix.length === 0)
+                return allCandidates;
+            const cached = candidatesByOwnerPattern.get(pointcut.ownerPattern);
+            if (cached !== undefined)
+                return cached;
+            const selected = [];
+            for (let index = lowerBoundByQualifiedName(ownerBuckets, prefix); index < ownerBuckets.length; index += 1) {
+                const bucket = ownerBuckets[index];
+                if (bucket === undefined || !bucket.qualifiedName.startsWith(prefix))
+                    break;
+                selected.push(...bucket.candidates);
+            }
+            candidatesByOwnerPattern.set(pointcut.ownerPattern, selected);
+            return selected;
+        },
+    };
+}