@ethlete/query 6.0.0-next.4 → 6.0.0-next.41

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

@@ -1,10 +1,16 @@
-import { visitNotIgnoredFiles } from '@nx/devkit';
 import * as ts from 'typescript';
 import { createSourceFile, ensureAngularCoreImports, getIndentation, getLineNumber, getLineNumberFromPosition, } from './shared.js';
-export const migrateLegacyPrepareCalls = (tree, report) => {
+/** Contexts that already have an injector of their own, so the call site needs no rewrite. */
+const CONTEXTS_WITH_INJECTOR = [
+    'queryComputed',
+    'injection-context',
+    'class-field',
+    'constructor',
+];
+export const migrateLegacyPrepareCalls = (tree, report, scope) => {
     console.log('\n🔍 Checking for legacy query creator usages...');
     const allUsages = [];
-    visitNotIgnoredFiles(tree, '', (filePath) => {
+    scope.visit(tree, (filePath) => {
         if (!filePath.endsWith('.ts') || filePath.endsWith('.spec.ts')) {
             return;
         }
@@ -27,7 +33,7 @@ export const migrateLegacyPrepareCalls = (tree, report) => {
         console.log(`   - ${context}: ${count} usages`);
     });
     console.log('\n🔍 Detecting polling usage...');
-    const pollingInfo = detectPollingUsage(tree);
+    const pollingInfo = detectPollingUsage(tree, scope);
     if (pollingInfo.size > 0) {
         console.log(`\n⚠️ Found ${pollingInfo.size} queries with polling:`);
         pollingInfo.forEach((info) => {
@@ -38,7 +44,7 @@ export const migrateLegacyPrepareCalls = (tree, report) => {
     }
     const classInjectors = findOrCreateInjectorMembers(tree, allUsages);
     createInjectorMembers(tree, classInjectors);
-    transformLegacyCreatorPrepareCalls(tree, classInjectors, pollingInfo);
+    transformLegacyCreatorPrepareCalls(tree, classInjectors, pollingInfo, scope);
     reportManualReviewLocations(tree, allUsages, report);
 };
 const findLegacyCreatorUsages = (content, filePath) => {
@@ -99,32 +105,88 @@ const findLegacyCreatorNames = (sourceFile) => {
     visit(sourceFile);
     return names;
 };
+/** Helpers that run their callback inside an injection context, so a `prepare()` in one needs nothing. */
+const CONTEXT_PROVIDING_CALLEES = new Set([
+    'runInInjectionContext',
+    'queryComputed',
+    'queryComputedTillTruthy',
+    'queryArrayComputed',
+]);
+/**
+ * Array methods, which call back synchronously in the caller's own context. Matched only on a property
+ * access (`items.map(…)`) - the bare-identifier form is an RxJS operator, whose callback runs later.
+ */
+const TRANSPARENT_ARRAY_METHODS = new Set([
+    'map',
+    'flatMap',
+    'filter',
+    'forEach',
+    'find',
+    'findLast',
+    'findIndex',
+    'some',
+    'every',
+    'reduce',
+    'reduceRight',
+    'sort',
+    'flat',
+]);
+const isCallbackFunction = (node) => ts.isArrowFunction(node) || ts.isFunctionExpression(node) || ts.isFunctionDeclaration(node);
+/** The call a function literal is being passed to, if it is an argument rather than a value. */
+const getCallbackHost = (node) => {
+    const parent = node.parent;
+    if (!ts.isCallExpression(parent) || !parent.arguments.some((argument) => argument === node)) {
+        return undefined;
+    }
+    return parent;
+};
+const isContextProvidingCallback = (node) => {
+    const host = getCallbackHost(node);
+    if (!host) {
+        return false;
+    }
+    if (ts.isIdentifier(host.expression)) {
+        return CONTEXT_PROVIDING_CALLEES.has(host.expression.text);
+    }
+    return ts.isPropertyAccessExpression(host.expression) && host.expression.name.text === 'runInContext';
+};
+const isTransparentCallback = (node) => {
+    const host = getCallbackHost(node);
+    return (!!host && ts.isPropertyAccessExpression(host.expression) && TRANSPARENT_ARRAY_METHODS.has(host.expression.name.text));
+};
+/**
+ * Classifies the **innermost** function boundary the call sits behind, not the first structural ancestor.
+ * The difference is the whole point: `effect(() => prepare())` in a constructor and
+ * `computed(() => prepare())` at a class field both run long after the context that created them, so they
+ * need an injector just like a plain method does - reading the constructor or the field as the answer
+ * skipped exactly the call sites that go on to throw ET950.
+ */
 const determineUsageContext = (node) => {
     let current = node;
     while (current) {
-        if (ts.isArrowFunction(current) || ts.isFunctionExpression(current)) {
-            const parent = current.parent;
-            if (ts.isCallExpression(parent) &&
-                ts.isIdentifier(parent.expression) &&
-                parent.expression.text === 'queryComputed') {
-                return 'queryComputed';
+        if (isCallbackFunction(current)) {
+            if (isContextProvidingCallback(current)) {
+                const host = getCallbackHost(current);
+                const callee = host && ts.isIdentifier(host.expression) ? host.expression.text : undefined;
+                return callee?.startsWith('query') ? 'queryComputed' : 'injection-context';
+            }
+            if (!isTransparentCallback(current)) {
+                return isInsideClass(current) ? 'method' : 'function';
             }
         }
+        // Reached without crossing a callback: the call really does run while the class is being built, which
+        // is an injection context.
         if (ts.isConstructorDeclaration(current)) {
             return 'constructor';
         }
-        if (ts.isMethodDeclaration(current)) {
+        if (ts.isMethodDeclaration(current) ||
+            ts.isGetAccessorDeclaration(current) ||
+            ts.isSetAccessorDeclaration(current)) {
             return 'method';
         }
         if (ts.isPropertyDeclaration(current)) {
             return 'class-field';
         }
-        if (ts.isFunctionDeclaration(current)) {
-            return 'function';
-        }
-        if ((ts.isArrowFunction(current) || ts.isFunctionExpression(current)) && !isInsideClass(current)) {
-            return 'function';
-        }
         current = current.parent;
     }
     return 'unknown';
@@ -178,7 +240,7 @@ const findOrCreateInjectorMembers = (tree, usages) => {
     const classInjectors = new Map();
     const usagesByFile = new Map();
     usages.forEach((usage) => {
-        if (['queryComputed', 'class-field', 'constructor'].includes(usage.context)) {
+        if (CONTEXTS_WITH_INJECTOR.includes(usage.context)) {
             return;
         }
         if (!usagesByFile.has(usage.filePath)) {
@@ -283,7 +345,7 @@ const addInjectorMemberToClass = (content, classInfo) => {
     const injectorMember = `${indentation}private ${classInfo.injectorMemberName} = inject(Injector);\n\n`;
     return content.slice(0, classBodyStart) + injectorMember + content.slice(classBodyStart);
 };
-const transformLegacyCreatorPrepareCalls = (tree, classInjectors, pollingInfo) => {
+const transformLegacyCreatorPrepareCalls = (tree, classInjectors, pollingInfo, scope) => {
     const updatedFiles = [];
     const filesByPath = new Map();
     classInjectors.forEach((classInfo) => {
@@ -292,7 +354,7 @@ const transformLegacyCreatorPrepareCalls = (tree, classInjectors, pollingInfo) =
         }
         filesByPath.get(classInfo.filePath).push(classInfo);
     });
-    visitNotIgnoredFiles(tree, '', (filePath) => {
+    scope.visit(tree, (filePath) => {
         if (!filePath.endsWith('.ts') || filePath.endsWith('.spec.ts') || filesByPath.has(filePath)) {
             return;
         }
@@ -343,7 +405,7 @@ const transformPrepareCallsInFile = (content, classes, pollingInfo) => {
                     return;
                 }
                 const context = determineUsageContext(node);
-                if (['queryComputed', 'constructor', 'class-field'].includes(context)) {
+                if (CONTEXTS_WITH_INJECTOR.includes(context)) {
                     ts.forEachChild(node, visit);
                     return;
                 }
@@ -536,7 +598,7 @@ const transformSinglePrepareCall = (callNode, injectorReference, sourceFile, pol
     }
     nextArgumentProperties.push(`injector: ${injectorReference}`);
     const queryVariableName = findQueryVariableNameForPrepareCall(callNode, sourceFile);
-    const addDestroyOnResponse = shouldAddDestroyOnResponse(queryVariableName, pollingInfo);
+    const addDestroyOnResponse = shouldAddDestroyOnResponse(queryVariableName, pollingInfo, isDiscardedPrepareCall(callNode));
     if (existingConfig && ts.isObjectLiteralExpression(existingConfig.initializer)) {
         const configProperties = [];
         existingConfig.initializer.properties.forEach((property) => {
@@ -569,7 +631,7 @@ const transformSinglePrepareCall = (callNode, injectorReference, sourceFile, pol
             : `{\n  ${nextArgumentProperties.join(',\n  ')}\n}`;
     return `${creatorName}.prepare(${nextArgumentString})`;
 };
-const findQueryVariableNameForPrepareCall = (prepareCallNode, sourceFile) => {
+const findQueryVariableNameForPrepareCall = (prepareCallNode, _sourceFile) => {
     let parent = prepareCallNode.parent;
     while (parent) {
         if (ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name)) {
@@ -663,9 +725,9 @@ const containsInjectCall = (node) => {
     visit(node);
     return hasInject;
 };
-const detectPollingUsage = (tree) => {
+const detectPollingUsage = (tree, scope) => {
     const pollingInfo = new Map();
-    visitNotIgnoredFiles(tree, '', (filePath) => {
+    scope.visit(tree, (filePath) => {
         if (filePath.endsWith('.spec.ts')) {
             return;
         }
@@ -764,9 +826,39 @@ const detectPollingInTemplate = (content, filePath, pollingInfo) => {
         }
     }
 };
-const shouldAddDestroyOnResponse = (queryVariableName, pollingInfo) => {
+/**
+ * Whether the prepared query is thrown away - `legacyGetUsers.prepare().execute()` as a statement, with
+ * nothing holding on to it. Chained `.poll()` disqualifies it: that query is meant to keep running.
+ */
+const isDiscardedPrepareCall = (callNode) => {
+    let current = callNode;
+    while (current.parent) {
+        const parent = current.parent;
+        if (ts.isParenthesizedExpression(parent) || ts.isAwaitExpression(parent) || ts.isNonNullExpression(parent)) {
+            current = parent;
+            continue;
+        }
+        if (ts.isPropertyAccessExpression(parent) && parent.expression === current) {
+            if (parent.name.text === 'poll') {
+                return false;
+            }
+            current = parent;
+            continue;
+        }
+        // Only a chained call keeps it discarded; being an *argument* means something else receives the query.
+        if (ts.isCallExpression(parent) && parent.expression === current) {
+            current = parent;
+            continue;
+        }
+        return ts.isExpressionStatement(parent);
+    }
+    return false;
+};
+const shouldAddDestroyOnResponse = (queryVariableName, pollingInfo, isDiscarded) => {
     if (!queryVariableName) {
-        return false;
+        // 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;
     }
     return !pollingInfo.get(queryVariableName)?.hasPolling;
 };

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

@@ -1,6 +1,8 @@
-import { visitNotIgnoredFiles } from '@nx/devkit';
 import * as ts from 'typescript';
-import { capitalizeFirstLetter, createSourceFile, ensureConfigSuffix, ensureImportFromQuery } from './shared.js';
+import { collectV2BearerAuthConfigs, 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';
 const LEGACY_HTTP_METHOD = {
     GET: 'get',
     POST: 'post',
@@ -11,16 +13,17 @@ const LEGACY_HTTP_METHOD = {
 const isLegacyHttpMethod = (value) => {
     return Object.values(LEGACY_HTTP_METHOD).includes(value);
 };
-export const createNewQueryCreators = (tree, queryClientFiles, report) => {
+export const createNewQueryCreators = (tree, queryClientFiles, report, scope) => {
     const createdFiles = [];
     const authProvidersNeeded = new Map();
     const clientNameToFilePath = new Map();
+    const creatorToClient = new Map();
     queryClientFiles.forEach((configNames, filePath) => {
         configNames.forEach((configName) => {
             clientNameToFilePath.set(configName, filePath);
         });
     });
-    visitNotIgnoredFiles(tree, '', (filePath) => {
+    scope.visit(tree, (filePath) => {
         if (!filePath.endsWith('.ts') || filePath.endsWith('.spec.ts')) {
             return;
         }
@@ -33,6 +36,7 @@ export const createNewQueryCreators = (tree, queryClientFiles, report) => {
             return;
         }
         legacyCreators.forEach((creator) => {
+            creatorToClient.set(creator.name, creator.clientName);
             if (!creator.secure) {
                 return;
             }
@@ -48,17 +52,23 @@ export const createNewQueryCreators = (tree, queryClientFiles, report) => {
         }
     });
     if (authProvidersNeeded.size > 0) {
-        createAuthProviders(tree, authProvidersNeeded, report);
+        createAuthProviders({
+            tree,
+            authProvidersNeeded,
+            report,
+            v2Configs: collectV2BearerAuthConfigs(tree, scope),
+            creatorToClient,
+        });
     }
     if (createdFiles.length > 0) {
         console.log('\n✅ Created new query creators in:');
         createdFiles.forEach((filePath) => console.log(`   - ${filePath}`));
     }
 };
-export const updateLegacyCreatorImportsAndUsages = (tree) => {
+export const updateLegacyCreatorImportsAndUsages = (tree, scope, report) => {
     const legacyCreators = new Map();
     const updatedFiles = [];
-    visitNotIgnoredFiles(tree, '', (filePath) => {
+    scope.visit(tree, (filePath) => {
         if (!filePath.endsWith('.ts') || filePath.endsWith('.spec.ts')) {
             return;
         }
@@ -66,16 +76,16 @@ export const updateLegacyCreatorImportsAndUsages = (tree) => {
         if (!content) {
             return;
         }
-        const wrappers = findLegacyWrappers(content);
-        wrappers.forEach((legacyName, originalName) => {
-            legacyCreators.set(originalName, legacyName);
+        findLegacyWrappers(content).forEach((legacyName, originalName) => {
+            legacyCreators.set(originalName, { legacyName, definedIn: filePath });
         });
     });
     if (legacyCreators.size === 0) {
         return;
     }
     console.log(`\n✅ Found ${legacyCreators.size} legacy query creator wrappers`);
-    visitNotIgnoredFiles(tree, '', (filePath) => {
+    const moduleGraph = createModuleGraph(tree);
+    scope.visit(tree, (filePath) => {
         if (!filePath.endsWith('.ts') || filePath.endsWith('.spec.ts')) {
             return;
         }
@@ -83,8 +93,13 @@ export const updateLegacyCreatorImportsAndUsages = (tree) => {
         if (!content || containsLegacyWrapperDefinitions(content)) {
             return;
         }
-        const nextImports = updateLegacyCreatorImports(content, legacyCreators);
-        const nextContent = updateLegacyCreatorUsages(nextImports, legacyCreators);
+        const nextContent = pointFileAtLegacyWrappers({
+            content,
+            filePath,
+            legacyCreators,
+            moduleGraph,
+            report,
+        });
         if (nextContent !== content) {
             tree.write(filePath, nextContent);
             updatedFiles.push(filePath);
@@ -95,6 +110,89 @@ export const updateLegacyCreatorImportsAndUsages = (tree) => {
         updatedFiles.forEach((filePath) => console.log(`   - ${filePath}`));
     }
 };
+/**
+ * Rewrites this file's imports of migrated creators to the `legacy*` wrappers.
+ *
+ * Two rules keep the rewrite honest, and both exist because the first version of this pass did not
+ * have them:
+ *
+ * - An import is only touched when the module it comes from really does resolve to the file that
+ *   defines the wrapper. A same-named export from an unrelated package stays as it is.
+ * - An alias is preserved (`legacyGetPerson as getPersonQuery`) instead of being dropped, so the
+ *   call sites using that alias keep compiling.
+ */
+const pointFileAtLegacyWrappers = ({ content, filePath, legacyCreators, moduleGraph, report, }) => {
+    const sourceFile = createSourceFile(content, filePath);
+    const replacements = [];
+    const referenceRenames = new Map();
+    const resolvesToWrapper = (specifier, importedName, registration) => moduleGraph.findDeclaringFile(filePath, specifier, importedName) === registration.definedIn;
+    const rewriteSpecifiers = (elements, moduleSpecifier) => {
+        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)) {
+                return element.getText(sourceFile);
+            }
+            changed = true;
+            // Aliased: only the imported half changes, so nothing in the file body has to move.
+            if (element.propertyName) {
+                return `${registration.legacyName} as ${element.name.text}`;
+            }
+            referenceRenames.set(element.name.text, registration.legacyName);
+            return registration.legacyName;
+        });
+        return changed ? nextElements : null;
+    };
+    for (const node of sourceFile.statements) {
+        if (ts.isImportDeclaration(node) &&
+            ts.isStringLiteral(node.moduleSpecifier) &&
+            node.importClause?.namedBindings &&
+            ts.isNamedImports(node.importClause.namedBindings)) {
+            const nextElements = rewriteSpecifiers(node.importClause.namedBindings.elements, node.moduleSpecifier.text);
+            if (nextElements) {
+                replacements.push({
+                    start: node.getStart(sourceFile),
+                    end: node.getEnd(),
+                    replacement: `import { ${nextElements.join(', ')} } from '${node.moduleSpecifier.text}';`,
+                });
+            }
+            continue;
+        }
+        // Re-exports need the same treatment, or a barrel keeps pointing at the v3 creator.
+        if (ts.isExportDeclaration(node) &&
+            node.moduleSpecifier &&
+            ts.isStringLiteral(node.moduleSpecifier) &&
+            node.exportClause &&
+            ts.isNamedExports(node.exportClause)) {
+            const nextElements = rewriteSpecifiers(node.exportClause.elements, node.moduleSpecifier.text);
+            if (nextElements) {
+                replacements.push({
+                    start: node.getStart(sourceFile),
+                    end: node.getEnd(),
+                    replacement: `export { ${nextElements.join(', ')} } from '${node.moduleSpecifier.text}';`,
+                });
+            }
+        }
+    }
+    let result = content;
+    replacements.sort((left, right) => right.start - left.start);
+    replacements.forEach(({ start, end, replacement }) => {
+        result = result.slice(0, start) + replacement + result.slice(end);
+    });
+    const renamed = renameImportedReferences(result, referenceRenames);
+    renamed.shadowed.forEach((name) => {
+        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)}`}\`.`,
+            locations: [{ filePath }],
+            source: 'legacy-query-creator-migration',
+            dedupeKey: `shadowed-rename:${filePath}:${name}`,
+        });
+    });
+    return renamed.content;
+};
 const toLegacyName = (name) => `legacy${capitalizeFirstLetter(name)}`;
 const analyzeLegacyQueryCreators = (content, queryClientFiles, filePath, report) => {
     const sourceFile = createSourceFile(content, filePath);
@@ -233,7 +331,10 @@ const transformLegacyQueryCreators = (content, legacyCreators) => {
         result = result.slice(0, start) + replacement + result.slice(end);
     });
     result = ensureImportFromQuery(result, ['createLegacyQueryCreator']);
-    return addCreatorImports(result, creatorsByClient);
+    result = addCreatorImports(result, creatorsByClient);
+    // The rewritten creators no longer go through `def<T>()` or the v2 client object, so whatever is
+    // left over from those constructs would land as a lint error the moment `formatFiles` runs.
+    return pruneUnusedNamedImports(result, 'all');
 };
 const addCreatorImports = (content, creatorsByClient) => {
     const sourceFile = createSourceFile(content);
@@ -340,9 +441,11 @@ const getTypeParameter = (creator) => {
     return '';
 };
 const generateLegacyWrapper = (creator) => {
-    return `export const ${toLegacyName(creator.name)} = createLegacyQueryCreator({ creator: ${creator.name} });`;
+    // `name` is what lets a `prepare()` called outside an injection context name itself in the error
+    // instead of surfacing as a bare NG0203.
+    return `/**\n * ${legacyQueryDeprecationTag(creator.name)}\n */\nexport const ${toLegacyName(creator.name)} = createLegacyQueryCreator({ name: '${toLegacyName(creator.name)}', creator: ${creator.name} });`;
 };
-const createAuthProviders = (tree, authProvidersNeeded, report) => {
+const createAuthProviders = ({ tree, authProvidersNeeded, report, v2Configs, creatorToClient, }) => {
     const createdProviders = [];
     authProvidersNeeded.forEach((filePath, clientName) => {
         const content = tree.read(filePath, 'utf-8');
@@ -353,19 +456,46 @@ const createAuthProviders = (tree, authProvidersNeeded, report) => {
         if (content.includes(`export const ${authProviderName} = createBearerAuthProvider(`)) {
             return;
         }
-        const nextContent = generateSecureQueryCreators(addAuthProviderToFile(content, clientName), clientName);
+        // Match on the refresh creator: it is the one thing a v2 provider config always names, and it
+        // 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);
         if (nextContent === content) {
             return;
         }
         tree.write(filePath, nextContent);
         createdProviders.push(filePath);
-        report.addFollowUp({
-            title: `Configure auth queries for ${authProviderName}`,
-            summary: `The migration created ${authProviderName} with an empty \`queries\` array because it cannot infer login or refresh builders safely.`,
-            action: 'Add authQuery/tokenRefreshQuery builders, verify token extraction, and remove the placeholder empty array once the provider is configured.',
+        if (body.isScaffolded) {
+            report.addFollowUp({
+                title: `Finish the scaffolded auth provider ${authProviderName}`,
+                summary: `${authProviderName} was scaffolded from the v2 BearerAuthProvider at ${v2Config?.filePath}:${v2Config?.line}. The refresh query and cookie config carried over; the adapters were copied verbatim and their parameter shapes changed between v2 and v3.`,
+                action: 'Resolve the TODO(query-v3) comments in the generated provider, add the login query via withAuthenticationQuery, and delete the v2 provider once the app logs in again.',
+                locations: [{ filePath }, ...(v2Config ? [{ filePath: v2Config.filePath, line: v2Config.line }] : [])],
+                source: 'legacy-query-creator-migration',
+                dedupeKey: `auth-provider:${filePath}:${authProviderName}`,
+            });
+        }
+        else {
+            report.addFollowUp({
+                title: `Configure auth queries for ${authProviderName}`,
+                summary: `The migration created ${authProviderName} with an empty \`queries\` array because no v2 BearerAuthProvider config could be matched to this client.`,
+                action: 'Add authQuery/tokenRefreshQuery builders, verify token extraction, and remove the placeholder empty array once the provider is configured.',
+                locations: [{ filePath }],
+                source: 'legacy-query-creator-migration',
+                dedupeKey: `auth-provider:${filePath}:${authProviderName}`,
+            });
+        }
+        // The generated layout only works if the auth queries live next to the provider: the provider
+        // needs the login/refresh creators, and the secure creators need the provider. Leaving them in
+        // an `auth.queries.ts` that imports the client's `post` creator closes the loop.
+        report.addManualReview({
+            title: `Keep the auth queries in ${filePath}`,
+            summary: `${authProviderName} needs the login and refresh creators, and the secure creators below it need the provider. If those creators stay in a separate auth queries file that imports this client, the two files form an import cycle.`,
+            action: `Move the login/refresh creators into ${filePath} above the provider, and have the auth queries file import them back for its legacy* wrappers.`,
             locations: [{ filePath }],
             source: 'legacy-query-creator-migration',
-            dedupeKey: `auth-provider:${filePath}:${authProviderName}`,
+            dedupeKey: `auth-provider-cycle:${filePath}`,
         });
     });
     if (createdProviders.length > 0) {
@@ -373,8 +503,8 @@ const createAuthProviders = (tree, authProvidersNeeded, report) => {
         createdProviders.forEach((filePath) => console.log(`   - ${filePath}`));
     }
 };
-const addAuthProviderToFile = (content, clientName) => {
-    const nextContent = ensureImportFromQuery(content, ['createBearerAuthProvider']);
+const addAuthProviderToFile = (content, clientName, body) => {
+    const nextContent = ensureImportFromEthleteCore(ensureImportFromQuery(content, ['createBearerAuthProvider', ...body.importsNeeded]), ['toInjectFn', 'toProvideFn']);
     const sourceFile = createSourceFile(nextContent);
     const configName = ensureConfigSuffix(clientName);
     const configPosition = findVariableStatementEnd(sourceFile, configName, 'createQueryClient');
@@ -388,10 +518,12 @@ const addAuthProviderToFile = (content, clientName) => {
         `export const ${authProviderName} = createBearerAuthProvider({`,
         `  name: '${clientName}',`,
         `  queryClientRef: ${configName},`,
-        `  queries: [],`,
+        body.queries,
+        ...(body.features ? [body.features] : []),
         '});',
         '',
-        `export const [provide${capitalizedClientName}AuthProvider, inject${capitalizedClientName}AuthProvider] = ${authProviderName};`,
+        `export const provide${capitalizedClientName}AuthProvider = toProvideFn(${authProviderName});`,
+        `export const inject${capitalizedClientName}AuthProvider = toInjectFn(${authProviderName});`,
     ].join('\n');
     return nextContent.slice(0, configPosition) + authProviderBlock + nextContent.slice(configPosition);
 };
@@ -473,117 +605,4 @@ const findLegacyWrappers = (content) => {
     visit(sourceFile);
     return wrappers;
 };
-const updateLegacyCreatorImports = (content, legacyCreators) => {
-    const sourceFile = createSourceFile(content);
-    const replacements = [];
-    const visit = (node) => {
-        if (ts.isImportDeclaration(node) &&
-            node.importClause?.namedBindings &&
-            ts.isNamedImports(node.importClause.namedBindings)) {
-            const nextElements = node.importClause.namedBindings.elements.map((element) => {
-                const importedName = element.propertyName ? element.propertyName.text : element.name.text;
-                const legacyName = legacyCreators.get(importedName);
-                return legacyName ?? element.getText(sourceFile);
-            });
-            const hasChanges = node.importClause.namedBindings.elements.some((element) => {
-                const importedName = element.propertyName ? element.propertyName.text : element.name.text;
-                return legacyCreators.has(importedName);
-            });
-            if (hasChanges) {
-                replacements.push({
-                    start: node.getStart(sourceFile),
-                    end: node.getEnd(),
-                    replacement: `import { ${nextElements.join(', ')} } from '${node.moduleSpecifier.text}';`,
-                });
-            }
-        }
-        ts.forEachChild(node, visit);
-    };
-    visit(sourceFile);
-    let result = content;
-    replacements.sort((left, right) => right.start - left.start);
-    replacements.forEach(({ start, end, replacement }) => {
-        result = result.slice(0, start) + replacement + result.slice(end);
-    });
-    return result;
-};
-const updateLegacyCreatorUsages = (content, legacyCreators) => {
-    const sourceFile = createSourceFile(content);
-    const replacements = [];
-    const visit = (node) => {
-        if (ts.isObjectLiteralExpression(node)) {
-            node.properties.forEach((property) => {
-                if (ts.isPropertyAssignment(property) && ts.isIdentifier(property.initializer)) {
-                    const nextName = legacyCreators.get(property.initializer.text);
-                    if (nextName) {
-                        replacements.push({
-                            start: property.initializer.getStart(sourceFile),
-                            end: property.initializer.getEnd(),
-                            replacement: nextName,
-                        });
-                    }
-                }
-                if (ts.isShorthandPropertyAssignment(property) && legacyCreators.has(property.name.text)) {
-                    replacements.push({
-                        start: property.getStart(sourceFile),
-                        end: property.getEnd(),
-                        replacement: `${property.name.text}: ${legacyCreators.get(property.name.text)}`,
-                    });
-                }
-            });
-        }
-        if (ts.isIdentifier(node) && legacyCreators.has(node.text)) {
-            const parent = node.parent;
-            if (ts.isPropertyAccessExpression(parent) && parent.name === node) {
-                ts.forEachChild(node, visit);
-                return;
-            }
-            if (ts.isPropertyAssignment(parent) && (parent.name === node || parent.initializer === node)) {
-                ts.forEachChild(node, visit);
-                return;
-            }
-            if (ts.isShorthandPropertyAssignment(parent) && parent.name === node) {
-                ts.forEachChild(node, visit);
-                return;
-            }
-            if (ts.isVariableDeclaration(parent) && parent.name === node) {
-                ts.forEachChild(node, visit);
-                return;
-            }
-            if (ts.isImportSpecifier(parent)) {
-                ts.forEachChild(node, visit);
-                return;
-            }
-            if (ts.isFunctionDeclaration(parent) && parent.name === node) {
-                ts.forEachChild(node, visit);
-                return;
-            }
-            if (ts.isMethodDeclaration(parent) && parent.name === node) {
-                ts.forEachChild(node, visit);
-                return;
-            }
-            if (ts.isParameter(parent) && parent.name === node) {
-                ts.forEachChild(node, visit);
-                return;
-            }
-            if (ts.isPropertyDeclaration(parent) && parent.name === node) {
-                ts.forEachChild(node, visit);
-                return;
-            }
-            replacements.push({
-                start: node.getStart(sourceFile),
-                end: node.getEnd(),
-                replacement: legacyCreators.get(node.text),
-            });
-        }
-        ts.forEachChild(node, visit);
-    };
-    visit(sourceFile);
-    let result = content;
-    replacements.sort((left, right) => right.start - left.start);
-    replacements.forEach(({ start, end, replacement }) => {
-        result = result.slice(0, start) + replacement + result.slice(end);
-    });
-    return result;
-};
 //# sourceMappingURL=legacy-query-creator-migration.js.map