codesearch-mcp 0.2.3-alpha → 0.4.0-alpha

package/dist/src/ast/GraphqlNameExtractor.js

@@ -0,0 +1,240 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphqlNameExtractor = void 0;
+const ts_morph_1 = require("ts-morph");
+const node_helpers_1 = require("./node-helpers");
+const graphql_grammar_1 = require("./graphql-grammar");
+class GraphqlNameExtractor {
+    resolver;
+    logger;
+    resolveDeclaration;
+    constructor(resolver, logger, resolveDeclaration = node_helpers_1.defaultResolveDeclaration) {
+        this.resolver = resolver;
+        this.logger = logger;
+        this.resolveDeclaration = resolveDeclaration;
+    }
+    buildGraphqlImportMap(sourceFile) {
+        const map = new Map();
+        for (const decl of sourceFile.getImportDeclarations()) {
+            if (decl.getModuleSpecifierValue() !== graphql_grammar_1.GRAPHQL_MODULE)
+                continue;
+            for (const named of decl.getNamedImports()) {
+                const exportedName = named.getName();
+                const localName = named.getAliasNode()?.getText() ?? exportedName;
+                map.set(localName, exportedName);
+            }
+        }
+        return map;
+    }
+    recognizedDecorator(dec, importMap) {
+        const idNode = (0, graphql_grammar_1.decoratorIdentifier)(dec);
+        if (!idNode)
+            return null;
+        const exported = importMap.get(idNode.getText());
+        if (!exported)
+            return null;
+        const expr = dec.getExpression();
+        const args = ts_morph_1.Node.isCallExpression(expr) ? expr.getArguments() : [];
+        return { name: exported, args };
+    }
+    deriveGraphqlName(args, allowOptionsName, fallbackName) {
+        if (args.length > 0) {
+            const first = args[0];
+            const { inner, wrapped } = (0, graphql_grammar_1.peekThroughWrapper)(first);
+            const literal = (0, graphql_grammar_1.literalStringValue)(inner);
+            if (literal !== null) {
+                if (wrapped)
+                    return { ok: false, reason: 'non-literal-name' };
+                return (0, graphql_grammar_1.checkGraphqlGrammar)(literal);
+            }
+            const isTypeFnOrOptions = ts_morph_1.Node.isArrowFunction(inner) || ts_morph_1.Node.isFunctionExpression(inner) || ts_morph_1.Node.isObjectLiteralExpression(inner);
+            if (!isTypeFnOrOptions)
+                return { ok: false, reason: 'non-literal-name' };
+        }
+        if (allowOptionsName) {
+            for (const arg of args) {
+                const { inner, wrapped } = (0, graphql_grammar_1.peekThroughWrapper)(arg);
+                if (!ts_morph_1.Node.isObjectLiteralExpression(inner))
+                    continue;
+                if (wrapped)
+                    return { ok: false, reason: 'non-literal-name' };
+                const nameProp = (0, graphql_grammar_1.findNameProperty)(inner);
+                if (!nameProp)
+                    continue;
+                if (ts_morph_1.Node.isShorthandPropertyAssignment(nameProp))
+                    return { ok: false, reason: 'non-literal-name' };
+                const init = nameProp.getInitializer();
+                const value = init ? (0, graphql_grammar_1.literalStringValue)(init) : null;
+                if (value !== null)
+                    return (0, graphql_grammar_1.checkGraphqlGrammar)(value);
+                return { ok: false, reason: 'non-literal-name' };
+            }
+        }
+        return (0, graphql_grammar_1.checkGraphqlGrammar)(fallbackName);
+    }
+    logGraphqlSkip(filePath, declaration, decorator, reason, value) {
+        const fields = { filePath, declaration, decorator, reason };
+        if (value !== undefined)
+            fields.value = value;
+        this.logger.debug('AstParser: graphql row skipped', fields);
+    }
+    declarationNameFor(node, fallback) {
+        const described = this.resolver.describeIndexedNode(node);
+        return described ? this.resolver.qualifiedName(described) : fallback;
+    }
+    classGraphqlTypeName(declClass) {
+        const declImportMap = this.buildGraphqlImportMap(declClass.getSourceFile());
+        const decorators = declClass.getDecorators();
+        const hasAnyTypeSpelledDecorator = decorators.some((d) => {
+            const idNode = (0, graphql_grammar_1.decoratorIdentifier)(d);
+            const text = idNode?.getText();
+            return text === 'ObjectType' || text === 'InterfaceType';
+        });
+        const recognized = decorators
+            .map(d => this.recognizedDecorator(d, declImportMap))
+            .find(r => r?.name === 'ObjectType')
+            ?? decorators.map(d => this.recognizedDecorator(d, declImportMap)).find(r => r?.name === 'InterfaceType');
+        if (recognized) {
+            const fallbackName = declClass.getName() ?? (declClass.isDefaultExport() ? 'default' : '');
+            const nameResult = this.deriveGraphqlName(recognized.args, false, fallbackName);
+            return nameResult.ok ? { ok: true, name: nameResult.name } : { ok: false };
+        }
+        if (hasAnyTypeSpelledDecorator)
+            return { ok: false };
+        const name = declClass.getName();
+        if (!name)
+            return { ok: false };
+        return graphql_grammar_1.GRAPHQL_NAME_RE.test(name) ? { ok: true, name } : { ok: false, value: name };
+    }
+    resolveResolverParentType(cls, importMap) {
+        const resolverDec = cls.getDecorators()
+            .map(d => this.recognizedDecorator(d, importMap))
+            .find(r => r?.name === 'Resolver');
+        if (!resolverDec || resolverDec.args.length === 0)
+            return { ok: false };
+        const argNode = resolverDec.args[0];
+        const literal = (0, graphql_grammar_1.literalStringValue)(argNode);
+        if (literal !== null) {
+            return graphql_grammar_1.GRAPHQL_NAME_RE.test(literal) ? { ok: true, name: literal } : { ok: false, value: literal };
+        }
+        const identifier = (0, graphql_grammar_1.extractResolverIdentifier)(argNode);
+        if (!identifier)
+            return { ok: false };
+        const resolve = this.resolveDeclaration;
+        const declaration = resolve(identifier);
+        if (!declaration || !ts_morph_1.Node.isClassDeclaration(declaration))
+            return { ok: false };
+        return this.classGraphqlTypeName(declaration);
+    }
+    extractClassTypeRows(cls, importMap, ownByDeclNode, filePath, serviceName, entries) {
+        const own = ownByDeclNode.get(cls);
+        const declaration = this.declarationNameFor(cls, own?.entry.name ?? cls.getName() ?? 'default');
+        const seenNames = new Set();
+        for (const dec of cls.getDecorators()) {
+            const rec = this.recognizedDecorator(dec, importMap);
+            if (!rec || !graphql_grammar_1.GRAPHQL_TYPE_DECORATORS.has(rec.name))
+                continue;
+            if ((0, graphql_grammar_1.isAbstractGraphqlType)(rec.args)) {
+                this.logGraphqlSkip(filePath, declaration, rec.name, 'abstract-type');
+                continue;
+            }
+            if (!own) {
+                this.logGraphqlSkip(filePath, declaration, rec.name, 'no-symbol-row');
+                continue;
+            }
+            const nameResult = this.deriveGraphqlName(rec.args, false, own.entry.name);
+            if (!nameResult.ok) {
+                this.logGraphqlSkip(filePath, declaration, rec.name, nameResult.reason, nameResult.reason === 'invalid-name' ? nameResult.value : undefined);
+                continue;
+            }
+            if (seenNames.has(nameResult.name)) {
+                this.logGraphqlSkip(filePath, declaration, rec.name, 'duplicate', own.entry.name);
+                continue;
+            }
+            seenNames.add(nameResult.name);
+            entries.push({
+                project: serviceName, filePath, name: nameResult.name, kind: 'graphql_type',
+                signature: own.entry.signature, line: own.entry.line, endLine: own.entry.endLine, col: own.entry.col,
+                container: null, isStatic: false, target: declaration,
+            });
+        }
+    }
+    extractResolveFieldRow(method, rec, own, declaration, importMap, filePath, serviceName, entries) {
+        if (!own) {
+            this.logGraphqlSkip(filePath, declaration, 'ResolveField', 'no-symbol-row');
+            return;
+        }
+        const cls = method.getParent();
+        if (!cls || !ts_morph_1.Node.isClassDeclaration(cls)) {
+            this.logGraphqlSkip(filePath, declaration, 'ResolveField', 'unresolvable-parent');
+            return;
+        }
+        const parent = this.resolveResolverParentType(cls, importMap);
+        if (!parent.ok) {
+            this.logGraphqlSkip(filePath, declaration, 'ResolveField', 'unresolvable-parent', parent.value);
+            return;
+        }
+        const nameResult = this.deriveGraphqlName(rec.args, true, own.entry.name);
+        if (!nameResult.ok) {
+            this.logGraphqlSkip(filePath, declaration, 'ResolveField', nameResult.reason, nameResult.reason === 'invalid-name' ? nameResult.value : undefined);
+            return;
+        }
+        entries.push({
+            project: serviceName, filePath, name: nameResult.name, kind: 'graphql_field',
+            signature: own.entry.signature, line: own.entry.line, endLine: own.entry.endLine, col: own.entry.col,
+            container: parent.name, isStatic: own.entry.isStatic, target: declaration,
+        });
+    }
+    extractMethodOperationRows(method, importMap, ownByDeclNode, filePath, serviceName, entries) {
+        const own = ownByDeclNode.get(method);
+        const declaration = this.declarationNameFor(method, own?.entry.name ?? (0, node_helpers_1.memberName)(method.getNameNode()) ?? '<anonymous>');
+        for (const dec of method.getDecorators()) {
+            const rec = this.recognizedDecorator(dec, importMap);
+            if (!rec)
+                continue;
+            if (rec.name === 'ResolveField') {
+                try {
+                    this.extractResolveFieldRow(method, rec, own, declaration, importMap, filePath, serviceName, entries);
+                }
+                catch (err) {
+                    this.logGraphqlSkip(filePath, declaration, 'ResolveField', 'unresolvable-parent');
+                }
+                continue;
+            }
+            const kind = graphql_grammar_1.GRAPHQL_OPERATION_KIND[rec.name];
+            if (!kind)
+                continue;
+            if (!own) {
+                this.logGraphqlSkip(filePath, declaration, rec.name, 'no-symbol-row');
+                continue;
+            }
+            const nameResult = this.deriveGraphqlName(rec.args, true, own.entry.name);
+            if (!nameResult.ok) {
+                this.logGraphqlSkip(filePath, declaration, rec.name, nameResult.reason, nameResult.reason === 'invalid-name' ? nameResult.value : undefined);
+                continue;
+            }
+            entries.push({
+                project: serviceName, filePath, name: nameResult.name, kind,
+                signature: own.entry.signature, line: own.entry.line, endLine: own.entry.endLine, col: own.entry.col,
+                container: rec.name, isStatic: own.entry.isStatic, target: declaration,
+            });
+        }
+    }
+    extractGraphqlNames(sourceFile, filePath, serviceName, ownRows) {
+        const importMap = this.buildGraphqlImportMap(sourceFile);
+        if (importMap.size === 0)
+            return [];
+        const ownByDeclNode = new Map();
+        for (const c of ownRows)
+            ownByDeclNode.set(c.declNode, c);
+        const entries = [];
+        for (const cls of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.ClassDeclaration)) {
+            this.extractClassTypeRows(cls, importMap, ownByDeclNode, filePath, serviceName, entries);
+        }
+        for (const method of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.MethodDeclaration)) {
+            this.extractMethodOperationRows(method, importMap, ownByDeclNode, filePath, serviceName, entries);
+        }
+        return entries;
+    }
+}
+exports.GraphqlNameExtractor = GraphqlNameExtractor;

