@ethlete/query 6.0.0-next.6 → 6.0.0-next.60

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

@@ -1,27 +1,36 @@
 import { formatFiles } from '@nx/devkit';
-import { migrateEmptyPrepareCalls, removeDevtoolsUsage, replaceAnyQueryWithLegacy } from './cleanup-migration.js';
+import { migrateDevtoolsUsage, migrateEmptyPrepareCalls, replaceAnyQueryWithLegacy, reportRemovedExperimentalQueryHelpers, } from './cleanup-migration.js';
+import { reportDefaultHeaderUsages, reportMissingHttpClientProviders } from './http-client-check.js';
 import { migrateLegacyPrepareCalls } from './legacy-prepare-migration.js';
 import { createNewQueryCreators, updateLegacyCreatorImportsAndUsages } from './legacy-query-creator-migration.js';
+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, report);
     }
-    replaceAnyQueryWithLegacy(tree);
-    removeDevtoolsUsage(tree);
-    migrateEmptyPrepareCalls(tree);
-    migrateLegacyPrepareCalls(tree, report);
-    report.writeToTree(tree);
+    replaceAnyQueryWithLegacy(tree, scope);
+    migrateDevtoolsUsage(tree, scope, report);
+    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, scope.isScoped ? scope.describe() : undefined);
     report.printSummary();
     if (!schema.skipFormat) {
         await formatFiles(tree);

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

@@ -0,0 +1,165 @@
+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 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)
+            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;
+            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);
+            });
+        }
+        catch {
+            // A tsconfig we cannot parse just means fewer resolvable aliases, not a failed migration.
+        }
+    }
+    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) => {
+    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 { 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('.'))
+            return findCandidate(normalizePath(`${dirName(fromFile)}/${specifier}`));
+        for (const [pattern, targets] of tsConfigPaths.entries()) {
+            const wildcard = matchPathAlias(pattern, specifier);
+            if (wildcard === null)
+                continue;
+            for (const target of targets) {
+                const candidate = findCandidate(normalizePath(`${baseUrl ?? ''}/${target.replace('*', wildcard)}`));
+                if (candidate)
+                    return candidate;
+            }
+        }
+        return baseUrl === null ? null : findCandidate(normalizePath(`${baseUrl}/${specifier}`));
+    };
+    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 {
+        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);
+            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