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

package/generators/migrate-from-ngrx-toolkit/store-removal.js

@@ -349,11 +349,37 @@ export const removeFeatureStores = (tree, graph, inScope, features, report) => {
         const content = tree.read(file, 'utf-8');
         return content ? createSourceFile(content, file).statements.flatMap(declaredNames) : [];
     };
-    let converting = new Set(features);
+    const importClosure = (feature, roots) => {
+        const storeFiles = new Set(storeFilesOf(feature));
+        const closure = new Set(roots);
+        const queue = [...closure];
+        for (let file = queue.pop(); file; file = queue.pop()) {
+            const content = tree.read(file, 'utf-8');
+            if (!content)
+                continue;
+            for (const statement of createSourceFile(content, file).statements) {
+                if ((!ts.isImportDeclaration(statement) && !ts.isExportDeclaration(statement)) ||
+                    !statement.moduleSpecifier ||
+                    !ts.isStringLiteral(statement.moduleSpecifier)) {
+                    continue;
+                }
+                const resolved = graph.resolveFile(file, statement.moduleSpecifier.text);
+                if (resolved && storeFiles.has(resolved) && !closure.has(resolved)) {
+                    closure.add(resolved);
+                    queue.push(resolved);
+                }
+            }
+        }
+        return closure;
+    };
+    const converting = new Set(features);
     let scan;
     const keptLocations = new Map();
+    const keptFiles = new Map();
+    const keptVia = new Map();
+    const removableFilesOf = (feature) => storeFilesOf(feature).filter((file) => !keptFiles.has(file));
     for (;;) {
-        const deletedFiles = new Set([...converting].flatMap(storeFilesOf));
+        const deletedFiles = new Set([...converting].flatMap(removableFilesOf));
         const movedFiles = new Map([...converting].map((feature) => [feature.files.actions, feature.queriesFile]));
         const needles = [
             ...new Set([...deletedFiles].flatMap((file) => [...declaredIn(file), file.split('/').pop().replace(/\.ts$/, '')])),
@@ -371,20 +397,34 @@ export const removeFeatureStores = (tree, graph, inScope, features, report) => {
             movedFiles,
             needles,
         });
-        const blocked = new Set();
+        const usedOutside = new Map();
         for (const reference of scan.references) {
             const feature = featureOfFile.get(reference.declaringFile);
             if (!feature || reference.target || !converting.has(feature))
                 continue;
-            blocked.add(feature);
-            keptLocations.set(feature, [
-                ...(keptLocations.get(feature) ?? []),
-                { filePath: reference.file, line: reference.line },
-            ]);
+            const files = usedOutside.get(feature) ?? new Map();
+            const location = { filePath: reference.file, line: reference.line };
+            files.set(reference.declaringFile, [...(files.get(reference.declaringFile) ?? []), location]);
+            usedOutside.set(feature, files);
+            keptLocations.set(feature, [...(keptLocations.get(feature) ?? []), location]);
         }
-        if (blocked.size === 0)
+        if (usedOutside.size === 0)
             break;
-        converting = new Set([...converting].filter((feature) => !blocked.has(feature)));
+        for (const [feature, files] of usedOutside) {
+            const closure = importClosure(feature, [...keptFiles.keys(), ...files.keys()].filter((file) => featureOfFile.get(file) === feature));
+            if (closure.has(feature.files.actions) || (feature.files.reducer && closure.has(feature.files.reducer))) {
+                converting.delete(feature);
+                continue;
+            }
+            for (const [file, locations] of files)
+                keptFiles.set(file, [...(keptFiles.get(file) ?? []), ...locations]);
+            for (const file of closure) {
+                if (keptFiles.has(file))
+                    continue;
+                keptFiles.set(file, []);
+                keptVia.set(file, [...files.keys()][0]);
+            }
+        }
     }
     for (const [feature, locations] of keptLocations) {
         if (converting.has(feature))
@@ -395,7 +435,20 @@ export const removeFeatureStores = (tree, graph, inScope, features, report) => {
             locations: [{ filePath: feature.files.actions }, ...locations],
         });
     }
