@ethlete/query 6.0.0-next.51 → 6.0.0-next.53

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

@@ -1,5 +1,5 @@
 import { formatFiles } from '@nx/devkit';
-import { migrateDevtoolsUsage, migrateEmptyPrepareCalls, replaceAnyQueryWithLegacy } from './cleanup-migration.js';
+import { migrateDevtoolsUsage, 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';
@@ -19,17 +19,18 @@ export default async function migrate(tree, schema) {
         updateLegacyCreatorImportsAndUsages(tree, scope, report);
     }
     if (variableRenames.size > 0) {
-        updateImportsAcrossWorkspace(tree, variableRenames, scope);
+        updateImportsAcrossWorkspace(tree, variableRenames, scope, report);
     }
     replaceAnyQueryWithLegacy(tree, scope);
     migrateDevtoolsUsage(tree, scope, report);
-    migrateEmptyPrepareCalls(tree, scope);
+    migrateEmptyPrepareCalls(tree, scope, report);
     migrateLegacyPrepareCalls(tree, report, scope);
+    reportRemovedExperimentalQueryHelpers(tree, scope, report);
     if (queryClientFiles.size > 0) {
         reportMissingHttpClientProviders(tree, report, scope);
         reportDefaultHeaderUsages(tree, report, scope);
     }
-    report.writeToTree(tree);
+    report.writeToTree(tree, scope.isScoped ? scope.describe() : undefined);
     report.printSummary();
     if (!schema.skipFormat) {
         await formatFiles(tree);

package/generators/migrate-to-query-v3/module-graph.js

@@ -15,8 +15,9 @@ const normalizePath = (path) => {
     return segments.join('/');
 };
 const dirName = (path) => path.slice(0, Math.max(0, path.lastIndexOf('/')));
-const readTsConfigPaths = (tree) => {
+const readTsConfig = (tree) => {
     const paths = new Map();
+    let baseUrl = null;
     for (const configPath of ['tsconfig.base.json', 'tsconfig.json']) {
         const raw = tree.read(configPath, 'utf-8');
         if (!raw)
@@ -25,6 +26,9 @@ const readTsConfigPaths = (tree) => {
             // tsconfig files are JSONC in practice; the TS parser is the only thing that reliably reads
             // them, comments and trailing commas included.
             const parsed = ts.parseConfigFileTextToJson(configPath, raw).config;
+            const configBaseUrl = parsed?.compilerOptions?.baseUrl;
+            if (baseUrl === null && typeof configBaseUrl === 'string')
+                baseUrl = normalizePath(configBaseUrl);
             Object.entries(parsed?.compilerOptions?.paths ?? {}).forEach(([key, targets]) => {
                 if (!paths.has(key))
                     paths.set(key, targets);
@@ -34,45 +38,49 @@ const readTsConfigPaths = (tree) => {
             // A tsconfig we cannot parse just means fewer resolvable aliases, not a failed migration.
         }
     }
-    return paths;
+    return { paths, baseUrl };
 };
+/** The part of `specifier` the `*` of `pattern` stands for, `''` for an exact match, or `null`. */
+const matchPathAlias = (pattern, specifier) => {
+    const wildcardIndex = pattern.indexOf('*');
+    if (wildcardIndex === -1)
+        return pattern === specifier ? '' : null;
+    const prefix = pattern.slice(0, wildcardIndex);
+    const patternSuffix = pattern.slice(wildcardIndex + 1);
+    if (!specifier.startsWith(prefix) || !specifier.endsWith(patternSuffix))
+        return null;
+    return specifier.slice(prefix.length, specifier.length - patternSuffix.length);
+};
+const JS_EXTENSION = /\.(m?)js$/;
 /** The files a specifier could point at, most specific first. */
-const candidateFiles = (base) => [
-    base.endsWith('.ts') ? base : `${base}.ts`,
-    `${base}/index.ts`,
-    `${base}.d.ts`,
-];
+const candidateFiles = (base) => {
+    if (base.endsWith('.ts'))
+        return [base];
+    const jsExtension = JS_EXTENSION.exec(base);
+    if (jsExtension) {
+        const stem = base.slice(0, -jsExtension[0].length);
+        return [`${stem}.${jsExtension[1]}ts`, `${stem}.ts`, `${stem}.d.ts`, `${base}/index.ts`];
+    }
+    return [`${base}.ts`, `${base}/index.ts`, `${base}.d.ts`];
+};
 export const createModuleGraph = (tree) => {
-    const tsConfigPaths = readTsConfigPaths(tree);
+    const { paths: tsConfigPaths, baseUrl } = readTsConfig(tree);
+    const findCandidate = (base) => candidateFiles(base).find((candidate) => tree.exists(candidate)) ?? null;
     const declaringFileCache = new Map();
     const resolveEntryFile = (fromFile, specifier) => {
-        if (specifier.startsWith('.')) {
-            const base = normalizePath(`${dirName(fromFile)}/${specifier}`);
-            return candidateFiles(base).find((candidate) => tree.exists(candidate)) ?? null;
-        }
+        if (specifier.startsWith('.'))
+            return findCandidate(normalizePath(`${dirName(fromFile)}/${specifier}`));
         for (const [pattern, targets] of tsConfigPaths.entries()) {
-            const wildcardIndex = pattern.indexOf('*');
-            let suffix;
-            if (wildcardIndex === -1) {
-                if (pattern !== specifier)
-                    continue;
-                suffix = '';
-            }
-            else {
-                const prefix = pattern.slice(0, wildcardIndex);
-                const patternSuffix = pattern.slice(wildcardIndex + 1);
-                if (!specifier.startsWith(prefix) || !specifier.endsWith(patternSuffix))
-                    continue;
-                suffix = specifier.slice(prefix.length, specifier.length - patternSuffix.length);
-            }
+            const wildcard = matchPathAlias(pattern, specifier);
+            if (wildcard === null)
+                continue;
             for (const target of targets) {
-                const resolvedTarget = normalizePath(target.replace('*', suffix));
-                const candidate = candidateFiles(resolvedTarget).find((option) => tree.exists(option));
+                const candidate = findCandidate(normalizePath(`${baseUrl ?? ''}/${target.replace('*', wildcard)}`));
                 if (candidate)
                     return candidate;
             }
         }
-        return null;
+        return baseUrl === null ? null : findCandidate(normalizePath(`${baseUrl}/${specifier}`));
     };
     const declaresSymbol = (sourceFile, symbolName) => {
         let declares = false;
@@ -138,6 +146,10 @@ export const createModuleGraph = (tree) => {
         return null;
     };
     return {
+        resolveFile: resolveEntryFile,
+        pathAliases: () => [...tsConfigPaths.keys()],
+        isWorkspaceSpecifier: (specifier) => specifier.startsWith('.') ||
+            [...tsConfigPaths.keys()].some((pattern) => matchPathAlias(pattern, specifier) !== null),
         findDeclaringFile: (fromFile, specifier, symbolName) => {
             const cacheKey = `${fromFile}|${specifier}|${symbolName}`;
             const cached = declaringFileCache.get(cacheKey);

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

@@ -1,5 +1,8 @@
 import * as ts from 'typescript';
-import { capitalizeFirstLetter, createSourceFile, ensureConfigSuffix, ensureImportFromEthleteCore, ensureImportFromQuery, getVariableStatementEnd, } from './shared.js';
+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();
@@ -13,9 +16,9 @@ export const migrateQueryClients = (tree, report, scope) => {
         }
         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);
@@ -68,10 +71,12 @@ export const generateQueryCreators = (tree, queryClientFiles) => {
         generatedFiles.forEach((filePath) => console.log(`   - ${filePath}`));
     }
 };
-export const updateImportsAcrossWorkspace = (tree, renames, scope) => {
+export const updateImportsAcrossWorkspace = (tree, renames, scope, report) => {
     if (renames.size === 0) {
         return;
     }
+    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;
@@ -80,12 +85,42 @@ export const updateImportsAcrossWorkspace = (tree, renames, scope) => {
         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;
@@ -151,6 +186,7 @@ const migrateQueryClientToConfig = ({ content, filePath, renamesOut, report }) =
                     }
                 }
                 reportDroppedClientOptions({ configArgument, sourceFile, filePath, report });
+                reportChangedClientDefaults({ configArgument, sourceFile, filePath, report });
                 replacements.push({
                     start: node.getStart(sourceFile),
                     end: node.getEnd(),
@@ -190,6 +226,7 @@ const removeQueryClientImport = (content, keepLegacyClient) => {
         'createPostQuery',
         'createPutQuery',
         'createQueryClient',
+        CLIENT_FEATURE,
     ];
     if (!queryImportNode?.importClause?.namedBindings || !ts.isNamedImports(queryImportNode.importClause.namedBindings)) {
         return ensureImportFromQuery(content, requiredImports);
@@ -199,11 +236,31 @@ const removeQueryClientImport = (content, keepLegacyClient) => {
     });
     const nextImports = new Set(requiredImports);
     existingElements.forEach((element) => nextImports.add(element.getText(sourceFile)));
-    const nextImportStatement = `import { ${Array.from(nextImports).sort().join(', ')} } from '@ethlete/query';`;
+    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;
@@ -211,48 +268,31 @@ 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.
  *
@@ -261,8 +301,8 @@ const renameVariables = (content, renames) => {
  * report from production.
  */
 const DROPPED_CLIENT_OPTIONS = {
-    'request.autoRefreshQueriesOnWindowFocus': 'No direct equivalent. Re-run the affected queries yourself - `withAutoRefresh({ onSignalChanges: [windowFocusSignal] })` per query, or `injectMyClient().refreshQueriesInUse()` from a focus listener.',
-    'request.enableSmartPolling': 'No direct equivalent. `withPolling({ interval })` polls unconditionally; pause it yourself when the tab is hidden if that matters.',
+    '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()`.',
@@ -315,6 +355,12 @@ const reportDroppedClientOptions = ({ configArgument, sourceFile, filePath, repo
                 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;
@@ -324,6 +370,59 @@ const reportDroppedClientOptions = ({ configArgument, sourceFile, filePath, repo
         }
     });
 };
+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;
@@ -361,6 +460,7 @@ const migrateConfigObject = (configArgument, node, sourceFile) => {
             }
         }
     }
+    nextConfig.push(`features: [${CLIENT_FEATURE}()]`);
     return `createQueryClient({\n  ${nextConfig.join(',\n  ')}\n})`;
 };
 const getVariableNameForQueryClient = (node) => {
@@ -470,107 +570,90 @@ const generateCreatorsForConfig = (configName) => {
         `export const ${creatorBaseName}Delete = createDeleteQuery(${configVariableName});`,
     ].join('\n');
 };
-const declaresName = (declarations, name) => declarations.some((declaration) => declaration.name && ts.isIdentifier(declaration.name) && declaration.name.text === name);
-const isShadowedByLocalDeclaration = (identifier) => {
-    for (let scope = identifier.parent; scope && !ts.isSourceFile(scope); scope = scope.parent) {
-        if (ts.isFunctionLike(scope) && declaresName(scope.parameters, identifier.text)) {
-            return true;
-        }
-        if (ts.isBlock(scope) &&
-            scope.statements.some((statement) => ts.isVariableStatement(statement) && declaresName(statement.declarationList.declarations, identifier.text))) {
-            return true;
-        }
-    }
-    return false;
-};
-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.propertyName?.text ?? 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) || isShadowedByLocalDeclaration(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