package/dist/src/ast/ImportEdgeExtractor.d.ts

@@ -0,0 +1,11 @@
+import { type SourceFile } from 'ts-morph';
+import type { DepEdge } from '../interfaces/IAstParser';
+import type { ILogger } from '../interfaces';
+export declare class ImportEdgeExtractor {
+    private readonly logger;
+    constructor(logger: ILogger);
+    extractEdges(sourceFile: SourceFile, filePath: string, serviceName: string): DepEdge[];
+    private resolveSideEffectModuleSpecifier;
+    private resolveFromSymbol;
+    private buildUsageMap;
+}

package/dist/src/ast/ImportEdgeExtractor.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportEdgeExtractor = void 0;
+const ts_morph_1 = require("ts-morph");
+class ImportEdgeExtractor {
+    logger;
+    constructor(logger) {
+        this.logger = logger;
+    }
+    extractEdges(sourceFile, filePath, serviceName) {
+        const edges = [];
+        const usageMap = this.buildUsageMap(sourceFile);
+        for (const decl of sourceFile.getImportDeclarations()) {
+            const namedImports = decl.getNamedImports();
+            const defaultImport = decl.getDefaultImport();
+            const namespaceImport = decl.getNamespaceImport();
+            const hasClause = Boolean(defaultImport || namespaceImport || namedImports.length > 0);
+            const resolved = decl.getModuleSpecifierSourceFile();
+            let toFile = resolved ? resolved.getFilePath() : null;
+            if (!toFile && !hasClause) {
+                toFile = this.resolveSideEffectModuleSpecifier(decl, sourceFile, filePath);
+            }
+            if (!toFile) {
+                const specifier = decl.getModuleSpecifierValue();
+                const isCodeImport = !/\.(json|css|scss|less|svg|png|jpg|gif|ico|woff2?|ttf|eot)(\?.*)?$/.test(specifier);
+                if (specifier.startsWith('.') && isCodeImport) {
+                    this.logger.debug('AstParser: unresolved import', { specifier, file: filePath });
+                }
+                continue;
+            }
+            if (toFile.includes('/node_modules/'))
+                continue;
+            if (!hasClause) {
+                edges.push({
+                    project: serviceName, fromFile: filePath, fromSymbol: null,
+                    toFile, toSymbol: null, depType: 'import-side-effect',
+                });
+                continue;
+            }
+            if (defaultImport) {
+                const fromSymbol = this.resolveFromSymbol(defaultImport.getText(), usageMap);
+                edges.push({
+                    project: serviceName, fromFile: filePath, fromSymbol,
+                    toFile, toSymbol: null, depType: 'import-default',
+                });
+            }
+            if (namespaceImport) {
+                const fromSymbol = this.resolveFromSymbol(namespaceImport.getText(), usageMap);
+                edges.push({
+                    project: serviceName, fromFile: filePath, fromSymbol,
+                    toFile, toSymbol: null, depType: 'import-namespace',
+                });
+            }
+            for (const named of namedImports) {
+                const localName = named.getAliasNode()?.getText() ?? named.getName();
+                const fromSymbol = this.resolveFromSymbol(localName, usageMap);
+                edges.push({
+                    project: serviceName, fromFile: filePath, fromSymbol,
+                    toFile, toSymbol: named.getName(), depType: 'import',
+                });
+            }
+        }
+        for (const decl of sourceFile.getExportDeclarations()) {
+            const resolved = decl.getModuleSpecifierSourceFile();
+            if (!resolved)
+                continue;
+            const toFile = resolved.getFilePath();
+            if (toFile.includes('/node_modules/'))
+                continue;
+            const namedExports = decl.getNamedExports();
+            if (namedExports.length > 0) {
+                for (const named of namedExports) {
+                    edges.push({
+                        project: serviceName, fromFile: filePath, fromSymbol: null,
+                        toFile, toSymbol: named.getName(), depType: 'reexport',
+                    });
+                }
+            }
+            else {
+                edges.push({
+                    project: serviceName, fromFile: filePath, fromSymbol: null,
+                    toFile, toSymbol: null, depType: 'reexport-namespace',
+                });
+            }
+        }
+        return edges;
+    }
+    resolveSideEffectModuleSpecifier(decl, sourceFile, filePath) {
+        const specifier = decl.getModuleSpecifierValue();
+        const compilerOptions = sourceFile.getProject().getCompilerOptions();
+        const result = ts_morph_1.ts.resolveModuleName(specifier, filePath, compilerOptions, ts_morph_1.ts.sys);
+        const resolvedFileName = result.resolvedModule?.resolvedFileName;
+        if (!resolvedFileName)
+            return null;
+        return sourceFile.getProject().getSourceFile(resolvedFileName)?.getFilePath() ?? null;
+    }
+    resolveFromSymbol(localName, usageMap) {
+        const users = usageMap.get(localName);
+        return users?.length === 1 ? users[0] : null;
+    }
+    buildUsageMap(sourceFile) {
+        const map = new Map();
+        const containers = [
+            ...sourceFile.getClasses().flatMap(n => n.getName() ? [{ name: n.getName(), node: n }] : []),
+            ...sourceFile.getFunctions().flatMap(n => n.getName() ? [{ name: n.getName(), node: n }] : []),
+            ...sourceFile.getVariableStatements()
+                .flatMap(stmt => stmt.getDeclarations())
+                .flatMap(n => {
+                const name = n.getName();
+                return name ? [{ name, node: n }] : [];
+            }),
+        ];
+        for (const { name, node } of containers) {
+            for (const id of node.getDescendantsOfKind(ts_morph_1.SyntaxKind.Identifier)) {
+                const text = id.getText();
+                const existing = map.get(text);
+                if (existing) {
+                    if (!existing.includes(name))
+                        existing.push(name);
+                }
+                else {
+                    map.set(text, [name]);
+                }
+            }
+        }
+        return map;
+    }
+}
+exports.ImportEdgeExtractor = ImportEdgeExtractor;

