@ethlete/query 5.42.0 → 5.42.1

package/generators/migrate-to-query-v3/migration.js

@@ -60,6 +60,10 @@ async function migrate(tree, schema) {
     replaceAnyQueryWithLegacy(tree);
     // Remove devtools usage
     removeDevtoolsUsage(tree);
+    // Migrate empty .prepare() calls to .prepare({})
+    migrateEmptyPrepareCalls(tree);
+    // Check for legacy query creator usage (step 1: just collect and report)
+    checkLegacyQueryCreatorUsage(tree);
     if (!schema.skipFormat) {
         await (0, devkit_1.formatFiles)(tree);
     }
@@ -1196,9 +1200,14 @@ function updateLegacyCreatorUsages(content, legacyCreators) {
                 }
             });
         }
-        // Handle regular identifier references
+        // Handle regular identifier references - but skip declarations and property access names
         if (ts.isIdentifier(node) && legacyCreators.has(node.text)) {
             const parent = node.parent;
+            // Skip if it's a property name in PropertyAccessExpression (e.g., obj.methodName)
+            if (ts.isPropertyAccessExpression(parent) && parent.name === node) {
+                ts.forEachChild(node, visit);
+                return;
+            }
             // Skip if it's a property name in an object literal (already handled above)
             if (ts.isPropertyAssignment(parent) && parent.name === node) {
                 ts.forEachChild(node, visit);
@@ -1224,6 +1233,25 @@ function updateLegacyCreatorUsages(content, legacyCreators) {
                 ts.forEachChild(node, visit);
                 return;
             }
+            // Skip if it's a function/method name declaration
+            if (ts.isFunctionDeclaration(parent) && parent.name === node) {
+                ts.forEachChild(node, visit);
+                return;
+            }
+            if (ts.isMethodDeclaration(parent) && parent.name === node) {
+                ts.forEachChild(node, visit);
+                return;
+            }
+            // Skip if it's a parameter name
+            if (ts.isParameter(parent) && parent.name === node) {
+                ts.forEachChild(node, visit);
+                return;
+            }
+            // Skip if it's a property declaration name (class field)
+            if (ts.isPropertyDeclaration(parent) && parent.name === node) {
+                ts.forEachChild(node, visit);
+                return;
+            }
             // Replace with legacy name
             const newName = legacyCreators.get(node.text);
             replacements.push({
@@ -1244,9 +1272,6 @@ function updateLegacyCreatorUsages(content, legacyCreators) {
     return result;
 }
 //#endregion
-//#region Check all files for usage of legacy query creators and add injector if needed
-// TODO
-//#endregion
 //#region Remove provideQueryClientForDevtools and QueryDevtoolsComponent in ts / et-query-devtools in html usage
 function removeDevtoolsUsage(tree) {
     const projects = (0, devkit_1.getProjects)(tree);
@@ -1740,5 +1765,1188 @@ function generateInjectFunction(configName) {
     const functionName = `inject${capitalizedName}`;
     return `export const ${functionName} = () => inject(${configName}Config.token);`;
 }
+function checkLegacyQueryCreatorUsage(tree) {
+    console.log('\n🔍 Checking for legacy query creator usages...');
+    // Step 1: Collect all usages BEFORE any transformations
+    const allUsages = [];
+    (0, devkit_1.visitNotIgnoredFiles)(tree, '', (filePath) => {
+        if (!filePath.endsWith('.ts') || filePath.endsWith('.spec.ts'))
+            return;
+        const content = tree.read(filePath, 'utf-8');
+        if (!content)
+            return;
+        const usages = findLegacyCreatorUsages(content, filePath);
+        allUsages.push(...usages);
+    });
+    if (allUsages.length === 0) {
+        console.log('\n✅ No legacy query creator usages found');
+        return;
+    }
+    console.log(`\n📊 Found ${allUsages.length} legacy query creator usages`);
+    // Log statistics
+    const contextCounts = new Map();
+    allUsages.forEach((usage) => {
+        contextCounts.set(usage.context, (contextCounts.get(usage.context) || 0) + 1);
+    });
+    contextCounts.forEach((count, context) => {
+        console.log(`   - ${context}: ${count} usages`);
+    });
+    // Step 1.5: Detect polling usage BEFORE any transformations
+    console.log('\n🔍 Detecting polling usage...');
+    const pollingInfo = detectPollingUsage(tree);
+    if (pollingInfo.size > 0) {
+        console.log(`\n⚠️  Found ${pollingInfo.size} queries with polling:`);
+        pollingInfo.forEach((info) => {
+            console.log(`   ${info.queryVariableName}:`);
+            info.locations.forEach((loc) => console.log(`     - ${loc}`));
+        });
+        console.log('\n   → These queries will NOT have destroyOnResponse: true added');
+    }
+    // Step 2: Find or create injector members in classes
+    const classInjectors = findOrCreateInjectorMembers(tree, allUsages);
+    createInjectorMembers(tree, classInjectors);
+    // Step 3: Transform prepare() calls with polling info
+    transformLegacyCreatorPrepareCall(tree, classInjectors, pollingInfo);
+    // Step 4: Report manual review locations (using original line numbers from allUsages)
+    reportManualReviewLocations(tree, allUsages);
+}
+function findLegacyCreatorUsages(content, filePath) {
+    const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
+    const usages = [];
+    // First, find all legacy query creator names imported/defined in this file
+    const legacyCreatorNames = findLegacyCreatorNames(sourceFile, content);
+    if (legacyCreatorNames.size === 0) {
+        return usages;
+    }
+    // Now find all .prepare() calls on these creators
+    function visit(node) {
+        // Look for: legacyCreator.prepare()
+        if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression)) {
+            const propAccess = node.expression;
+            if (ts.isIdentifier(propAccess.name) && propAccess.name.text === 'prepare') {
+                // Check if the object is a legacy creator
+                let creatorName;
+                if (ts.isIdentifier(propAccess.expression)) {
+                    creatorName = propAccess.expression.text;
+                }
+                if (creatorName && legacyCreatorNames.has(creatorName)) {
+                    const context = determineUsageContext(node, sourceFile);
+                    const hasInjector = checkForExistingInjector(node, sourceFile);
+                    const lineNumber = getLineNumber(node, sourceFile);
+                    usages.push({
+                        filePath,
+                        creatorName,
+                        line: lineNumber,
+                        position: {
+                            start: node.getStart(sourceFile),
+                            end: node.getEnd(),
+                        },
+                        context,
+                        hasExistingInjector: hasInjector,
+                    });
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return usages;
+}
+function findLegacyCreatorNames(sourceFile, content) {
+    const names = new Set();
+    function visit(node) {
+        // Find imports of legacy creators (names starting with 'legacy')
+        if (ts.isImportDeclaration(node) &&
+            node.importClause?.namedBindings &&
+            ts.isNamedImports(node.importClause.namedBindings)) {
+            node.importClause.namedBindings.elements.forEach((element) => {
+                const name = element.name.text;
+                if (name.startsWith('legacy')) {
+                    names.add(name);
+                }
+            });
+        }
+        // Find local legacy creator definitions
+        if (ts.isVariableDeclaration(node) &&
+            ts.isIdentifier(node.name) &&
+            node.name.text.startsWith('legacy') &&
+            node.initializer &&
+            ts.isCallExpression(node.initializer)) {
+            const callExpr = node.initializer;
+            if (ts.isPropertyAccessExpression(callExpr.expression) &&
+                ts.isIdentifier(callExpr.expression.expression) &&
+                callExpr.expression.expression.text === 'E' &&
+                ts.isIdentifier(callExpr.expression.name) &&
+                callExpr.expression.name.text === 'createLegacyQueryCreator') {
+                names.add(node.name.text);
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return names;
+}
+function determineUsageContext(node, sourceFile) {
+    let current = node;
+    while (current) {
+        // Check for queryComputed FIRST (before checking for generic functions)
+        // We need to look at the parent of arrow/function expressions
+        if (ts.isArrowFunction(current) || ts.isFunctionExpression(current)) {
+            const parent = current.parent;
+            // Check if this function is a callback to queryComputed
+            if (ts.isCallExpression(parent)) {
+                const expr = parent.expression;
+                // Check for queryComputed()
+                if (ts.isIdentifier(expr) && expr.text === 'queryComputed') {
+                    return 'queryComputed';
+                }
+                // Check for E.queryComputed()
+                if (ts.isPropertyAccessExpression(expr) &&
+                    ts.isIdentifier(expr.expression) &&
+                    expr.expression.text === 'E' &&
+                    ts.isIdentifier(expr.name) &&
+                    expr.name.text === 'queryComputed') {
+                    return 'queryComputed';
+                }
+            }
+        }
+        // Check for constructor
+        if (ts.isConstructorDeclaration(current)) {
+            return 'constructor';
+        }
+        // Check for method
+        if (ts.isMethodDeclaration(current)) {
+            return 'method';
+        }
+        // Check for class field
+        if (ts.isPropertyDeclaration(current)) {
+            return 'class-field';
+        }
+        // Check for function declarations
+        if (ts.isFunctionDeclaration(current)) {
+            return 'function';
+        }
+        // Check for arrow functions and function expressions (standalone, not callbacks)
+        // But make sure we're not inside a class (which would make it a method/field)
+        if ((ts.isArrowFunction(current) || ts.isFunctionExpression(current)) && !isInsideClass(current)) {
+            return 'function';
+        }
+        current = current.parent;
+    }
+    return 'unknown';
+}
+function isInsideClass(node) {
+    let current = node.parent;
+    while (current) {
+        if (ts.isClassDeclaration(current)) {
+            return true;
+        }
+        current = current.parent;
+    }
+    return false;
+}
+function checkForExistingInjector(node, sourceFile) {
+    // Walk up to find the containing class
+    let current = node;
+    while (current && !ts.isClassDeclaration(current)) {
+        current = current.parent;
+    }
+    if (!current || !ts.isClassDeclaration(current)) {
+        return false;
+    }
+    const classDecl = current;
+    // Check if class has any member that calls inject(Injector)
+    for (const member of classDecl.members) {
+        if (ts.isPropertyDeclaration(member) && member.initializer) {
+            if (hasInjectInjectorCall(member.initializer)) {
+                return true;
+            }
+        }
+        if (ts.isConstructorDeclaration(member)) {
+            for (const param of member.parameters) {
+                if (param.initializer && hasInjectInjectorCall(param.initializer)) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+function hasInjectInjectorCall(node) {
+    let found = false;
+    function visit(n) {
+        if (found)
+            return;
+        // Look for: inject(Injector)
+        if (ts.isCallExpression(n) && ts.isIdentifier(n.expression) && n.expression.text === 'inject') {
+            if (n.arguments.length > 0 && ts.isIdentifier(n.arguments[0]) && n.arguments[0].text === 'Injector') {
+                found = true;
+                return;
+            }
+        }
+        ts.forEachChild(n, visit);
+    }
+    visit(node);
+    return found;
+}
+function getLineNumber(node, sourceFile) {
+    const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+    return line + 1;
+}
+function findOrCreateInjectorMembers(tree, usages) {
+    const classInjectors = new Map();
+    // Group usages by file and class
+    const usagesByFile = new Map();
+    usages.forEach((usage) => {
+        // Skip usages that don't need injector (queryComputed, class-field, constructor)
+        if (['queryComputed', 'class-field', 'constructor'].includes(usage.context)) {
+            return;
+        }
+        if (!usagesByFile.has(usage.filePath)) {
+            usagesByFile.set(usage.filePath, []);
+        }
+        usagesByFile.get(usage.filePath).push(usage);
+    });
+    // Process each file
+    usagesByFile.forEach((fileUsages, filePath) => {
+        const content = tree.read(filePath, 'utf-8');
+        if (!content)
+            return;
+        const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
+        // Find all classes in this file that have usages
+        const classesNeedingInjector = findClassesNeedingInjector(sourceFile, fileUsages);
+        classesNeedingInjector.forEach((classInfo) => {
+            const key = `${filePath}:${classInfo.className}`;
+            classInjectors.set(key, {
+                ...classInfo,
+                filePath,
+            });
+        });
+    });
+    return classInjectors;
+}
+function findClassesNeedingInjector(sourceFile, usages) {
+    const classes = [];
+    const actualFilePath = usages[0]?.filePath || sourceFile.fileName; // Get the real file path from usages
+    function visit(node) {
+        if (ts.isClassDeclaration(node)) {
+            const className = node.name?.text || 'UnnamedClass';
+            // Check if any usage is within this class
+            const usagesInClass = usages.filter((usage) => {
+                return usage.position.start >= node.getStart(sourceFile) && usage.position.end <= node.getEnd();
+            });
+            if (usagesInClass.length === 0) {
+                ts.forEachChild(node, visit);
+                return;
+            }
+            // Check if class already has an injector member
+            const existingInjector = findExistingInjectorMember(node, sourceFile);
+            if (existingInjector) {
+                classes.push({
+                    filePath: actualFilePath,
+                    className,
+                    injectorMemberName: existingInjector.name,
+                    needsToCreate: false,
+                    classStart: node.getStart(sourceFile),
+                    classEnd: node.getEnd(),
+                });
+            }
+            else {
+                // Need to create one
+                classes.push({
+                    filePath: actualFilePath,
+                    className,
+                    injectorMemberName: 'injector', // Default name
+                    needsToCreate: true,
+                    classStart: node.getStart(sourceFile),
+                    classEnd: node.getEnd(),
+                });
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return classes;
+}
+function findExistingInjectorMember(classNode, sourceFile) {
+    for (const member of classNode.members) {
+        if (ts.isPropertyDeclaration(member) && member.initializer) {
+            // Check if it's: inject(Injector)
+            if (hasInjectInjectorCall(member.initializer)) {
+                const memberName = member.name && ts.isIdentifier(member.name) ? member.name.text : undefined;
+                if (memberName) {
+                    return { name: memberName, node: member };
+                }
+            }
+        }
+    }
+    return undefined;
+}
+function createInjectorMembers(tree, classInjectors) {
+    const filesToUpdate = new Map();
+    // Group by file
+    classInjectors.forEach((classInfo) => {
+        if (!classInfo.needsToCreate)
+            return;
+        if (!filesToUpdate.has(classInfo.filePath)) {
+            filesToUpdate.set(classInfo.filePath, []);
+        }
+        filesToUpdate.get(classInfo.filePath).push(classInfo);
+    });
+    // Update each file
+    filesToUpdate.forEach((classes, filePath) => {
+        let content = tree.read(filePath, 'utf-8');
+        if (!content)
+            return;
+        // Add inject and Injector imports if needed
+        content = ensureInjectAndInjectorImports(content);
+        // Add injector member to each class (in reverse order to maintain positions)
+        const sortedClasses = [...classes].sort((a, b) => b.classStart - a.classStart);
+        for (const classInfo of sortedClasses) {
+            content = addInjectorMemberToClass(content, classInfo);
+        }
+        tree.write(filePath, content);
+    });
+    if (filesToUpdate.size > 0) {
+        console.log(`\n✅ Added injector members to ${Array.from(filesToUpdate.values()).flat().length} classes`);
+    }
+}
+function ensureInjectAndInjectorImports(content) {
+    const sourceFile = ts.createSourceFile('temp.ts', content, ts.ScriptTarget.Latest, true);
+    let angularCoreImport;
+    ts.forEachChild(sourceFile, (node) => {
+        if (ts.isImportDeclaration(node) &&
+            ts.isStringLiteral(node.moduleSpecifier) &&
+            node.moduleSpecifier.text === '@angular/core') {
+            angularCoreImport = node;
+        }
+    });
+    const neededImports = new Set();
+    let hasInject = false;
+    let hasInjector = false;
+    if (angularCoreImport?.importClause?.namedBindings &&
+        ts.isNamedImports(angularCoreImport.importClause.namedBindings)) {
+        const namedBindings = angularCoreImport.importClause.namedBindings;
+        namedBindings.elements.forEach((el) => {
+            if (el.name.text === 'inject')
+                hasInject = true;
+            if (el.name.text === 'Injector')
+                hasInjector = true;
+        });
+    }
+    if (!hasInject)
+        neededImports.add('inject');
+    if (!hasInjector)
+        neededImports.add('Injector');
+    if (neededImports.size === 0) {
+        return content; // Already has both imports
+    }
+    if (angularCoreImport?.importClause?.namedBindings &&
+        ts.isNamedImports(angularCoreImport.importClause.namedBindings)) {
+        // Add to existing import
+        const namedBindings = angularCoreImport.importClause.namedBindings;
+        const existingImports = namedBindings.elements.map((el) => el.name.text);
+        const allImports = [...existingImports, ...Array.from(neededImports)].sort();
+        const newImportStatement = `import { ${allImports.join(', ')} } from '@angular/core';`;
+        const importStart = angularCoreImport.getStart(sourceFile);
+        const importEnd = angularCoreImport.getEnd();
+        return content.slice(0, importStart) + newImportStatement + content.slice(importEnd);
+    }
+    // Find last import to add after it
+    let lastImportEnd = 0;
+    ts.forEachChild(sourceFile, (node) => {
+        if (ts.isImportDeclaration(node)) {
+            const end = node.getEnd();
+            if (end > lastImportEnd) {
+                lastImportEnd = end;
+            }
+        }
+    });
+    const newImports = Array.from(neededImports).sort();
+    const newImportStatement = `\nimport { ${newImports.join(', ')} } from '@angular/core';`;
+    if (lastImportEnd > 0) {
+        return content.slice(0, lastImportEnd) + newImportStatement + content.slice(lastImportEnd);
+    }
+    return `import { ${newImports.join(', ')} } from '@angular/core';\n\n${content}`;
+}
+function addInjectorMemberToClass(content, classInfo) {
+    const sourceFile = ts.createSourceFile('temp.ts', content, ts.ScriptTarget.Latest, true);
+    // Find the class
+    let targetClass;
+    function visit(node) {
+        if (ts.isClassDeclaration(node)) {
+            const className = node.name?.text;
+            if (className === classInfo.className) {
+                targetClass = node;
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    if (!targetClass)
+        return content;
+    // Find where to insert the injector member (after the opening brace)
+    const classBodyStart = targetClass.members.length > 0 ? targetClass.members[0].getStart(sourceFile) : targetClass.getEnd() - 1; // Before closing brace
+    const indentation = getIndentation(content, classBodyStart);
+    const injectorMember = `${indentation}private ${classInfo.injectorMemberName} = inject(Injector);\n\n`;
+    return content.slice(0, classBodyStart) + injectorMember + content.slice(classBodyStart);
+}
+function getIndentation(content, position) {
+    // Walk backwards to find the start of the line
+    let lineStart = position;
+    while (lineStart > 0 && content[lineStart - 1] !== '\n') {
+        lineStart--;
+    }
+    // Count spaces/tabs
+    let indentation = '';
+    for (let i = lineStart; i < position && /\s/.test(content[i]); i++) {
+        indentation += content[i];
+    }
+    return indentation || '  '; // Default to 2 spaces if no indentation found
+}
+//#endregion
+//#region Step 3: Transform legacy query creator prepare() calls to add injector
+function transformLegacyCreatorPrepareCall(tree, classInjectors, pollingInfo) {
+    const updatedFiles = [];
+    // Get all files that have classes with injector OR have standalone function usages
+    const filesByPath = new Map();
+    classInjectors.forEach((classInfo) => {
+        if (!filesByPath.has(classInfo.filePath)) {
+            filesByPath.set(classInfo.filePath, []);
+        }
+        filesByPath.get(classInfo.filePath).push(classInfo);
+    });
+    // Also check files with standalone function usages
+    (0, devkit_1.visitNotIgnoredFiles)(tree, '', (filePath) => {
+        if (!filePath.endsWith('.ts') || filePath.endsWith('.spec.ts'))
+            return;
+        if (filesByPath.has(filePath))
+            return; // Already processing
+        const content = tree.read(filePath, 'utf-8');
+        if (!content)
+            return;
+        // Only analyze files that have .prepare() calls
+        if (!content.includes('.prepare('))
+            return;
+        const usages = findLegacyCreatorUsages(content, filePath);
+        const functionUsages = usages.filter((u) => u.context === 'function');
+        if (functionUsages.length > 0) {
+            filesByPath.set(filePath, []); // Empty array means standalone functions only
+        }
+    });
+    filesByPath.forEach((classes, filePath) => {
+        let content = tree.read(filePath, 'utf-8');
+        if (!content)
+            return;
+        // Ensure imports are added (for both classes and functions)
+        content = ensureInjectAndInjectorImports(content);
+        // Transform prepare calls for each class and functions
+        const newContent = transformPrepareCallsInFile(content, classes, pollingInfo);
+        if (newContent !== content) {
+            tree.write(filePath, newContent);
+            updatedFiles.push(filePath);
+        }
+    });
+    if (updatedFiles.length > 0) {
+        console.log(`\n✅ Transformed legacy query creator prepare() calls in ${updatedFiles.length} files`);
+    }
+}
+function transformPrepareCallsInFile(content, classes, pollingInfo) {
+    const sourceFile = ts.createSourceFile('temp.ts', content, ts.ScriptTarget.Latest, true);
+    const replacements = [];
+    // Find all legacy creator names
+    const legacyCreatorNames = findLegacyCreatorNames(sourceFile, content);
+    if (legacyCreatorNames.size === 0)
+        return content;
+    // Build a map of class NAME to their injector member name
+    const classNameToInjector = new Map();
+    classes.forEach((classInfo) => {
+        classNameToInjector.set(classInfo.className, classInfo.injectorMemberName);
+    });
+    // Track standalone functions that need injector by their position
+    const functionsNeedingInjector = new Map();
+    function visit(node) {
+        // Find: legacyCreator.prepare(...)
+        if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression)) {
+            const propAccess = node.expression;
+            if (ts.isIdentifier(propAccess.name) && propAccess.name.text === 'prepare') {
+                let creatorName;
+                if (ts.isIdentifier(propAccess.expression)) {
+                    creatorName = propAccess.expression.text;
+                }
+                if (!creatorName || !legacyCreatorNames.has(creatorName)) {
+                    ts.forEachChild(node, visit);
+                    return;
+                }
+                // Check if this is in a context that needs injector
+                const context = determineUsageContext(node, sourceFile);
+                if (['queryComputed', 'constructor', 'class-field'].includes(context)) {
+                    // Safe contexts that don't need injector or destroyOnResponse
+                    ts.forEachChild(node, visit);
+                    return;
+                }
+                // Find the containing class or function
+                const containingClass = findContainingClass(node, sourceFile);
+                const containingFunction = findContainingStandaloneFunction(node, sourceFile);
+                if (containingClass) {
+                    // Handle class method (NOT class fields - they were filtered above)
+                    const className = containingClass.name?.text;
+                    if (!className) {
+                        ts.forEachChild(node, visit);
+                        return;
+                    }
+                    const injectorMember = classNameToInjector.get(className);
+                    if (!injectorMember) {
+                        ts.forEachChild(node, visit);
+                        return;
+                    }
+                    // Transform the prepare call
+                    const transformedCall = transformSinglePrepareCall(node, `this.${injectorMember}`, sourceFile, pollingInfo);
+                    if (transformedCall) {
+                        replacements.push({
+                            start: node.getStart(sourceFile),
+                            end: node.getEnd(),
+                            replacement: transformedCall,
+                        });
+                    }
+                }
+                else if (containingFunction) {
+                    // Handle standalone function - find the outermost function with inject()
+                    const functionWithInject = findOutermostFunctionWithInject(containingFunction, sourceFile);
+                    if (functionWithInject) {
+                        const funcPosition = functionWithInject.getStart(sourceFile);
+                        // Check if we haven't already processed this function
+                        if (!functionsNeedingInjector.has(funcPosition)) {
+                            // Check if the function already has an injector parameter
+                            const existingInjectorParam = findInjectorParameter(functionWithInject);
+                            if (existingInjectorParam) {
+                                // Use the existing parameter name
+                                functionsNeedingInjector.set(funcPosition, {
+                                    injectorName: existingInjectorParam,
+                                    bodyStart: -1, // No declaration needed
+                                    needsDeclaration: false,
+                                });
+                            }
+                            else {
+                                // Need to declare injector
+                                let bodyStart;
+                                if ((ts.isFunctionDeclaration(functionWithInject) || ts.isFunctionExpression(functionWithInject)) &&
+                                    functionWithInject.body &&
+                                    ts.isBlock(functionWithInject.body)) {
+                                    if (functionWithInject.body.statements.length > 0) {
+                                        bodyStart = functionWithInject.body.statements[0].getStart(sourceFile);
+                                    }
+                                    else {
+                                        bodyStart = functionWithInject.body.getStart(sourceFile) + 1;
+                                    }
+                                }
+                                else if (ts.isArrowFunction(functionWithInject) &&
+                                    functionWithInject.body &&
+                                    ts.isBlock(functionWithInject.body)) {
+                                    if (functionWithInject.body.statements.length > 0) {
+                                        bodyStart = functionWithInject.body.statements[0].getStart(sourceFile);
+                                    }
+                                    else {
+                                        bodyStart = functionWithInject.body.getStart(sourceFile) + 1;
+                                    }
+                                }
+                                if (bodyStart !== undefined) {
+                                    functionsNeedingInjector.set(funcPosition, {
+                                        injectorName: 'injector',
+                                        bodyStart,
+                                        needsDeclaration: true,
+                                    });
+                                }
+                            }
+                        }
+                        const injectorInfo = functionsNeedingInjector.get(funcPosition);
+                        const injectorName = injectorInfo?.injectorName || 'injector';
+                        // Transform the prepare call
+                        const transformedCall = transformSinglePrepareCall(node, injectorName, sourceFile, pollingInfo);
+                        if (transformedCall) {
+                            replacements.push({
+                                start: node.getStart(sourceFile),
+                                end: node.getEnd(),
+                                replacement: transformedCall,
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    // Apply injector declarations first (in reverse order) - only for functions that need them
+    let result = content;
+    const injectorDeclarations = [];
+    functionsNeedingInjector.forEach(({ injectorName, bodyStart, needsDeclaration }) => {
+        if (needsDeclaration && bodyStart > 0) {
+            const indentation = getIndentation(content, bodyStart);
+            const injectorDecl = `${indentation}const ${injectorName} = inject(Injector);\n`;
+            injectorDeclarations.push({
+                position: bodyStart,
+                text: injectorDecl,
+            });
+        }
+    });
+    injectorDeclarations.sort((a, b) => b.position - a.position);
+    for (const { position, text } of injectorDeclarations) {
+        result = result.slice(0, position) + text + result.slice(position);
+    }
+    // Then apply prepare call replacements (need to adjust positions for injector insertions)
+    const sortedReplacements = [...replacements].sort((a, b) => b.start - a.start);
+    for (const { start, end, replacement } of sortedReplacements) {
+        // Calculate position adjustment from injector declarations that came before this replacement
+        let adjustment = 0;
+        for (const decl of injectorDeclarations) {
+            if (decl.position <= start) {
+                adjustment += decl.text.length;
+            }
+        }
+        result = result.slice(0, start + adjustment) + replacement + result.slice(end + adjustment);
+    }
+    return result;
+}
+function findInjectorParameter(func) {
+    if (!func.parameters || func.parameters.length === 0) {
+        return undefined;
+    }
+    // Look for a parameter named 'injector' or with a type containing 'Injector'
+    for (const param of func.parameters) {
+        if (ts.isIdentifier(param.name)) {
+            const paramName = param.name.text;
+            // Check if parameter is named 'injector'
+            if (paramName.toLowerCase() === 'injector') {
+                return paramName;
+            }
+            // Check if parameter type contains 'Injector'
+            if (param.type) {
+                const typeText = param.type.getText();
+                if (typeText.includes('Injector')) {
+                    return paramName;
+                }
+            }
+        }
+    }
+    return undefined;
+}
+function findOutermostFunctionWithInject(startFunction, sourceFile) {
+    let current = startFunction;
+    let outermostWithInject;
+    // Walk up the tree looking for functions with inject() calls
+    while (current) {
+        // Stop if we hit a class - we don't want to go outside the function scope
+        if (ts.isClassDeclaration(current)) {
+            break;
+        }
+        // Check if this is a function with inject()
+        if ((ts.isFunctionDeclaration(current) || ts.isArrowFunction(current) || ts.isFunctionExpression(current)) &&
+            containsInjectCall(current)) {
+            outermostWithInject = current;
+        }
+        current = current.parent;
+    }
+    return outermostWithInject;
+}
+function findContainingStandaloneFunction(node, sourceFile) {
+    let current = node;
+    while (current) {
+        // Check if we hit a class first - then it's not a standalone function
+        if (ts.isClassDeclaration(current)) {
+            return undefined;
+        }
+        // Check for function declarations, arrow functions, or function expressions
+        if (ts.isFunctionDeclaration(current) || ts.isArrowFunction(current) || ts.isFunctionExpression(current)) {
+            return current;
+        }
+        current = current.parent;
+    }
+    return undefined;
+}
+function findOrCreateInjectorInFunction(func, sourceFile, functionsNeedingInjector) {
+    // Check if function already has an injector variable
+    const existingInjector = findExistingInjectorVariable(func, sourceFile);
+    if (existingInjector) {
+        return existingInjector;
+    }
+    // Check if we already marked this function for injector creation
+    const existing = functionsNeedingInjector.get(func);
+    if (existing) {
+        return existing;
+    }
+    // Mark for creation
+    const injectorName = 'injector';
+    functionsNeedingInjector.set(func, injectorName);
+    return injectorName;
+}
+function findExistingInjectorVariable(func, sourceFile) {
+    const body = func.body;
+    if (!body || !ts.isBlock(body)) {
+        return undefined;
+    }
+    for (const statement of body.statements) {
+        if (ts.isVariableStatement(statement)) {
+            for (const declaration of statement.declarationList.declarations) {
+                if (ts.isIdentifier(declaration.name) &&
+                    declaration.initializer &&
+                    hasInjectInjectorCall(declaration.initializer)) {
+                    return declaration.name.text;
+                }
+            }
+        }
+    }
+    return undefined;
+}
+function findContainingClass(node, sourceFile) {
+    let current = node;
+    while (current) {
+        if (ts.isClassDeclaration(current)) {
+            return current;
+        }
+        current = current.parent;
+    }
+    return undefined;
+}
+function transformSinglePrepareCall(callNode, injectorReference, sourceFile, pollingInfo) {
+    const propAccess = callNode.expression;
+    const creatorName = propAccess.expression.text;
+    // Get existing arguments
+    const existingArgs = callNode.arguments.length > 0 ? callNode.arguments[0] : undefined;
+    // Build new argument object
+    const newArgProperties = [];
+    let existingConfig;
+    let needsSpread = false;
+    let spreadExpression;
+    // If there's an existing argument and it's an object literal, extract its properties
+    if (existingArgs) {
+        if (ts.isObjectLiteralExpression(existingArgs)) {
+            existingArgs.properties.forEach((prop) => {
+                if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+                    const propName = prop.name.text;
+                    // Handle config specially - we need to merge it
+                    if (propName === 'config') {
+                        existingConfig = prop;
+                        return; // Don't add it yet
+                    }
+                    const propValue = prop.initializer.getText(sourceFile);
+                    newArgProperties.push(`${propName}: ${propValue}`);
+                }
+                else if (ts.isShorthandPropertyAssignment(prop)) {
+                    const propName = prop.name.text;
+                    newArgProperties.push(propName);
+                }
+                else if (ts.isSpreadAssignment(prop)) {
+                    // Existing spread - preserve it
+                    spreadExpression = prop.expression.getText(sourceFile);
+                    needsSpread = true;
+                }
+            });
+        }
+        else {
+            // If it's not an object literal (e.g., a variable or expression), we need to spread it
+            spreadExpression = existingArgs.getText(sourceFile);
+            needsSpread = true;
+        }
+    }
+    // Add injector
+    newArgProperties.push(`injector: ${injectorReference}`);
+    // Conditionally add or merge config
+    const queryVariableName = findQueryVariableNameForPrepareCall(callNode, sourceFile);
+    const addDestroyOnResponse = shouldAddDestroyOnResponse(queryVariableName, pollingInfo);
+    if (existingConfig) {
+        // Merge with existing config
+        const existingConfigObj = existingConfig.initializer;
+        if (ts.isObjectLiteralExpression(existingConfigObj)) {
+            const configProps = [];
+            // Add existing config properties
+            existingConfigObj.properties.forEach((prop) => {
+                if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+                    const propName = prop.name.text;
+                    const propValue = prop.initializer.getText(sourceFile);
+                    configProps.push(`${propName}: ${propValue}`);
+                }
+                else if (ts.isShorthandPropertyAssignment(prop)) {
+                    const propName = prop.name.text;
+                    configProps.push(propName);
+                }
+            });
+            // Add destroyOnResponse if needed
+            if (addDestroyOnResponse) {
+                configProps.push('destroyOnResponse: true');
+            }
+            if (configProps.length > 2) {
+                newArgProperties.push(`config: {\n    ${configProps.join(',\n    ')}\n  }`);
+            }
+            else {
+                newArgProperties.push(`config: { ${configProps.join(', ')} }`);
+            }
+        }
+        else {
+            // Config is not an object literal (e.g., a variable) - can't merge
+            // Just keep the existing config
+            newArgProperties.push(`config: ${existingConfigObj.getText(sourceFile)}`);
+        }
+    }
+    else if (addDestroyOnResponse) {
+        // No existing config - add destroyOnResponse
+        newArgProperties.push(`config: { destroyOnResponse: true }`);
+    }
+    // Format based on whether we need to spread and number of properties
+    let argsString;
+    if (needsSpread && spreadExpression) {
+        // Need to spread the existing argument
+        if (newArgProperties.length <= 2 && !newArgProperties.some((p) => p.includes('\n'))) {
+            // Single line for short objects
+            argsString = `{ ...${spreadExpression}, ${newArgProperties.join(', ')} }`;
+        }
+        else {
+            // Multi-line for longer objects
+            argsString = `{\n  ...${spreadExpression},\n  ${newArgProperties.join(',\n  ')}\n}`;
+        }
+    }
+    else {
+        // No spread needed
+        if (newArgProperties.length <= 2 && !newArgProperties.some((p) => p.includes('\n'))) {
+            // Single line for short objects
+            argsString = `{ ${newArgProperties.join(', ')} }`;
+        }
+        else {
+            // Multi-line for longer objects
+            argsString = `{\n  ${newArgProperties.join(',\n  ')}\n}`;
+        }
+    }
+    return `${creatorName}.prepare(${argsString})`;
+}
+function findQueryVariableNameForPrepareCall(prepareCallNode, sourceFile) {
+    // Walk up to find if this prepare call is assigned to a variable
+    // e.g., const query = legacyGetUsers.prepare()
+    let parent = prepareCallNode.parent;
+    while (parent) {
+        // Check if assigned to a variable
+        if (ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name)) {
+            return parent.name.text;
+        }
+        // Check if assigned to a class property
+        if (ts.isPropertyDeclaration(parent) && ts.isIdentifier(parent.name)) {
+            return parent.name.text;
+        }
+        // Check if it's a return statement - look for the method/function name
+        if (ts.isReturnStatement(parent)) {
+            const containingFunction = findContainingMethod(parent, sourceFile);
+            if (containingFunction) {
+                return containingFunction;
+            }
+        }
+        parent = parent.parent;
+    }
+    return undefined;
+}
+function findContainingMethod(node, sourceFile) {
+    let current = node;
+    while (current) {
+        if (ts.isMethodDeclaration(current) && ts.isIdentifier(current.name)) {
+            return current.name.text;
+        }
+        if (ts.isFunctionDeclaration(current) && current.name && ts.isIdentifier(current.name)) {
+            return current.name.text;
+        }
+        if (ts.isArrowFunction(current)) {
+            // Check if it's assigned to a variable
+            const parent = current.parent;
+            if (ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name)) {
+                return parent.name.text;
+            }
+        }
+        current = current.parent;
+    }
+    return undefined;
+}
+function reportManualReviewLocations(tree, allUsages) {
+    const needsReview = [];
+    allUsages.forEach((usage) => {
+        // Check if this usage needs manual review
+        if (usage.context === 'function') {
+            // For function context, we need to check if it was in a function WITHOUT inject()
+            // This means it should have been flagged for manual review during transformation
+            // We can check if the function had inject by looking at the original file
+            // (before transformation) since we need to report the original line number anyway
+            const originalContent = tree.read(usage.filePath, 'utf-8');
+            if (!originalContent)
+                return;
+            // Parse the CURRENT file to check if inject was added
+            // But use the ORIGINAL line number from usage
+            const sourceFile = ts.createSourceFile(usage.filePath, originalContent, ts.ScriptTarget.Latest, true);
+            // Find any function that contains a .prepare() call around the original position
+            let foundFunctionWithoutInject = false;
+            function checkFunctions(node) {
+                // Look for functions that might contain our usage
+                if (ts.isFunctionDeclaration(node) || ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
+                    const funcStart = node.getStart(sourceFile);
+                    const funcEnd = node.getEnd();
+                    // Check if our usage position is within this function
+                    if (usage.position.start >= funcStart && usage.position.end <= funcEnd) {
+                        // Check if this function or any parent function has inject()
+                        if (!containsInjectCall(node) && !findOutermostFunctionWithInject(node, sourceFile)) {
+                            foundFunctionWithoutInject = true;
+                        }
+                    }
+                }
+                ts.forEachChild(node, checkFunctions);
+            }
+            checkFunctions(sourceFile);
+            if (foundFunctionWithoutInject) {
+                needsReview.push({
+                    filePath: usage.filePath,
+                    line: usage.line, // Use the original line number from Step 1
+                    creatorName: usage.creatorName,
+                    reason: 'Used in standalone function without inject() - may need manual injector passing',
+                });
+            }
+        }
+        else if (usage.context === 'unknown') {
+            needsReview.push({
+                filePath: usage.filePath,
+                line: usage.line, // Use the original line number from Step 1
+                creatorName: usage.creatorName,
+                reason: 'Could not determine execution context - please verify manually',
+            });
+        }
+    });
+    if (needsReview.length > 0) {
+        console.warn(`\n⚠️  Found ${needsReview.length} locations that may need manual review:`);
+        // Group by file for cleaner output
+        const byFile = new Map();
+        needsReview.forEach((location) => {
+            if (!byFile.has(location.filePath)) {
+                byFile.set(location.filePath, []);
+            }
+            byFile.get(location.filePath).push(location);
+        });
+        byFile.forEach((locations, filePath) => {
+            console.warn(`\n   📄 ${filePath}:`);
+            locations.forEach((location) => {
+                console.warn(`      Line ${location.line}: ${location.creatorName}`);
+                console.warn(`         → ${location.reason}`);
+            });
+        });
+        console.warn('\n💡 Solve these warnings by:');
+        console.warn('   - [HIGHLY RECOMMENDED] Passing an injector as a parameter to the prepare method call alongside a config: { destroyOnResponse: true }');
+        console.warn('   - Using queryComputed() if appropriate');
+        console.warn('   - Putting the prepare call into an injection context');
+    }
+}
+//#endregion
+//#region Helper functions for inject detection
+function containsInjectCall(node) {
+    let hasInject = false;
+    function visit(n) {
+        if (hasInject)
+            return;
+        // Check for direct inject() call
+        if (ts.isCallExpression(n) && ts.isIdentifier(n.expression) && n.expression.text === 'inject') {
+            hasInject = true;
+            return;
+        }
+        // Check for any function call that starts with "inject"
+        if (ts.isCallExpression(n) && ts.isIdentifier(n.expression)) {
+            if (n.expression.text.startsWith('inject')) {
+                hasInject = true;
+                return;
+            }
+        }
+        ts.forEachChild(n, visit);
+    }
+    visit(node);
+    return hasInject;
+}
+//#endregion
+//#region Migrate empty .prepare() calls to .prepare({})
+function migrateEmptyPrepareCalls(tree) {
+    const updatedFiles = [];
+    (0, devkit_1.visitNotIgnoredFiles)(tree, '', (filePath) => {
+        if (!filePath.endsWith('.ts') || filePath.endsWith('.spec.ts'))
+            return;
+        const content = tree.read(filePath, 'utf-8');
+        if (!content)
+            return;
+        // Only analyze files that have .prepare() calls
+        if (!content.includes('.prepare()'))
+            return;
+        const newContent = transformEmptyPrepareCalls(content);
+        if (newContent !== content) {
+            tree.write(filePath, newContent);
+            updatedFiles.push(filePath);
+        }
+    });
+    if (updatedFiles.length > 0) {
+        console.log(`\n✅ Migrated empty .prepare() calls to .prepare({}) in ${updatedFiles.length} files`);
+    }
+}
+function transformEmptyPrepareCalls(content) {
+    const sourceFile = ts.createSourceFile('temp.ts', content, ts.ScriptTarget.Latest, true);
+    const replacements = [];
+    function visit(node) {
+        // Find: something.prepare()
+        if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression)) {
+            const propAccess = node.expression;
+            if (ts.isIdentifier(propAccess.name) && propAccess.name.text === 'prepare') {
+                // Check if it has no arguments
+                if (node.arguments.length === 0) {
+                    // Get the full text of the call: "something.prepare()"
+                    const callStart = node.getStart(sourceFile);
+                    const callEnd = node.getEnd();
+                    const callText = content.slice(callStart, callEnd);
+                    // Replace with: "something.prepare({})"
+                    const replacement = callText.replace(/\.prepare\(\)/, '.prepare({})');
+                    replacements.push({
+                        start: callStart,
+                        end: callEnd,
+                        replacement,
+                    });
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    // Apply replacements in reverse order
+    let result = content;
+    replacements.sort((a, b) => b.start - a.start);
+    for (const { start, end, replacement } of replacements) {
+        result = result.slice(0, start) + replacement + result.slice(end);
+    }
+    return result;
+}
+function detectPollingUsage(tree) {
+    const pollingInfo = new Map();
+    (0, devkit_1.visitNotIgnoredFiles)(tree, '', (filePath) => {
+        if (filePath.endsWith('.spec.ts'))
+            return;
+        const content = tree.read(filePath, 'utf-8');
+        if (!content)
+            return;
+        // Check TypeScript files
+        if (filePath.endsWith('.ts')) {
+            detectPollingInTypeScript(content, filePath, pollingInfo);
+        }
+        // Check HTML templates
+        if (filePath.endsWith('.html')) {
+            detectPollingInTemplate(content, filePath, pollingInfo);
+        }
+    });
+    return pollingInfo;
+}
+function detectPollingInTypeScript(content, filePath, pollingInfo) {
+    const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
+    function visit(node) {
+        // Find .poll() or .stopPolling() calls
+        if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression)) {
+            const propAccess = node.expression;
+            const methodName = propAccess.name;
+            if (ts.isIdentifier(methodName) && (methodName.text === 'poll' || methodName.text === 'stopPolling')) {
+                // Walk back to find the root variable name
+                const queryVariableName = getQueryVariableName(propAccess.expression, sourceFile);
+                if (queryVariableName) {
+                    const existing = pollingInfo.get(queryVariableName);
+                    if (existing) {
+                        existing.hasPolling = true;
+                        existing.locations.push(`${filePath}:${getLineNumber(node, sourceFile)} (.${methodName.text})`);
+                    }
+                    else {
+                        pollingInfo.set(queryVariableName, {
+                            queryVariableName,
+                            hasPolling: true,
+                            locations: [`${filePath}:${getLineNumber(node, sourceFile)} (.${methodName.text})`],
+                        });
+                    }
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+}
+function getQueryVariableName(expr, sourceFile) {
+    // Walk back through the chain to find the root variable
+    let current = expr;
+    while (true) {
+        if (ts.isIdentifier(current)) {
+            return current.text;
+        }
+        if (ts.isPropertyAccessExpression(current)) {
+            current = current.expression;
+            continue;
+        }
+        if (ts.isCallExpression(current)) {
+            // For chained calls like query.prepare().execute().poll()
+            // We want to get the root query variable
+            current = current.expression;
+            continue;
+        }
+        // Can't determine the root variable
+        return undefined;
+    }
+}
+function detectPollingInTemplate(content, filePath, pollingInfo) {
+    // Use regex to find .poll() or .stopPolling() in templates
+    // This is not perfect but catches most cases
+    const pollRegex = /(\w+)\.poll\(\)/g;
+    const stopPollingRegex = /(\w+)\.stopPolling\(\)/g;
+    let match;
+    // Find .poll() calls
+    while ((match = pollRegex.exec(content)) !== null) {
+        const queryVariableName = match[1];
+        const lineNumber = getLineNumberFromPosition(content, match.index);
+        const existing = pollingInfo.get(queryVariableName);
+        if (existing) {
+            existing.hasPolling = true;
+            existing.locations.push(`${filePath}:${lineNumber} (.poll() in template)`);
+        }
+        else {
+            pollingInfo.set(queryVariableName, {
+                queryVariableName,
+                hasPolling: true,
+                locations: [`${filePath}:${lineNumber} (.poll() in template)`],
+            });
+        }
+    }
+    // Find .stopPolling() calls
+    while ((match = stopPollingRegex.exec(content)) !== null) {
+        const queryVariableName = match[1];
+        const lineNumber = getLineNumberFromPosition(content, match.index);
+        const existing = pollingInfo.get(queryVariableName);
+        if (existing) {
+            existing.hasPolling = true;
+            existing.locations.push(`${filePath}:${lineNumber} (.stopPolling() in template)`);
+        }
+        else {
+            pollingInfo.set(queryVariableName, {
+                queryVariableName,
+                hasPolling: true,
+                locations: [`${filePath}:${lineNumber} (.stopPolling() in template)`],
+            });
+        }
+    }
+}
+function getLineNumberFromPosition(content, position) {
+    const lines = content.slice(0, position).split('\n');
+    return lines.length;
+}
+function shouldAddDestroyOnResponse(queryVariableName, pollingInfo) {
+    if (!queryVariableName) {
+        // Can't determine - be conservative and don't add destroyOnResponse
+        return false;
+    }
+    const info = pollingInfo.get(queryVariableName);
+    // If we found polling usage, don't add destroyOnResponse
+    if (info && info.hasPolling) {
+        return false;
+    }
+    // No polling detected - safe to add destroyOnResponse
+    return true;
+}
 //#endregion
+// TODO:
+// - Only add destroyOnResponse if we are 00% sure there is no .poll / stopPolling calls on it
 //# sourceMappingURL=migration.js.map