@ethlete/query 6.0.0-next.61 → 6.0.0-next.63

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

@@ -1,5 +1,5 @@
 import * as ts from 'typescript';
-import { collectV2BearerAuthConfigs, renderAuthProviderBody } from './auth-provider-scaffold.js';
+import { collectV2BearerAuthConfigs, rebaseModuleSpecifier, renderAuthProviderBody, } from './auth-provider-scaffold.js';
 import { createModuleGraph } from './module-graph.js';
 import { pruneUnusedNamedImports, renameImportedReferences } from './rename-symbols.js';
 import { capitalizeFirstLetter, createSourceFile, ensureConfigSuffix, ensureImportFromEthleteCore, ensureImportFromQuery, legacyQueryDeprecationTag, } from './shared.js';
@@ -15,7 +15,7 @@ const HTTP_OPTION_NAMES = ['reportProgress', 'responseType', 'transferCache', 'w
 const isLegacyHttpMethod = (value) => {
     return Object.values(LEGACY_HTTP_METHOD).includes(value);
 };
-export const createNewQueryCreators = (tree, queryClientFiles, report, scope) => {
+export const createNewQueryCreators = (tree, queryClientFiles, report, scope, gqlGetClients = new Set()) => {
     const createdFiles = [];
     const authProvidersNeeded = new Map();
     const clientNameToFilePath = new Map();
@@ -33,7 +33,7 @@ export const createNewQueryCreators = (tree, queryClientFiles, report, scope) =>
         if (!content) {
             return;
         }
-        const legacyCreators = analyzeLegacyQueryCreators(content, queryClientFiles, filePath, report);
+        const legacyCreators = analyzeLegacyQueryCreators(content, queryClientFiles, filePath, report, gqlGetClients);
         if (legacyCreators.length === 0) {
             return;
         }
@@ -79,7 +79,10 @@ export const updateLegacyCreatorImportsAndUsages = (tree, scope, report) => {
             return;
         }
         findLegacyWrappers(content).forEach((legacyName, originalName) => {
-            legacyCreators.set(originalName, { legacyName, definedIn: filePath });
+            legacyCreators.set(originalName, [
+                ...(legacyCreators.get(originalName) ?? []),
+                { legacyName, definedIn: filePath },
+            ]);
         });
     });
     if (legacyCreators.size === 0) {
@@ -137,8 +140,10 @@ const pointFileAtLegacyWrappers = ({ content, filePath, legacyCreators, moduleGr
         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)) {
+            const registration = legacyCreators
+                .get(importedName)
+                ?.find((candidate) => resolvesToWrapper(moduleSpecifier, importedName, candidate));
+            if (!registration) {
                 return element.getText(sourceFile);
             }
             changed = true;
@@ -192,7 +197,7 @@ const pointFileAtLegacyWrappers = ({ content, filePath, legacyCreators, moduleGr
         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)}`}\`.`,
+            action: `Rename the local declaration or the import alias, then point the query usages at \`${legacyCreators.get(name)?.[0]?.legacyName ?? `legacy${capitalizeFirstLetter(name)}`}\`.`,
             locations: [{ filePath }],
             source: 'legacy-query-creator-migration',
             dedupeKey: `shadowed-rename:${filePath}:${name}`,
@@ -201,13 +206,17 @@ const pointFileAtLegacyWrappers = ({ content, filePath, legacyCreators, moduleGr
     return renamed.content;
 };
 const toLegacyName = (name) => `legacy${capitalizeFirstLetter(name)}`;
-const analyzeLegacyQueryCreators = (content, queryClientFiles, filePath, report) => {
+const analyzeLegacyQueryCreators = (content, queryClientFiles, filePath, report, gqlGetClients) => {
     const sourceFile = createSourceFile(content, filePath);
     const creators = [];
     const oldClientNames = new Set();
+    const renamedOwnClients = new Map();
     queryClientFiles.forEach((configNames) => {
         configNames.forEach((configName) => oldClientNames.add(configName));
     });
+    queryClientFiles.get(filePath)?.forEach((configName) => {
+        renamedOwnClients.set(ensureConfigSuffix(configName), configName);
+    });
     const visit = (node) => {
         if (ts.isVariableDeclaration(node) &&
             ts.isIdentifier(node.name) &&
@@ -220,24 +229,15 @@ const analyzeLegacyQueryCreators = (content, queryClientFiles, filePath, report)
                 ts.forEachChild(node, visit);
                 return;
             }
-            if (oldClientNames.has(objectExpression.text) && LEGACY_GQL_METHODS.includes(methodExpression.text)) {
-                report.addManualReview({
-                    title: `Rewrite the GraphQL creator ${node.name.text} by hand`,
-                    summary: `${node.name.text} is built with \`${objectExpression.text}.${methodExpression.text}()\`. The migration only rewrites REST creators, so this one still calls a method the migrated client no longer has.`,
-                    action: `Rebuild it on the v3 client with \`${methodExpression.text === 'gqlQuery' ? 'createGqlQueryViaPost' : 'createGqlMutationViaPost'}\` (or the \`ViaGet\` variant) and a \`gql\` document, then wrap it in \`createLegacyQueryCreator\` if its call sites stay on v2. See https://ethlete-sdk-docs.web.app/query/gql.`,
-                    locations: [{ filePath, line: sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1 }],
-                    source: 'legacy-query-creator-migration',
-                    dedupeKey: `gql-creator:${filePath}:${node.name.text}`,
-                });
-            }
-            if (!oldClientNames.has(objectExpression.text) || !isLegacyHttpMethod(methodExpression.text)) {
+            const clientName = renamedOwnClients.get(objectExpression.text) ?? objectExpression.text;
+            if (!oldClientNames.has(clientName) || !isLegacyHttpMethod(methodExpression.text)) {
                 ts.forEachChild(node, visit);
                 return;
             }
             const creatorName = node.name.text;
             const info = {
                 name: creatorName,
-                clientName: objectExpression.text,
+                clientName,
                 method: methodExpression.text,
                 route: '',
                 secure: false,
@@ -363,8 +363,109 @@ const analyzeLegacyQueryCreators = (content, queryClientFiles, filePath, report)
         ts.forEachChild(node, visit);
     };
     visit(sourceFile);
+    reportLegacyGqlCalls(sourceFile, filePath, oldClientNames, gqlGetClients, report);
     return creators;
 };
+const collectClientAliases = (sourceFile, oldClientNames) => {
+    const aliases = new Map();
+    const resolve = (expression) => {
+        if (!ts.isIdentifier(expression)) {
+            return undefined;
+        }
+        return aliases.get(expression.text) ?? (oldClientNames.has(expression.text) ? expression.text : undefined);
+    };
+    const visitImports = (node) => {
+        if (ts.isImportSpecifier(node) && node.propertyName && oldClientNames.has(node.propertyName.text)) {
+            aliases.set(node.name.text, node.propertyName.text);
+        }
+        ts.forEachChild(node, visitImports);
+    };
+    visitImports(sourceFile);
+    const aliasDeclarations = [];
+    const collectDeclarations = (node) => {
+        if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer) {
+            aliasDeclarations.push({ name: node.name.text, initializer: node.initializer });
+        }
+        ts.forEachChild(node, collectDeclarations);
+    };
+    collectDeclarations(sourceFile);
+    const addAlias = ({ name, initializer }) => {
+        const clientName = resolve(initializer);
+        if (!clientName || clientName === name || aliases.has(name)) {
+            return false;
+        }
+        aliases.set(name, clientName);
+        return true;
+    };
+    while (aliasDeclarations.filter(addAlias).length > 0) {
+        continue;
+    }
+    return resolve;
+};
+const describeGqlCall = (call, sourceFile) => {
+    const path = [];
+    let node = call;
+    while (node.parent && !ts.isSourceFile(node.parent)) {
+        node = node.parent;
+        if (ts.isPropertyAssignment(node)) {
+            path.unshift(node.name.getText(sourceFile));
+            continue;
+        }
+        if (ts.isVariableDeclaration(node) || ts.isFunctionDeclaration(node)) {
+            if (node.name && ts.isIdentifier(node.name)) {
+                path.unshift(node.name.text);
+            }
+            break;
+        }
+        if (ts.isPropertyDeclaration(node) || ts.isMethodDeclaration(node)) {
+            path.unshift(node.name.getText(sourceFile));
+            if (ts.isClassLike(node.parent) && node.parent.name) {
+                path.unshift(node.parent.name.text);
+            }
+            break;
+        }
+    }
+    return path.length > 0
+        ? path.join('.')
+        : `at line ${sourceFile.getLineAndCharacterOfPosition(call.getStart(sourceFile)).line + 1}`;
+};
+const reportLegacyGqlCalls = (sourceFile, filePath, oldClientNames, gqlGetClients, report) => {
+    const resolveClient = collectClientAliases(sourceFile, oldClientNames);
+    const visit = (node) => {
+        if (ts.isCallExpression(node) &&
+            ts.isPropertyAccessExpression(node.expression) &&
+            LEGACY_GQL_METHODS.includes(node.expression.name.text)) {
+            const receiver = node.expression.expression;
+            const receiverText = receiver.getText(sourceFile);
+            const method = node.expression.name.text;
+            const clientName = resolveClient(receiver);
+            const name = describeGqlCall(node, sourceFile);
+            const isQuery = method === 'gqlQuery';
+            const viaGet = isQuery && !!clientName && gqlGetClients.has(clientName);
+            const creator = !isQuery
+                ? '`createGqlMutationViaPost`'
+                : viaGet
+                    ? '`createGqlQueryViaGet`'
+                    : clientName || gqlGetClients.size === 0
+                        ? '`createGqlQueryViaPost`'
+                        : "`createGqlQueryViaPost` (or `createGqlQueryViaGet` if its client set `request.gql.transferVia: 'GET'`)";
+            const builtWith = clientName
+                ? `\`${receiverText}.${method}()\``
+                : `\`${receiverText}.${method}()\`, which the migration takes for a v2 query client`;
+            const line = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1;
+            report.addManualReview({
+                title: `Rewrite the GraphQL creator ${name} by hand`,
+                summary: `${name} is built with ${builtWith}. The migration only rewrites REST creators, so this one still calls a method the migrated client no longer has, and the callback parameters in its config lose their types: expect implicit-any errors (TS7006) there until it is rebuilt.${viaGet ? " The v2 client sent GraphQL queries with `request.gql.transferVia: 'GET'`, which v3 sets per creator." : ''}`,
+                action: `Rebuild it on the v3 client with ${creator} and a \`gql\` document, then wrap it in \`createLegacyQueryCreator\` if its call sites stay on v2. See https://ethlete-sdk-docs.web.app/query/gql.`,
+                locations: [{ filePath, line }],
+                source: 'legacy-query-creator-migration',
+                dedupeKey: `gql-creator:${filePath}:${name}:${line}`,
+            });
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+};
 const extractTypeFromDef = (node, sourceFile) => {
     if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === 'def') {
         if (node.typeArguments && node.typeArguments.length > 0) {
@@ -505,8 +606,11 @@ const generateNewQueryCreator = (creator) => {
         ? `${clientBaseName}${capitalizedMethod}Secure`
         : `${clientBaseName}${capitalizedMethod}`;
     const typeParameter = getTypeParameter(creator);
-    const options = Array.from(creator.httpOptions.entries()).map(([key, value]) => `${key}: ${value}`);
-    const optionsBlock = options.length > 0 ? `, {\n  ${options.join(',\n  ')}\n}` : '';
+    const options = [
+        'reportErrors: false',
+        ...Array.from(creator.httpOptions.entries()).map(([key, value]) => `${key}: ${value}`),
+    ];
+    const optionsBlock = `, {\n  ${options.join(',\n  ')}\n}`;
     return `${creatorFunction}${typeParameter}(${creator.route}${optionsBlock})`;
 };
 const getTypeParameter = (creator) => {
@@ -555,12 +659,22 @@ const createAuthProviders = ({ tree, authProvidersNeeded, report, v2Configs, cre
         // 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);
+        const nextContent = generateSecureQueryCreators(addAuthProviderToFile(content, clientName, body, v2Config, filePath), clientName);
         if (nextContent === content) {
             return;
         }
         tree.write(filePath, nextContent);
         createdProviders.push(filePath);
+        if (v2Config && v2Config.localNames.length > 0) {
+            report.addWarning({
+                title: 'Import the names the scaffolded auth provider copied',
+                summary: `The scaffolded provider uses ${v2Config.localNames.join(', ')}, declared in ${v2Config.filePath} and not exported to ${filePath}.`,
+                action: 'Move each declaration into the provider file, or export it and import it there.',
+                locations: [{ filePath }, { filePath: v2Config.filePath, line: v2Config.line }],
+                source: 'legacy-query-creator-migration',
+                dedupeKey: `auth-provider-local-names:${filePath}:${authProviderName}`,
+            });
+        }
         body.warnings.forEach((warning) => {
             report.addWarning({
                 ...warning,
@@ -606,8 +720,40 @@ const createAuthProviders = ({ tree, authProvidersNeeded, report, v2Configs, cre
         createdProviders.forEach((filePath) => console.log(`   - ${filePath}`));
     }
 };
-const addAuthProviderToFile = (content, clientName, body) => {
-    const nextContent = ensureImportFromEthleteCore(ensureImportFromQuery(content, ['createBearerAuthProvider', ...body.importsNeeded]), ['toInjectFn', 'toProvideFn']);
+const addCopiedImports = (content, v2Config, filePath) => {
+    if (!v2Config || v2Config.filePath === filePath) {
+        return content;
+    }
+    const sourceFile = createSourceFile(content);
+    const bound = new Set();
+    let lastImportEnd = 0;
+    sourceFile.statements.forEach((statement) => {
+        if (!ts.isImportDeclaration(statement)) {
+            return;
+        }
+        lastImportEnd = Math.max(lastImportEnd, statement.getEnd());
+        const clause = statement.importClause;
+        if (clause?.name)
+            bound.add(clause.name.text);
+        if (clause?.namedBindings && ts.isNamespaceImport(clause.namedBindings))
+            bound.add(clause.namedBindings.name.text);
+        if (clause?.namedBindings && ts.isNamedImports(clause.namedBindings)) {
+            clause.namedBindings.elements.forEach((element) => bound.add(element.name.text));
+        }
+    });
+    const statements = v2Config.copiedImports
+        .filter(({ names }) => names.every((name) => !bound.has(name)))
+        .map(({ moduleSpecifier, statement }) => statement(rebaseModuleSpecifier(moduleSpecifier, v2Config.filePath, filePath)));
+    if (statements.length === 0) {
+        return content;
+    }
+    return content.slice(0, lastImportEnd) + `\n${statements.join('\n')}` + content.slice(lastImportEnd);
+};
+const addAuthProviderToFile = (content, clientName, body, v2Config, filePath) => {
+    const nextContent = addCopiedImports(ensureImportFromEthleteCore(ensureImportFromQuery(content, ['createBearerAuthProvider', ...body.importsNeeded]), [
+        'toInjectFn',
+        'toProvideFn',
+    ]), v2Config, filePath);
     const sourceFile = createSourceFile(nextContent);
     const configName = ensureConfigSuffix(clientName);
     const configPosition = findVariableStatementEnd(sourceFile, configName, 'createQueryClient');

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

@@ -1,21 +1,23 @@
 import { formatFiles } from '@nx/devkit';
-import { migrateDevtoolsUsage, migrateEmptyPrepareCalls, replaceAnyQueryWithLegacy, reportRemovedExperimentalQueryHelpers, } from './cleanup-migration.js';
+import { reportAuthConsumers } from './auth-consumers-migration.js';
+import { migrateDevtoolsUsage, reportLeftoverLegacyDevtools, reportLeftoverV2Clients, 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';
 import { createMigrationScope } from './migration-scope.js';
 import { generateProviderAliases, generateQueryCreators, migrateQueryClients, updateImportsAcrossWorkspace, } from './query-client-migration.js';
+import { reportLegacyModuleResolution } from './module-resolution.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, scope);
+    const { queryClientFiles, variableRenames, gqlGetClients } = migrateQueryClients(tree, report, scope);
     if (queryClientFiles.size > 0) {
         generateProviderAliases(tree, queryClientFiles);
         generateQueryCreators(tree, queryClientFiles);
-        createNewQueryCreators(tree, queryClientFiles, report, scope);
+        createNewQueryCreators(tree, queryClientFiles, report, scope, gqlGetClients);
         updateLegacyCreatorImportsAndUsages(tree, scope, report);
     }
     if (variableRenames.size > 0) {
@@ -26,10 +28,14 @@ export default async function migrate(tree, schema) {
     migrateEmptyPrepareCalls(tree, scope, report);
     migrateLegacyPrepareCalls(tree, report, scope);
     reportRemovedExperimentalQueryHelpers(tree, scope, report);
+    reportLeftoverV2Clients(tree, scope, report);
+    reportLeftoverLegacyDevtools(tree, scope, report);
+    reportAuthConsumers(tree, scope, report);
     if (queryClientFiles.size > 0) {
         reportMissingHttpClientProviders(tree, report, scope);
         reportDefaultHeaderUsages(tree, report, scope);
     }
+    reportLegacyModuleResolution(tree, scope, report);
     report.writeToTree(tree, scope.isScoped ? scope.describe() : undefined);
     report.printSummary();
     if (!schema.skipFormat) {

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

@@ -0,0 +1,131 @@
+import { joinPathFragments, readJson, visitNotIgnoredFiles } from '@nx/devkit';
+import { dirname } from 'node:path';
+import { createModuleGraph } from './module-graph.js';
+const PROJECT_TSCONFIGS = ['tsconfig.lib.json', 'tsconfig.app.json', 'tsconfig.spec.json'];
+const LEGACY_RESOLUTIONS = new Set(['node', 'node10']);
+const MODULE_SPECIFIER = /(?:\bfrom\s*|\bimport\s*\(?\s*)['"]([^'"]+)['"]/g;
+const projectRootOf = (tree, filePath) => {
+    let dir = dirname(filePath);
+    while (dir !== '.' && dir !== '/' && dir !== '') {
+        if (tree.exists(joinPathFragments(dir, 'project.json')))
+            return dir;
+        dir = dirname(dir);
+    }
+    return null;
+};
+const effectiveModuleResolution = (tree, configPath, seen = new Set()) => {
+    if (seen.has(configPath) || !tree.exists(configPath))
+        return null;
+    seen.add(configPath);
+    const config = readJson(tree, configPath);
+    const own = config.compilerOptions?.moduleResolution;
+    if (own)
+        return own.toLowerCase();
+    const parents = config.extends === undefined ? [] : [config.extends].flat();
+    for (const parent of [...parents].reverse()) {
+        if (!parent.startsWith('.'))
+            continue;
+        const resolved = effectiveModuleResolution(tree, joinPathFragments(dirname(configPath), parent.endsWith('.json') ? parent : `${parent}.json`), seen);
+        if (resolved)
+            return resolved;
+    }
+    return null;
+};
+const collectAliasEdges = (tree, graph) => {
+    const edges = new Map();
+    visitNotIgnoredFiles(tree, '', (filePath) => {
+        if (!filePath.endsWith('.ts') || filePath.includes('node_modules/'))
+            return;
+        const fromRoot = projectRootOf(tree, filePath);
+        if (!fromRoot)
+            return;
+        for (const [, specifier] of (tree.read(filePath, 'utf-8') ?? '').matchAll(MODULE_SPECIFIER)) {
+            if (!specifier || specifier.startsWith('.') || !graph.isWorkspaceSpecifier(specifier))
+                continue;
+            const target = graph.resolveFile(filePath, specifier);
+            const targetRoot = target ? projectRootOf(tree, target) : null;
+            if (!targetRoot || targetRoot === fromRoot)
+                continue;
+            const list = edges.get(fromRoot) ?? [];
+            if (!list.some((edge) => edge.alias === specifier))
+                list.push({ alias: specifier, targetRoot });
+            edges.set(fromRoot, list);
+        }
+    });
+    edges.forEach((list) => list.sort((a, b) => a.alias.localeCompare(b.alias)));
+    return edges;
+};
+const projectsReaching = (tree, graph, importingRoots) => {
+    const reached = new Map([...importingRoots].map((root) => [root, null]));
+    const edges = collectAliasEdges(tree, graph);
+    const roots = [...edges.keys()].sort();
+    let grew = true;
+    while (grew) {
+        grew = false;
+        for (const root of roots) {
+            if (reached.has(root))
+                continue;
+            const edge = edges.get(root).find(({ targetRoot }) => reached.has(targetRoot));
+            if (!edge)
+                continue;
+            reached.set(root, edge.alias);
+            grew = true;
+        }
+    }
+    return reached;
+};
+/**
+ * Lists every project tsconfig that resolves modules with `node` / `node10` while the project imports a specifier
+ * `matches` accepts, directly or through a workspace path alias. That resolution ignores the `exports` map, so a
+ * package subpath like `@ethlete/query/testing` does not resolve.
+ */
+export const findLegacyModuleResolutions = (tree, graph, files, matches) => {
+    const directSpecifiers = new Map();
+    for (const filePath of files) {
+        if (!filePath.endsWith('.ts'))
+            continue;
+        const root = projectRootOf(tree, filePath);
+        if (!root || directSpecifiers.has(root))
+            continue;
+        const specifier = Array.from((tree.read(filePath, 'utf-8') ?? '').matchAll(MODULE_SPECIFIER), ([, s]) => s).find((s) => s !== undefined && matches(s));
+        if (specifier)
+            directSpecifiers.set(root, specifier);
+    }
+    if (!directSpecifiers.size)
+        return [];
+    const reached = projectsReaching(tree, graph, new Set(directSpecifiers.keys()));
+    const findings = [];
+    for (const root of [...reached.keys()].sort()) {
+        const alias = reached.get(root) ?? null;
+        for (const name of PROJECT_TSCONFIGS) {
+            const configPath = joinPathFragments(root, name);
+            const resolution = effectiveModuleResolution(tree, configPath);
+            if (!resolution || !LEGACY_RESOLUTIONS.has(resolution))
+                continue;
+            findings.push({ configPath, resolution, specifier: directSpecifiers.get(root) ?? null, alias });
+        }
+    }
+    return findings;
+};
+const ETHLETE_SUBPATH = /^@ethlete\/[^/]+\/./;
+/**
+ * Records a follow-up for every node-resolving project tsconfig whose project imports an `@ethlete/*` subpath
+ * (`@ethlete/query/testing`, `@ethlete/query-devtools/lazy`, ...), directly or through a workspace path alias.
+ * Runs after the rewrites, so it also sees the subpaths the migration itself adds.
+ */
+export const reportLegacyModuleResolution = (tree, scope, report) => {
+    const files = [];
+    scope.visit(tree, (filePath) => files.push(filePath));
+    for (const { configPath, resolution, specifier, alias } of findLegacyModuleResolutions(tree, createModuleGraph(tree), files, (candidate) => ETHLETE_SUBPATH.test(candidate))) {
+        report.addFollowUp({
+            title: 'Project resolves modules with `node`, which cannot find `@ethlete/*` subpaths',
+            summary: alias
+                ? `${configPath} resolves modules with \`${resolution}\` and reaches an \`@ethlete/*\` subpath through \`${alias}\`.`
+                : `${configPath} resolves modules with \`${resolution}\` and imports \`${specifier}\`.`,
+            action: '`moduleResolution: node` (`node10`) ignores the `exports` map of the `@ethlete/*` packages, so subpath imports like `@ethlete/query-devtools/lazy` do not resolve - also when they sit in another project this one imports through a path alias. Set `moduleResolution` to `bundler` (or `node16` / `nodenext`) in the listed tsconfig or the base config it inherits it from.',
+            locations: [{ filePath: configPath }],
+            source: 'module-resolution',
+        });
+    }
+};
+//# sourceMappingURL=module-resolution.js.map