@ethlete/query 6.0.0-next.6 → 6.0.0-next.60

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

@@ -1,10 +1,12 @@
-import { visitNotIgnoredFiles } from '@nx/devkit';
 import * as ts from 'typescript';
-import { capitalizeFirstLetter, createSourceFile, ensureConfigSuffix, ensureImportFromQuery, getVariableStatementEnd, } from './shared.js';
-export const migrateQueryClients = (tree, report) => {
+import { CLIENT_FEATURE, reportClientErrorPipelineAdded } from '../migrate-query-opt-in-features/migration.js';
+import { createModuleGraph } from './module-graph.js';
+import { isNamePosition, isShadowedInNestedScope, renamedReference } from './rename-symbols.js';
+import { capitalizeFirstLetter, createSourceFile, ensureConfigSuffix, ensureImportFromEthleteCore, ensureImportFromQuery, getVariableStatementEnd, printImportDeclaration, } from './shared.js';
+export const migrateQueryClients = (tree, report, scope) => {
     const queryClientFiles = new Map();
     const variableRenames = new Map();
-    visitNotIgnoredFiles(tree, '', (filePath) => {
+    scope.visit(tree, (filePath) => {
         if (!filePath.endsWith('.ts')) {
             return;
         }
@@ -14,9 +16,9 @@ export const migrateQueryClients = (tree, report) => {
         }
         const renames = new Map();
         const nextContent = migrateQueryClientToConfig({ content, filePath, renamesOut: renames, report });
-        renames.forEach((newName, oldName) => {
-            variableRenames.set(oldName, newName);
-        });
+        if (renames.size > 0) {
+            variableRenames.set(filePath, { originalContent: content, renames });
+        }
         const configNames = extractClientConfigNames(nextContent);
         if (configNames.length > 0) {
             queryClientFiles.set(filePath, configNames);
@@ -69,11 +71,13 @@ export const generateQueryCreators = (tree, queryClientFiles) => {
         generatedFiles.forEach((filePath) => console.log(`   - ${filePath}`));
     }
 };
-export const updateImportsAcrossWorkspace = (tree, renames) => {
+export const updateImportsAcrossWorkspace = (tree, renames, scope, report) => {
     if (renames.size === 0) {
         return;
     }
-    visitNotIgnoredFiles(tree, '', (filePath) => {
+    const originalContents = new Map(Array.from(renames.entries()).map(([filePath, { originalContent }]) => [filePath, originalContent]));
+    const graph = createModuleGraph(withOriginalContents(tree, originalContents));
+    scope.visit(tree, (filePath) => {
         if (!filePath.endsWith('.ts')) {
             return;
         }
@@ -81,12 +85,42 @@ export const updateImportsAcrossWorkspace = (tree, renames) => {
         if (!content) {
             return;
         }
-        const nextContent = updateImportsInFile(content, renames);
+        const { content: nextContent, renamedByName } = updateImportsInFile(content, filePath, renames, graph);
+        if (renamedByName.size > 0) {
+            report.addManualReview({
+                title: `Check the client rename in ${filePath}`,
+                summary: `The migration could not resolve ${[...renamedByName].map((specifier) => `\`${specifier}\``).join(', ')} to a file, so it renamed the imported client by its name alone.`,
+                action: 'Confirm the renamed import really is the migrated query client, and revert it if it is not.',
+                locations: [{ filePath }],
+                source: 'query-client-migration',
+                dedupeKey: `client-rename-by-name:${filePath}`,
+            });
+        }
         if (nextContent !== content) {
+            originalContents.set(filePath, content);
             tree.write(filePath, nextContent);
         }
     });
 };
+/**
+ * A view of `tree` that still reads the pre-migration content of `originalContents`, so the module
+ * graph resolves a client import by the name it had when the import was written.
+ */
+const withOriginalContents = (tree, originalContents) => new Proxy(tree, {
+    get: (target, property) => {
+        if (property === 'read') {
+            return (filePath, encoding) => {
+                const original = originalContents.get(filePath);
+                if (original === undefined) {
+                    return encoding ? target.read(filePath, encoding) : target.read(filePath);
+                }
+                return encoding ? original : Buffer.from(original);
+            };
+        }
+        const value = Reflect.get(target, property, target);
+        return typeof value === 'function' ? value.bind(target) : value;
+    },
+});
 const hasQueryClientInstantiation = (content) => {
     const sourceFile = createSourceFile(content);
     let hasQueryClientImport = false;
@@ -116,17 +150,25 @@ const migrateQueryClientToConfig = ({ content, filePath, renamesOut, report }) =
     const sourceFile = createSourceFile(content, filePath);
     const replacements = [];
     const variableRenames = new Map();
+    let hasUnmigratedClient = false;
     const visit = (node) => {
-        if (ts.isNewExpression(node) &&
-            ts.isIdentifier(node.expression) &&
-            node.expression.text === 'V2QueryClient' &&
-            node.arguments &&
-            node.arguments.length > 0) {
-            const configArgument = node.arguments[0];
-            if (ts.isObjectLiteralExpression(configArgument)) {
+        if (ts.isNewExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === 'V2QueryClient') {
+            const configArgument = node.arguments?.[0];
+            if (!configArgument || !ts.isObjectLiteralExpression(configArgument)) {
+                hasUnmigratedClient = true;
+                report.addManualReview({
+                    title: 'Migrate a V2QueryClient whose config is not an object literal',
+                    summary: `\`${node.getText(sourceFile)}\` passes its config indirectly, so the migration cannot read it and left the client on v2.`,
+                    action: 'Inline the config object and re-run the migration, or rewrite the client by hand as `createQueryClient({ baseUrl, name })` with provider aliases and creators.',
+                    locations: [{ filePath, line: sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1 }],
+                    source: 'query-client-migration',
+                    dedupeKey: `unmigrated-client:${filePath}:${node.getStart(sourceFile)}`,
+                });
+            }
+            else {
                 const oldVariableName = getVariableNameForQueryClient(node);
-                const newVariableName = ensureConfigSuffix(oldVariableName);
-                if (oldVariableName !== newVariableName) {
+                const newVariableName = oldVariableName && ensureConfigSuffix(oldVariableName);
+                if (oldVariableName && newVariableName && oldVariableName !== newVariableName) {
                     const collisionRegex = new RegExp(`\\b(?:const|let|var)\\s+${newVariableName}\\b`);
                     if (collisionRegex.test(content)) {
                         report.addWarning({
@@ -143,6 +185,8 @@ const migrateQueryClientToConfig = ({ content, filePath, renamesOut, report }) =
                         renamesOut.set(oldVariableName, newVariableName);
                     }
                 }
+                reportDroppedClientOptions({ configArgument, sourceFile, filePath, report });
+                reportChangedClientDefaults({ configArgument, sourceFile, filePath, report });
                 replacements.push({
                     start: node.getStart(sourceFile),
                     end: node.getEnd(),
@@ -158,16 +202,20 @@ const migrateQueryClientToConfig = ({ content, filePath, renamesOut, report }) =
     replacements.forEach(({ start, end, replacement }) => {
         result = result.slice(0, start) + replacement + result.slice(end);
     });
-    result = removeQueryClientImport(result);
+    result = removeQueryClientImport(result, hasUnmigratedClient);
     return renameVariables(result, variableRenames);
 };
-const removeQueryClientImport = (content) => {
+const removeQueryClientImport = (content, keepLegacyClient) => {
     const sourceFile = createSourceFile(content);
     let queryImportNode;
     ts.forEachChild(sourceFile, (node) => {
-        if (ts.isImportDeclaration(node) &&
+        if (!queryImportNode &&
+            ts.isImportDeclaration(node) &&
             ts.isStringLiteral(node.moduleSpecifier) &&
-            node.moduleSpecifier.text === '@ethlete/query') {
+            node.moduleSpecifier.text === '@ethlete/query' &&
+            node.importClause?.namedBindings &&
+            ts.isNamedImports(node.importClause.namedBindings) &&
+            node.importClause.namedBindings.elements.some((element) => element.name.text === 'V2QueryClient')) {
             queryImportNode = node;
         }
     });
@@ -178,20 +226,41 @@ const removeQueryClientImport = (content) => {
         'createPostQuery',
         'createPutQuery',
         'createQueryClient',
+        CLIENT_FEATURE,
     ];
     if (!queryImportNode?.importClause?.namedBindings || !ts.isNamedImports(queryImportNode.importClause.namedBindings)) {
         return ensureImportFromQuery(content, requiredImports);
     }
     const existingElements = queryImportNode.importClause.namedBindings.elements.filter((element) => {
-        return element.name.text !== 'V2QueryClient';
+        return keepLegacyClient || element.name.text !== 'V2QueryClient';
     });
     const nextImports = new Set(requiredImports);
-    existingElements.forEach((element) => nextImports.add(element.name.text));
-    const nextImportStatement = `import { ${Array.from(nextImports).sort().join(', ')} } from '@ethlete/query';`;
+    existingElements.forEach((element) => nextImports.add(element.getText(sourceFile)));
+    const nextImportStatement = printImportDeclaration(queryImportNode, sourceFile, Array.from(nextImports).sort());
     return (content.slice(0, queryImportNode.getStart(sourceFile)) +
         nextImportStatement +
         content.slice(queryImportNode.getEnd()));
 };
+const isTopLevelVariableName = (node) => {
+    const declaration = node.parent;
+    return (ts.isVariableDeclaration(declaration) &&
+        declaration.name === node &&
+        ts.isVariableStatement(declaration.parent.parent) &&
+        ts.isSourceFile(declaration.parent.parent.parent));
+};
+const renameInDeclaringFile = (node, nextName) => {
+    const parent = node.parent;
+    if (isTopLevelVariableName(node)) {
+        return nextName;
+    }
+    if (ts.isExportSpecifier(parent) && !parent.parent.parent.moduleSpecifier) {
+        return (parent.propertyName ?? parent.name) === node ? nextName : undefined;
+    }
+    if (isNamePosition(node) || isShadowedInNestedScope(node)) {
+        return undefined;
+    }
+    return renamedReference(node, nextName);
+};
 const renameVariables = (content, renames) => {
     if (renames.size === 0) {
         return content;
@@ -199,83 +268,199 @@ const renameVariables = (content, renames) => {
     const sourceFile = createSourceFile(content);
     const replacements = [];
     const visit = (node) => {
-        if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name)) {
-            const nextName = renames.get(node.name.text);
-            if (nextName) {
-                replacements.push({
-                    start: node.name.getStart(sourceFile),
-                    end: node.name.getEnd(),
-                    replacement: nextName,
-                });
-            }
-        }
-        else if (ts.isIdentifier(node)) {
-            const nextName = renames.get(node.text);
-            if (nextName) {
-                const parent = node.parent;
-                if (!ts.isPropertyAssignment(parent) || parent.name !== node) {
-                    replacements.push({
-                        start: node.getStart(sourceFile),
-                        end: node.getEnd(),
-                        replacement: nextName,
-                    });
-                }
-            }
+        const nextName = ts.isIdentifier(node) ? renames.get(node.text) : undefined;
+        const replacement = nextName && renameInDeclaringFile(node, nextName);
+        if (replacement) {
+            replacements.push({ start: node.getStart(sourceFile), end: node.getEnd(), replacement });
         }
         ts.forEachChild(node, visit);
     };
     visit(sourceFile);
-    const seen = new Set();
-    const uniqueReplacements = replacements.filter((replacement) => {
-        const key = `${replacement.start}:${replacement.end}`;
-        if (seen.has(key)) {
-            return false;
-        }
-        seen.add(key);
-        return true;
-    });
+    return applyReplacements(content, replacements);
+};
+const applyReplacements = (content, replacements) => {
     let result = content;
-    uniqueReplacements.sort((left, right) => right.start - left.start);
-    uniqueReplacements.forEach(({ start, end, replacement }) => {
+    [...replacements]
+        .sort((left, right) => right.start - left.start)
+        .forEach(({ start, end, replacement }) => {
         result = result.slice(0, start) + replacement + result.slice(end);
     });
     return result;
 };
+const WINDOW_FOCUS_REPLACEMENT = 'Opt in per query: `withPolling({ interval, refetchOnFocus: true })` on a polled query, `withAutoRefresh({ onSignalChanges: [windowFocusSignal] })` on any other, or `injectMyClient().refreshQueriesInUse()` from a focus listener.';
+const SMART_POLLING_REPLACEMENT = 'Opt in per query: `withPolling({ interval, pauseWhileHidden: true })`. Without it v3 keeps polling in a hidden tab.';
+const V2_ON_BY_DEFAULT_REQUEST_OPTIONS = {
+    autoRefreshQueriesOnWindowFocus: WINDOW_FOCUS_REPLACEMENT,
+    enableSmartPolling: SMART_POLLING_REPLACEMENT,
+};
+/**
+ * What each v2 client option turns into, or why it has nowhere to go.
+ *
+ * Silently dropping these is how two apps here lost their default headers without a single warning.
+ * A dropped option that shows up in the report is a five-minute fix; one that doesn't is a bug
+ * report from production.
+ */
+const DROPPED_CLIENT_OPTIONS = {
+    'request.autoRefreshQueriesOnWindowFocus': WINDOW_FOCUS_REPLACEMENT,
+    'request.enableSmartPolling': SMART_POLLING_REPLACEMENT,
+    'logging.preparedQuerySubscriptions': 'Removed. Use the v3 devtools (`provideQueryDevtools()`) or `withLogging({ logFn })` on the queries you want to trace.',
+    'logging.queryStateChanges': 'Removed. Use the v3 devtools (`provideQueryDevtools()`) or `withLogging({ logFn })` on the queries you want to trace.',
+    'request.autoRefreshOn': 'No direct equivalent. Re-run the affected queries yourself with `withAutoRefresh` or `refreshQueriesInUse()`.',
+};
+const reportDroppedClientOptions = ({ configArgument, sourceFile, filePath, report, }) => {
+    const migrated = new Set(['baseRoute', 'queryParams', 'cacheAdapter', 'retryFn', 'request', 'logging']);
+    const raise = (optionPath, node) => {
+        report.addWarning({
+            title: `Reconfigure dropped query client option "${optionPath}"`,
+            summary: `The v2 client option \`${optionPath}\` has no place in \`createQueryClient\` and was dropped by the migration.`,
+            action: DROPPED_CLIENT_OPTIONS[optionPath] ?? 'Check whether the behaviour is still needed and reimplement it.',
+            locations: [{ filePath, line: sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1 }],
+            source: 'query-client-migration',
+            dedupeKey: `dropped-client-option:${filePath}:${optionPath}`,
+        });
+    };
+    const raiseSpread = (spread) => {
+        const text = spread.getText(sourceFile);
+        report.addWarning({
+            title: `Reconfigure spread query client options "${text}"`,
+            summary: `The v2 client config spreads \`${text}\`. The migration cannot see which options it holds, so none of them were carried over to \`createQueryClient\`.`,
+            action: 'Inline the spread options that are still needed (`baseRoute` becomes `baseUrl`) and re-check the result.',
+            locations: [{ filePath, line: sourceFile.getLineAndCharacterOfPosition(spread.getStart(sourceFile)).line + 1 }],
+            source: 'query-client-migration',
+            dedupeKey: `dropped-client-spread:${filePath}:${spread.getStart(sourceFile)}`,
+        });
+    };
+    configArgument.properties.forEach((property) => {
+        if (ts.isSpreadAssignment(property)) {
+            raiseSpread(property);
+            return;
+        }
+        if ((!ts.isPropertyAssignment(property) && !ts.isShorthandPropertyAssignment(property)) ||
+            !ts.isIdentifier(property.name)) {
+            return;
+        }
+        const name = property.name.text;
+        if ((name === 'request' || name === 'logging') &&
+            ts.isPropertyAssignment(property) &&
+            ts.isObjectLiteralExpression(property.initializer)) {
+            property.initializer.properties.forEach((nested) => {
+                if (ts.isSpreadAssignment(nested)) {
+                    raiseSpread(nested);
+                    return;
+                }
+                if ((!ts.isPropertyAssignment(nested) && !ts.isShorthandPropertyAssignment(nested)) ||
+                    !ts.isIdentifier(nested.name)) {
+                    return;
+                }
+                if (name === 'request' && ['queryParams', 'cacheAdapter', 'retryFn'].includes(nested.name.text)) {
+                    return;
+                }
+                if (name === 'request' &&
+                    nested.name.text in V2_ON_BY_DEFAULT_REQUEST_OPTIONS &&
+                    ts.isPropertyAssignment(nested) &&
+                    nested.initializer.kind === ts.SyntaxKind.FalseKeyword) {
+                    return;
+                }
+                raise(`${name}.${nested.name.text}`, nested);
+            });
+            return;
+        }
+        if (!migrated.has(name)) {
+            raise(name, property);
+        }
+    });
+};
+const reportChangedClientDefaults = ({ configArgument, sourceFile, filePath, report, }) => {
+    const location = {
+        filePath,
+        line: sourceFile.getLineAndCharacterOfPosition(configArgument.getStart(sourceFile)).line + 1,
+    };
+    const requestProperty = findProperty(configArgument, 'request');
+    const requestConfig = requestProperty &&
+        ts.isPropertyAssignment(requestProperty) &&
+        ts.isObjectLiteralExpression(requestProperty.initializer)
+        ? requestProperty.initializer
+        : undefined;
+    const hasUnreadableRequestConfig = (!!requestProperty && !requestConfig) || !!requestConfig?.properties.some(ts.isSpreadAssignment);
+    reportClientErrorPipelineAdded(report, location, 'query-client-migration', `\`${CLIENT_FEATURE}()\` was added so failed requests still retry and Symfony / HTML error bodies are still parsed, as they were by default in v2.`);
+    if (!requestConfig || !findProperty(requestConfig, 'retryFn')) {
+        report.addWarning({
+            title: 'Check the retry behaviour of the migrated client',
+            summary: 'v2 retried every request method on a 5xx (500 included), 408, 425 and 429, up to four times with a linear delay. The v3 default policy that `withEthleteApiErrors()` installs retries three times with an exponential, jittered delay, never retries a `POST`, a `PATCH` or a plain `500`, and also retries a connection failure.',
+            action: 'Accept the v3 policy, or pass `withEthleteApiErrors({ retry: { maxAttempts, retryableStatusCodes, retryNonIdempotent } })` - only set `retryNonIdempotent` for endpoints that deduplicate on their own.',
+            locations: [location],
+            source: 'query-client-migration',
+            dedupeKey: `changed-retry-default:${filePath}`,
+        });
+    }
+    const cacheAdapter = requestConfig && findProperty(requestConfig, 'cacheAdapter');
+    if (cacheAdapter) {
+        report.addWarning({
+            title: 'Check the carried-over cacheAdapter',
+            summary: 'The v2 `cacheAdapter` was carried over as is and still sets the freshness TTL: a TTL of `0` means an `execute({ options: { allowCache: true } })` always hits the server, as a v2 `execute()` did. Two things differ: v3 passes Angular `HttpHeaders` (read them with `headers.get(name)`) where v2 passed a plain record, and v3 keeps an entry for `keepUnusedFor` (5 minutes) after its last consumer, rendering the old response on a remount while it refetches.',
+            action: 'Rewrite an adapter that reads headers for `HttpHeaders`. If the adapter was meant to switch caching off, also set `keepUnusedFor: 0` on the client.',
+            locations: [
+                { filePath, line: sourceFile.getLineAndCharacterOfPosition(cacheAdapter.getStart(sourceFile)).line + 1 },
+            ],
+            source: 'query-client-migration',
+            dedupeKey: `carried-cache-adapter:${filePath}`,
+        });
+    }
+    if (hasUnreadableRequestConfig) {
+        return;
+    }
+    Object.entries(V2_ON_BY_DEFAULT_REQUEST_OPTIONS).forEach(([option, action]) => {
+        if (requestConfig && findProperty(requestConfig, option)) {
+            return;
+        }
+        report.addWarning({
+            title: `Restore the v2 default "request.${option}"`,
+            summary: `The v2 client did not set \`request.${option}\`, so it ran with the v2 default \`true\`. v3 has no client-wide equivalent and the behaviour is off for every migrated query.`,
+            action,
+            locations: [location],
+            source: 'query-client-migration',
+            dedupeKey: `dropped-client-default:${filePath}:${option}`,
+        });
+    });
+};
+const getPropertyValueText = (property, sourceFile) => {
+    if (ts.isShorthandPropertyAssignment(property)) {
+        return property.name.text;
+    }
+    return ts.isPropertyAssignment(property) ? property.initializer.getText(sourceFile) : undefined;
+};
+const findProperty = (objectLiteral, name) => objectLiteral.properties.find((property) => {
+    return ((ts.isPropertyAssignment(property) || ts.isShorthandPropertyAssignment(property)) &&
+        ts.isIdentifier(property.name) &&
+        property.name.text === name);
+});
 const migrateConfigObject = (configArgument, node, sourceFile) => {
-    const variableName = getVariableNameForQueryClient(node);
+    const variableName = getVariableNameForQueryClient(node) ?? 'client';
     const nextConfig = [];
-    const baseRouteProperty = configArgument.properties.find((property) => {
-        return ts.isPropertyAssignment(property) && ts.isIdentifier(property.name) && property.name.text === 'baseRoute';
-    });
-    if (baseRouteProperty && ts.isPropertyAssignment(baseRouteProperty)) {
-        const baseRouteValue = baseRouteProperty.initializer
-            .getText(sourceFile)
-            .replace('as `https://${string}`', '')
-            .trim();
-        nextConfig.push(`baseUrl: ${baseRouteValue}`);
+    const baseRouteProperty = findProperty(configArgument, 'baseRoute');
+    const baseRouteText = baseRouteProperty && getPropertyValueText(baseRouteProperty, sourceFile);
+    if (baseRouteText) {
+        nextConfig.push(`baseUrl: ${baseRouteText.replace('as `https://${string}`', '').trim()}`);
     }
     nextConfig.push(`name: '${variableName}'`);
-    const requestProperty = configArgument.properties.find((property) => {
-        return ts.isPropertyAssignment(property) && ts.isIdentifier(property.name) && property.name.text === 'request';
-    });
+    const requestProperty = findProperty(configArgument, 'request');
     if (requestProperty &&
         ts.isPropertyAssignment(requestProperty) &&
         ts.isObjectLiteralExpression(requestProperty.initializer)) {
-        requestProperty.initializer.properties.forEach((property) => {
-            if (!ts.isPropertyAssignment(property) || !ts.isIdentifier(property.name)) {
-                return;
+        const requestConfig = requestProperty.initializer;
+        for (const [from, to] of [
+            ['queryParams', 'queryString'],
+            ['cacheAdapter', 'cacheAdapter'],
+            ['retryFn', 'retryFn'],
+        ]) {
+            const property = findProperty(requestConfig, from);
+            const valueText = property && getPropertyValueText(property, sourceFile);
+            if (valueText) {
+                nextConfig.push(`${to}: ${valueText}`);
             }
-            if (property.name.text === 'queryParams') {
-                nextConfig.push(`queryString: ${property.initializer.getText(sourceFile)}`);
-            }
-            if (property.name.text === 'cacheAdapter') {
-                nextConfig.push(`cacheAdapter: ${property.initializer.getText(sourceFile)}`);
-            }
-            if (property.name.text === 'retryFn') {
-                nextConfig.push(`retryFn: ${property.initializer.getText(sourceFile)}`);
-            }
-        });
+        }
     }
+    nextConfig.push(`features: [${CLIENT_FEATURE}()]`);
     return `createQueryClient({\n  ${nextConfig.join(',\n  ')}\n})`;
 };
 const getVariableNameForQueryClient = (node) => {
@@ -286,7 +471,7 @@ const getVariableNameForQueryClient = (node) => {
         }
         parent = parent.parent;
     }
-    return 'client';
+    return undefined;
 };
 const extractClientConfigNames = (content) => {
     const sourceFile = createSourceFile(content);
@@ -326,19 +511,20 @@ const addProviderAliasesToFile = (content, configNames) => {
             return;
         }
         const { injectName, provideName } = getProviderAliasNames(variableName);
-        if (result.includes(`export const [${provideName}, ${injectName}] = ${variableName};`)) {
+        if (result.includes(`export const ${injectName} = toInjectFn(${variableName});`)) {
             return;
         }
         insertions.push({
             position,
-            text: `\n\nexport const [${provideName}, ${injectName}] = ${variableName};`,
+            text: `\n\nexport const ${provideName} = toProvideFn(${variableName});` +
+                `\nexport const ${injectName} = toInjectFn(${variableName});`,
         });
     });
     insertions.sort((left, right) => right.position - left.position);
     insertions.forEach(({ position, text }) => {
         result = result.slice(0, position) + text + result.slice(position);
     });
-    return result;
+    return insertions.length > 0 ? ensureImportFromEthleteCore(result, ['toInjectFn', 'toProvideFn']) : result;
 };
 const getProviderAliasNames = (configVariableName) => {
     const baseName = configVariableName.replace(/Config$/, '');
@@ -384,94 +570,90 @@ const generateCreatorsForConfig = (configName) => {
         `export const ${creatorBaseName}Delete = createDeleteQuery(${configVariableName});`,
     ].join('\n');
 };
-const updateImportsInFile = (content, renames) => {
-    const sourceFile = createSourceFile(content);
+/**
+ * Points imports and re-exports of a renamed client at its new name, and renames the references to
+ * each unaliased import. Only a binding the module graph resolves to the client's declaring file is
+ * touched; a same-named symbol from any other module stays as it is. A workspace specifier the graph
+ * cannot resolve falls back to the rename by name and is returned in `renamedByName` for the report.
+ */
+const updateImportsInFile = (content, filePath, renames, graph) => {
+    const sourceFile = createSourceFile(content, filePath);
     const replacements = [];
-    const visit = (node) => {
-        if (ts.isImportDeclaration(node) &&
-            node.importClause?.namedBindings &&
-            ts.isNamedImports(node.importClause.namedBindings)) {
-            const nextElements = [];
+    const localRenames = new Map();
+    const renamedByName = new Set();
+    const resolveRename = (specifier, importedName) => {
+        const declaringFile = graph.findDeclaringFile(filePath, specifier, importedName);
+        if (declaringFile) {
+            return declaringFile !== filePath ? renames.get(declaringFile)?.renames.get(importedName) : undefined;
+        }
+        if (!graph.isWorkspaceSpecifier(specifier))
+            return undefined;
+        const nextName = [...renames.values()].find((entry) => entry.renames.has(importedName))?.renames.get(importedName);
+        if (nextName)
+            renamedByName.add(specifier);
+        return nextName;
+    };
+    for (const statement of sourceFile.statements) {
+        if (ts.isImportDeclaration(statement) &&
+            ts.isStringLiteral(statement.moduleSpecifier) &&
+            statement.importClause?.namedBindings &&
+            ts.isNamedImports(statement.importClause.namedBindings)) {
+            const specifier = statement.moduleSpecifier.text;
             let hasChanges = false;
-            node.importClause.namedBindings.elements.forEach((element) => {
-                const nextName = renames.get(element.name.text);
+            const nextElements = statement.importClause.namedBindings.elements.map((element) => {
+                const nextName = resolveRename(specifier, (element.propertyName ?? element.name).text);
                 if (!nextName) {
-                    nextElements.push(element.getText(sourceFile));
-                    return;
+                    return element.getText(sourceFile);
                 }
                 hasChanges = true;
-                nextElements.push(element.propertyName ? `${nextName} as ${element.name.text}` : nextName);
+                const typePrefix = element.isTypeOnly ? 'type ' : '';
+                if (element.propertyName) {
+                    return `${typePrefix}${nextName} as ${element.name.text}`;
+                }
+                localRenames.set(element.name.text, nextName);
+                return `${typePrefix}${nextName}`;
             });
             if (hasChanges) {
                 replacements.push({
-                    start: node.getStart(sourceFile),
-                    end: node.getEnd(),
-                    replacement: `import { ${nextElements.join(', ')} } from '${node.moduleSpecifier.text}';`,
+                    start: statement.getStart(sourceFile),
+                    end: statement.getEnd(),
+                    replacement: printImportDeclaration(statement, sourceFile, nextElements),
                 });
             }
         }
-        if (ts.isIdentifier(node)) {
-            const nextName = renames.get(node.text);
-            if (!nextName) {
-                ts.forEachChild(node, visit);
-                return;
-            }
-            const parent = node.parent;
-            if (ts.isImportSpecifier(parent)) {
-                ts.forEachChild(node, visit);
-                return;
-            }
-            if (ts.isVariableDeclaration(parent) && parent.name === node) {
-                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;
-            }
-            if (ts.isPropertyAccessExpression(parent) && parent.name === node) {
-                ts.forEachChild(node, visit);
-                return;
-            }
-            if (ts.isPropertyAssignment(parent) && parent.name === node) {
-                ts.forEachChild(node, visit);
-                return;
-            }
+        if (ts.isExportDeclaration(statement) &&
+            statement.moduleSpecifier &&
+            ts.isStringLiteral(statement.moduleSpecifier) &&
+            statement.exportClause &&
+            ts.isNamedExports(statement.exportClause)) {
+            const specifier = statement.moduleSpecifier.text;
+            statement.exportClause.elements.forEach((element) => {
+                const exportedFrom = element.propertyName ?? element.name;
+                const nextName = ts.isIdentifier(exportedFrom) ? resolveRename(specifier, exportedFrom.text) : undefined;
+                if (nextName) {
+                    replacements.push({
+                        start: exportedFrom.getStart(sourceFile),
+                        end: exportedFrom.getEnd(),
+                        replacement: nextName,
+                    });
+                }
+            });
+        }
+    }
+    const visit = (node) => {
+        const nextName = ts.isIdentifier(node) ? localRenames.get(node.text) : undefined;
+        if (nextName && !isNamePosition(node) && !isShadowedInNestedScope(node)) {
             replacements.push({
                 start: node.getStart(sourceFile),
                 end: node.getEnd(),
-                replacement: nextName,
+                replacement: renamedReference(node, nextName),
             });
         }
         ts.forEachChild(node, visit);
     };
-    visit(sourceFile);
-    let result = content;
-    const seen = new Set();
-    const uniqueReplacements = replacements.filter((replacement) => {
-        const key = `${replacement.start}:${replacement.end}`;
-        if (seen.has(key)) {
-            return false;
-        }
-        seen.add(key);
-        return true;
-    });
-    uniqueReplacements.sort((left, right) => right.start - left.start);
-    uniqueReplacements.forEach(({ start, end, replacement }) => {
-        result = result.slice(0, start) + replacement + result.slice(end);
-    });
-    return result;
+    if (localRenames.size > 0) {
+        visit(sourceFile);
+    }
+    return { content: applyReplacements(content, replacements), renamedByName };
 };
 //# sourceMappingURL=query-client-migration.js.map