-    const deletedFiles = new Set([...converting].flatMap(storeFilesOf));
+    for (const [file, locations] of keptFiles) {
+        const feature = featureOfFile.get(file);
+        if (!converting.has(feature))
+            continue;
+        const via = keptVia.get(file);
+        report.add({
+            id: TOOLKIT_TASK.STORE_FILE_KEPT,
+            summary: via
+                ? `\`${file}\` of \`${feature.base}\` is kept because the kept \`${via}\` imports it.`
+                : `\`${file}\` of \`${feature.base}\` is kept because code outside the feature uses it.`,
+            locations: [{ filePath: file }, ...locations],
+        });
+    }
+    const deletedFiles = new Set([...converting].flatMap(removableFilesOf));
     const movedFiles = new Map([...converting].map((feature) => [feature.files.actions, feature.queriesFile]));
     const editedFiles = new Set();
     const applyScan = (result, extraEdits) => {

package/generators/migrate-to-query-v3/auth-provider-scaffold.js

@@ -176,7 +176,7 @@ export const renderAuthProviderBody = (config) => {
     }
     const refreshEntries = [`      queryCreator: ${config.refreshCreatorName},`];
     if (config.responseAdapter) {
-        refreshEntries.push('      extractTokens: (response) => {', `        const { token, refreshToken } = (${config.responseAdapter})(response);`, '', '        return { accessToken: token, refreshToken };', '      },');
+        refreshEntries.push('      extractTokens: (response) => {', `        const { token, refreshToken } = (${config.responseAdapter})(response) as { token: string; refreshToken: string };`, '', '        return { accessToken: token, refreshToken };', '      },');
     }
     if (config.requestArgsAdapter) {
         refreshEntries.push(`      // TODO(query-v3): v2 requestArgsAdapter took { token, refreshToken }; buildArgs takes the refresh token alone.`, `      buildArgs: ${config.requestArgsAdapter},`);

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

@@ -1,6 +1,6 @@
 import * as ts from 'typescript';
 import { createModuleGraph } from './module-graph.js';
-import { isShadowedInNestedScope } from './rename-symbols.js';
+import { findUsedNames, isShadowedInNestedScope, pruneUnusedNamedImports } from './rename-symbols.js';
 import { REMOVED_EXPERIMENTAL_QUERY_HELPERS, createSourceFile, ensureImportFromQuery, ensureNamedImports, findRemovedExperimentalQueryHelpers, getLineNumber, printImportDeclaration, } from './shared.js';
 export const reportRemovedExperimentalQueryHelpers = (tree, scope, report) => {
     scope.visit(tree, (filePath) => {
@@ -34,10 +34,16 @@ export const reportRemovedExperimentalQueryHelpers = (tree, scope, report) => {
 export const migrateDevtoolsUsage = (tree, scope, report) => {
     const updatedFiles = [];
     const filesNeedingDevtoolsPackage = [];
+    let mountsFromProvider = false;
+    scope.visit(tree, (filePath) => {
+        if (filePath.endsWith('.ts') && tree.read(filePath, 'utf-8')?.includes('provideQueryClientForDevtools')) {
+            mountsFromProvider = true;
+        }
+    });
     scope.visit(tree, (filePath) => {
         if (filePath.endsWith('.html')) {
             const html = tree.read(filePath, 'utf-8');
-            const nextHtml = html && selectLazyDevtools(html);
+            const nextHtml = html && (mountsFromProvider ? removeDevtoolsTags(html) : selectLazyDevtools(html));
             if (nextHtml && nextHtml !== html) {
                 tree.write(filePath, nextHtml);
                 updatedFiles.push(filePath);
@@ -52,13 +58,14 @@ export const migrateDevtoolsUsage = (tree, scope, report) => {
             (!content.includes('provideQueryClientForDevtools') && !content.includes('QueryDevtoolsComponent'))) {
             return;
         }
-        const { content: nextContent, importsComponent } = migrateDevtoolsInFile(content);
+        const { content: migrated, importsComponent, mountsDevtools } = migrateDevtoolsInFile(content, mountsFromProvider);
+        const nextContent = pruneUnusedNamedImports(mountsFromProvider ? removeDevtoolsTags(migrated) : migrated, findUsedNames(content));
         if (nextContent === content) {
             return;
         }
         tree.write(filePath, nextContent);
         updatedFiles.push(filePath);
-        if (importsComponent) {
+        if (importsComponent || mountsDevtools) {
             filesNeedingDevtoolsPackage.push(filePath);
         }
     });
@@ -73,7 +80,7 @@ export const migrateDevtoolsUsage = (tree, scope, report) => {
         // `@ethlete/query-devtools`.
         report.addManualReview({
             title: 'Add @ethlete/query-devtools for the query devtools',
-            summary: '`QueryDevtoolsComponent` is now `QueryDevtoolsLazyComponent` from `@ethlete/query-devtools/lazy`, and `<et-query-devtools>` is `<et-query-devtools-lazy>`. The imports and templates were rewritten, but the package may not be a dependency of these projects yet.',
+            summary: "`provideQueryDevtools()` now mounts the devtools through `ui: () => import('@ethlete/query-devtools/lazy')`, so `<et-query-devtools>` and its component import were removed. Where no devtools provider was found, `QueryDevtoolsLazyComponent` and `<et-query-devtools-lazy>` replace them. The package may not be a dependency of these projects yet.",
             action: 'Run `yarn add @ethlete/query-devtools` where needed, then `yarn install` and re-lint the affected libs so the `@nx/dependency-checks` rule sees the new dependency.',
             locations: filesNeedingDevtoolsPackage.map((filePath) => ({ filePath })),
             source: 'cleanup-migration',
@@ -122,6 +129,27 @@ export const reportLeftoverV2Clients = (tree, scope, report) => {
         });
     });
 };
+export const reportLeftoverLegacyDevtools = (tree, scope, report) => {
+    scope.visit(tree, (filePath) => {
+        if (filePath.endsWith('.spec.ts') || (!filePath.endsWith('.ts') && !filePath.endsWith('.html'))) {
+            return;
+        }
+        const content = tree.read(filePath, 'utf-8');
+        const index = content?.search(/<et-query-devtools(?![\w-])|\b(QueryDevtoolsComponent|provideQueryClientForDevtools)\b/);
+        if (!content || index === undefined || index < 0) {
+            return;
+        }
+        const line = content.slice(0, index).split('\n').length;
+        report.addManualReview({
+            title: 'Migrator error: legacy devtools usage is left',
+            summary: 'The migration should leave no legacy `<et-query-devtools>`, `QueryDevtoolsComponent` or `provideQueryClientForDevtools` behind, so it missed this one. Report this case as a migrator bug.',
+            action: 'Switch it by hand to `provideQueryDevtools()` and `QueryDevtoolsLazyComponent` from `@ethlete/query-devtools/lazy`, then report the shape the migration did not handle.',
+            locations: [{ filePath, line }],
+            source: 'cleanup-migration',
+            dedupeKey: `leftover-legacy-devtools:${filePath}:${line}`,
+        });
+    });
+};
 export const migrateEmptyPrepareCalls = (tree, scope, report) => {
     const updatedFiles = [];
     const graph = createModuleGraph(tree);
@@ -154,7 +182,32 @@ export const migrateEmptyPrepareCalls = (tree, scope, report) => {
     }
 };
 const LAZY_DEVTOOLS_COMPONENT = 'QueryDevtoolsLazyComponent';
+const DEVTOOLS_UI_PROVIDER_CALL = "provideQueryDevtools({ ui: () => import('@ethlete/query-devtools/lazy') })";
 const selectLazyDevtools = (content) => content.replace(/(<\/?)et-query-devtools(?![\w-])/g, '$1et-query-devtools-lazy');
+const removeDevtoolsTags = (content) => content.replace(/[ \t]*<et-query-devtools(?![\w-])[^>]*?(?:\/>|>\s*<\/et-query-devtools>)[ \t]*\n?/g, '');
+const removeFromImportsArrays = (content, names) => {
+    const sourceFile = createSourceFile(content);
+    const ranges = [];
+    const visit = (node) => {
+        if (ts.isPropertyAssignment(node) &&
+            ts.isIdentifier(node.name) &&
+            node.name.text === 'imports' &&
+            ts.isArrayLiteralExpression(node.initializer)) {
+            node.initializer.elements
+                .filter((element) => ts.isIdentifier(element) && names.has(element.text))
+                .forEach((element) => {
+                const range = withSurroundingComma(content, element.getStart(sourceFile), element.getEnd());
+                const padding = content[range.start - 1] === '[' ? (/^[ \t]*/.exec(content.slice(range.end))?.[0] ?? '') : '';
+                ranges.push({ start: range.start, end: range.end + padding.length });
+            });
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return ranges
+        .sort((left, right) => right.start - left.start)
+        .reduce((result, { start, end }) => result.slice(0, start) + result.slice(end), content);
+};
 const renameIdentifiers = (content, names, replacement) => {
     const sourceFile = createSourceFile(content);
     const ranges = [];
@@ -172,19 +225,23 @@ const renameIdentifiers = (content, names, replacement) => {
         .sort((left, right) => right.start - left.start)
         .reduce((result, { start, end }) => result.slice(0, start) + replacement + result.slice(end), content);
 };
-const migrateDevtoolsInFile = (content) => {
+const migrateDevtoolsInFile = (content, mountsFromProvider) => {
     const componentNames = localNamesImportedFromQuery(content, 'QueryDevtoolsComponent');
     const providerNames = new Set([
         'provideQueryClientForDevtools',
         ...localNamesImportedFromQuery(content, 'provideQueryClientForDevtools'),
     ]);
-    let result = replaceDevtoolsProviderCalls(content, providerNames);
-    const hasProvider = result.includes('provideQueryDevtools()');
+    const providerCall = mountsFromProvider ? DEVTOOLS_UI_PROVIDER_CALL : 'provideQueryDevtools()';
+    let result = replaceDevtoolsProviderCalls(content, providerNames, providerCall);
+    const hasProvider = result.includes(providerCall);
     result = dropLegacyDevtoolsImports(result);
     if (hasProvider) {
         result = ensureImportFromQuery(result, ['provideQueryDevtools']);
     }
-    if (componentNames.length > 0) {
+    if (componentNames.length > 0 && mountsFromProvider) {
+        result = removeFromImportsArrays(result, new Set(componentNames));
+    }
+    else if (componentNames.length > 0) {
         result = selectLazyDevtools(renameIdentifiers(result, new Set(componentNames), LAZY_DEVTOOLS_COMPONENT));
         result = ensureNamedImports({
             content: result,
@@ -192,7 +249,11 @@ const migrateDevtoolsInFile = (content) => {
             moduleSpecifier: '@ethlete/query-devtools/lazy',
         });
     }
-    return { content: result, importsComponent: componentNames.length > 0 };
+    return {
+        content: result,
+        importsComponent: componentNames.length > 0 && !mountsFromProvider,
+        mountsDevtools: hasProvider && mountsFromProvider,
+    };
 };
 const queryImports = (sourceFile) => sourceFile.statements.filter((node) => ts.isImportDeclaration(node) &&
     ts.isStringLiteral(node.moduleSpecifier) &&
@@ -212,7 +273,7 @@ const localNamesImportedFromQuery = (content, name) => queryImports(createSource
  * first call site keeps its position - it is already where the app wanted its devtools - and the
  * rest are removed along with the comma that separated them.
  */
-const replaceDevtoolsProviderCalls = (content, providerNames) => {
+const replaceDevtoolsProviderCalls = (content, providerNames, providerCall) => {
     const sourceFile = createSourceFile(content);
     const calls = [];
     const visit = (node) => {
@@ -229,7 +290,7 @@ const replaceDevtoolsProviderCalls = (content, providerNames) => {
         const start = call.getStart(sourceFile);
         const end = call.getEnd();
         if (index === 0) {
-            return { start, end, replacement: 'provideQueryDevtools()' };
+            return { start, end, replacement: providerCall };
         }
         return { ...withSurroundingComma(content, start, end), replacement: '' };
     });

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

@@ -1,4 +1,5 @@
 import * as ts from 'typescript';
+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']);
@@ -412,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);
@@ -493,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,
                             });
@@ -561,7 +568,7 @@ const transformPrepareCallsInFile = (content, classes, pollingInfo) => {
     });
     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;
@@ -573,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) => {
@@ -676,7 +700,8 @@ 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), isOneShotLocalVariable(callNode) || isInsideAsyncValidator(callNode));
     if (existingConfig && ts.isObjectLiteralExpression(existingConfig.initializer)) {
@@ -984,22 +1009,30 @@ const getPlainComputedHost = (node) => {
 const ASYNC_VALIDATOR_PROPERTIES = new Set(['asyncValidator', 'asyncValidators']);
 const ASYNC_VALIDATOR_SETTERS = new Set(['setAsyncValidators', 'addAsyncValidators']);
 /**
- * Whether the innermost function around the call is an Angular async validator: a value of an
- * `asyncValidator(s)` property or setter argument, an `AsyncValidatorFn`, or `validate` of an `AsyncValidator`.
+ * 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) => {
-    let fn = callNode.parent;
-    while (fn && !isCallbackFunction(fn) && !ts.isMethodDeclaration(fn))
-        fn = fn.parent;
-    if (!fn)
-        return false;
-    if (ts.isMethodDeclaration(fn)) {
-        const owner = fn.parent;
-        return (ts.isIdentifier(fn.name) &&
-            fn.name.text === 'validate' &&
-            ts.isClassDeclaration(owner) &&
-            !!owner.heritageClauses?.some((clause) => clause.types.some((type) => type.expression.getText() === 'AsyncValidator')));
+    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;

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

@@ -210,9 +210,13 @@ const analyzeLegacyQueryCreators = (content, queryClientFiles, filePath, report,
     const sourceFile = createSourceFile(content, filePath);
     const creators = [];
     const oldClientNames = new Set();
+    const renamedOwnClients = new Map();
     queryClientFiles.forEach((configNames) => {
         configNames.forEach((configName) => oldClientNames.add(configName));
     });
+    queryClientFiles.get(filePath)?.forEach((configName) => {
+        renamedOwnClients.set(ensureConfigSuffix(configName), configName);
+    });
     const visit = (node) => {
         if (ts.isVariableDeclaration(node) &&
             ts.isIdentifier(node.name) &&
@@ -225,27 +229,15 @@ const analyzeLegacyQueryCreators = (content, queryClientFiles, filePath, report,
                 ts.forEachChild(node, visit);
                 return;
             }
-            if (oldClientNames.has(objectExpression.text) && LEGACY_GQL_METHODS.includes(methodExpression.text)) {
-                const isQuery = methodExpression.text === 'gqlQuery';
-                const viaGet = isQuery && gqlGetClients.has(objectExpression.text);
-                const creator = isQuery ? `createGqlQueryVia${viaGet ? 'Get' : 'Post'}` : 'createGqlMutationViaPost';
-                report.addManualReview({
-                    title: `Rewrite the GraphQL creator ${node.name.text} by hand`,
-                    summary: `${node.name.text} is built with \`${objectExpression.text}.${methodExpression.text}()\`. The migration only rewrites REST creators, so this one still calls a method the migrated client no longer has.${viaGet ? " The v2 client sent GraphQL queries with `request.gql.transferVia: 'GET'`, which v3 sets per creator." : ''}`,
-                    action: `Rebuild it on the v3 client with \`${creator}\` and a \`gql\` document, then wrap it in \`createLegacyQueryCreator\` if its call sites stay on v2. See https://ethlete-sdk-docs.web.app/query/gql.`,
-                    locations: [{ filePath, line: sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1 }],
-                    source: 'legacy-query-creator-migration',
-                    dedupeKey: `gql-creator:${filePath}:${node.name.text}`,
-                });
-            }
-            if (!oldClientNames.has(objectExpression.text) || !isLegacyHttpMethod(methodExpression.text)) {
+            const clientName = renamedOwnClients.get(objectExpression.text) ?? objectExpression.text;
+            if (!oldClientNames.has(clientName) || !isLegacyHttpMethod(methodExpression.text)) {
                 ts.forEachChild(node, visit);
                 return;
             }
             const creatorName = node.name.text;
             const info = {
                 name: creatorName,
-                clientName: objectExpression.text,
+                clientName,
                 method: methodExpression.text,
                 route: '',
                 secure: false,
@@ -371,8 +363,109 @@ const analyzeLegacyQueryCreators = (content, queryClientFiles, filePath, report,
         ts.forEachChild(node, visit);
     };
     visit(sourceFile);
+    reportLegacyGqlCalls(sourceFile, filePath, oldClientNames, gqlGetClients, report);
     return creators;
 };
+const collectClientAliases = (sourceFile, oldClientNames) => {
+    const aliases = new Map();
+    const resolve = (expression) => {
+        if (!ts.isIdentifier(expression)) {
+            return undefined;
+        }
+        return aliases.get(expression.text) ?? (oldClientNames.has(expression.text) ? expression.text : undefined);
+    };
+    const visitImports = (node) => {
+        if (ts.isImportSpecifier(node) && node.propertyName && oldClientNames.has(node.propertyName.text)) {
+            aliases.set(node.name.text, node.propertyName.text);
+        }
+        ts.forEachChild(node, visitImports);
+    };
+    visitImports(sourceFile);
+    const aliasDeclarations = [];
+    const collectDeclarations = (node) => {
+        if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer) {
+            aliasDeclarations.push({ name: node.name.text, initializer: node.initializer });
+        }
+        ts.forEachChild(node, collectDeclarations);
+    };
+    collectDeclarations(sourceFile);
+    const addAlias = ({ name, initializer }) => {
+        const clientName = resolve(initializer);
+        if (!clientName || clientName === name || aliases.has(name)) {
+            return false;
+        }
+        aliases.set(name, clientName);
+        return true;
+    };
+    while (aliasDeclarations.filter(addAlias).length > 0) {
+        continue;
+    }
+    return resolve;
+};
+const describeGqlCall = (call, sourceFile) => {
+    const path = [];
+    let node = call;
+    while (node.parent && !ts.isSourceFile(node.parent)) {
+        node = node.parent;
+        if (ts.isPropertyAssignment(node)) {
+            path.unshift(node.name.getText(sourceFile));
+            continue;
+        }
+        if (ts.isVariableDeclaration(node) || ts.isFunctionDeclaration(node)) {
+            if (node.name && ts.isIdentifier(node.name)) {
+                path.unshift(node.name.text);
+            }
+            break;
+        }
+        if (ts.isPropertyDeclaration(node) || ts.isMethodDeclaration(node)) {
+            path.unshift(node.name.getText(sourceFile));
+            if (ts.isClassLike(node.parent) && node.parent.name) {
+                path.unshift(node.parent.name.text);
+            }
+            break;
+        }
+    }
+    return path.length > 0
+        ? path.join('.')
+        : `at line ${sourceFile.getLineAndCharacterOfPosition(call.getStart(sourceFile)).line + 1}`;
+};
+const reportLegacyGqlCalls = (sourceFile, filePath, oldClientNames, gqlGetClients, report) => {
+    const resolveClient = collectClientAliases(sourceFile, oldClientNames);
+    const visit = (node) => {
+        if (ts.isCallExpression(node) &&
+            ts.isPropertyAccessExpression(node.expression) &&
+            LEGACY_GQL_METHODS.includes(node.expression.name.text)) {
+            const receiver = node.expression.expression;
+            const receiverText = receiver.getText(sourceFile);
+            const method = node.expression.name.text;
+            const clientName = resolveClient(receiver);
+            const name = describeGqlCall(node, sourceFile);
+            const isQuery = method === 'gqlQuery';
+            const viaGet = isQuery && !!clientName && gqlGetClients.has(clientName);
+            const creator = !isQuery
+                ? '`createGqlMutationViaPost`'
+                : viaGet
+                    ? '`createGqlQueryViaGet`'
+                    : clientName || gqlGetClients.size === 0
+                        ? '`createGqlQueryViaPost`'
+                        : "`createGqlQueryViaPost` (or `createGqlQueryViaGet` if its client set `request.gql.transferVia: 'GET'`)";
+            const builtWith = clientName
+                ? `\`${receiverText}.${method}()\``
+                : `\`${receiverText}.${method}()\`, which the migration takes for a v2 query client`;
+            const line = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1;
+            report.addManualReview({
+                title: `Rewrite the GraphQL creator ${name} by hand`,
+                summary: `${name} is built with ${builtWith}. The migration only rewrites REST creators, so this one still calls a method the migrated client no longer has, and the callback parameters in its config lose their types: expect implicit-any errors (TS7006) there until it is rebuilt.${viaGet ? " The v2 client sent GraphQL queries with `request.gql.transferVia: 'GET'`, which v3 sets per creator." : ''}`,
+                action: `Rebuild it on the v3 client with ${creator} and a \`gql\` document, then wrap it in \`createLegacyQueryCreator\` if its call sites stay on v2. See https://ethlete-sdk-docs.web.app/query/gql.`,
+                locations: [{ filePath, line }],
+                source: 'legacy-query-creator-migration',
+                dedupeKey: `gql-creator:${filePath}:${name}:${line}`,
+            });
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+};
 const extractTypeFromDef = (node, sourceFile) => {
     if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === 'def') {
         if (node.typeArguments && node.typeArguments.length > 0) {

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

@@ -1,11 +1,12 @@
 import { formatFiles } from '@nx/devkit';
 import { reportAuthConsumers } from './auth-consumers-migration.js';
-import { migrateDevtoolsUsage, reportLeftoverV2Clients, migrateEmptyPrepareCalls, replaceAnyQueryWithLegacy, reportRemovedExperimentalQueryHelpers, } from './cleanup-migration.js';
+import { migrateDevtoolsUsage, reportLeftoverLegacyDevtools, reportLeftoverV2Clients, migrateEmptyPrepareCalls, replaceAnyQueryWithLegacy, reportRemovedExperimentalQueryHelpers, } from './cleanup-migration.js';
 import { reportDefaultHeaderUsages, reportMissingHttpClientProviders } from './http-client-check.js';
 import { migrateLegacyPrepareCalls } from './legacy-prepare-migration.js';
 import { createNewQueryCreators, updateLegacyCreatorImportsAndUsages } from './legacy-query-creator-migration.js';
 import { createMigrationScope } from './migration-scope.js';
 import { generateProviderAliases, generateQueryCreators, migrateQueryClients, updateImportsAcrossWorkspace, } from './query-client-migration.js';
+import { reportLegacyModuleResolution } from './module-resolution.js';
 import { QueryV3MigrationReport } from './report.js';
 export default async function migrate(tree, schema) {
     console.log('\n🔄 Starting query v3 migration...');
@@ -28,11 +29,13 @@ export default async function migrate(tree, schema) {
     migrateLegacyPrepareCalls(tree, report, scope);
     reportRemovedExperimentalQueryHelpers(tree, scope, report);
     reportLeftoverV2Clients(tree, scope, report);
+    reportLeftoverLegacyDevtools(tree, scope, report);
     reportAuthConsumers(tree, scope, report);
     if (queryClientFiles.size > 0) {
         reportMissingHttpClientProviders(tree, report, scope);
         reportDefaultHeaderUsages(tree, report, scope);
     }
+    reportLegacyModuleResolution(tree, scope, report);
     report.writeToTree(tree, scope.isScoped ? scope.describe() : undefined);
     report.printSummary();
     if (!schema.skipFormat) {