codesearch-mcp 0.2.1-alpha → 0.2.3-alpha

package/dist/src/services/AstParserService.js

@@ -36,9 +36,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AstParserService = void 0;
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
-const typescript_1 = require("typescript");
 const ts_morph_1 = require("ts-morph");
 const LoggerService_1 = require("./LoggerService");
+const GRAPHQL_MODULE = '@nestjs/graphql';
+const GRAPHQL_TYPE_DECORATORS = new Set(['ObjectType', 'InputType', 'InterfaceType']);
+const GRAPHQL_OPERATION_KIND = {
+    Query: 'graphql_query', Mutation: 'graphql_mutation', Subscription: 'graphql_subscription',
+};
+const GRAPHQL_NAME_RE = /^[_A-Za-z][_0-9A-Za-z]*$/;
 const FALLBACK_OPTS = {
     skipAddingFilesFromTsConfig: true,
     skipFileDependencyResolution: false,
@@ -48,9 +53,11 @@ const MORPH_CACHE_MAX = 10;
 const VALID_SEGMENT = /^#?[\w$]+$/;
 class AstParserService {
     logger;
+    deps;
     morphProjects = new Map();
-    constructor(logger = LoggerService_1.LoggerService.silent()) {
+    constructor(logger = LoggerService_1.LoggerService.silent(), deps = {}) {
         this.logger = logger;
+        this.deps = deps;
     }
     // ── public interface ────────────────────────────────────────────────────────
     async analyzeProject(filePaths, serviceName, projectRoot = process.cwd(), opts = {}) {
@@ -62,7 +69,7 @@ class AstParserService {
         const morphProject = this.createMorphProject(projectRoot, skipDependencyResolution, rootTsConfigPath);
         for (const filePath of filePaths) {
             if (!/\.(ts|tsx|js|jsx)$/.test(filePath) || /\.d\.ts$/.test(filePath)) {
-                analysisMap.set(filePath, { edges: [], symbols: [], calls: [], members: [] });
+                analysisMap.set(filePath, { edges: [], symbols: [], calls: [], members: [], graphqlNames: [] });
                 continue;
             }
             try {
@@ -70,7 +77,7 @@ class AstParserService {
             }
             catch (err) {
                 this.logger.warn('AstParser: failed to add source file', { filePath, reason: err.message });
-                analysisMap.set(filePath, { edges: [], symbols: [], calls: [], members: [] });
+                analysisMap.set(filePath, { edges: [], symbols: [], calls: [], members: [], graphqlNames: [] });
             }
         }
         for (const sourceFile of morphProject.getSourceFiles()) {
@@ -102,7 +109,7 @@ class AstParserService {
         this.logger.debug('AstParser: analyzeFile start', { filePath, serviceName, projectRoot });
         if (!/\.(ts|tsx|js|jsx)$/.test(filePath) || /\.d\.ts$/.test(filePath)) {
             this.logger.debug('AstParser: analyzeFile skip (non-TS)', { filePath, ms: Date.now() - t0 });
-            return { edges: [], symbols: [], calls: [], members: [] };
+            return { edges: [], symbols: [], calls: [], members: [], graphqlNames: [] };
         }
         const morphProject = this.getMorphProject(projectRoot);
         const existing = morphProject.getSourceFile(filePath);
@@ -114,7 +121,7 @@ class AstParserService {
         }
         catch (err) {
             this.logger.warn('AstParser: analyzeFile failed to add source file', { filePath, reason: err.message, ms: Date.now() - t0 });
-            return { edges: [], symbols: [], calls: [], members: [] };
+            return { edges: [], symbols: [], calls: [], members: [], graphqlNames: [] };
         }
         const result = this.analyzeSourceFile(sourceFile, filePath, serviceName);
         morphProject.removeSourceFile(sourceFile);
@@ -149,11 +156,24 @@ class AstParserService {
             const members = memberCandidates.map(c => c.entry);
             const calls = this.extractCalls(sourceFile, filePath, serviceName);
             const ownerRanges = this.buildOwnerRanges([...symbolCandidates, ...memberCandidates]);
-            return { edges, symbols, members, calls, ownerRanges };
+            // GraphQL-named rows are isolated like members: a bug here must never
+            // change a file's symbols, members, chunks, ownerPath or call graph.
+            // Runs after member extraction (decision 6 of `graphql-symbols`) — a
+            // GraphQL row is written only when the decorated declaration's own row
+            // was written to code_symbol.
+            let graphqlNames = [];
+            try {
+                graphqlNames = this.extractGraphqlNames(sourceFile, filePath, serviceName, [...symbolCandidates, ...memberCandidates]);
+            }
+            catch (err) {
+                this.logger.warn('AstParser: GraphQL extraction failed', { filePath, reason: err.message });
+                graphqlNames = [];
+            }
+            return { edges, symbols, members, calls, ownerRanges, graphqlNames };
         }
         catch (err) {
             this.logger.warn('AstParser: failed to analyze file', { filePath, reason: err.message });
-            return { edges: [], symbols: [], calls: [], members: [] };
+            return { edges: [], symbols: [], calls: [], members: [], graphqlNames: [] };
         }
     }
     // ── private: MorphProject cache (LRU, max MORPH_CACHE_MAX entries) ──────────
@@ -231,8 +251,19 @@ class AstParserService {
         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();
-            if (!resolved) {
+            let toFile = resolved ? resolved.getFilePath() : null;
+            // A bindingless specifier never resolves through ts-morph's bound symbol
+            // (nothing is bound), even for a real project file — fall back to
+            // TypeScript's own resolver and map the result back onto the project.
+            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) {
@@ -240,34 +271,37 @@ class AstParserService {
                 }
                 continue;
             }
-            const toFile = resolved.getFilePath();
             if (toFile.includes('/node_modules/'))
                 continue;
-            const namedImports = decl.getNamedImports();
-            const defaultImport = decl.getDefaultImport();
-            const namespaceImport = decl.getNamespaceImport();
-            if (namedImports.length > 0) {
-                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',
-                    });
-                }
-            }
-            else if (defaultImport) {
+            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',
                 });
             }
-            else if (namespaceImport) {
+            if (namespaceImport) {
+                const fromSymbol = this.resolveFromSymbol(namespaceImport.getText(), usageMap);
                 edges.push({
-                    project: serviceName, fromFile: filePath, fromSymbol: null,
+                    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();
@@ -294,6 +328,18 @@ class AstParserService {
         }
         return edges;
     }
+    /** Manual fallback for a bindingless import specifier (design.md decision 2) —
+     * ts-morph's `getModuleSpecifierSourceFile()` is `null` for these even when
+     * the target is a real project file, since nothing is bound to resolve through. */
+    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;
@@ -478,7 +524,7 @@ class AstParserService {
             const described = this.describeIndexedNode(c);
             if (!described)
                 continue;
-            const kw = c.getFirstChildByKind(typescript_1.SyntaxKind.ConstructorKeyword) ?? c;
+            const kw = c.getFirstChildByKind(ts_morph_1.SyntaxKind.ConstructorKeyword) ?? c;
             push(c, kw, described.name, 'constructor', described.container, false, c.getBody() !== undefined);
         }
         for (const p of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.PropertyDeclaration)) {
@@ -560,6 +606,364 @@ class AstParserService {
             endLine: c.declNode.getEndLineNumber(),
         }));
     }
+    // ── private: GraphQL-named rows (graphql-symbols) ───────────────────────────
+    /** Local name → the name exported by `@nestjs/graphql`, for every named import
+     * of that module specifier (aliases followed). Recognition is import-based,
+     * not type-checker-based, so `skipFileDependencyResolution` batches agree. */
+    buildGraphqlImportMap(sourceFile) {
+        const map = new Map();
+        for (const decl of sourceFile.getImportDeclarations()) {
+            if (decl.getModuleSpecifierValue() !== 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;
+    }
+    /** The identifier naming a decorator's expression (`@Foo` or the callee of `@Foo(...)`). */
+    static decoratorIdentifier(dec) {
+        const expr = dec.getExpression();
+        if (ts_morph_1.Node.isCallExpression(expr)) {
+            const callee = expr.getExpression();
+            return ts_morph_1.Node.isIdentifier(callee) ? callee : undefined;
+        }
+        return ts_morph_1.Node.isIdentifier(expr) ? expr : undefined;
+    }
+    /** `dec` recognised against `importMap` — its exported `@nestjs/graphql` name and its call arguments (`[]` for a bare `@Foo`). */
+    recognizedDecorator(dec, importMap) {
+        const idNode = AstParserService.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 };
+    }
+    static literalStringValue(node) {
+        if (ts_morph_1.Node.isStringLiteral(node) || ts_morph_1.Node.isNoSubstitutionTemplateLiteral(node))
+            return node.getLiteralValue();
+        return null;
+    }
+    static checkGraphqlGrammar(name) {
+        return GRAPHQL_NAME_RE.test(name) ? { ok: true, name } : { ok: false, reason: 'invalid-name', value: name };
+    }
+    /** `true` when any decorator argument is an (unwrapped) options object
+     * literal with `isAbstract: true` — an abstract base type (`PaginatedType`
+     * pattern) that NestJS never registers in the actual GraphQL schema. */
+    static isAbstractGraphqlType(args) {
+        return args.some((arg) => {
+            if (!ts_morph_1.Node.isObjectLiteralExpression(arg))
+                return false;
+            const prop = arg.getProperties().find((p) => {
+                if (!ts_morph_1.Node.isPropertyAssignment(p))
+                    return false;
+                const nameNode = p.getNameNode();
+                if (ts_morph_1.Node.isIdentifier(nameNode))
+                    return nameNode.getText() === 'isAbstract';
+                if (ts_morph_1.Node.isStringLiteral(nameNode))
+                    return nameNode.getLiteralValue() === 'isAbstract';
+                return false;
+            });
+            const init = prop?.getInitializer();
+            return init !== undefined && ts_morph_1.Node.isTrueLiteral(init);
+        });
+    }
+    /** `obj`'s own `name` property (`PropertyAssignment` or `ShorthandPropertyAssignment`), if any. */
+    static findNameProperty(obj) {
+        return obj.getProperties().find((p) => {
+            if (!ts_morph_1.Node.isPropertyAssignment(p) && !ts_morph_1.Node.isShorthandPropertyAssignment(p))
+                return false;
+            const nameNode = p.getNameNode();
+            if (ts_morph_1.Node.isIdentifier(nameNode))
+                return nameNode.getText() === 'name';
+            if (ts_morph_1.Node.isStringLiteral(nameNode))
+                return nameNode.getLiteralValue() === 'name';
+            return false;
+        });
+    }
+    /** Strips parens/`as`/`satisfies`/non-null wrappers (any nesting) to find the
+     * underlying node — used only to classify an argument's *shape* (type
+     * function vs. options object vs. literal vs. other), never to read a name
+     * value through the wrapper (decision 4 of `graphql-symbols` forbids that). */
+    static peekThroughWrapper(node) {
+        let current = node;
+        let wrapped = false;
+        while (true) {
+            if (ts_morph_1.Node.isParenthesizedExpression(current) || ts_morph_1.Node.isAsExpression(current) || ts_morph_1.Node.isSatisfiesExpression(current) || ts_morph_1.Node.isNonNullExpression(current)) {
+                current = current.getExpression();
+                wrapped = true;
+                continue;
+            }
+            break;
+        }
+        return { inner: current, wrapped };
+    }
+    /**
+     * GraphQL name from a decorator's arguments (design decision 4 of
+     * `graphql-symbols`) — syntactic, no wrapper looked through at any step.
+     * `allowOptionsName` gates step 2 (the `name` option — `Query`/`Mutation`/
+     * `Subscription`/`ResolveField` only); `fallbackName` is the TS name used at
+     * step 3.
+     */
+    deriveGraphqlName(args, allowOptionsName, fallbackName) {
+        if (args.length > 0) {
+            const first = args[0];
+            const { inner, wrapped } = AstParserService.peekThroughWrapper(first);
+            const literal = AstParserService.literalStringValue(inner);
+            if (literal !== null) {
+                // A wrapped literal is still "a wrapped ... argument", an anything-else
+                // node (decision 4) — reading its value through the wrapper is exactly
+                // what "no wrapper is looked through" forbids.
+                if (wrapped)
+                    return { ok: false, reason: 'non-literal-name' };
+                return AstParserService.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' };
+            // Type function / options object, wrapped or not — this is a routing
+            // decision only (go to step 2/3); nothing is read from it here, so its
+            // wrapper doesn't matter yet.
+        }
+        if (allowOptionsName) {
+            for (const arg of args) {
+                const { inner, wrapped } = AstParserService.peekThroughWrapper(arg);
+                if (!ts_morph_1.Node.isObjectLiteralExpression(inner))
+                    continue;
+                // A wrapped options object cannot be trusted without looking through
+                // the wrapper, which decision 4 forbids — treat it as non-literal
+                // rather than silently skipping to the next argument or to step 3.
+                if (wrapped)
+                    return { ok: false, reason: 'non-literal-name' };
+                const nameProp = AstParserService.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 ? AstParserService.literalStringValue(init) : null;
+                if (value !== null)
+                    return AstParserService.checkGraphqlGrammar(value);
+                return { ok: false, reason: 'non-literal-name' };
+            }
+        }
+        return AstParserService.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);
+    }
+    /** `declNode`'s qualified TypeScript name for diagnostics, independent of
+     * whether its own `code_symbol` row was actually written. */
+    declarationNameFor(node, fallback) {
+        const described = this.describeIndexedNode(node);
+        return described ? this.qualifiedName(described) : fallback;
+    }
+    /** The identifier named by a `@Resolver` argument: directly, or as an arrow
+     * function's expression body; or the sole identifier of a single-element
+     * array literal in either position (list-returning resolver). */
+    static extractResolverIdentifier(argNode) {
+        let target = argNode;
+        if (ts_morph_1.Node.isArrowFunction(target)) {
+            const body = target.getBody();
+            if (ts_morph_1.Node.isBlock(body))
+                return null;
+            target = body;
+        }
+        if (ts_morph_1.Node.isIdentifier(target))
+            return target;
+        if (ts_morph_1.Node.isArrayLiteralExpression(target)) {
+            const elements = target.getElements();
+            if (elements.length === 1 && ts_morph_1.Node.isIdentifier(elements[0]))
+                return elements[0];
+        }
+        return null;
+    }
+    defaultResolveDeclaration(identifier) {
+        const sym = identifier.getSymbol();
+        if (!sym)
+            return undefined;
+        const firstDecl = sym.getDeclarations()?.[0];
+        const resolved = firstDecl && ts_morph_1.Node.isImportSpecifier(firstDecl) ? (sym.getAliasedSymbol() ?? sym) : sym;
+        return resolved.getDeclarations()?.[0];
+    }
+    /** The GraphQL type name of a `@ResolveField`'s resolved parent class
+     * (design decision 5, second half): its recognised `@ObjectType` (else
+     * `@InterfaceType`) decorator, or its class name when it carries no
+     * decorator spelled `ObjectType`/`InterfaceType` at all, recognised or not. */
+    classGraphqlTypeName(declClass) {
+        const declImportMap = this.buildGraphqlImportMap(declClass.getSourceFile());
+        const decorators = declClass.getDecorators();
+        const hasAnyTypeSpelledDecorator = decorators.some((d) => {
+            const idNode = AstParserService.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 };
+        }
+        // Carries a type-spelled decorator that isn't recognised (e.g. imported
+        // through a barrel) — its GraphQL name is unreadable; the class-name
+        // fallback never applies to it (it may differ from the unreadable name).
+        if (hasAnyTypeSpelledDecorator)
+            return { ok: false };
+        const name = declClass.getName();
+        if (!name)
+            return { ok: false };
+        return GRAPHQL_NAME_RE.test(name) ? { ok: true, name } : { ok: false, value: name };
+    }
+    /** The parent type of a `@ResolveField` — the enclosing class's recognised
+     * `@Resolver` argument (design decision 5, first half). */
+    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 = AstParserService.literalStringValue(argNode);
+        if (literal !== null) {
+            return GRAPHQL_NAME_RE.test(literal) ? { ok: true, name: literal } : { ok: false, value: literal };
+        }
+        const identifier = AstParserService.extractResolverIdentifier(argNode);
+        if (!identifier)
+            return { ok: false };
+        const resolve = this.deps.resolveDeclaration ?? this.defaultResolveDeclaration.bind(this);
+        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_TYPE_DECORATORS.has(rec.name))
+                continue;
+            if (AstParserService.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 ?? AstParserService.memberName(method.getNameNode()) ?? '<anonymous>');
+        for (const dec of method.getDecorators()) {
+            const rec = this.recognizedDecorator(dec, importMap);
+            if (!rec)
+                continue;
+            if (rec.name === 'ResolveField') {
+                // Isolated per field: a throw resolving this field's parent (e.g. the
+                // injected test seam) degrades to "no row for that field" and never
+                // trips the file-level catch in `analyzeSourceFile`.
+                try {
+                    this.extractResolveFieldRow(method, rec, own, declaration, importMap, filePath, serviceName, entries);
+                }
+                catch (err) {
+                    this.logGraphqlSkip(filePath, declaration, 'ResolveField', 'unresolvable-parent');
+                }
+                continue;
+            }
+            const kind = GRAPHQL_OPERATION_KIND[rec.name];
+            if (!kind)
+                continue; // recognised but not an operation decorator (wrong declaration kind) — ignored, no log
+            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,
+            });
+        }
+    }
+    /** GraphQL-named rows for every recognised `@nestjs/graphql` decorator in
+     * the file (`graphql-symbols`). `ownRows` is `symbols ∪ members` — the
+     * declarations' own `code_symbol` candidates, checked so a GraphQL row is
+     * never written without its decorated declaration's own row. */
+    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;
+    }
     // ── private: shared container resolution ────────────────────────────────────
     static isValidSegment(s) {
         return VALID_SEGMENT.test(s);
@@ -632,7 +1036,7 @@ class AstParserService {
      * (exclude) everything nested inside it? */
     walkStep(node) {
         if (ts_morph_1.Node.isModuleDeclaration(node)) {
-            if (node.compilerNode.flags & typescript_1.NodeFlags.GlobalAugmentation)
+            if (node.compilerNode.flags & ts_morph_1.NodeFlags.GlobalAugmentation)
                 return { kind: 'exclude' };
             const nameNode = node.getNameNode();
             if (ts_morph_1.Node.isStringLiteral(nameNode))

package/dist/src/services/DatabaseService.d.ts

@@ -6,7 +6,6 @@ import * as schema from '../db/schema';
 type Schema = typeof schema;
 export type DrizzleDb = NodePgDatabase<Schema>;
 export type DrizzleTx = NodePgTransaction<Schema, ExtractTablesWithRelations<Schema>>;
-export declare const CURRENT_SYMBOL_INDEX_VERSION = 2;
 export declare class DatabaseService implements IDatabase {
     private config;
     private pool;
@@ -32,17 +31,6 @@ export declare class DatabaseService implements IDatabase {
     deleteFiles(project: string, filePaths: string[]): Promise<void>;
     listIndexedProjects(): Promise<string[]>;
     deleteProject(name: string): Promise<void>;
-    listProjectsWithIndexRows(): Promise<string[]>;
-    /**
-     * Among `projectNames` (or every project with rows when null), those with at
-     * least one row in `code_chunk`/`code_symbol` and a `symbol_index_version`
-     * below `CURRENT_SYMBOL_INDEX_VERSION` (a missing row counts as version 1).
-     * A missing `symbol_index_version` table (un-migrated DB, `rag-mcp`/`rag-web`
-     * bootstrapped with `initDb`) counts as "no marker rows" — every project with
-     * rows is then outdated. Any other database error propagates.
-     */
-    listOutdatedProjects(projectNames: string[] | null): Promise<string[]>;
-    upsertSymbolIndexVersion(project: string): Promise<void>;
     /** Guard against SQL injection — the dimension is interpolated into DDL. */
     private assertDim;
     private assertMinPostgresVersion;