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

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

@@ -1,5 +1,7 @@
 import * as ts from 'typescript';
-import { createSourceFile, ensureAngularCoreImports, getIndentation, getLineNumber, getLineNumberFromPosition, } from './shared.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 +24,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 +63,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 +86,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 +363,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 +382,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 +403,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);
@@ -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),
@@ -457,7 +518,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,7 +559,7 @@ 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) => {
     for (const parameter of func.parameters) {
@@ -560,6 +622,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;
@@ -596,7 +678,7 @@ const transformSinglePrepareCall = (callNode, injectorReference, sourceFile, pol
     }
     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 +767,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 +779,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 +933,145 @@ 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 !pollingInfo.get(queryVariableName)?.hasPolling;
+    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 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`.
+ */
+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')));
+    }
+    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;
+    }
+    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

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

@@ -1,5 +1,5 @@
 import * as ts from 'typescript';
-import { collectV2BearerAuthConfigs, renderAuthProviderBody } from './auth-provider-scaffold.js';
+import { collectV2BearerAuthConfigs, rebaseModuleSpecifier, renderAuthProviderBody, } from './auth-provider-scaffold.js';
 import { createModuleGraph } from './module-graph.js';
 import { pruneUnusedNamedImports, renameImportedReferences } from './rename-symbols.js';
 import { capitalizeFirstLetter, createSourceFile, ensureConfigSuffix, ensureImportFromEthleteCore, ensureImportFromQuery, legacyQueryDeprecationTag, } from './shared.js';
@@ -15,7 +15,7 @@ const HTTP_OPTION_NAMES = ['reportProgress', 'responseType', 'transferCache', 'w
 const isLegacyHttpMethod = (value) => {
     return Object.values(LEGACY_HTTP_METHOD).includes(value);
 };
-export const createNewQueryCreators = (tree, queryClientFiles, report, scope) => {
+export const createNewQueryCreators = (tree, queryClientFiles, report, scope, gqlGetClients = new Set()) => {
     const createdFiles = [];
     const authProvidersNeeded = new Map();
     const clientNameToFilePath = new Map();
@@ -33,7 +33,7 @@ export const createNewQueryCreators = (tree, queryClientFiles, report, scope) =>
         if (!content) {
             return;
         }
-        const legacyCreators = analyzeLegacyQueryCreators(content, queryClientFiles, filePath, report);
+        const legacyCreators = analyzeLegacyQueryCreators(content, queryClientFiles, filePath, report, gqlGetClients);
         if (legacyCreators.length === 0) {
             return;
         }
@@ -79,7 +79,10 @@ export const updateLegacyCreatorImportsAndUsages = (tree, scope, report) => {
             return;
         }
         findLegacyWrappers(content).forEach((legacyName, originalName) => {
-            legacyCreators.set(originalName, { legacyName, definedIn: filePath });
+            legacyCreators.set(originalName, [
+                ...(legacyCreators.get(originalName) ?? []),
+                { legacyName, definedIn: filePath },
+            ]);
         });
     });
     if (legacyCreators.size === 0) {
@@ -137,8 +140,10 @@ const pointFileAtLegacyWrappers = ({ content, filePath, legacyCreators, moduleGr
         let changed = false;
         const nextElements = elements.map((element) => {
             const importedName = element.propertyName?.text ?? element.name.text;
-            const registration = legacyCreators.get(importedName);
-            if (!registration || !resolvesToWrapper(moduleSpecifier, importedName, registration)) {
+            const registration = legacyCreators
+                .get(importedName)
+                ?.find((candidate) => resolvesToWrapper(moduleSpecifier, importedName, candidate));
+            if (!registration) {
                 return element.getText(sourceFile);
             }
             changed = true;
@@ -192,7 +197,7 @@ const pointFileAtLegacyWrappers = ({ content, filePath, legacyCreators, moduleGr
         report.addManualReview({
             title: `Point ${name} at its legacy wrapper by hand`,
             summary: `${filePath} imports the migrated creator \`${name}\` but also declares something with that name, so the migration left its usages alone to avoid rewriting the wrong symbol.`,
-            action: `Rename the local declaration or the import alias, then point the query usages at \`${legacyCreators.get(name)?.legacyName ?? `legacy${capitalizeFirstLetter(name)}`}\`.`,
+            action: `Rename the local declaration or the import alias, then point the query usages at \`${legacyCreators.get(name)?.[0]?.legacyName ?? `legacy${capitalizeFirstLetter(name)}`}\`.`,
             locations: [{ filePath }],
             source: 'legacy-query-creator-migration',
             dedupeKey: `shadowed-rename:${filePath}:${name}`,
@@ -201,7 +206,7 @@ const pointFileAtLegacyWrappers = ({ content, filePath, legacyCreators, moduleGr
     return renamed.content;
 };
 const toLegacyName = (name) => `legacy${capitalizeFirstLetter(name)}`;
-const analyzeLegacyQueryCreators = (content, queryClientFiles, filePath, report) => {
+const analyzeLegacyQueryCreators = (content, queryClientFiles, filePath, report, gqlGetClients) => {
     const sourceFile = createSourceFile(content, filePath);
     const creators = [];
     const oldClientNames = new Set();
@@ -221,10 +226,13 @@ const analyzeLegacyQueryCreators = (content, queryClientFiles, filePath, report)
                 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.`,
-                    action: `Rebuild it on the v3 client with \`${methodExpression.text === 'gqlQuery' ? 'createGqlQueryViaPost' : 'createGqlMutationViaPost'}\` (or the \`ViaGet\` variant) 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.`,
+                    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}`,
@@ -505,8 +513,11 @@ const generateNewQueryCreator = (creator) => {
         ? `${clientBaseName}${capitalizedMethod}Secure`
         : `${clientBaseName}${capitalizedMethod}`;
     const typeParameter = getTypeParameter(creator);
-    const options = Array.from(creator.httpOptions.entries()).map(([key, value]) => `${key}: ${value}`);
-    const optionsBlock = options.length > 0 ? `, {\n  ${options.join(',\n  ')}\n}` : '';
+    const options = [
+        'reportErrors: false',
+        ...Array.from(creator.httpOptions.entries()).map(([key, value]) => `${key}: ${value}`),
+    ];
+    const optionsBlock = `, {\n  ${options.join(',\n  ')}\n}`;
     return `${creatorFunction}${typeParameter}(${creator.route}${optionsBlock})`;
 };
 const getTypeParameter = (creator) => {
@@ -555,12 +566,22 @@ const createAuthProviders = ({ tree, authProvidersNeeded, report, v2Configs, cre
         // belongs to exactly one client.
         const v2Config = v2Configs.find((candidate) => candidate.refreshCreatorName && creatorToClient.get(candidate.refreshCreatorName) === clientName);
         const body = renderAuthProviderBody(v2Config);
-        const nextContent = generateSecureQueryCreators(addAuthProviderToFile(content, clientName, body), clientName);
+        const nextContent = generateSecureQueryCreators(addAuthProviderToFile(content, clientName, body, v2Config, filePath), clientName);
         if (nextContent === content) {
             return;
         }
         tree.write(filePath, nextContent);
         createdProviders.push(filePath);
+        if (v2Config && v2Config.localNames.length > 0) {
+            report.addWarning({
+                title: 'Import the names the scaffolded auth provider copied',
+                summary: `The scaffolded provider uses ${v2Config.localNames.join(', ')}, declared in ${v2Config.filePath} and not exported to ${filePath}.`,
+                action: 'Move each declaration into the provider file, or export it and import it there.',
+                locations: [{ filePath }, { filePath: v2Config.filePath, line: v2Config.line }],
+                source: 'legacy-query-creator-migration',
+                dedupeKey: `auth-provider-local-names:${filePath}:${authProviderName}`,
+            });
+        }
         body.warnings.forEach((warning) => {
             report.addWarning({
                 ...warning,
@@ -606,8 +627,40 @@ const createAuthProviders = ({ tree, authProvidersNeeded, report, v2Configs, cre
         createdProviders.forEach((filePath) => console.log(`   - ${filePath}`));
     }
 };
-const addAuthProviderToFile = (content, clientName, body) => {
-    const nextContent = ensureImportFromEthleteCore(ensureImportFromQuery(content, ['createBearerAuthProvider', ...body.importsNeeded]), ['toInjectFn', 'toProvideFn']);
+const addCopiedImports = (content, v2Config, filePath) => {
+    if (!v2Config || v2Config.filePath === filePath) {
+        return content;
+    }
+    const sourceFile = createSourceFile(content);
+    const bound = new Set();
+    let lastImportEnd = 0;
+    sourceFile.statements.forEach((statement) => {
+        if (!ts.isImportDeclaration(statement)) {
+            return;
+        }
+        lastImportEnd = Math.max(lastImportEnd, statement.getEnd());
+        const clause = statement.importClause;
+        if (clause?.name)
+            bound.add(clause.name.text);
+        if (clause?.namedBindings && ts.isNamespaceImport(clause.namedBindings))
+            bound.add(clause.namedBindings.name.text);
+        if (clause?.namedBindings && ts.isNamedImports(clause.namedBindings)) {
+            clause.namedBindings.elements.forEach((element) => bound.add(element.name.text));
+        }
+    });
+    const statements = v2Config.copiedImports
+        .filter(({ names }) => names.every((name) => !bound.has(name)))
+        .map(({ moduleSpecifier, statement }) => statement(rebaseModuleSpecifier(moduleSpecifier, v2Config.filePath, filePath)));
+    if (statements.length === 0) {
+        return content;
+    }
+    return content.slice(0, lastImportEnd) + `\n${statements.join('\n')}` + content.slice(lastImportEnd);
+};
+const addAuthProviderToFile = (content, clientName, body, v2Config, filePath) => {
+    const nextContent = addCopiedImports(ensureImportFromEthleteCore(ensureImportFromQuery(content, ['createBearerAuthProvider', ...body.importsNeeded]), [
+        'toInjectFn',
+        'toProvideFn',
+    ]), v2Config, filePath);
     const sourceFile = createSourceFile(nextContent);
     const configName = ensureConfigSuffix(clientName);
     const configPosition = findVariableStatementEnd(sourceFile, configName, 'createQueryClient');

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

@@ -1,5 +1,6 @@
 import { formatFiles } from '@nx/devkit';
-import { migrateDevtoolsUsage, migrateEmptyPrepareCalls, replaceAnyQueryWithLegacy, reportRemovedExperimentalQueryHelpers, } from './cleanup-migration.js';
+import { reportAuthConsumers } from './auth-consumers-migration.js';
+import { migrateDevtoolsUsage, 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';
@@ -11,11 +12,11 @@ export default async function migrate(tree, schema) {
     const scope = createMigrationScope(tree, schema);
     console.log(`   Scope: ${scope.describe()}`);
     const report = new QueryV3MigrationReport();
-    const { queryClientFiles, variableRenames } = migrateQueryClients(tree, report, scope);
+    const { queryClientFiles, variableRenames, gqlGetClients } = migrateQueryClients(tree, report, scope);
     if (queryClientFiles.size > 0) {
         generateProviderAliases(tree, queryClientFiles);
         generateQueryCreators(tree, queryClientFiles);
-        createNewQueryCreators(tree, queryClientFiles, report, scope);
+        createNewQueryCreators(tree, queryClientFiles, report, scope, gqlGetClients);
         updateLegacyCreatorImportsAndUsages(tree, scope, report);
     }
     if (variableRenames.size > 0) {
@@ -26,6 +27,8 @@ export default async function migrate(tree, schema) {
     migrateEmptyPrepareCalls(tree, scope, report);
     migrateLegacyPrepareCalls(tree, report, scope);
     reportRemovedExperimentalQueryHelpers(tree, scope, report);
+    reportLeftoverV2Clients(tree, scope, report);
+    reportAuthConsumers(tree, scope, report);
     if (queryClientFiles.size > 0) {
         reportMissingHttpClientProviders(tree, report, scope);
         reportDefaultHeaderUsages(tree, report, scope);