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

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

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

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

@@ -0,0 +1,41 @@
+import { getProjects, visitNotIgnoredFiles } from '@nx/devkit';
+const stripTrailingSlash = (value) => (value.endsWith('/') ? value.slice(0, -1) : value);
+/**
+ * Limits the migration to a set of projects or paths.
+ *
+ * Rewriting every app in a monorepo in one run is rarely how adoption actually goes, and a 300-file
+ * diff is not reviewable. Note the one coupling that cannot be split: a query client and the
+ * creators built on it have to be migrated together, because the creators are rewritten in terms of
+ * the client's generated `xGet` / `xPostSecure` helpers.
+ */
+export const createMigrationScope = (tree, options) => {
+    const roots = [];
+    for (const projectName of options.projects ?? []) {
+        const project = getProjects(tree).get(projectName);
+        if (!project) {
+            throw new Error(`Unknown project "${projectName}". Pass names as they appear in \`nx show projects\`, or use --include with a path prefix.`);
+        }
+        roots.push(stripTrailingSlash(project.root));
+    }
+    for (const includePath of options.include ?? []) {
+        roots.push(stripTrailingSlash(includePath));
+    }
+    if (roots.length === 0) {
+        return {
+            visit: (targetTree, callback) => visitNotIgnoredFiles(targetTree, '', callback),
+            includes: () => true,
+            describe: () => 'the whole workspace',
+        };
+    }
+    const includes = (filePath) => roots.some((root) => filePath === root || filePath.startsWith(`${root}/`));
+    return {
+        visit: (targetTree, callback) => {
+            for (const root of roots) {
+                visitNotIgnoredFiles(targetTree, root, callback);
+            }
+        },
+        includes,
+        describe: () => roots.join(', '),
+    };
+};
+//# sourceMappingURL=migration-scope.js.map

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

@@ -1,26 +1,34 @@
 import { formatFiles } from '@nx/devkit';
-import { migrateEmptyPrepareCalls, removeDevtoolsUsage, replaceAnyQueryWithLegacy } from './cleanup-migration.js';
+import { migrateDevtoolsUsage, migrateEmptyPrepareCalls, replaceAnyQueryWithLegacy } 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';
+import { createMigrationScope } from './migration-scope.js';
 import { generateProviderAliases, generateQueryCreators, migrateQueryClients, updateImportsAcrossWorkspace, } from './query-client-migration.js';
 import { QueryV3MigrationReport } from './report.js';
 export default async function migrate(tree, schema) {
     console.log('\n🔄 Starting query v3 migration...');
+    const scope = createMigrationScope(tree, schema);
+    console.log(`   Scope: ${scope.describe()}`);
     const report = new QueryV3MigrationReport();
-    const { queryClientFiles, variableRenames } = migrateQueryClients(tree, report);
+    const { queryClientFiles, variableRenames } = migrateQueryClients(tree, report, scope);
     if (queryClientFiles.size > 0) {
         generateProviderAliases(tree, queryClientFiles);
         generateQueryCreators(tree, queryClientFiles);
-        createNewQueryCreators(tree, queryClientFiles, report);
-        updateLegacyCreatorImportsAndUsages(tree);
+        createNewQueryCreators(tree, queryClientFiles, report, scope);
+        updateLegacyCreatorImportsAndUsages(tree, scope, report);
     }
     if (variableRenames.size > 0) {
-        updateImportsAcrossWorkspace(tree, variableRenames);
+        updateImportsAcrossWorkspace(tree, variableRenames, scope);
+    }
+    replaceAnyQueryWithLegacy(tree, scope);
+    migrateDevtoolsUsage(tree, scope, report);
+    migrateEmptyPrepareCalls(tree, scope);
+    migrateLegacyPrepareCalls(tree, report, scope);
+    if (queryClientFiles.size > 0) {
+        reportMissingHttpClientProviders(tree, report, scope);
+        reportDefaultHeaderUsages(tree, report, scope);
     }
-    replaceAnyQueryWithLegacy(tree);
-    removeDevtoolsUsage(tree);
-    migrateEmptyPrepareCalls(tree);
-    migrateLegacyPrepareCalls(tree, report);
     report.writeToTree(tree);
     report.printSummary();
     if (!schema.skipFormat) {

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