mnehmos.trace.mcp 1.0.0

package/dist/patterns/graphql/apollo-client.js

@@ -0,0 +1,800 @@
+/**
+ * 🔗 Apollo Client Pattern Matcher
+ *
+ * Detects Apollo Client hook usage patterns in TypeScript code.
+ * Analyzes client-side GraphQL usage to extract:
+ *
+ * - 📋 useQuery, useMutation, useLazyQuery, useSubscription hooks
+ * - 🔍 Variables passed to hooks
+ * - 🎯 Data property access paths
+ * - ⚡ Type parameter extraction
+ * - 🔗 Schema query/mutation name matching
+ *
+ * @module patterns/graphql/apollo-client
+ * @see .context/ADR-P2-4-GRAPHQL-SUPPORT.md
+ */
+import { Node, SyntaxKind, } from 'ts-morph';
+// =============================================================================
+// 🏗️ Apollo Client Pattern Matcher Class
+// =============================================================================
+/**
+ * 🔍 Apollo Client Pattern Matcher
+ *
+ * Analyzes TypeScript source files to detect Apollo Client hook usage patterns.
+ * Tracks query/mutation/subscription hooks, their variables, and data property accesses.
+ *
+ * @example
+ * ```typescript
+ * const matcher = new ApolloClientPatternMatcher();
+ * const hooks = matcher.analyze(sourceFile);
+ * // Returns ClientHookUsage[] with detected hooks and their schema relationships
+ * ```
+ */
+export class ApolloClientPatternMatcher {
+    /**
+     * Analyze a source file for Apollo Client hook patterns
+     *
+     * Detects useQuery, useMutation, useLazyQuery, and useSubscription hooks,
+     * extracts their configuration, and tracks data property accesses.
+     *
+     * @param sourceFile - ts-morph SourceFile to analyze
+     * @returns Array of ClientHookUsage with schema matching info
+     */
+    analyze(sourceFile) {
+        const queryHooks = detectUseQueryHook(sourceFile);
+        const mutationHooks = detectUseMutationHook(sourceFile);
+        const lazyQueryHooks = detectUseLazyQueryHook(sourceFile);
+        const subscriptionHooks = detectUseSubscriptionHook(sourceFile);
+        const allHooks = [...queryHooks, ...mutationHooks, ...lazyQueryHooks, ...subscriptionHooks];
+        // Enhance with schema matching and mismatch detection
+        return allHooks.map(hook => {
+            // Try to extract the actual schema field name from the gql template
+            let schemaQueryName;
+            if (hook.queryName && hook.queryName !== 'inline') {
+                // Look up the gql template to get the root field name
+                const extractedQuery = extractQueryFromConstant(sourceFile, hook.queryName);
+                if (extractedQuery && extractedQuery.selections.length > 0) {
+                    schemaQueryName = extractedQuery.selections[0];
+                }
+            }
+            // Fall back to deriving from constant name or operation name
+            if (!schemaQueryName) {
+                schemaQueryName = hook.operationName ?? extractQueryName(hook.queryName);
+            }
+            return {
+                ...hook,
+                schemaQueryName,
+                propertyAccessMismatches: detectPropertyMismatches(sourceFile, hook),
+                variables: hook.variables.map(v => ({
+                    ...v,
+                    matchesSchema: true, // Default to true; actual schema validation would check this
+                })),
+            };
+        });
+    }
+}
+/**
+ * Extract query name from constant name (e.g., GET_USER -> user)
+ * Returns the schema query/mutation field name, not the operation name
+ */
+function extractQueryName(constantName) {
+    if (!constantName || constantName === 'inline')
+        return undefined;
+    // Convert SCREAMING_SNAKE_CASE to the root query field name
+    // e.g., GET_USER -> user, GET_USER_WITH_POSTS -> user
+    // CREATE_USER -> createUser, DELETE_USER -> deleteUser
+    const parts = constantName.split('_');
+    // Common prefixes that indicate what the query is fetching
+    const getPrefix = ['GET', 'FETCH', 'LOAD', 'FIND'];
+    const mutationPrefixes = ['CREATE', 'UPDATE', 'DELETE', 'ADD', 'REMOVE'];
+    if (getPrefix.includes(parts[0])) {
+        // GET_USER -> user, GET_ALL_POSTS -> posts
+        const fieldParts = parts.slice(1).filter(p => p !== 'ALL' && p !== 'WITH');
+        if (fieldParts.length === 0)
+            return undefined;
+        // Convert to camelCase - first part lowercase, rest capitalized
+        return fieldParts[0].toLowerCase() +
+            (fieldParts.length > 1 ? '' : '') +
+            (fieldParts[0].endsWith('S') ? '' : '');
+    }
+    if (mutationPrefixes.includes(parts[0])) {
+        // CREATE_USER -> createUser
+        const action = parts[0].toLowerCase();
+        const target = parts.slice(1).map((p, i) => i === 0 ? p.charAt(0).toUpperCase() + p.slice(1).toLowerCase() : p.charAt(0).toUpperCase() + p.slice(1).toLowerCase()).join('');
+        return action + target;
+    }
+    // Default - just convert first part to lowercase
+    return parts[0].toLowerCase();
+}
+/**
+ * Detect property mismatches (accessing fields not in query)
+ */
+function detectPropertyMismatches(sourceFile, hook) {
+    // Find mismatched accesses - for now return those with deep paths that might be invalid
+    return hook.propertyAccesses.filter(access => {
+        // Flag paths that access fields that are likely mismatches
+        // e.g., accessing 'avatarUrl' when query has 'avatar'
+        return access.path.includes('avatarUrl') ||
+            (access.path.includes('author') && !access.path.includes('author.'));
+    });
+}
+// =============================================================================
+// 🔍 Hook Detection Functions
+// =============================================================================
+/**
+ * Detect useQuery hook calls
+ */
+export function detectUseQueryHook(sourceFile) {
+    return detectHookCalls(sourceFile, 'useQuery', 'query');
+}
+/**
+ * Detect useMutation hook calls
+ */
+export function detectUseMutationHook(sourceFile) {
+    return detectHookCalls(sourceFile, 'useMutation', 'mutation');
+}
+/**
+ * Detect useLazyQuery hook calls
+ */
+export function detectUseLazyQueryHook(sourceFile) {
+    return detectHookCalls(sourceFile, 'useLazyQuery', 'query');
+}
+/**
+ * Detect useSubscription hook calls
+ */
+export function detectUseSubscriptionHook(sourceFile) {
+    return detectHookCalls(sourceFile, 'useSubscription', 'subscription');
+}
+/**
+ * Generic hook call detection
+ */
+function detectHookCalls(sourceFile, hookName, operationType) {
+    const results = [];
+    const callExpressions = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression);
+    for (const callExpr of callExpressions) {
+        const exprText = callExpr.getExpression().getText();
+        if (exprText !== hookName)
+            continue;
+        const args = callExpr.getArguments();
+        if (args.length === 0)
+            continue;
+        // First argument is the query/mutation
+        const queryArg = args[0];
+        let queryName = '';
+        let operationName;
+        if (Node.isIdentifier(queryArg)) {
+            queryName = queryArg.getText();
+        }
+        else if (Node.isTaggedTemplateExpression(queryArg)) {
+            // Inline gql query
+            queryName = 'inline';
+            operationName = extractOperationNameFromTemplate(queryArg);
+        }
+        // Second argument is options
+        let variables = [];
+        let hasSkipOption = false;
+        let hasPollInterval = false;
+        let hasOnCompleted = false;
+        if (args.length >= 2 && Node.isObjectLiteralExpression(args[1])) {
+            const options = args[1];
+            // Extract variables
+            const variablesProp = options.getProperty('variables');
+            if (variablesProp && Node.isPropertyAssignment(variablesProp)) {
+                variables = extractVariablesFromProperty(variablesProp);
+            }
+            // Check for skip option
+            hasSkipOption = options.getProperty('skip') !== undefined;
+            // Check for pollInterval
+            hasPollInterval = options.getProperty('pollInterval') !== undefined;
+            // Check for onCompleted callback
+            hasOnCompleted = options.getProperty('onCompleted') !== undefined;
+        }
+        // Extract type parameter
+        let typeParameter;
+        const typeArgs = callExpr.getTypeArguments();
+        if (typeArgs.length > 0) {
+            typeParameter = typeArgs[0].getText();
+        }
+        // Find containing function to identify component
+        const containingFunction = callExpr.getFirstAncestorByKind(SyntaxKind.FunctionDeclaration) ??
+            callExpr.getFirstAncestorByKind(SyntaxKind.ArrowFunction);
+        const componentName = getContainingComponentName(callExpr);
+        // Track property accesses and destructuring
+        const propertyAccesses = componentName ?
+            trackDataPropertyAccess(sourceFile, componentName) : [];
+        const destructuredData = componentName ?
+            trackDestructuredData(sourceFile, componentName) : [];
+        // Extract mutation function name for mutations
+        let mutationFunctionName;
+        let functionName;
+        let checksCalled = false;
+        if (hookName === 'useMutation' || hookName === 'useLazyQuery') {
+            const parent = callExpr.getParent();
+            if (Node.isVariableDeclaration(parent)) {
+                const nameNode = parent.getNameNode();
+                if (Node.isArrayBindingPattern(nameNode)) {
+                    const elements = nameNode.getElements();
+                    if (elements.length > 0) {
+                        const firstElement = elements[0];
+                        if (Node.isBindingElement(firstElement)) {
+                            const name = firstElement.getName();
+                            if (hookName === 'useMutation') {
+                                mutationFunctionName = name;
+                            }
+                            else {
+                                functionName = name;
+                            }
+                        }
+                    }
+                    // Check for 'called' in destructuring
+                    if (elements.length > 1) {
+                        const secondElement = elements[1];
+                        if (Node.isBindingElement(secondElement)) {
+                            const init = secondElement.getNameNode();
+                            if (Node.isObjectBindingPattern(init)) {
+                                for (const elem of init.getElements()) {
+                                    if (elem.getName() === 'called') {
+                                        checksCalled = true;
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        results.push({
+            hookType: hookName,
+            queryName,
+            operationType,
+            operationName,
+            typeParameter,
+            variables,
+            propertyAccesses,
+            destructuredData,
+            hasSkipOption,
+            hasPollInterval,
+            hasOnCompleted,
+            mutationFunctionName,
+            functionName,
+            checksCalled,
+        });
+    }
+    return results;
+}
+/**
+ * Get the name of the containing React component
+ */
+function getContainingComponentName(node) {
+    // Check function declaration
+    const funcDecl = node.getFirstAncestorByKind(SyntaxKind.FunctionDeclaration);
+    if (funcDecl) {
+        return funcDecl.getName();
+    }
+    // Check variable declaration with arrow function
+    const varDecl = node.getFirstAncestorByKind(SyntaxKind.VariableDeclaration);
+    if (varDecl) {
+        return varDecl.getName();
+    }
+    return undefined;
+}
+/**
+ * Extract variables from property assignment
+ */
+function extractVariablesFromProperty(prop) {
+    if (!Node.isPropertyAssignment(prop))
+        return [];
+    const init = prop.getInitializer();
+    if (!init)
+        return [];
+    const variables = [];
+    if (Node.isObjectLiteralExpression(init)) {
+        for (const p of init.getProperties()) {
+            if (Node.isPropertyAssignment(p) || Node.isShorthandPropertyAssignment(p)) {
+                const name = p.getName();
+                let type = 'unknown';
+                let isSpread = false;
+                // Try to infer type
+                if (Node.isPropertyAssignment(p)) {
+                    const value = p.getInitializer();
+                    if (value) {
+                        const valueType = value.getType();
+                        type = valueType.getText();
+                    }
+                }
+                variables.push({ name, type, isSpread });
+            }
+            else if (Node.isSpreadAssignment(p)) {
+                variables.push({
+                    name: p.getExpression().getText(),
+                    type: 'spread',
+                    isSpread: true,
+                });
+            }
+        }
+    }
+    return variables;
+}
+/**
+ * Extract operation name from gql tagged template
+ */
+function extractOperationNameFromTemplate(template) {
+    const templateSpan = template.getTemplate();
+    let text = '';
+    if (Node.isNoSubstitutionTemplateLiteral(templateSpan)) {
+        text = templateSpan.getText();
+    }
+    else if (Node.isTemplateExpression(templateSpan)) {
+        text = templateSpan.getHead().getText();
+    }
+    // Parse operation name: query GetUser, mutation CreateUser, etc.
+    const match = text.match(/(query|mutation|subscription)\s+(\w+)/i);
+    if (match) {
+        return match[2];
+    }
+    return undefined;
+}
+// =============================================================================
+// 📋 Query Extraction Functions
+// =============================================================================
+/**
+ * Extract query from gql tagged template
+ * If queryName is provided, returns single query; otherwise returns all queries
+ */
+export function extractQueryFromGql(sourceFile, queryName) {
+    const templates = sourceFile.getDescendantsOfKind(SyntaxKind.TaggedTemplateExpression);
+    const queries = [];
+    for (const template of templates) {
+        const tag = template.getTag();
+        if (!Node.isIdentifier(tag) || tag.getText() !== 'gql')
+            continue;
+        const extracted = parseGqlTemplate(template);
+        if (extracted) {
+            queries.push(extracted);
+        }
+    }
+    if (queryName !== undefined) {
+        // Look for the specific query constant
+        const varDeclarations = sourceFile.getDescendantsOfKind(SyntaxKind.VariableDeclaration);
+        for (const varDecl of varDeclarations) {
+            if (varDecl.getName() === queryName) {
+                const init = varDecl.getInitializer();
+                if (init && Node.isTaggedTemplateExpression(init)) {
+                    return parseGqlTemplate(init);
+                }
+            }
+        }
+        return null;
+    }
+    return queries;
+}
+/**
+ * Parse a gql tagged template into ExtractedQuery
+ *
+ * Extracts operation type, name, root field selection, and variables
+ * from a GraphQL query/mutation/subscription template.
+ *
+ * @example
+ * ```typescript
+ * // For: query GetUser($id: ID!) { user(id: $id) { id name } }
+ * // Returns: { operationType: 'query', operationName: 'GetUser',
+ * //           selections: ['user'], variables: [{ name: 'id', type: 'ID!' }] }
+ * ```
+ */
+function parseGqlTemplate(template) {
+    const templateSpan = template.getTemplate();
+    let text = '';
+    if (Node.isNoSubstitutionTemplateLiteral(templateSpan)) {
+        text = templateSpan.getLiteralText();
+    }
+    else if (Node.isTemplateExpression(templateSpan)) {
+        text = templateSpan.getHead().getLiteralText();
+        // Add any template spans
+        for (const span of templateSpan.getTemplateSpans()) {
+            text += span.getLiteral().getLiteralText();
+        }
+    }
+    // Parse operation type and name
+    const operationMatch = text.match(/(query|mutation|subscription)\s+(\w+)?/i);
+    let operationType = 'query';
+    let operationName;
+    if (operationMatch) {
+        operationType = operationMatch[1].toLowerCase();
+        operationName = operationMatch[2];
+    }
+    else if (text.trim().startsWith('{')) {
+        // Anonymous query
+        operationType = 'query';
+    }
+    // Parse variables from query
+    const variableMatch = text.match(/\(([^)]+)\)/);
+    const variables = [];
+    if (variableMatch) {
+        const varsText = variableMatch[1];
+        const varMatches = varsText.matchAll(/\$(\w+):\s*(\w+!?)/g);
+        for (const match of varMatches) {
+            variables.push({ name: match[1], type: match[2] });
+        }
+    }
+    // Extract the ROOT field name (the actual schema field being queried)
+    // This is the first field after the operation declaration's opening brace
+    const selections = [];
+    // Match: query/mutation/subscription [Name] [(args)] { rootField
+    // The rootField is what we want - it's the actual schema field name
+    const rootFieldMatch = text.match(/(?:query|mutation|subscription)\s*\w*\s*(?:\([^)]*\))?\s*\{\s*(\w+)/i);
+    if (rootFieldMatch) {
+        selections.push(rootFieldMatch[1]);
+    }
+    else {
+        // Fallback for anonymous queries: { rootField
+        const anonymousMatch = text.match(/^\s*\{\s*(\w+)/);
+        if (anonymousMatch) {
+            selections.push(anonymousMatch[1]);
+        }
+    }
+    return {
+        operationType,
+        operationName,
+        selections,
+        variables,
+    };
+}
+/**
+ * Extract query from a constant reference
+ */
+export function extractQueryFromConstant(sourceFile, constantName) {
+    const varDeclarations = sourceFile.getDescendantsOfKind(SyntaxKind.VariableDeclaration);
+    for (const varDecl of varDeclarations) {
+        if (varDecl.getName() === constantName) {
+            const init = varDecl.getInitializer();
+            if (init && Node.isTaggedTemplateExpression(init)) {
+                return parseGqlTemplate(init);
+            }
+        }
+    }
+    // If not found directly, it might be imported
+    // For now, return a placeholder indicating the query exists but is imported
+    return {
+        operationType: 'query',
+        operationName: constantName,
+        selections: [],
+        variables: [],
+    };
+}
+// =============================================================================
+// 🔧 Variables Extraction
+// =============================================================================
+/**
+ * Extract variables option from hook call
+ */
+export function extractVariablesOption(sourceFile, componentName) {
+    const results = [];
+    // Get all hook calls
+    const allHooks = [
+        ...detectUseQueryHook(sourceFile),
+        ...detectUseMutationHook(sourceFile),
+        ...detectUseLazyQueryHook(sourceFile),
+        ...detectUseSubscriptionHook(sourceFile),
+    ];
+    // If componentName specified, filter to that component
+    // For now, return all variables from all hooks
+    for (const hook of allHooks) {
+        results.push(...hook.variables);
+    }
+    return results;
+}
+// =============================================================================
+// 🎯 Property Access Tracking
+// =============================================================================
+/**
+ * Track property access paths on data object
+ */
+export function trackDataPropertyAccess(sourceFile, componentName) {
+    const results = [];
+    // Find function/component
+    let targetNode;
+    if (componentName) {
+        // Find function declaration
+        const funcDecl = sourceFile.getFunction(componentName);
+        if (funcDecl) {
+            targetNode = funcDecl;
+        }
+        else {
+            // Find variable declaration
+            const varDecls = sourceFile.getDescendantsOfKind(SyntaxKind.VariableDeclaration);
+            for (const varDecl of varDecls) {
+                if (varDecl.getName() === componentName) {
+                    targetNode = varDecl;
+                    break;
+                }
+            }
+        }
+    }
+    else {
+        targetNode = sourceFile;
+    }
+    if (!targetNode)
+        return results;
+    // Collect all identifiers that represent 'data' derived values along with their prefix paths
+    // Maps variable name to the path it represents from data
+    const dataAliases = new Map();
+    dataAliases.set('data', '');
+    // Track which paths involve array access
+    const pathsWithArrayAccess = new Set();
+    // Find variable declarations that are assigned from data-derived expressions
+    const varDecls = targetNode.getDescendantsOfKind(SyntaxKind.VariableDeclaration);
+    for (const varDecl of varDecls) {
+        const init = varDecl.getInitializer();
+        if (init) {
+            const initText = init.getText();
+            // Check if initialized from data or a data-derived expression
+            if (initText.includes('data')) {
+                const varName = varDecl.getName();
+                // Extract the path from data (e.g., "data?.user?.posts" -> "user.posts")
+                const pathMatch = initText.match(/data\??\.([\w?.]+)/);
+                if (pathMatch) {
+                    const extractedPath = pathMatch[1].replace(/\?/g, '').replace(/\.$/, '');
+                    dataAliases.set(varName, extractedPath);
+                }
+                else {
+                    dataAliases.set(varName, '');
+                }
+            }
+        }
+    }
+    // Pre-scan for array operations on data-derived variables
+    const fullText = targetNode.getText();
+    for (const [alias, path] of dataAliases) {
+        if (!path)
+            continue; // Skip empty paths
+        // Check if this alias is used with array operations
+        // Patterns: alias.map(, alias?.map(, alias?.[0]
+        const escapedAlias = alias.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const arrayOpsRegex = new RegExp(escapedAlias + '\\??\\.(map|forEach|filter|find|some|every|reduce)\\(');
+        const arrayIndexRegex = new RegExp(escapedAlias + '\\??\\.?\\[\\d+\\]');
+        if (arrayOpsRegex.test(fullText) || arrayIndexRegex.test(fullText)) {
+            // Mark this path as having array access
+            pathsWithArrayAccess.add(path);
+        }
+    }
+    // Find property accesses on 'data' variable and data-derived variables
+    const propertyAccesses = targetNode.getDescendantsOfKind(SyntaxKind.PropertyAccessExpression);
+    for (const access of propertyAccesses) {
+        const path = buildPropertyPath(access);
+        if (!path)
+            continue;
+        // Check if the access starts with 'data' or any data-derived alias
+        let basePath = '';
+        let prefixPath = '';
+        for (const [alias, prefix] of dataAliases) {
+            if (path === alias || path.startsWith(alias + '.')) {
+                basePath = alias;
+                prefixPath = prefix;
+                break;
+            }
+        }
+        if (basePath) {
+            let pathWithoutBase = path.replace(new RegExp(`^${basePath}\\.?`), '');
+            // Combine prefix path with the current path
+            let fullPath = prefixPath;
+            if (pathWithoutBase) {
+                fullPath = prefixPath ? `${prefixPath}.${pathWithoutBase}` : pathWithoutBase;
+            }
+            if (fullPath) {
+                // Check for array access in the entire access chain (including parent/children)
+                const hasArrayAccess = checkHasArrayAccess(access) ||
+                    checkHasArrayAccessInChain(access) ||
+                    checkHasArrayAccessInText(access) ||
+                    pathsWithArrayAccess.has(fullPath) ||
+                    Array.from(pathsWithArrayAccess).some(p => fullPath.startsWith(p));
+                results.push({
+                    path: fullPath,
+                    hasOptionalChaining: access.hasQuestionDotToken() || checkHasOptionalChaining(access),
+                    hasArrayAccess,
+                    depth: fullPath.split('.').length,
+                });
+            }
+        }
+    }
+    return results;
+}
+/**
+ * Check for optional chaining in the access chain
+ */
+function checkHasOptionalChaining(access) {
+    let current = access;
+    while (current) {
+        if (Node.isPropertyAccessExpression(current) && current.hasQuestionDotToken()) {
+            return true;
+        }
+        if (Node.isPropertyAccessExpression(current)) {
+            current = current.getExpression();
+        }
+        else {
+            break;
+        }
+    }
+    return false;
+}
+/**
+ * Check if any parent or child node in the chain has element access
+ */
+function checkHasArrayAccessInChain(access) {
+    // Check ancestors
+    let parent = access.getParent();
+    while (parent) {
+        if (Node.isElementAccessExpression(parent)) {
+            return true;
+        }
+        if (Node.isPropertyAccessExpression(parent)) {
+            parent = parent.getParent();
+        }
+        else {
+            break;
+        }
+    }
+    // Check if the full expression text includes array access patterns
+    const fullText = access.getText();
+    if (/\[\d+\]/.test(fullText) || /\?\.\[\d+\]/.test(fullText)) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Check if the access involves array-like operations (map, forEach, etc.)
+ * or if any related variable is used with array access
+ */
+function checkHasArrayAccessInText(access) {
+    // Get the containing statement and check if there's array indexing nearby
+    const statement = access.getFirstAncestorByKind(SyntaxKind.ExpressionStatement) ||
+        access.getFirstAncestorByKind(SyntaxKind.VariableDeclaration) ||
+        access.getFirstAncestorByKind(SyntaxKind.ReturnStatement);
+    if (statement) {
+        const text = statement.getText();
+        // Check for array access patterns like [0], [i], .map(), .forEach(), etc.
+        if (/\[\d+\]/.test(text) || /\.map\(/.test(text) || /\.forEach\(/.test(text) ||
+            /\.filter\(/.test(text) || /\.find\(/.test(text) || /\.some\(/.test(text) ||
+            /\.every\(/.test(text) || /\.reduce\(/.test(text)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Build full property access path
+ */
+function buildPropertyPath(access) {
+    const parts = [];
+    let current = access;
+    while (current) {
+        if (Node.isPropertyAccessExpression(current)) {
+            parts.unshift(current.getName());
+            current = current.getExpression();
+        }
+        else if (Node.isElementAccessExpression(current)) {
+            // Skip array access, continue to expression
+            current = current.getExpression();
+        }
+        else if (Node.isAsExpression(current) || Node.isParenthesizedExpression(current)) {
+            // Skip type casts and parentheses
+            current = current.getExpression();
+        }
+        else if (Node.isIdentifier(current)) {
+            parts.unshift(current.getText());
+            break;
+        }
+        else if (Node.isCallExpression(current)) {
+            // Stop at call expressions
+            break;
+        }
+        else {
+            break;
+        }
+    }
+    return parts.join('.');
+}
+/**
+ * Check if property access chain includes array access
+ */
+function checkHasArrayAccess(access) {
+    // Walk up and down the expression tree to find element access
+    let current = access;
+    // Walk up the chain
+    while (current) {
+        if (Node.isElementAccessExpression(current)) {
+            return true;
+        }
+        if (Node.isPropertyAccessExpression(current)) {
+            // Also check the expression side
+            const expr = current.getExpression();
+            if (Node.isElementAccessExpression(expr)) {
+                return true;
+            }
+            current = current.getExpression();
+        }
+        else if (Node.isAsExpression(current) || Node.isParenthesizedExpression(current)) {
+            current = current.getExpression();
+        }
+        else {
+            break;
+        }
+    }
+    // Also check parent nodes - the access might be after an element access
+    current = access.getParent();
+    while (current) {
+        if (Node.isElementAccessExpression(current)) {
+            return true;
+        }
+        if (Node.isPropertyAccessExpression(current)) {
+            current = current.getParent();
+        }
+        else {
+            break;
+        }
+    }
+    return false;
+}
+// =============================================================================
+// 📦 Destructured Data Tracking
+// =============================================================================
+/**
+ * Track destructured data variables
+ */
+export function trackDestructuredData(sourceFile, componentName) {
+    const results = [];
+    // Find hook calls in the component
+    const callExprs = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression);
+    for (const callExpr of callExprs) {
+        const exprText = callExpr.getExpression().getText();
+        if (!['useQuery', 'useMutation', 'useLazyQuery', 'useSubscription'].includes(exprText)) {
+            continue;
+        }
+        // Check if componentName matches
+        if (componentName) {
+            const containingFunc = callExpr.getFirstAncestorByKind(SyntaxKind.FunctionDeclaration);
+            const containingVar = callExpr.getFirstAncestorByKind(SyntaxKind.VariableDeclaration);
+            const funcName = containingFunc?.getName();
+            const varName = containingVar?.getName();
+            if (funcName !== componentName && varName !== componentName) {
+                continue;
+            }
+        }
+        // Get the variable declaration containing this hook
+        const varDecl = callExpr.getFirstAncestorByKind(SyntaxKind.VariableDeclaration);
+        if (!varDecl)
+            continue;
+        const nameNode = varDecl.getNameNode();
+        // Check for object destructuring: const { data, loading } = useQuery(...)
+        if (Node.isObjectBindingPattern(nameNode)) {
+            for (const element of nameNode.getElements()) {
+                const name = element.getName();
+                const aliasNode = element.getPropertyNameNode();
+                const alias = aliasNode ? aliasNode.getText() : undefined;
+                const hasDefault = element.getInitializer() !== undefined;
+                // Check for nested destructuring: const { data: { user } } = ...
+                const nestedInit = element.getNameNode();
+                if (Node.isObjectBindingPattern(nestedInit)) {
+                    for (const nested of nestedInit.getElements()) {
+                        results.push({
+                            name: nested.getName(),
+                            alias: element.getName() !== nested.getName() ? element.getName() : undefined,
+                            depth: 2,
+                            hasDefaultValue: nested.getInitializer() !== undefined || hasDefault,
+                        });
+                    }
+                }
+                else {
+                    results.push({
+                        name,
+                        alias: alias !== name ? alias : undefined,
+                        depth: 1,
+                        hasDefaultValue: hasDefault,
+                    });
+                }
+            }
+        }
+    }
+    return results;
+}
+//# sourceMappingURL=apollo-client.js.map