@ethlete/query 6.0.0-next.2 → 6.0.0-next.20

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

@@ -0,0 +1,153 @@
+import * as ts from 'typescript';
+import { createSourceFile } from './shared.js';
+const MAX_BARREL_DEPTH = 8;
+const normalizePath = (path) => {
+    const segments = [];
+    for (const segment of path.split('/')) {
+        if (segment === '' || segment === '.')
+            continue;
+        if (segment === '..') {
+            segments.pop();
+            continue;
+        }
+        segments.push(segment);
+    }
+    return segments.join('/');
+};
+const dirName = (path) => path.slice(0, Math.max(0, path.lastIndexOf('/')));
+const readTsConfigPaths = (tree) => {
+    const paths = new Map();
+    for (const configPath of ['tsconfig.base.json', 'tsconfig.json']) {
+        const raw = tree.read(configPath, 'utf-8');
+        if (!raw)
+            continue;
+        try {
+            // 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;
+            Object.entries(parsed?.compilerOptions?.paths ?? {}).forEach(([key, targets]) => {
+                if (!paths.has(key))
+                    paths.set(key, targets);
+            });
+        }
+        catch {
+            // A tsconfig we cannot parse just means fewer resolvable aliases, not a failed migration.
+        }
+    }
+    return paths;
+};
+/** 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`,
+];
+export const createModuleGraph = (tree) => {
+    const tsConfigPaths = readTsConfigPaths(tree);
+    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;
+        }
+        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);
+            }
+            for (const target of targets) {
+                const resolvedTarget = normalizePath(target.replace('*', suffix));
+                const candidate = candidateFiles(resolvedTarget).find((option) => tree.exists(option));
+                if (candidate)
+                    return candidate;
+            }
+        }
+        return null;
+    };
+    const declaresSymbol = (sourceFile, symbolName) => {
+        let declares = false;
+        const isExported = (node) => ts.canHaveModifiers(node) &&
+            ts.getModifiers(node)?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword);
+        ts.forEachChild(sourceFile, (node) => {
+            if (declares)
+                return;
+            if (ts.isVariableStatement(node) && isExported(node)) {
+                declares = node.declarationList.declarations.some((declaration) => ts.isIdentifier(declaration.name) && declaration.name.text === symbolName);
+                return;
+            }
+            if ((ts.isFunctionDeclaration(node) ||
+                ts.isClassDeclaration(node) ||
+                ts.isInterfaceDeclaration(node) ||
+                ts.isTypeAliasDeclaration(node) ||
+                ts.isEnumDeclaration(node)) &&
+                isExported(node) &&
+                node.name?.text === symbolName) {
+                declares = true;
+            }
+        });
+        return declares;
+    };
+    const findDeclaringFileIn = (entryFile, symbolName, depth, seen) => {
+        if (depth > MAX_BARREL_DEPTH || seen.has(`${entryFile}#${symbolName}`))
+            return null;
+        seen.add(`${entryFile}#${symbolName}`);
+        const content = tree.read(entryFile, 'utf-8');
+        if (!content)
+            return null;
+        const sourceFile = createSourceFile(content, entryFile);
+        if (declaresSymbol(sourceFile, symbolName))
+            return entryFile;
+        const starExports = [];
+        for (const node of sourceFile.statements) {
+            if (!ts.isExportDeclaration(node) || !node.moduleSpecifier || !ts.isStringLiteral(node.moduleSpecifier)) {
+                continue;
+            }
+            const nextEntry = resolveEntryFile(entryFile, node.moduleSpecifier.text);
+            if (!nextEntry)
+                continue;
+            if (!node.exportClause) {
+                starExports.push(nextEntry);
+                continue;
+            }
+            if (!ts.isNamedExports(node.exportClause))
+                continue;
+            for (const element of node.exportClause.elements) {
+                if (element.name.text !== symbolName)
+                    continue;
+                const originalName = element.propertyName?.text ?? symbolName;
+                const found = findDeclaringFileIn(nextEntry, originalName, depth + 1, seen);
+                if (found)
+                    return found;
+            }
+        }
+        for (const starExport of starExports) {
+            const found = findDeclaringFileIn(starExport, symbolName, depth + 1, seen);
+            if (found)
+                return found;
+        }
+        return null;
+    };
+    return {
+        findDeclaringFile: (fromFile, specifier, symbolName) => {
+            const cacheKey = `${fromFile}|${specifier}|${symbolName}`;
+            const cached = declaringFileCache.get(cacheKey);
+            if (cached !== undefined)
+                return cached;
+            const entryFile = resolveEntryFile(fromFile, specifier);
+            const declaringFile = entryFile ? findDeclaringFileIn(entryFile, symbolName, 0, new Set()) : null;
+            declaringFileCache.set(cacheKey, declaringFile);
+            return declaringFile;
+        },
+    };
+};
+//# sourceMappingURL=module-graph.js.map

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

@@ -0,0 +1,525 @@
+import * as ts from 'typescript';
+import { capitalizeFirstLetter, createSourceFile, ensureConfigSuffix, ensureImportFromQuery, getVariableStatementEnd, } from './shared.js';
+export const migrateQueryClients = (tree, report, scope) => {
+    const queryClientFiles = new Map();
+    const variableRenames = new Map();
+    scope.visit(tree, (filePath) => {
+        if (!filePath.endsWith('.ts')) {
+            return;
+        }
+        const content = tree.read(filePath, 'utf-8');
+        if (!content || !hasQueryClientInstantiation(content)) {
+            return;
+        }
+        const renames = new Map();
+        const nextContent = migrateQueryClientToConfig({ content, filePath, renamesOut: renames, report });
+        renames.forEach((newName, oldName) => {
+            variableRenames.set(oldName, newName);
+        });
+        const configNames = extractClientConfigNames(nextContent);
+        if (configNames.length > 0) {
+            queryClientFiles.set(filePath, configNames);
+        }
+        if (nextContent !== content) {
+            tree.write(filePath, nextContent);
+        }
+    });
+    if (queryClientFiles.size > 0) {
+        console.log('\n✅ Migrated QueryClient instantiations in:');
+        queryClientFiles.forEach((configNames, filePath) => {
+            console.log(`   - ${filePath} (${configNames.join(', ')})`);
+        });
+    }
+    return { queryClientFiles, variableRenames };
+};
+export const generateProviderAliases = (tree, queryClientFiles) => {
+    const updatedFiles = [];
+    for (const [filePath, configNames] of queryClientFiles.entries()) {
+        const content = tree.read(filePath, 'utf-8');
+        if (!content) {
+            continue;
+        }
+        const nextContent = addProviderAliasesToFile(content, configNames);
+        if (nextContent !== content) {
+            tree.write(filePath, nextContent);
+            updatedFiles.push(filePath);
+        }
+    }
+    if (updatedFiles.length > 0) {
+        console.log('\n✅ Generated query client provider aliases in:');
+        updatedFiles.forEach((filePath) => console.log(`   - ${filePath}`));
+    }
+};
+export const generateQueryCreators = (tree, queryClientFiles) => {
+    const generatedFiles = [];
+    for (const [filePath, configNames] of queryClientFiles.entries()) {
+        const content = tree.read(filePath, 'utf-8');
+        if (!content) {
+            continue;
+        }
+        const nextContent = addQueryCreatorsToFile(content, configNames);
+        if (nextContent !== content) {
+            tree.write(filePath, nextContent);
+            generatedFiles.push(filePath);
+        }
+    }
+    if (generatedFiles.length > 0) {
+        console.log('\n✅ Generated query creators in:');
+        generatedFiles.forEach((filePath) => console.log(`   - ${filePath}`));
+    }
+};
+export const updateImportsAcrossWorkspace = (tree, renames, scope) => {
+    if (renames.size === 0) {
+        return;
+    }
+    scope.visit(tree, (filePath) => {
+        if (!filePath.endsWith('.ts')) {
+            return;
+        }
+        const content = tree.read(filePath, 'utf-8');
+        if (!content) {
+            return;
+        }
+        const nextContent = updateImportsInFile(content, renames);
+        if (nextContent !== content) {
+            tree.write(filePath, nextContent);
+        }
+    });
+};
+const hasQueryClientInstantiation = (content) => {
+    const sourceFile = createSourceFile(content);
+    let hasQueryClientImport = false;
+    let hasNewQueryClient = false;
+    const visit = (node) => {
+        if (ts.isImportDeclaration(node) &&
+            ts.isStringLiteral(node.moduleSpecifier) &&
+            node.moduleSpecifier.text === '@ethlete/query' &&
+            node.importClause?.namedBindings &&
+            ts.isNamedImports(node.importClause.namedBindings)) {
+            const hasLegacyClientImport = node.importClause.namedBindings.elements.some((element) => {
+                return element.name.text === 'V2QueryClient';
+            });
+            if (hasLegacyClientImport) {
+                hasQueryClientImport = true;
+            }
+        }
+        if (ts.isNewExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === 'V2QueryClient') {
+            hasNewQueryClient = true;
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return hasQueryClientImport && hasNewQueryClient;
+};
+const migrateQueryClientToConfig = ({ content, filePath, renamesOut, report }) => {
+    const sourceFile = createSourceFile(content, filePath);
+    const replacements = [];
+    const variableRenames = new Map();
+    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)) {
+                const oldVariableName = getVariableNameForQueryClient(node);
+                const newVariableName = ensureConfigSuffix(oldVariableName);
+                if (oldVariableName !== newVariableName) {
+                    const collisionRegex = new RegExp(`\\b(?:const|let|var)\\s+${newVariableName}\\b`);
+                    if (collisionRegex.test(content)) {
+                        report.addWarning({
+                            title: `Resolve query client rename collision for ${oldVariableName}`,
+                            summary: `The migration renamed ${oldVariableName} to ${newVariableName}, but a declaration with the target name already exists.`,
+                            action: `Verify the declarations in ${filePath} and rename one side manually before shipping the migrated client.`,
+                            locations: [{ filePath }],
+                            source: 'query-client-migration',
+                            dedupeKey: `rename-collision:${filePath}:${oldVariableName}:${newVariableName}`,
+                        });
+                    }
+                    variableRenames.set(oldVariableName, newVariableName);
+                    if (renamesOut) {
+                        renamesOut.set(oldVariableName, newVariableName);
+                    }
+                }
+                reportDroppedClientOptions({ configArgument, sourceFile, filePath, report });
+                replacements.push({
+                    start: node.getStart(sourceFile),
+                    end: node.getEnd(),
+                    replacement: migrateConfigObject(configArgument, node, sourceFile),
+                });
+            }
+        }
+        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);
+    });
+    result = removeQueryClientImport(result);
+    return renameVariables(result, variableRenames);
+};
+const removeQueryClientImport = (content) => {
+    const sourceFile = createSourceFile(content);
+    let queryImportNode;
+    ts.forEachChild(sourceFile, (node) => {
+        if (ts.isImportDeclaration(node) &&
+            ts.isStringLiteral(node.moduleSpecifier) &&
+            node.moduleSpecifier.text === '@ethlete/query') {
+            queryImportNode = node;
+        }
+    });
+    const requiredImports = [
+        'createDeleteQuery',
+        'createGetQuery',
+        'createPatchQuery',
+        'createPostQuery',
+        'createPutQuery',
+        'createQueryClient',
+    ];
+    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';
+    });
+    const nextImports = new Set(requiredImports);
+    existingElements.forEach((element) => nextImports.add(element.name.text));
+    const nextImportStatement = `import { ${Array.from(nextImports).sort().join(', ')} } from '@ethlete/query';`;
+    return (content.slice(0, queryImportNode.getStart(sourceFile)) +
+        nextImportStatement +
+        content.slice(queryImportNode.getEnd()));
+};
+const renameVariables = (content, renames) => {
+    if (renames.size === 0) {
+        return content;
+    }
+    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,
+                    });
+                }
+            }
+        }
+        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;
+    });
+    let result = content;
+    uniqueReplacements.sort((left, right) => right.start - left.start);
+    uniqueReplacements.forEach(({ start, end, replacement }) => {
+        result = result.slice(0, start) + replacement + result.slice(end);
+    });
+    return result;
+};
+/**
+ * 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': '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.',
+    '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}`,
+        });
+    };
+    configArgument.properties.forEach((property) => {
+        if (!ts.isPropertyAssignment(property) || !ts.isIdentifier(property.name)) {
+            return;
+        }
+        const name = property.name.text;
+        if ((name === 'request' || name === 'logging') && ts.isObjectLiteralExpression(property.initializer)) {
+            property.initializer.properties.forEach((nested) => {
+                if (!ts.isPropertyAssignment(nested) || !ts.isIdentifier(nested.name)) {
+                    return;
+                }
+                if (name === 'request' && ['queryParams', 'cacheAdapter', 'retryFn'].includes(nested.name.text)) {
+                    return;
+                }
+                raise(`${name}.${nested.name.text}`, nested);
+            });
+            return;
+        }
+        if (!migrated.has(name)) {
+            raise(name, property);
+        }
+    });
+};
+const migrateConfigObject = (configArgument, node, sourceFile) => {
+    const variableName = getVariableNameForQueryClient(node);
+    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}`);
+    }
+    nextConfig.push(`name: '${variableName}'`);
+    const requestProperty = configArgument.properties.find((property) => {
+        return ts.isPropertyAssignment(property) && ts.isIdentifier(property.name) && property.name.text === 'request';
+    });
+    if (requestProperty &&
+        ts.isPropertyAssignment(requestProperty) &&
+        ts.isObjectLiteralExpression(requestProperty.initializer)) {
+        requestProperty.initializer.properties.forEach((property) => {
+            if (!ts.isPropertyAssignment(property) || !ts.isIdentifier(property.name)) {
+                return;
+            }
+            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)}`);
+            }
+        });
+    }
+    return `createQueryClient({\n  ${nextConfig.join(',\n  ')}\n})`;
+};
+const getVariableNameForQueryClient = (node) => {
+    let parent = node.parent;
+    while (parent) {
+        if (ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name)) {
+            return parent.name.text;
+        }
+        parent = parent.parent;
+    }
+    return 'client';
+};
+const extractClientConfigNames = (content) => {
+    const sourceFile = createSourceFile(content);
+    const configNames = [];
+    const visit = (node) => {
+        if (ts.isVariableDeclaration(node) &&
+            ts.isIdentifier(node.name) &&
+            node.initializer &&
+            ts.isCallExpression(node.initializer) &&
+            ts.isIdentifier(node.initializer.expression) &&
+            node.initializer.expression.text === 'createQueryClient') {
+            const configArgument = node.initializer.arguments[0];
+            if (!configArgument || !ts.isObjectLiteralExpression(configArgument)) {
+                ts.forEachChild(node, visit);
+                return;
+            }
+            const nameProperty = configArgument.properties.find((property) => {
+                return ts.isPropertyAssignment(property) && ts.isIdentifier(property.name) && property.name.text === 'name';
+            });
+            if (nameProperty && ts.isPropertyAssignment(nameProperty) && ts.isStringLiteral(nameProperty.initializer)) {
+                configNames.push(nameProperty.initializer.text);
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return configNames;
+};
+const addProviderAliasesToFile = (content, configNames) => {
+    const sourceFile = createSourceFile(content);
+    const insertions = [];
+    let result = content;
+    configNames.forEach((configName) => {
+        const variableName = ensureConfigSuffix(configName);
+        const position = getVariableStatementEnd(sourceFile, variableName, 'createQueryClient');
+        if (!position) {
+            return;
+        }
+        const { injectName, provideName } = getProviderAliasNames(variableName);
+        if (result.includes(`export const [${provideName}, ${injectName}] = ${variableName};`)) {
+            return;
+        }
+        insertions.push({
+            position,
+            text: `\n\nexport const [${provideName}, ${injectName}] = ${variableName};`,
+        });
+    });
+    insertions.sort((left, right) => right.position - left.position);
+    insertions.forEach(({ position, text }) => {
+        result = result.slice(0, position) + text + result.slice(position);
+    });
+    return result;
+};
+const getProviderAliasNames = (configVariableName) => {
+    const baseName = configVariableName.replace(/Config$/, '');
+    const capitalizedBaseName = capitalizeFirstLetter(baseName);
+    return {
+        provideName: `provide${capitalizedBaseName}`,
+        injectName: `inject${capitalizedBaseName}`,
+    };
+};
+const addQueryCreatorsToFile = (content, configNames) => {
+    const sourceFile = createSourceFile(content);
+    const insertions = [];
+    let result = content;
+    configNames.forEach((configName) => {
+        const variableName = ensureConfigSuffix(configName);
+        const position = getVariableStatementEnd(sourceFile, variableName, 'createQueryClient');
+        if (!position) {
+            return;
+        }
+        const creatorBlock = generateCreatorsForConfig(configName);
+        if (result.includes(creatorBlock.split('\n')[0])) {
+            return;
+        }
+        insertions.push({
+            position,
+            text: `\n\n${creatorBlock}`,
+        });
+    });
+    insertions.sort((left, right) => right.position - left.position);
+    insertions.forEach(({ position, text }) => {
+        result = result.slice(0, position) + text + result.slice(position);
+    });
+    return result;
+};
+const generateCreatorsForConfig = (configName) => {
+    const creatorBaseName = configName.replace('Client', '');
+    const configVariableName = ensureConfigSuffix(configName);
+    return [
+        `export const ${creatorBaseName}Get = createGetQuery(${configVariableName});`,
+        `export const ${creatorBaseName}Post = createPostQuery(${configVariableName});`,
+        `export const ${creatorBaseName}Put = createPutQuery(${configVariableName});`,
+        `export const ${creatorBaseName}Patch = createPatchQuery(${configVariableName});`,
+        `export const ${creatorBaseName}Delete = createDeleteQuery(${configVariableName});`,
+    ].join('\n');
+};
+const updateImportsInFile = (content, renames) => {
+    const sourceFile = createSourceFile(content);
+    const replacements = [];
+    const visit = (node) => {
+        if (ts.isImportDeclaration(node) &&
+            node.importClause?.namedBindings &&
+            ts.isNamedImports(node.importClause.namedBindings)) {
+            const nextElements = [];
+            let hasChanges = false;
+            node.importClause.namedBindings.elements.forEach((element) => {
+                const nextName = renames.get(element.name.text);
+                if (!nextName) {
+                    nextElements.push(element.getText(sourceFile));
+                    return;
+                }
+                hasChanges = true;
+                nextElements.push(element.propertyName ? `${nextName} as ${element.name.text}` : nextName);
+            });
+            if (hasChanges) {
+                replacements.push({
+                    start: node.getStart(sourceFile),
+                    end: node.getEnd(),
+                    replacement: `import { ${nextElements.join(', ')} } from '${node.moduleSpecifier.text}';`,
+                });
+            }
+        }
+        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;
+            }
+            replacements.push({
+                start: node.getStart(sourceFile),
+                end: node.getEnd(),
+                replacement: 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;
+};
+//# sourceMappingURL=query-client-migration.js.map