@ethlete/query 6.0.0-next.52 → 6.0.0-next.54

package/generators/migrate-from-ngrx-toolkit/consumers.js

@@ -8,6 +8,7 @@ export const CONSUMER_TASK = {
     UNCONVERTED_ACTION_GROUP: 'NTK-UNCONVERTED-ACTION-GROUP',
     SELECT_BY_ACTION_ID: 'NTK-SELECT-BY-ACTION-ID',
     AUTH_INTERCEPTOR: 'NTK-AUTH-INTERCEPTOR',
+    FACADE_ON: 'NTK-FACADE-ON',
 };
 const defineConsumerTasks = (report) => {
     report.define(CONSUMER_TASK.UNSUPPORTED_IMPORT, {
@@ -16,12 +17,16 @@ const defineConsumerTasks = (report) => {
     });
     report.define(CONSUMER_TASK.UNCONVERTED_ACTION_GROUP, {
         title: 'Consumer types name an action group that is still on the toolkit',
-        action: 'The file was left on `@tomtomb/ngrx-toolkit` because a `MappedEntityState` / `ActionCallArgs` type names an action group whose feature was not converted. Resolve that feature’s task, then re-run the generator.',
+        action: 'The file was left on `@tomtomb/ngrx-toolkit` because a `MappedEntityState` / `ActionCallArgs` type names an action group whose feature was not converted. Until then the file does not typecheck where it takes handles from facades that were migrated: the interop `MappedEntityState` has no `isPolling$`, `type$` or `entityId$`, and other generics. Resolve that feature’s task, then re-run the generator.',
     });
     report.define(CONSUMER_TASK.SELECT_BY_ACTION_ID, {
         title: 'Handle looked up by action id',
         action: 'The interop has no action ids. Pass the args instead and look the handle up with `toolkitSelect(creator, args, { injector })` - equal args return the handle `toolkitCall` created.',
     });
+    report.define(CONSUMER_TASK.FACADE_ON, {
+        title: 'Facade `on()` / `once()` call on a migrated facade',
+        action: 'The migrated facade has no `on()` / `once()`, and the v3 creators have no `.success` / `.failure` actions, so the call does not typecheck. Rewrite it by hand: react to the `response$` / `error$` of the handle the facade method returns, or subscribe to the creator’s result.',
+    });
     report.define(CONSUMER_TASK.AUTH_INTERCEPTOR, {
         title: 'HTTP interceptor attaches the bearer token',
         action: 'v3 secure creators already send the token, so this interceptor sends it twice, and it adds it to every other `HttpClient` call too - third-party hosts included. Delete it and its registration. Requests it skipped must use public creators: pass their prefixes as `--publicRoutes` and re-run.',
@@ -416,8 +421,70 @@ const findInterceptors = (tree, inScope, filePath, content) => {
     visit(sourceFile);
     return tasks;
 };
+const migratedFacadeNames = (graph, migratedFacades, filePath, sourceFile) => {
+    const names = new Set();
+    for (const statement of sourceFile.statements) {
+        if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier))
+            continue;
+        const bindings = statement.importClause?.namedBindings;
+        if (!bindings || !ts.isNamedImports(bindings))
+            continue;
+        for (const element of bindings.elements) {
+            const imported = element.propertyName?.text ?? element.name.text;
+            const declaringFile = graph.findDeclaringFile(filePath, statement.moduleSpecifier.text, imported);
+            if (declaringFile && migratedFacades.has(declaringFile))
+                names.add(element.name.text);
+        }
+    }
+    return names;
+};
+const findFacadeEventCalls = (graph, migratedFacades, filePath, content) => {
+    if (!/\.(on|once)\s*\(/.test(content))
+        return [];
+    const sourceFile = createSourceFile(content, filePath);
+    const facadeNames = migratedFacadeNames(graph, migratedFacades, filePath, sourceFile);
+    if (facadeNames.size === 0)
+        return [];
+    const isFacadeType = (type) => !!type && ts.isTypeReferenceNode(type) && ts.isIdentifier(type.typeName) && facadeNames.has(type.typeName.text);
+    const isFacadeInject = (node) => !!node && isCall(node, 'inject') && !!node.arguments[0] && facadeNames.has(node.arguments[0].getText(sourceFile));
+    const bound = new Set();
+    const collect = (node) => {
+        if ((ts.isPropertyDeclaration(node) || ts.isParameter(node) || ts.isVariableDeclaration(node)) &&
+            ts.isIdentifier(node.name) &&
+            (isFacadeType(node.type) || isFacadeInject(node.initializer))) {
+            bound.add(node.name.text);
+        }
+        ts.forEachChild(node, collect);
+    };
+    collect(sourceFile);
+    const isFacade = (receiver) => {
+        if (isFacadeInject(receiver))
+            return true;
+        if (ts.isIdentifier(receiver))
+            return bound.has(receiver.text);
+        return (ts.isPropertyAccessExpression(receiver) &&
+            receiver.expression.kind === ts.SyntaxKind.ThisKeyword &&
+            bound.has(receiver.name.text));
+    };
+    const tasks = [];
+    const visit = (node) => {
+        if (ts.isCallExpression(node) &&
+            ts.isPropertyAccessExpression(node.expression) &&
+            ['on', 'once'].includes(node.expression.name.text) &&
+            isFacade(node.expression.expression)) {
+            tasks.push({
+                id: CONSUMER_TASK.FACADE_ON,
+                summary: `${code(node.getText(sourceFile).replace(/\s+/g, ' '))} listens to toolkit actions the migrated facade no longer emits.`,
+                locations: [{ filePath, line: lineOf(sourceFile, node.getStart(sourceFile)) }],
+            });
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return tasks;
+};
 /** Runs the consumer side of the migration on every scoped file that still imports `@tomtomb/ngrx-toolkit`. */
-export const migrateToolkitConsumers = (tree, graph, inScope, report) => {
+export const migrateToolkitConsumers = (tree, graph, inScope, report, migratedFacades) => {
     defineConsumerTasks(report);
     const stats = {
         filesRewritten: 0,
@@ -434,6 +501,7 @@ export const migrateToolkitConsumers = (tree, graph, inScope, report) => {
         const interceptors = findInterceptors(tree, inScope, filePath, content);
         interceptors.forEach((task) => report.add(task));
         stats.interceptorsFound += interceptors.length;
+        findFacadeEventCalls(graph, migratedFacades, filePath, content).forEach((task) => report.add(task));
         if (!content.includes(TOOLKIT_MODULE))
             continue;
         const result = rewriteConsumer(tree, graph, filePath, content);

package/generators/migrate-from-ngrx-toolkit/migration.js

@@ -112,7 +112,8 @@ export const migrateToolkitStores = (tree, options, report) => {
         ready.push(feature);
     }
     const removal = removeFeatureStores(tree, graph, inScope, ready, report);
-    const consumers = migrateToolkitConsumers(tree, createModuleGraph(tree), inScope, report);
+    const migratedFacades = new Set(ready.map((feature) => feature.files.facade).filter((file) => !!file));
+    const consumers = migrateToolkitConsumers(tree, createModuleGraph(tree), inScope, report, migratedFacades);
     return {
         featuresFound: discovered.features.length,
         featuresConverted: ready.length,

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

@@ -1,5 +1,7 @@
 import * as ts from 'typescript';
-import { REMOVED_EXPERIMENTAL_QUERY_HELPERS, createSourceFile, ensureImportFromQuery, ensureNamedImports, findRemovedExperimentalQueryHelpers, } from './shared.js';
+import { createModuleGraph } from './module-graph.js';
+import { isShadowedInNestedScope } from './rename-symbols.js';
+import { REMOVED_EXPERIMENTAL_QUERY_HELPERS, createSourceFile, ensureImportFromQuery, ensureNamedImports, findRemovedExperimentalQueryHelpers, getLineNumber, printImportDeclaration, } from './shared.js';
 export const reportRemovedExperimentalQueryHelpers = (tree, scope, report) => {
     scope.visit(tree, (filePath) => {
         if (!filePath.endsWith('.ts')) {
@@ -90,8 +92,9 @@ export const replaceAnyQueryWithLegacy = (tree, scope) => {
         console.log(`\n✅ Replaced legacy AnyV2Query aliases in ${updatedFiles.length} files`);
     }
 };
-export const migrateEmptyPrepareCalls = (tree, scope) => {
+export const migrateEmptyPrepareCalls = (tree, scope, report) => {
     const updatedFiles = [];
+    const graph = createModuleGraph(tree);
     scope.visit(tree, (filePath) => {
         if (!filePath.endsWith('.ts') || filePath.endsWith('.spec.ts')) {
             return;
@@ -100,7 +103,17 @@ export const migrateEmptyPrepareCalls = (tree, scope) => {
         if (!content || !content.includes('.prepare()')) {
             return;
         }
-        const nextContent = transformEmptyPrepareCalls(content);
+        const { content: nextContent, unresolved } = transformEmptyPrepareCalls(tree, graph, filePath, content);
+        unresolved.forEach(({ line, receiver }) => {
+            report.addManualReview({
+                title: `Check the empty prepare() call on ${receiver}`,
+                summary: `The migration could not tell whether \`${receiver}\` is a legacy query creator, so it left \`${receiver}.prepare()\` as is. A legacy creator needs \`.prepare({})\` in v3.`,
+                action: `Change the call to \`${receiver}.prepare({})\` if \`${receiver}\` is a legacy query creator, otherwise leave it.`,
+                locations: [{ filePath, line }],
+                source: 'cleanup-migration',
+                dedupeKey: `unresolved-empty-prepare:${filePath}:${line}`,
+            });
+        });
         if (nextContent !== content) {
             tree.write(filePath, nextContent);
             updatedFiles.push(filePath);
@@ -111,31 +124,36 @@ export const migrateEmptyPrepareCalls = (tree, scope) => {
     }
 };
 const migrateDevtoolsInFile = (content) => {
-    const importsComponent = importsFromQuery(content, 'QueryDevtoolsComponent');
-    let result = replaceDevtoolsProviderCalls(content);
+    const componentNames = localNamesImportedFromQuery(content, 'QueryDevtoolsComponent');
+    const providerNames = new Set([
+        'provideQueryClientForDevtools',
+        ...localNamesImportedFromQuery(content, 'provideQueryClientForDevtools'),
+    ]);
+    let result = replaceDevtoolsProviderCalls(content, providerNames);
     const hasProvider = result.includes('provideQueryDevtools()');
     result = dropLegacyDevtoolsImports(result);
     if (hasProvider) {
         result = ensureImportFromQuery(result, ['provideQueryDevtools']);
     }
-    if (importsComponent) {
+    if (componentNames.length > 0) {
         result = ensureNamedImports({
             content: result,
-            importsNeeded: ['QueryDevtoolsComponent'],
+            importsNeeded: componentNames.map((name) => name === 'QueryDevtoolsComponent' ? name : `QueryDevtoolsComponent as ${name}`),
             moduleSpecifier: '@ethlete/query-devtools',
         });
     }
-    return { content: result, importsComponent };
-};
-const importsFromQuery = (content, name) => {
-    const sourceFile = createSourceFile(content);
-    return sourceFile.statements.some((node) => ts.isImportDeclaration(node) &&
-        ts.isStringLiteral(node.moduleSpecifier) &&
-        node.moduleSpecifier.text === '@ethlete/query' &&
-        !!node.importClause?.namedBindings &&
-        ts.isNamedImports(node.importClause.namedBindings) &&
-        node.importClause.namedBindings.elements.some((element) => element.name.text === name));
+    return { content: result, importsComponent: componentNames.length > 0 };
 };
+const queryImports = (sourceFile) => sourceFile.statements.filter((node) => ts.isImportDeclaration(node) &&
+    ts.isStringLiteral(node.moduleSpecifier) &&
+    node.moduleSpecifier.text === '@ethlete/query');
+const namedImportElements = (node) => node.importClause?.namedBindings && ts.isNamedImports(node.importClause.namedBindings)
+    ? node.importClause.namedBindings.elements
+    : [];
+const importedName = (element) => (element.propertyName ?? element.name).text;
+const localNamesImportedFromQuery = (content, name) => queryImports(createSourceFile(content)).flatMap((node) => namedImportElements(node)
+    .filter((element) => importedName(element) === name)
+    .map((element) => element.name.text));
 /**
  * Turns every `provideQueryClientForDevtools({ client, displayName })` into a single
  * `provideQueryDevtools()`.
@@ -144,13 +162,11 @@ const importsFromQuery = (content, name) => {
  * first call site keeps its position - it is already where the app wanted its devtools - and the
  * rest are removed along with the comma that separated them.
  */
-const replaceDevtoolsProviderCalls = (content) => {
+const replaceDevtoolsProviderCalls = (content, providerNames) => {
     const sourceFile = createSourceFile(content);
     const calls = [];
     const visit = (node) => {
-        if (ts.isCallExpression(node) &&
-            ts.isIdentifier(node.expression) &&
-            node.expression.text === 'provideQueryClientForDevtools') {
+        if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && providerNames.has(node.expression.text)) {
             calls.push(node);
         }
         ts.forEachChild(node, visit);
@@ -190,30 +206,27 @@ const withSurroundingComma = (content, start, end) => {
     }
     return { start, end };
 };
-/** Drops the v2 devtools names from the `@ethlete/query` import; both moved or were renamed. */
+const LEGACY_DEVTOOLS_IMPORTS = new Set(['QueryDevtoolsComponent', 'provideQueryClientForDevtools']);
+/** Drops the v2 devtools names from the `@ethlete/query` imports; both moved or were renamed. */
 const dropLegacyDevtoolsImports = (content) => {
     const sourceFile = createSourceFile(content);
-    let importNode;
-    ts.forEachChild(sourceFile, (node) => {
-        if (ts.isImportDeclaration(node) &&
-            ts.isStringLiteral(node.moduleSpecifier) &&
-            node.moduleSpecifier.text === '@ethlete/query') {
-            importNode = node;
+    const replacements = [];
+    for (const node of queryImports(sourceFile)) {
+        const elements = namedImportElements(node);
+        const nextElements = elements.filter((element) => !LEGACY_DEVTOOLS_IMPORTS.has(importedName(element)));
+        if (nextElements.length === elements.length) {
+            continue;
         }
-    });
-    if (!importNode?.importClause?.namedBindings || !ts.isNamedImports(importNode.importClause.namedBindings)) {
-        return content;
+        const nextImport = printImportDeclaration(node, sourceFile, nextElements.map((element) => element.getText(sourceFile)));
+        const end = !nextImport && content[node.getEnd()] === '\n' ? node.getEnd() + 1 : node.getEnd();
+        replacements.push({ start: node.getStart(sourceFile), end, replacement: nextImport });
     }
-    const nextElements = importNode.importClause.namedBindings.elements.filter((element) => element.name.text !== 'QueryDevtoolsComponent' && element.name.text !== 'provideQueryClientForDevtools');
-    if (nextElements.length === importNode.importClause.namedBindings.elements.length) {
-        return content;
-    }
-    if (nextElements.length === 0) {
-        const nextLineEnd = content[importNode.getEnd()] === '\n' ? importNode.getEnd() + 1 : importNode.getEnd();
-        return content.slice(0, importNode.getStart(sourceFile)) + content.slice(nextLineEnd);
-    }
-    const nextImport = `import { ${nextElements.map((element) => element.getText(sourceFile)).join(', ')} } from '@ethlete/query';`;
-    return content.slice(0, importNode.getStart(sourceFile)) + nextImport + content.slice(importNode.getEnd());
+    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 replaceAnyQueryInFile = (content) => {
     const sourceFile = createSourceFile(content);
@@ -245,20 +258,96 @@ const replaceAnyQueryInFile = (content) => {
     });
     return result;
 };
-const transformEmptyPrepareCalls = (content) => {
-    const sourceFile = createSourceFile(content);
+const findTopLevelVariable = (sourceFile, name) => {
+    for (const statement of sourceFile.statements) {
+        if (!ts.isVariableStatement(statement))
+            continue;
+        const declaration = statement.declarationList.declarations.find((candidate) => ts.isIdentifier(candidate.name) && candidate.name.text === name);
+        if (declaration)
+            return declaration;
+    }
+    return undefined;
+};
+const findNamedImport = (sourceFile, localName) => {
+    for (const statement of sourceFile.statements) {
+        if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier))
+            continue;
+        const element = namedImportElements(statement).find((candidate) => candidate.name.text === localName);
+        if (element)
+            return { specifier: statement.moduleSpecifier.text, importedName: importedName(element) };
+    }
+    return undefined;
+};
+const QUERY_CLIENT_CONSTRUCTORS = new Set(['V2QueryClient', 'QueryClient']);
+/**
+ * Classifies what a top-level binding of `sourceFile` holds: a query creator (a call to an
+ * `@ethlete/query` export such as `createLegacyQueryCreator`, or a method call on a v2 client), something
+ * provably unrelated, or `unknown` when the binding cannot be followed.
+ */
+const classifyBinding = (tree, graph, filePath, sourceFile, name, isClient, depth) => {
+    if (depth > 4)
+        return 'unknown';
+    const declaration = findTopLevelVariable(sourceFile, name);
+    if (declaration) {
+        const initializer = declaration.initializer;
+        if (isClient) {
+            return initializer &&
+                ts.isNewExpression(initializer) &&
+                ts.isIdentifier(initializer.expression) &&
+                QUERY_CLIENT_CONSTRUCTORS.has(initializer.expression.text) &&
+                findNamedImport(sourceFile, initializer.expression.text)?.specifier === '@ethlete/query'
+                ? 'query'
+                : 'foreign';
+        }
+        if (!initializer || !ts.isCallExpression(initializer))
+            return 'foreign';
+        const callee = initializer.expression;
+        if (ts.isIdentifier(callee)) {
+            return findNamedImport(sourceFile, callee.text)?.specifier === '@ethlete/query' ? 'query' : 'foreign';
+        }
+        if (ts.isPropertyAccessExpression(callee) && ts.isIdentifier(callee.expression)) {
+            return classifyBinding(tree, graph, filePath, sourceFile, callee.expression.text, true, depth + 1);
+        }
+        return 'foreign';
+    }
+    const binding = findNamedImport(sourceFile, name);
+    if (!binding || binding.specifier === '@ethlete/query')
+        return 'unknown';
+    const declaringFile = graph.findDeclaringFile(filePath, binding.specifier, binding.importedName);
+    if (!declaringFile)
+        return graph.isWorkspaceSpecifier(binding.specifier) ? 'unknown' : 'foreign';
+    const declaringContent = tree.read(declaringFile, 'utf-8');
+    if (!declaringContent)
+        return 'unknown';
+    return classifyBinding(tree, graph, declaringFile, createSourceFile(declaringContent, declaringFile), binding.importedName, isClient, depth + 1);
+};
+const classifyPrepareReceiver = (tree, graph, filePath, sourceFile, receiver) => {
+    if (!ts.isIdentifier(receiver) || isShadowedInNestedScope(receiver))
+        return 'unknown';
+    return classifyBinding(tree, graph, filePath, sourceFile, receiver.text, false, 0);
+};
+const transformEmptyPrepareCalls = (tree, graph, filePath, content) => {
+    const sourceFile = createSourceFile(content, filePath);
     const replacements = [];
+    const unresolved = [];
     const visit = (node) => {
-        if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression)) {
-            const propertyAccess = node.expression;
-            if (ts.isIdentifier(propertyAccess.name) &&
-                propertyAccess.name.text === 'prepare' &&
-                node.arguments.length === 0) {
-                const callText = content.slice(node.getStart(sourceFile), node.getEnd());
+        if (ts.isCallExpression(node) &&
+            ts.isPropertyAccessExpression(node.expression) &&
+            ts.isIdentifier(node.expression.name) &&
+            node.expression.name.text === 'prepare' &&
+            node.arguments.length === 0) {
+            const kind = classifyPrepareReceiver(tree, graph, filePath, sourceFile, node.expression.expression);
+            if (kind === 'query') {
                 replacements.push({
-                    start: node.getStart(sourceFile),
-                    end: node.getEnd(),
-                    replacement: callText.replace(/\.prepare\(\)/, '.prepare({})'),
+                    start: node.arguments.pos,
+                    end: node.arguments.end,
+                    replacement: '{}',
+                });
+            }
+            else if (kind === 'unknown') {
+                unresolved.push({
+                    line: getLineNumber(node, sourceFile),
+                    receiver: node.expression.expression.getText(sourceFile),
                 });
             }
         }
@@ -270,6 +359,6 @@ const transformEmptyPrepareCalls = (content) => {
     replacements.forEach(({ start, end, replacement }) => {
         result = result.slice(0, start) + replacement + result.slice(end);
     });
-    return result;
+    return { content: result, unresolved };
 };
 //# sourceMappingURL=cleanup-migration.js.map

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

@@ -24,6 +24,7 @@ export const createMigrationScope = (tree, options) => {
         return {
             visit: (targetTree, callback) => visitNotIgnoredFiles(targetTree, '', callback),
             describe: () => 'the whole workspace',
+            isScoped: false,
         };
     }
     return {
@@ -33,6 +34,7 @@ export const createMigrationScope = (tree, options) => {
             }
         },
         describe: () => roots.join(', '),
+        isScoped: true,
     };
 };
 //# sourceMappingURL=migration-scope.js.map

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

@@ -19,18 +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;
@@ -140,6 +148,8 @@ export const createModuleGraph = (tree) => {
     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);