@ethlete/query 6.0.0-next.61 → 6.0.0-next.63

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

@@ -1,5 +1,8 @@
 import * as ts from 'typescript';
-import { createSourceFile, ensureAngularCoreImports, getIndentation, getLineNumber, getLineNumberFromPosition, } from './shared.js';
+import { findUsedNames, pruneUnusedNamedImports } from './rename-symbols.js';
+import { createSourceFile, ensureAngularCoreImports, ensureImportFromQuery, getIndentation, getLineNumber, getLineNumberFromPosition, } from './shared.js';
+/** The creator methods that resolve an injector, and so throw `ET950` when called without one. */
+const INJECTOR_METHODS = new Set(['prepare', 'createSubject', 'createSignal', 'behaviorSubject']);
 /** `default` can never be a class name, so it cannot collide with a named class of the same file. */
 const ANONYMOUS_DEFAULT_CLASS_KEY = 'default';
 const getClassKey = (node) => node.name?.text ?? ANONYMOUS_DEFAULT_CLASS_KEY;
@@ -22,6 +25,7 @@ export const migrateLegacyPrepareCalls = (tree, report, scope) => {
             return;
         }
         allUsages.push(...findLegacyCreatorUsages(content, filePath));
+        reportUnresolvedReceivers(content, filePath, report);
     });
     if (allUsages.length === 0) {
         console.log('\n✅ No legacy query creator usages found');
@@ -60,12 +64,13 @@ const findLegacyCreatorUsages = (content, filePath) => {
     const visit = (node) => {
         if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression)) {
             const propertyAccess = node.expression;
-            if (ts.isIdentifier(propertyAccess.name) && propertyAccess.name.text === 'prepare') {
+            if (ts.isIdentifier(propertyAccess.name) && INJECTOR_METHODS.has(propertyAccess.name.text)) {
                 const creatorName = ts.isIdentifier(propertyAccess.expression) ? propertyAccess.expression.text : undefined;
                 if (creatorName && legacyCreatorNames.has(creatorName)) {
                     usages.push({
                         filePath,
                         creatorName,
+                        method: propertyAccess.name.text,
                         line: getLineNumber(node, sourceFile),
                         position: {
                             start: node.getStart(sourceFile),
@@ -82,6 +87,35 @@ const findLegacyCreatorUsages = (content, filePath) => {
     visit(sourceFile);
     return usages;
 };
+const LEGACY_PROPERTY_NAME = /^legacy[A-Z]/;
+const reportUnresolvedReceivers = (content, filePath, report) => {
+    if (!/\blegacy[A-Z]\w*\s*\.(prepare|createSubject|createSignal|behaviorSubject)\(/.test(content)) {
+        return;
+    }
+    const sourceFile = createSourceFile(content, filePath);
+    const visit = (node) => {
+        if (ts.isCallExpression(node) &&
+            ts.isPropertyAccessExpression(node.expression) &&
+            ts.isIdentifier(node.expression.name) &&
+            INJECTOR_METHODS.has(node.expression.name.text) &&
+            ts.isPropertyAccessExpression(node.expression.expression) &&
+            LEGACY_PROPERTY_NAME.test(node.expression.expression.name.text) &&
+            !CONTEXTS_WITH_INJECTOR.includes(determineUsageContext(node))) {
+            const line = getLineNumber(node, sourceFile);
+            const receiver = node.expression.expression.getText(sourceFile);
+            report.addManualReview({
+                title: `Check the injector of ${receiver}.${node.expression.name.text}()`,
+                summary: `${receiver}.${node.expression.name.text}() is called on a creator the migration cannot resolve, because the receiver is not a plain legacy* identifier. The call may run outside an injection context and then throws ET950.`,
+                action: 'Pass `{ injector }` to the call, or add provideLegacyPrepareFallback() to the app providers. A call in a constructor, a field initializer or an inject() function needs nothing.',
+                locations: [{ filePath, line }],
+                source: 'legacy-prepare-migration',
+                dedupeKey: `unresolved-receiver:${filePath}:${line}`,
+            });
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+};
 const findLegacyCreatorNames = (sourceFile) => {
     const names = new Set();
     const visit = (node) => {
@@ -330,6 +364,12 @@ const createInjectorMembers = (tree, classInjectors) => {
         console.log(`\n✅ Added injector members to ${Array.from(filesToUpdate.values()).flat().length} classes`);
     }
 };
+const getMemberStartWithComments = (content, member) => {
+    const ownLineComment = ts
+        .getLeadingCommentRanges(content, member.getFullStart())
+        ?.find((range) => /\n[ \t]*$/.test(content.slice(0, range.pos)));
+    return ownLineComment?.pos ?? member.getStart();
+};
 const addInjectorMemberToClass = (content, classInfo) => {
     const sourceFile = createSourceFile(content);
     let targetClass;
@@ -343,7 +383,9 @@ const addInjectorMemberToClass = (content, classInfo) => {
     if (!targetClass) {
         return content;
     }
-    const classBodyStart = targetClass.members.length > 0 ? targetClass.members[0].getStart(sourceFile) : targetClass.getEnd() - 1;
+    const classBodyStart = targetClass.members.length > 0
+        ? getMemberStartWithComments(content, targetClass.members[0])
+        : targetClass.getEnd() - 1;
     const indentation = getIndentation(content, classBodyStart);
     const injectorMember = `private ${classInfo.injectorMemberName} = inject(Injector);\n\n${indentation}`;
     return content.slice(0, classBodyStart) + injectorMember + content.slice(classBodyStart);
@@ -362,7 +404,7 @@ const transformLegacyCreatorPrepareCalls = (tree, classInjectors, pollingInfo, s
             return;
         }
         const content = tree.read(filePath, 'utf-8');
-        if (!content || !content.includes('.prepare(')) {
+        if (!content || !/\.(prepare|createSubject|createSignal|behaviorSubject)\(/.test(content)) {
             return;
         }
         const usages = findLegacyCreatorUsages(content, filePath);
@@ -371,12 +413,11 @@ const transformLegacyCreatorPrepareCalls = (tree, classInjectors, pollingInfo, s
         }
     });
     filesByPath.forEach((classes, filePath) => {
-        let content = tree.read(filePath, 'utf-8');
+        const content = tree.read(filePath, 'utf-8');
         if (!content) {
             return;
         }
-        content = ensureAngularCoreImports(content, ['inject', 'Injector']);
-        const nextContent = transformPrepareCallsInFile(content, classes, pollingInfo);
+        const nextContent = pruneUnusedNamedImports(transformPrepareCallsInFile(ensureAngularCoreImports(content, ['inject', 'Injector']), classes, pollingInfo), new Set([...findUsedNames(content), 'inject', 'Injector']));
         if (nextContent !== content) {
             tree.write(filePath, nextContent);
             updatedFiles.push(filePath);
@@ -391,6 +432,7 @@ const transformPrepareCallsInFile = (content, classes, pollingInfo) => {
     const replacements = [];
     const legacyCreatorNames = findLegacyCreatorNames(sourceFile);
     const classNameToInjector = new Map();
+    const rewrittenComputeds = new Set();
     const functionsNeedingInjector = new Map();
     if (legacyCreatorNames.size === 0) {
         return content;
@@ -401,13 +443,31 @@ const transformPrepareCallsInFile = (content, classes, pollingInfo) => {
     const visit = (node) => {
         if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression)) {
             const propertyAccess = node.expression;
-            if (ts.isIdentifier(propertyAccess.name) && propertyAccess.name.text === 'prepare') {
+            if (ts.isIdentifier(propertyAccess.name) && INJECTOR_METHODS.has(propertyAccess.name.text)) {
                 const creatorName = ts.isIdentifier(propertyAccess.expression) ? propertyAccess.expression.text : undefined;
                 if (!creatorName || !legacyCreatorNames.has(creatorName)) {
                     ts.forEachChild(node, visit);
                     return;
                 }
                 const context = determineUsageContext(node);
+                const computedHost = findReturningPlainComputed(node);
+                const rewriteComputed = (injectorExpression) => {
+                    if (!computedHost || rewrittenComputeds.has(computedHost))
+                        return;
+                    rewrittenComputeds.add(computedHost);
+                    replacements.push({
+                        start: computedHost.expression.getStart(sourceFile),
+                        end: computedHost.expression.getEnd(),
+                        replacement: 'queryComputed',
+                    });
+                    if (computedHost.arguments.length === 1) {
+                        replacements.push({
+                            start: computedHost.arguments[0].getEnd(),
+                            end: computedHost.arguments[0].getEnd(),
+                            replacement: `, { injector: ${injectorExpression} }`,
+                        });
+                    }
+                };
                 if (CONTEXTS_WITH_INJECTOR.includes(context)) {
                     ts.forEachChild(node, visit);
                     return;
@@ -420,7 +480,8 @@ const transformPrepareCallsInFile = (content, classes, pollingInfo) => {
                         ts.forEachChild(node, visit);
                         return;
                     }
-                    const transformedCall = transformSinglePrepareCall(node, `this.${injectorMember}`, sourceFile, pollingInfo);
+                    rewriteComputed(`this.${injectorMember}`);
+                    const transformedCall = transformCall(node, `this.${injectorMember}`, sourceFile, pollingInfo);
                     if (transformedCall) {
                         replacements.push({
                             start: node.getStart(sourceFile),
@@ -432,15 +493,22 @@ const transformPrepareCallsInFile = (content, classes, pollingInfo) => {
                 else if (containingFunction) {
                     const functionWithInject = findOutermostFunctionWithInject(containingFunction);
                     if (!functionWithInject) {
+                        if (propertyAccess.name.text === 'prepare' && isInsideAsyncValidator(node)) {
+                            replacements.push({
+                                start: node.getStart(sourceFile),
+                                end: node.getEnd(),
+                                replacement: transformSinglePrepareCall(node, undefined, sourceFile, pollingInfo),
+                            });
+                        }
                         ts.forEachChild(node, visit);
                         return;
                     }
                     const functionPosition = functionWithInject.getStart(sourceFile);
                     if (!functionsNeedingInjector.has(functionPosition)) {
-                        const existingInjectorParameter = findInjectorParameter(functionWithInject);
-                        if (existingInjectorParameter) {
+                        const existingInjector = findExistingInjector(functionWithInject);
+                        if (existingInjector) {
                             functionsNeedingInjector.set(functionPosition, {
-                                injectorName: existingInjectorParameter,
+                                injectorName: existingInjector,
                                 bodyStart: -1,
                                 needsDeclaration: false,
                             });
@@ -457,7 +525,8 @@ const transformPrepareCallsInFile = (content, classes, pollingInfo) => {
                         }
                     }
                     const injectorName = functionsNeedingInjector.get(functionPosition)?.injectorName ?? 'injector';
-                    const transformedCall = transformSinglePrepareCall(node, injectorName, sourceFile, pollingInfo);
+                    rewriteComputed(injectorName);
+                    const transformedCall = transformCall(node, injectorName, sourceFile, pollingInfo);
                     if (transformedCall) {
                         replacements.push({
                             start: node.getStart(sourceFile),
@@ -497,9 +566,9 @@ const transformPrepareCallsInFile = (content, classes, pollingInfo) => {
         });
         result = result.slice(0, start + adjustment) + replacement + result.slice(end + adjustment);
     });
-    return result;
+    return rewrittenComputeds.size > 0 ? ensureImportFromQuery(result, ['queryComputed']) : result;
 };
-const findInjectorParameter = (func) => {
+const findExistingInjector = (func) => {
     for (const parameter of func.parameters) {
         if (!ts.isIdentifier(parameter.name)) {
             continue;
@@ -511,6 +580,23 @@ const findInjectorParameter = (func) => {
             return parameter.name.text;
         }
     }
+    if (!func.body || !ts.isBlock(func.body))
+        return undefined;
+    for (const statement of func.body.statements) {
+        if (!ts.isVariableStatement(statement))
+            continue;
+        for (const declaration of statement.declarationList.declarations) {
+            const initializer = declaration.initializer;
+            if (ts.isIdentifier(declaration.name) &&
+                initializer &&
+                ts.isCallExpression(initializer) &&
+                ts.isIdentifier(initializer.expression) &&
+                initializer.expression.text === 'inject' &&
+                initializer.arguments[0]?.getText() === 'Injector') {
+                return declaration.name.text;
+            }
+        }
+    }
     return undefined;
 };
 const getFunctionBodyStart = (func, sourceFile) => {
@@ -560,6 +646,26 @@ const findContainingClass = (node) => {
     }
     return undefined;
 };
+const transformCall = (callNode, injectorReference, sourceFile, pollingInfo) => callNode.expression.name.text === 'prepare'
+    ? transformSinglePrepareCall(callNode, injectorReference, sourceFile, pollingInfo)
+    : transformContainerCall(callNode, injectorReference, sourceFile);
+const transformContainerCall = (callNode, injectorReference, sourceFile) => {
+    const propertyAccess = callNode.expression;
+    const initialValue = callNode.arguments[0]?.getText(sourceFile) ?? 'null';
+    const config = callNode.arguments[1];
+    let nextConfig = `{ injector: ${injectorReference} }`;
+    if (config && ts.isObjectLiteralExpression(config)) {
+        const hasInjector = config.properties.some((property) => !!property.name && ts.isIdentifier(property.name) && property.name.text === 'injector');
+        if (hasInjector) {
+            return undefined;
+        }
+        nextConfig = `{ ${[...config.properties.map((property) => property.getText(sourceFile)), `injector: ${injectorReference}`].join(', ')} }`;
+    }
+    else if (config) {
+        nextConfig = `{ ...${config.getText(sourceFile)}, injector: ${injectorReference} }`;
+    }
+    return `${propertyAccess.expression.getText(sourceFile)}.${propertyAccess.name.text}(${initialValue}, ${nextConfig})`;
+};
 const transformSinglePrepareCall = (callNode, injectorReference, sourceFile, pollingInfo) => {
     const propertyAccess = callNode.expression;
     const creatorName = propertyAccess.expression.text;
@@ -594,9 +700,10 @@ const transformSinglePrepareCall = (callNode, injectorReference, sourceFile, pol
             spreadExpression = existingArgument.getText(sourceFile);
         }
     }
-    nextArgumentProperties.push(`injector: ${injectorReference}`);
+    if (injectorReference)
+        nextArgumentProperties.push(`injector: ${injectorReference}`);
     const queryVariableName = findQueryVariableNameForPrepareCall(callNode, sourceFile);
-    const addDestroyOnResponse = shouldAddDestroyOnResponse(queryVariableName, pollingInfo, isDiscardedPrepareCall(callNode));
+    const addDestroyOnResponse = shouldAddDestroyOnResponse(queryVariableName, pollingInfo, isDiscardedPrepareCall(callNode), isOneShotLocalVariable(callNode) || isInsideAsyncValidator(callNode));
     if (existingConfig && ts.isObjectLiteralExpression(existingConfig.initializer)) {
         const configProperties = [];
         existingConfig.initializer.properties.forEach((property) => {
@@ -685,9 +792,9 @@ const reportManualReviewLocations = (tree, allUsages, report) => {
             visit(sourceFile);
             if (foundFunctionWithoutInject) {
                 report.addManualReview({
-                    title: `Review standalone prepare() usage for ${usage.creatorName}`,
-                    summary: `${usage.creatorName}.prepare() is used in a standalone function without an obvious injection context.`,
-                    action: 'Pass an Injector explicitly, move the call into queryComputed(), or wrap the logic in a function that already uses inject().',
+                    title: `Review standalone ${usage.method}() usage for ${usage.creatorName}`,
+                    summary: `${usage.creatorName}.${usage.method}() is used in a standalone function without an obvious injection context.`,
+                    action: 'If the factory that returns this function runs in an injection context, add `const injector = inject(Injector);` at the top of the factory and pass `{ injector }` to the call. Otherwise pass an Injector from the caller, move the call into queryComputed(), or add provideLegacyPrepareFallback() to the app providers.',
                     locations: [{ filePath: usage.filePath, line: usage.line }],
                     source: 'legacy-prepare-migration',
                     dedupeKey: `manual-review:${usage.filePath}:${usage.line}:${usage.creatorName}`,
@@ -697,7 +804,7 @@ const reportManualReviewLocations = (tree, allUsages, report) => {
         if (usage.context === 'unknown') {
             report.addManualReview({
                 title: `Verify execution context for ${usage.creatorName}`,
-                summary: `The migration could not classify the execution context of ${usage.creatorName}.prepare().`,
+                summary: `The migration could not classify the execution context of ${usage.creatorName}.${usage.method}().`,
                 action: 'Inspect the surrounding code and confirm that the generated injector handling and destroyOnResponse behavior are correct.',
                 locations: [{ filePath: usage.filePath, line: usage.line }],
                 source: 'legacy-prepare-migration',
@@ -851,12 +958,153 @@ const isDiscardedPrepareCall = (callNode) => {
     }
     return false;
 };
-const shouldAddDestroyOnResponse = (queryVariableName, pollingInfo, isDiscarded) => {
-    if (!queryVariableName) {
-        // A discarded query is the one case where nothing else can clean it up: no variable for a container
-        // to hold, no caller to destroy it. That is exactly what `destroyOnResponse` is for.
-        return isDiscarded;
+const unwrapChainEnd = (callNode) => {
+    let current = callNode;
+    while (current.parent) {
+        const parent = current.parent;
+        if (ts.isParenthesizedExpression(parent) || ts.isNonNullExpression(parent)) {
+            current = parent;
+            continue;
+        }
+        const call = parent.parent;
+        if (ts.isPropertyAccessExpression(parent) &&
+            parent.expression === current &&
+            parent.name.text === 'execute' &&
+            call &&
+            ts.isCallExpression(call) &&
+            call.expression === parent) {
+            current = call;
+            continue;
+        }
+        break;
+    }
+    return current;
+};
+/**
+ * The Angular `computed(() => legacy.prepare(...).execute())` whose callback returns the prepared query.
+ * Such a computed builds one unmanaged query per input change, so it becomes `queryComputed`, whose
+ * container destroys the superseded one.
+ */
+const findReturningPlainComputed = (callNode) => {
+    const chainEnd = unwrapChainEnd(callNode);
+    const callback = chainEnd.parent;
+    if (!callback || !ts.isArrowFunction(callback) || callback.body !== chainEnd) {
+        const returnStatement = chainEnd.parent;
+        if (!returnStatement || !ts.isReturnStatement(returnStatement))
+            return undefined;
+        let fn = returnStatement.parent;
+        while (fn && !isCallbackFunction(fn))
+            fn = fn.parent;
+        return fn && isCallbackFunction(fn) ? getPlainComputedHost(fn) : undefined;
+    }
+    return getPlainComputedHost(callback);
+};
+const getPlainComputedHost = (node) => {
+    const host = getCallbackHost(node);
+    if (!host || !ts.isIdentifier(host.expression) || host.expression.text !== 'computed' || host.arguments[0] !== node) {
+        return undefined;
+    }
+    return host;
+};
+const ASYNC_VALIDATOR_PROPERTIES = new Set(['asyncValidator', 'asyncValidators']);
+const ASYNC_VALIDATOR_SETTERS = new Set(['setAsyncValidators', 'addAsyncValidators']);
+/**
+ * Whether a function around the call is an Angular async validator: a value of an `asyncValidator(s)` property or
+ * setter argument, an `AsyncValidatorFn` or a factory of one, a function returning `Observable`/`Promise` of
+ * `ValidationErrors`, or `validate` of an `AsyncValidator`.
+ */
+const isInsideAsyncValidator = (callNode) => {
+    for (let node = callNode.parent; node; node = node.parent) {
+        if (ts.isMethodDeclaration(node))
+            return isAsyncValidatorMethod(node);
+        if (isCallbackFunction(node) && isAsyncValidatorFunction(node))
+            return true;
+    }
+    return false;
+};
+const isAsyncValidatorMethod = (method) => {
+    const owner = method.parent;
+    return (ts.isIdentifier(method.name) &&
+        method.name.text === 'validate' &&
+        ts.isClassDeclaration(owner) &&
+        !!owner.heritageClauses?.some((clause) => clause.types.some((type) => type.expression.getText() === 'AsyncValidator')));
+};
+const ASYNC_VALIDATOR_SIGNATURE = /\bAsyncValidatorFn\b|\b(?:Observable|Promise)<\s*ValidationErrors\b/;
+const isAsyncValidatorFunction = (fn) => {
+    if (fn.type && ASYNC_VALIDATOR_SIGNATURE.test(fn.type.getText()))
+        return true;
+    let value = fn;
+    if (ts.isArrayLiteralExpression(value.parent))
+        value = value.parent;
+    const parent = value.parent;
+    if (ts.isPropertyAssignment(parent) && ts.isIdentifier(parent.name)) {
+        return ASYNC_VALIDATOR_PROPERTIES.has(parent.name.text);
+    }
+    if (ts.isCallExpression(parent) && ts.isPropertyAccessExpression(parent.expression)) {
+        return ASYNC_VALIDATOR_SETTERS.has(parent.expression.name.text);
+    }
+    if ((ts.isVariableDeclaration(parent) || ts.isPropertyDeclaration(parent)) && parent.type) {
+        return parent.type.getText().includes('AsyncValidatorFn');
+    }
+    return false;
+};
+const ONE_SHOT_QUERY_MEMBERS = ['execute', 'onSuccess', 'onFailure'];
+const isOneShotLocalVariable = (callNode) => {
+    let chainEnd = callNode;
+    let executeCalls = 0;
+    while (chainEnd.parent) {
+        const parent = chainEnd.parent;
+        if (ts.isPropertyAccessExpression(parent) && parent.expression === chainEnd) {
+            if (!ONE_SHOT_QUERY_MEMBERS.includes(parent.name.text))
+                return false;
+            if (parent.name.text === 'execute')
+                executeCalls++;
+            chainEnd = parent;
+            continue;
+        }
+        if (ts.isCallExpression(parent) && parent.expression === chainEnd) {
+            chainEnd = parent;
+            continue;
+        }
+        break;
+    }
+    const declaration = chainEnd.parent;
+    if (!declaration ||
+        !ts.isVariableDeclaration(declaration) ||
+        declaration.initializer !== chainEnd ||
+        !ts.isIdentifier(declaration.name)) {
+        return false;
     }
-    return !pollingInfo.get(queryVariableName)?.hasPolling;
+    const scope = declaration.parent.parent.parent;
+    if (!ts.isVariableStatement(declaration.parent.parent) || !ts.isBlock(scope))
+        return false;
+    const variableName = declaration.name.text;
+    let isOneShot = executeCalls <= 1;
+    const visit = (node) => {
+        if (!isOneShot)
+            return;
+        if (ts.isIdentifier(node) && node.text === variableName && node !== declaration.name) {
+            const parent = node.parent;
+            if (ts.isPropertyAccessExpression(parent) &&
+                parent.expression === node &&
+                ONE_SHOT_QUERY_MEMBERS.includes(parent.name.text)) {
+                if (parent.name.text === 'execute')
+                    executeCalls++;
+                if (executeCalls > 1)
+                    isOneShot = false;
+            }
+            else if (!(ts.isPropertyAccessExpression(parent) && parent.name === node)) {
+                isOneShot = false;
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(scope);
+    return isOneShot;
+};
+const shouldAddDestroyOnResponse = (queryVariableName, pollingInfo, isDiscarded, isOneShotLocal) => {
+    if (queryVariableName && pollingInfo.get(queryVariableName)?.hasPolling)
+        return false;
+    return isDiscarded || isOneShotLocal;
 };
 //# sourceMappingURL=legacy-prepare-migration.js.map