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

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

@@ -1,45 +1,80 @@
-import { visitNotIgnoredFiles } from '@nx/devkit';
 import * as ts from 'typescript';
-import { createSourceFile, getLineNumberFromPosition } from './shared.js';
-export const removeDevtoolsUsage = (tree) => {
-    const updatedFiles = [];
-    visitNotIgnoredFiles(tree, '', (filePath) => {
-        if (!filePath.endsWith('.ts') && !filePath.endsWith('.html')) {
+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')) {
             return;
         }
         const content = tree.read(filePath, 'utf-8');
-        if (!content) {
+        if (!content?.includes('@ethlete/query')) {
             return;
         }
-        if (filePath.endsWith('.ts')) {
-            if (!content.includes('provideQueryClientForDevtools') && !content.includes('QueryDevtoolsComponent')) {
-                return;
-            }
-            const withoutProviders = removeProvideQueryClientForDevtools(content);
-            const nextContent = removeQueryDevtoolsComponent(withoutProviders);
-            if (nextContent !== content) {
-                tree.write(filePath, nextContent);
-                updatedFiles.push(filePath);
-            }
+        findRemovedExperimentalQueryHelpers(createSourceFile(content, filePath)).forEach(({ name, line }) => {
+            report.addWarning({
+                title: `Replace the removed helper ${name}`,
+                summary: `\`${name}\` came from the pre-v3 \`ExperimentalQuery\` namespace and is no longer exported by \`@ethlete/query\`, so this import does not compile. The migration does not rewrite it.`,
+                action: REMOVED_EXPERIMENTAL_QUERY_HELPERS[name],
+                locations: [{ filePath, line }],
+                source: 'cleanup-migration',
+                dedupeKey: `removed-experimental-helper:${filePath}:${name}`,
+            });
+        });
+    });
+};
+/**
+ * Points existing devtools usage at the v3 components instead of deleting it.
+ *
+ * Both versions render `<et-query-devtools>`, so templates need no change at all - only the provider
+ * call and the component's import move. Stripping the markup (as this phase used to) threw away
+ * something that would have kept working, and left every migrated app without devtools until someone
+ * noticed they were gone.
+ */
+export const migrateDevtoolsUsage = (tree, scope, report) => {
+    const updatedFiles = [];
+    const filesNeedingDevtoolsPackage = [];
+    scope.visit(tree, (filePath) => {
+        if (!filePath.endsWith('.ts')) {
             return;
         }
-        if (!content.includes('et-query-devtools')) {
+        const content = tree.read(filePath, 'utf-8');
+        if (!content ||
+            (!content.includes('provideQueryClientForDevtools') && !content.includes('QueryDevtoolsComponent'))) {
             return;
         }
-        const nextContent = removeDevtoolsFromHtml(content);
-        if (nextContent !== content) {
-            tree.write(filePath, nextContent);
-            updatedFiles.push(filePath);
+        const { content: nextContent, importsComponent } = migrateDevtoolsInFile(content);
+        if (nextContent === content) {
+            return;
+        }
+        tree.write(filePath, nextContent);
+        updatedFiles.push(filePath);
+        if (importsComponent) {
+            filesNeedingDevtoolsPackage.push(filePath);
         }
     });
-    if (updatedFiles.length > 0) {
-        console.log('\n✅ Removed legacy query devtools usage in:');
-        updatedFiles.forEach((filePath) => console.log(`   - ${filePath}`));
+    if (updatedFiles.length === 0) {
+        return;
+    }
+    console.log('\n✅ Migrated query devtools usage to v3 in:');
+    updatedFiles.forEach((filePath) => console.log(`   - ${filePath}`));
+    if (filesNeedingDevtoolsPackage.length > 0) {
+        // The component moved packages, which is the one part of this rewrite that can fail outside the
+        // file being edited: an app that only ever depended on `@ethlete/query` now needs
+        // `@ethlete/query-devtools`.
+        report.addManualReview({
+            title: 'Add @ethlete/query-devtools for the query devtools',
+            summary: '`QueryDevtoolsComponent` now lives in `@ethlete/query-devtools`. The imports were rewritten, but the package may not be a dependency of these projects yet.',
+            action: 'Run `yarn add @ethlete/query-devtools` where needed, then `yarn install` and re-lint the affected libs so the `@nx/dependency-checks` rule sees the new dependency.',
+            locations: filesNeedingDevtoolsPackage.map((filePath) => ({ filePath })),
+            source: 'cleanup-migration',
+            dedupeKey: 'devtools-package-dependency',
+        });
     }
 };
-export const replaceAnyQueryWithLegacy = (tree) => {
+export const replaceAnyQueryWithLegacy = (tree, scope) => {
     const updatedFiles = [];
-    visitNotIgnoredFiles(tree, '', (filePath) => {
+    scope.visit(tree, (filePath) => {
         if (!filePath.endsWith('.ts') || filePath.endsWith('.spec.ts')) {
             return;
         }
@@ -57,9 +92,10 @@ export const replaceAnyQueryWithLegacy = (tree) => {
         console.log(`\n✅ Replaced legacy AnyV2Query aliases in ${updatedFiles.length} files`);
     }
 };
-export const migrateEmptyPrepareCalls = (tree) => {
+export const migrateEmptyPrepareCalls = (tree, scope, report) => {
     const updatedFiles = [];
-    visitNotIgnoredFiles(tree, '', (filePath) => {
+    const graph = createModuleGraph(tree);
+    scope.visit(tree, (filePath) => {
         if (!filePath.endsWith('.ts') || filePath.endsWith('.spec.ts')) {
             return;
         }
@@ -67,7 +103,17 @@ export const migrateEmptyPrepareCalls = (tree) => {
         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);
@@ -77,42 +123,66 @@ export const migrateEmptyPrepareCalls = (tree) => {
         console.log(`\n✅ Migrated empty .prepare() calls in ${updatedFiles.length} files`);
     }
 };
-const removeProvideQueryClientForDevtools = (content) => {
-    return content
-        .replace(/,?\s*provideQueryClientForDevtools\([^)]*\)/g, '')
-        .replace(/\[\s*,/g, '[')
-        .replace(/,\s*\]/g, ']')
-        .replace(/\n\s*\n\s*\n/g, '\n\n');
-};
-const removeQueryDevtoolsComponent = (content) => {
-    const withoutImportsArray = removeQueryDevtoolsImportsFromMetadata(content);
-    return removeDevtoolsImports(withoutImportsArray);
+const migrateDevtoolsInFile = (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 (componentNames.length > 0) {
+        result = ensureNamedImports({
+            content: result,
+            importsNeeded: componentNames.map((name) => name === 'QueryDevtoolsComponent' ? name : `QueryDevtoolsComponent as ${name}`),
+            moduleSpecifier: '@ethlete/query-devtools',
+        });
+    }
+    return { content: result, importsComponent: componentNames.length > 0 };
 };
-const removeQueryDevtoolsImportsFromMetadata = (content) => {
+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()`.
+ *
+ * v3 registers every client and auth provider at once, so N per-client calls collapse to one. The
+ * 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, providerNames) => {
     const sourceFile = createSourceFile(content);
-    const replacements = [];
+    const calls = [];
     const visit = (node) => {
-        if (ts.isPropertyAssignment(node) &&
-            ts.isIdentifier(node.name) &&
-            node.name.text === 'imports' &&
-            ts.isArrayLiteralExpression(node.initializer)) {
-            const nextElements = node.initializer.elements.filter((element) => {
-                return !(ts.isIdentifier(element) && element.text === 'QueryDevtoolsComponent');
-            });
-            if (nextElements.length === node.initializer.elements.length) {
-                ts.forEachChild(node, visit);
-                return;
-            }
-            const replacement = `imports: [${nextElements.map((element) => element.getText(sourceFile)).join(', ')}]`;
-            replacements.push({
-                start: node.getStart(sourceFile),
-                end: node.getEnd(),
-                replacement,
-            });
+        if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && providerNames.has(node.expression.text)) {
+            calls.push(node);
         }
         ts.forEachChild(node, visit);
     };
     visit(sourceFile);
+    if (calls.length === 0) {
+        return content;
+    }
+    const replacements = calls.map((call, index) => {
+        const start = call.getStart(sourceFile);
+        const end = call.getEnd();
+        if (index === 0) {
+            return { start, end, replacement: 'provideQueryDevtools()' };
+        }
+        return { ...withSurroundingComma(content, start, end), replacement: '' };
+    });
     let result = content;
     replacements.sort((left, right) => right.start - left.start);
     replacements.forEach(({ start, end, replacement }) => {
@@ -120,37 +190,43 @@ const removeQueryDevtoolsImportsFromMetadata = (content) => {
     });
     return result;
 };
-const removeDevtoolsImports = (content) => {
+/** Widens a range to swallow the comma that separated the element from its neighbours. */
+const withSurroundingComma = (content, start, end) => {
+    let nextEnd = end;
+    while (nextEnd < content.length && /\s/.test(content[nextEnd]))
+        nextEnd += 1;
+    if (content[nextEnd] === ',') {
+        return { start, end: nextEnd + 1 };
+    }
+    let nextStart = start;
+    while (nextStart > 0 && /\s/.test(content[nextStart - 1]))
+        nextStart -= 1;
+    if (content[nextStart - 1] === ',') {
+        return { start: nextStart - 1, end };
+    }
+    return { start, end };
+};
+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) => {
-        return element.name.text !== 'QueryDevtoolsComponent' && element.name.text !== 'provideQueryClientForDevtools';
+    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);
     });
-    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());
-};
-const removeDevtoolsFromHtml = (content) => {
-    return content
-        .replace(/<et-query-devtools\s*\/>/g, '')
-        .replace(/<et-query-devtools[^>]*>[\s\S]*?<\/et-query-devtools>/g, '')
-        .replace(/\n\s*\n\s*\n/g, '\n\n');
+    return result;
 };
 const replaceAnyQueryInFile = (content) => {
     const sourceFile = createSourceFile(content);
@@ -180,48 +256,98 @@ const replaceAnyQueryInFile = (content) => {
     replacements.forEach(({ start, end, replacement }) => {
         result = result.slice(0, start) + replacement + result.slice(end);
     });
-    return removeAnyQueryFromImports(result);
+    return result;
 };
-const removeAnyQueryFromImports = (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;
-        }
-    });
-    if (!importNode?.importClause?.namedBindings || !ts.isNamedImports(importNode.importClause.namedBindings)) {
-        return 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;
     }
-    const nextElements = importNode.importClause.namedBindings.elements.filter((element) => {
-        return element.name.text !== 'AnyV2Query' && element.name.text !== 'AnyV2QueryCreator';
-    });
-    const names = nextElements.map((element) => element.getText(sourceFile));
-    if (!names.includes('AnyLegacyQuery')) {
-        names.push('AnyLegacyQuery');
+    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) };
     }
-    if (!names.includes('AnyLegacyQueryCreator')) {
-        names.push('AnyLegacyQueryCreator');
+    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 nextImport = `import { ${names.sort().join(', ')} } from '@ethlete/query';`;
-    return content.slice(0, importNode.getStart(sourceFile)) + nextImport + content.slice(importNode.getEnd());
+    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 transformEmptyPrepareCalls = (content) => {
-    const sourceFile = createSourceFile(content);
+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),
                 });
             }
         }
@@ -233,10 +359,6 @@ const transformEmptyPrepareCalls = (content) => {
     replacements.forEach(({ start, end, replacement }) => {
         result = result.slice(0, start) + replacement + result.slice(end);
     });
-    return result;
-};
-export const describeTemplateLine = (content, position, suffix) => {
-    const lineNumber = getLineNumberFromPosition(content, position);
-    return `${lineNumber} (${suffix})`;
+    return { content: result, unresolved };
 };
 //# sourceMappingURL=cleanup-migration.js.map

package/generators/migrate-to-query-v3/http-client-check.js

@@ -0,0 +1,93 @@
+import { getLineNumberFromPosition } from './shared.js';
+const APP_CONFIG_MARKERS = ['bootstrapApplication(', 'ApplicationConfig', 'provideServerRendering('];
+/**
+ * Flags the v2 default-header APIs, which the client migration drops on the floor.
+ *
+ * `setDefaultHeaders` is not cosmetic - an API token or a preview credential lives there, so losing
+ * it means every request goes out unauthenticated. v3 has a home for it (`headers` on
+ * `createQueryClient`), but the call sites are imperative and scattered, so this is a pointer rather
+ * than a rewrite.
+ */
+export const reportDefaultHeaderUsages = (tree, report, scope) => {
+    const locations = [];
+    scope.visit(tree, (filePath) => {
+        if (!filePath.endsWith('.ts')) {
+            return;
+        }
+        const content = tree.read(filePath, 'utf-8');
+        if (!content) {
+            return;
+        }
+        for (const marker of ['setDefaultHeaders', 'globalHeaders']) {
+            const index = content.indexOf(marker);
+            if (index >= 0) {
+                locations.push({ filePath, line: getLineNumberFromPosition(content, index) });
+            }
+        }
+    });
+    if (locations.length === 0) {
+        return;
+    }
+    report.addWarning({
+        title: 'Move default headers onto the query client',
+        summary: 'This workspace sets client-wide headers through the v2 `setDefaultHeaders` / `globalHeaders` API, which `createQueryClient` does not have. Left as is, those headers are simply not sent.',
+        action: 'Pass `headers` to `createQueryClient` - a function form re-reads on every request, so a signal can drive it. `refreshQueriesInUse: true` becomes `injectMyClient().refreshQueriesInUse()` after the value changes.',
+        locations,
+        source: 'http-client-check',
+        dedupeKey: 'default-headers',
+    });
+};
+/**
+ * Flags applications that will build cleanly and then fail on their first request.
+ *
+ * The v2 client shipped its own transport; v3 does `inject(HttpClient)`. An app that never needed
+ * `provideHttpClient()` therefore keeps compiling after the migration and dies at runtime instead -
+ * the one failure mode a codemod should never leave behind silently.
+ */
+export const reportMissingHttpClientProviders = (tree, report, scope) => {
+    const appConfigFiles = [];
+    const filesWithProvider = [];
+    const filesWithUploadProgress = [];
+    scope.visit(tree, (filePath) => {
+        if (!filePath.endsWith('.ts') || filePath.endsWith('.spec.ts')) {
+            return;
+        }
+        const content = tree.read(filePath, 'utf-8');
+        if (!content) {
+            return;
+        }
+        if (content.includes('provideHttpClient(')) {
+            filesWithProvider.push(filePath);
+        }
+        const markerIndex = APP_CONFIG_MARKERS.map((marker) => content.indexOf(marker)).find((index) => index >= 0);
+        if (markerIndex !== undefined) {
+            appConfigFiles.push({ filePath, line: getLineNumberFromPosition(content, markerIndex) });
+        }
+        const progressIndex = content.indexOf('reportProgress');
+        if (progressIndex >= 0) {
+            filesWithUploadProgress.push({ filePath, line: getLineNumberFromPosition(content, progressIndex) });
+        }
+    });
+    if (appConfigFiles.length > 0 && filesWithProvider.length === 0) {
+        report.addWarning({
+            title: 'Add provideHttpClient() to the application providers',
+            summary: 'v3 queries run on Angular’s `HttpClient`, but no `provideHttpClient()` was found. The app compiles and then throws on the first request - `@ethlete/query` never provides it, that is the application’s job.',
+            action: 'Add `provideHttpClient()` to every app config that uses a query client. If anything relies on upload progress, use `provideHttpClient(withXhr())` - on Angular ≥ 22 the default is fetch, which emits no upload progress events.',
+            locations: appConfigFiles,
+            source: 'http-client-check',
+            dedupeKey: 'missing-provide-http-client',
+        });
+        return;
+    }
+    if (filesWithUploadProgress.length > 0) {
+        report.addManualReview({
+            title: 'Confirm the HttpClient backend supports upload progress',
+            summary: 'Queries in this workspace set `reportProgress`. On Angular ≥ 22 `provideHttpClient()` defaults to the fetch backend, which never emits upload progress events, so those queries would report download progress only.',
+            action: 'Switch the affected app to `provideHttpClient(withXhr())`, or drop `reportProgress` where it is unused.',
+            locations: filesWithUploadProgress,
+            source: 'http-client-check',
+            dedupeKey: 'upload-progress-backend',
+        });
+    }
+};
+//# sourceMappingURL=http-client-check.js.map