package/dist/src/ast/IndexedNodeResolver.d.ts

@@ -0,0 +1,14 @@
+import { Node } from 'ts-morph';
+import type { IIndexedNodeResolver, IndexedNodeDescription } from '../interfaces/IIndexedNodeResolver';
+export declare class IndexedNodeResolver implements IIndexedNodeResolver {
+    private static isValidSegment;
+    private isModuleOrNamespaceLevelVariable;
+    private classExpressionRoot;
+    private objectLiteralRootValid;
+    private isTopLevelOrNamespaceDirect;
+    private walkStep;
+    private containerSegments;
+    describeIndexedNode(node: Node): IndexedNodeDescription | null;
+    qualifiedName(described: IndexedNodeDescription): string;
+    findFromSymbol(node: Node): string | null;
+}

package/dist/src/ast/IndexedNodeResolver.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexedNodeResolver = void 0;
+const ts_morph_1 = require("ts-morph");
+const node_helpers_1 = require("./node-helpers");
+const VALID_SEGMENT = /^#?[\w$]+$/;
+class IndexedNodeResolver {
+    static isValidSegment(s) {
+        return VALID_SEGMENT.test(s);
+    }
+    isModuleOrNamespaceLevelVariable(varDecl) {
+        const stmt = varDecl.getParent()?.getParent();
+        const stmtParent = stmt?.getParent();
+        return ts_morph_1.Node.isSourceFile(stmtParent) || ts_morph_1.Node.isModuleBlock(stmtParent);
+    }
+    classExpressionRoot(classExpr) {
+        const parent = (0, node_helpers_1.unwrapParent)(classExpr);
+        if (!parent)
+            return null;
+        if (ts_morph_1.Node.isVariableDeclaration(parent)) {
+            const name = parent.getName();
+            return name ? { name, namingParent: parent } : null;
+        }
+        if (ts_morph_1.Node.isExportAssignment(parent) && !parent.isExportEquals()) {
+            return { name: 'default', namingParent: parent };
+        }
+        return null;
+    }
+    objectLiteralRootValid(obj) {
+        const parent = (0, node_helpers_1.unwrapParent)(obj);
+        if (!parent)
+            return false;
+        if (ts_morph_1.Node.isPropertyAssignment(parent))
+            return true;
+        if (ts_morph_1.Node.isVariableDeclaration(parent))
+            return this.isModuleOrNamespaceLevelVariable(parent);
+        if (ts_morph_1.Node.isExportAssignment(parent) && !parent.isExportEquals())
+            return true;
+        return false;
+    }
+    isTopLevelOrNamespaceDirect(node) {
+        return ts_morph_1.Node.isSourceFile(node) || ts_morph_1.Node.isModuleBlock(node);
+    }
+    walkStep(node) {
+        if (ts_morph_1.Node.isModuleDeclaration(node)) {
+            if (node.compilerNode.flags & ts_morph_1.NodeFlags.GlobalAugmentation)
+                return { kind: 'exclude' };
+            const nameNode = node.getNameNode();
+            if (ts_morph_1.Node.isStringLiteral(nameNode))
+                return { kind: 'exclude' };
+            return { kind: 'segment', text: nameNode.getText() };
+        }
+        if (ts_morph_1.Node.isClassDeclaration(node)) {
+            const name = node.getName();
+            if (name)
+                return { kind: 'segment', text: name };
+            if (node.isDefaultExport())
+                return { kind: 'segment', text: 'default' };
+            return { kind: 'exclude' };
+        }
+        if (ts_morph_1.Node.isClassExpression(node)) {
+            const root = this.classExpressionRoot(node);
+            if (!root)
+                return { kind: 'exclude' };
+            return { kind: 'segment', text: root.name, skipTo: root.namingParent };
+        }
+        if (ts_morph_1.Node.isFunctionDeclaration(node)) {
+            const name = node.getName();
+            return name ? { kind: 'segment', text: name } : { kind: 'transparent' };
+        }
+        if (ts_morph_1.Node.isMethodDeclaration(node) || ts_morph_1.Node.isGetAccessorDeclaration(node) || ts_morph_1.Node.isSetAccessorDeclaration(node)) {
+            const name = (0, node_helpers_1.memberName)(node.getNameNode());
+            return name !== null ? { kind: 'segment', text: name } : { kind: 'exclude' };
+        }
+        if (ts_morph_1.Node.isConstructorDeclaration(node)) {
+            return { kind: 'segment', text: 'constructor' };
+        }
+        if (ts_morph_1.Node.isPropertyDeclaration(node) || ts_morph_1.Node.isPropertyAssignment(node)) {
+            const name = (0, node_helpers_1.memberName)(node.getNameNode());
+            return name !== null ? { kind: 'segment', text: name } : { kind: 'exclude' };
+        }
+        if (ts_morph_1.Node.isInterfaceDeclaration(node)) {
+            return { kind: 'segment', text: node.getName() };
+        }
+        if (ts_morph_1.Node.isTypeAliasDeclaration(node)) {
+            return { kind: 'segment', text: node.getName() };
+        }
+        if (ts_morph_1.Node.isVariableDeclaration(node)) {
+            return { kind: 'segment', text: node.getName() };
+        }
+        if (ts_morph_1.Node.isObjectLiteralExpression(node)) {
+            return this.objectLiteralRootValid(node) ? { kind: 'transparent' } : { kind: 'exclude' };
+        }
+        return { kind: 'transparent' };
+    }
+    containerSegments(node) {
+        const segments = [];
+        let current = node.getParent();
+        while (current) {
+            const step = this.walkStep(current);
+            if (step.kind === 'exclude')
+                return null;
+            if (step.kind === 'segment') {
+                if (!IndexedNodeResolver.isValidSegment(step.text))
+                    return null;
+                segments.unshift(step.text);
+                current = step.skipTo ? step.skipTo.getParent() : current.getParent();
+                continue;
+            }
+            current = current.getParent();
+        }
+        return segments;
+    }
+    describeIndexedNode(node) {
+        if (ts_morph_1.Node.isClassDeclaration(node)) {
+            const name = node.getName() ?? (node.isDefaultExport() ? 'default' : null);
+            if (name === null)
+                return null;
+            const container = this.containerSegments(node);
+            return container === null ? null : { name, container };
+        }
+        if (ts_morph_1.Node.isClassExpression(node)) {
+            const root = this.classExpressionRoot(node);
+            if (!root)
+                return null;
+            const container = this.containerSegments(root.namingParent);
+            return container === null ? null : { name: root.name, container };
+        }
+        if (ts_morph_1.Node.isFunctionDeclaration(node)) {
+            const name = node.getName();
+            if (!name || !this.isTopLevelOrNamespaceDirect(node.getParent()))
+                return null;
+            const container = this.containerSegments(node);
+            return container === null ? null : { name, container };
+        }
+        if (ts_morph_1.Node.isMethodDeclaration(node) || ts_morph_1.Node.isGetAccessorDeclaration(node) || ts_morph_1.Node.isSetAccessorDeclaration(node)) {
+            const name = (0, node_helpers_1.memberName)(node.getNameNode());
+            if (name === null)
+                return null;
+            const container = this.containerSegments(node);
+            return container === null ? null : { name, container };
+        }
+        if (ts_morph_1.Node.isConstructorDeclaration(node)) {
+            const container = this.containerSegments(node);
+            return container === null ? null : { name: 'constructor', container };
+        }
+        if (ts_morph_1.Node.isPropertyDeclaration(node) || ts_morph_1.Node.isPropertyAssignment(node)) {
+            const init = node.getInitializer();
+            if (!init)
+                return null;
+            const unwrapped = (0, node_helpers_1.unwrapExpr)(init);
+            if (!(ts_morph_1.Node.isArrowFunction(unwrapped) || ts_morph_1.Node.isFunctionExpression(unwrapped)))
+                return null;
+            const name = (0, node_helpers_1.memberName)(node.getNameNode());
+            if (name === null)
+                return null;
+            const container = this.containerSegments(node);
+            return container === null ? null : { name, container };
+        }
+        if (ts_morph_1.Node.isInterfaceDeclaration(node)) {
+            if (!this.isTopLevelOrNamespaceDirect(node.getParent()))
+                return null;
+            const container = this.containerSegments(node);
+            return container === null ? null : { name: node.getName(), container };
+        }
+        if (ts_morph_1.Node.isTypeAliasDeclaration(node)) {
+            if (!this.isTopLevelOrNamespaceDirect(node.getParent()))
+                return null;
+            const container = this.containerSegments(node);
+            return container === null ? null : { name: node.getName(), container };
+        }
+        if (ts_morph_1.Node.isVariableDeclaration(node)) {
+            if (!this.isModuleOrNamespaceLevelVariable(node))
+                return null;
+            const container = this.containerSegments(node);
+            return container === null ? null : { name: node.getName(), container };
+        }
+        if (ts_morph_1.Node.isMethodSignature(node) || ts_morph_1.Node.isPropertySignature(node)) {
+            if (ts_morph_1.Node.isPropertySignature(node)) {
+                const typeNode = node.getTypeNode();
+                if (!typeNode || !ts_morph_1.Node.isFunctionTypeNode(typeNode))
+                    return null;
+            }
+            const parent = node.getParent();
+            let validParent = false;
+            if (ts_morph_1.Node.isInterfaceDeclaration(parent)) {
+                validParent = true;
+            }
+            else if (ts_morph_1.Node.isTypeLiteral(parent)) {
+                const aliasParent = parent.getParent();
+                validParent = ts_morph_1.Node.isTypeAliasDeclaration(aliasParent) && aliasParent.getTypeNode() === parent;
+            }
+            if (!validParent)
+                return null;
+            const name = (0, node_helpers_1.memberName)(node.getNameNode());
+            if (name === null)
+                return null;
+            const container = this.containerSegments(node);
+            return container === null ? null : { name, container };
+        }
+        return null;
+    }
+    qualifiedName(described) {
+        return described.container.length ? `${described.container.join('.')}.${described.name}` : described.name;
+    }
+    findFromSymbol(node) {
+        let current = node.getParent();
+        while (current) {
+            const described = this.describeIndexedNode(current);
+            if (described)
+                return this.qualifiedName(described);
+            current = current.getParent();
+        }
+        return null;
+    }
+}
+exports.IndexedNodeResolver = IndexedNodeResolver;

package/dist/src/ast/MemberExtractor.d.ts

@@ -0,0 +1,8 @@
+import { type SourceFile } from 'ts-morph';
+import type { IIndexedNodeResolver } from '../interfaces';
+import type { DeclarationCandidate } from '../declarations/DeclarationTreeBuilder';
+export declare class MemberExtractor {
+    private readonly resolver;
+    constructor(resolver: IIndexedNodeResolver);
+    extractMembers(sourceFile: SourceFile, filePath: string, serviceName: string): DeclarationCandidate[];
+}