@ethlete/query 6.0.0-next.5 → 6.0.0-next.50

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

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

@@ -1,10 +1,19 @@
-import { visitNotIgnoredFiles } from '@nx/devkit';
 import * as ts from 'typescript';
 import { createSourceFile, ensureAngularCoreImports, getIndentation, getLineNumber, getLineNumberFromPosition, } from './shared.js';
-export const migrateLegacyPrepareCalls = (tree, report) => {
+/** `default` can never be a class name, so it cannot collide with a named class of the same file. */
+const ANONYMOUS_DEFAULT_CLASS_KEY = 'default';
+const getClassKey = (node) => node.name?.text ?? ANONYMOUS_DEFAULT_CLASS_KEY;
+/** Contexts that already have an injector of their own, so the call site needs no rewrite. */
+const CONTEXTS_WITH_INJECTOR = [
+    'queryComputed',
+    'injection-context',
+    'class-field',
+    'constructor',
+];
+export const migrateLegacyPrepareCalls = (tree, report, scope) => {
     console.log('\n🔍 Checking for legacy query creator usages...');
     const allUsages = [];
-    visitNotIgnoredFiles(tree, '', (filePath) => {
+    scope.visit(tree, (filePath) => {
         if (!filePath.endsWith('.ts') || filePath.endsWith('.spec.ts')) {
             return;
         }
@@ -27,7 +36,7 @@ export const migrateLegacyPrepareCalls = (tree, report) => {
         console.log(`   - ${context}: ${count} usages`);
     });
     console.log('\n🔍 Detecting polling usage...');
-    const pollingInfo = detectPollingUsage(tree);
+    const pollingInfo = detectPollingUsage(tree, scope);
     if (pollingInfo.size > 0) {
         console.log(`\n⚠️ Found ${pollingInfo.size} queries with polling:`);
         pollingInfo.forEach((info) => {
@@ -38,7 +47,7 @@ export const migrateLegacyPrepareCalls = (tree, report) => {
     }
     const classInjectors = findOrCreateInjectorMembers(tree, allUsages);
     createInjectorMembers(tree, classInjectors);
-    transformLegacyCreatorPrepareCalls(tree, classInjectors, pollingInfo);
+    transformLegacyCreatorPrepareCalls(tree, classInjectors, pollingInfo, scope);
     reportManualReviewLocations(tree, allUsages, report);
 };
 const findLegacyCreatorUsages = (content, filePath) => {
@@ -99,32 +108,88 @@ const findLegacyCreatorNames = (sourceFile) => {
     visit(sourceFile);
     return names;
 };
+/** Helpers that run their callback inside an injection context, so a `prepare()` in one needs nothing. */
+const CONTEXT_PROVIDING_CALLEES = new Set([
+    'runInInjectionContext',
+    'queryComputed',
+    'queryComputedTillTruthy',
+    'queryArrayComputed',
+]);
+/**
+ * Array methods, which call back synchronously in the caller's own context. Matched only on a property
+ * access (`items.map(…)`) - the bare-identifier form is an RxJS operator, whose callback runs later.
+ */
+const TRANSPARENT_ARRAY_METHODS = new Set([
+    'map',
+    'flatMap',
+    'filter',
+    'forEach',
+    'find',
+    'findLast',
+    'findIndex',
+    'some',
+    'every',
+    'reduce',
+    'reduceRight',
+    'sort',
+    'flat',
+]);
+const isCallbackFunction = (node) => ts.isArrowFunction(node) || ts.isFunctionExpression(node) || ts.isFunctionDeclaration(node);
+/** The call a function literal is being passed to, if it is an argument rather than a value. */
+const getCallbackHost = (node) => {
+    const parent = node.parent;
+    if (!ts.isCallExpression(parent) || !parent.arguments.some((argument) => argument === node)) {
+        return undefined;
+    }
+    return parent;
+};
+const isContextProvidingCallback = (node) => {
+    const host = getCallbackHost(node);
+    if (!host) {
+        return false;
+    }
+    if (ts.isIdentifier(host.expression)) {
+        return CONTEXT_PROVIDING_CALLEES.has(host.expression.text);
+    }
+    return ts.isPropertyAccessExpression(host.expression) && host.expression.name.text === 'runInContext';
+};
+const isTransparentCallback = (node) => {
+    const host = getCallbackHost(node);
+    return (!!host && ts.isPropertyAccessExpression(host.expression) && TRANSPARENT_ARRAY_METHODS.has(host.expression.name.text));
+};
+/**
+ * Classifies the **innermost** function boundary the call sits behind, not the first structural ancestor.
+ * The difference is the whole point: `effect(() => prepare())` in a constructor and
+ * `computed(() => prepare())` at a class field both run long after the context that created them, so they
+ * need an injector just like a plain method does - reading the constructor or the field as the answer
+ * skipped exactly the call sites that go on to throw ET950.
+ */
 const determineUsageContext = (node) => {
     let current = node;
     while (current) {
-        if (ts.isArrowFunction(current) || ts.isFunctionExpression(current)) {
-            const parent = current.parent;
-            if (ts.isCallExpression(parent) &&
-                ts.isIdentifier(parent.expression) &&
-                parent.expression.text === 'queryComputed') {
-                return 'queryComputed';
+        if (isCallbackFunction(current)) {
+            if (isContextProvidingCallback(current)) {
+                const host = getCallbackHost(current);
+                const callee = host && ts.isIdentifier(host.expression) ? host.expression.text : undefined;
+                return callee?.startsWith('query') ? 'queryComputed' : 'injection-context';
+            }
+            if (!isTransparentCallback(current)) {
+                return isInsideClass(current) ? 'method' : 'function';
             }
         }
+        // Reached without crossing a callback: the call really does run while the class is being built, which
+        // is an injection context.
         if (ts.isConstructorDeclaration(current)) {
             return 'constructor';
         }
-        if (ts.isMethodDeclaration(current)) {
+        if (ts.isMethodDeclaration(current) ||
+            ts.isGetAccessorDeclaration(current) ||
+            ts.isSetAccessorDeclaration(current)) {
             return 'method';
         }
         if (ts.isPropertyDeclaration(current)) {
             return 'class-field';
         }
-        if (ts.isFunctionDeclaration(current)) {
-            return 'function';
-        }
-        if ((ts.isArrowFunction(current) || ts.isFunctionExpression(current)) && !isInsideClass(current)) {
-            return 'function';
-        }
         current = current.parent;
     }
     return 'unknown';
@@ -178,7 +243,7 @@ const findOrCreateInjectorMembers = (tree, usages) => {
     const classInjectors = new Map();
     const usagesByFile = new Map();
     usages.forEach((usage) => {
-        if (['queryComputed', 'class-field', 'constructor'].includes(usage.context)) {
+        if (CONTEXTS_WITH_INJECTOR.includes(usage.context)) {
             return;
         }
         if (!usagesByFile.has(usage.filePath)) {
@@ -203,7 +268,7 @@ const findClassesNeedingInjector = (sourceFile, usages) => {
     const filePath = usages[0]?.filePath ?? sourceFile.fileName;
     const visit = (node) => {
         if (ts.isClassDeclaration(node)) {
-            const className = node.name?.text ?? 'UnnamedClass';
+            const className = getClassKey(node);
             const usagesInClass = usages.filter((usage) => {
                 return usage.position.start >= node.getStart(sourceFile) && usage.position.end <= node.getEnd();
             });
@@ -269,7 +334,7 @@ const addInjectorMemberToClass = (content, classInfo) => {
     const sourceFile = createSourceFile(content);
     let targetClass;
     const visit = (node) => {
-        if (ts.isClassDeclaration(node) && node.name?.text === classInfo.className) {
+        if (ts.isClassDeclaration(node) && getClassKey(node) === classInfo.className) {
             targetClass = node;
         }
         ts.forEachChild(node, visit);
@@ -280,10 +345,10 @@ const addInjectorMemberToClass = (content, classInfo) => {
     }
     const classBodyStart = targetClass.members.length > 0 ? targetClass.members[0].getStart(sourceFile) : targetClass.getEnd() - 1;
     const indentation = getIndentation(content, classBodyStart);
-    const injectorMember = `${indentation}private ${classInfo.injectorMemberName} = inject(Injector);\n\n`;
+    const injectorMember = `private ${classInfo.injectorMemberName} = inject(Injector);\n\n${indentation}`;
     return content.slice(0, classBodyStart) + injectorMember + content.slice(classBodyStart);
 };
-const transformLegacyCreatorPrepareCalls = (tree, classInjectors, pollingInfo) => {
+const transformLegacyCreatorPrepareCalls = (tree, classInjectors, pollingInfo, scope) => {
     const updatedFiles = [];
     const filesByPath = new Map();
     classInjectors.forEach((classInfo) => {
@@ -292,7 +357,7 @@ const transformLegacyCreatorPrepareCalls = (tree, classInjectors, pollingInfo) =
         }
         filesByPath.get(classInfo.filePath).push(classInfo);
     });
-    visitNotIgnoredFiles(tree, '', (filePath) => {
+    scope.visit(tree, (filePath) => {
         if (!filePath.endsWith('.ts') || filePath.endsWith('.spec.ts') || filesByPath.has(filePath)) {
             return;
         }
@@ -343,19 +408,14 @@ const transformPrepareCallsInFile = (content, classes, pollingInfo) => {
                     return;
                 }
                 const context = determineUsageContext(node);
-                if (['queryComputed', 'constructor', 'class-field'].includes(context)) {
+                if (CONTEXTS_WITH_INJECTOR.includes(context)) {
                     ts.forEachChild(node, visit);
                     return;
                 }
                 const containingClass = findContainingClass(node);
                 const containingFunction = findContainingStandaloneFunction(node);
                 if (containingClass) {
-                    const className = containingClass.name?.text;
-                    if (!className) {
-                        ts.forEachChild(node, visit);
-                        return;
-                    }
-                    const injectorMember = classNameToInjector.get(className);
+                    const injectorMember = classNameToInjector.get(getClassKey(containingClass));
                     if (!injectorMember) {
                         ts.forEachChild(node, visit);
                         return;
@@ -419,7 +479,7 @@ const transformPrepareCallsInFile = (content, classes, pollingInfo) => {
         }
         injectorDeclarations.push({
             position: bodyStart,
-            text: `${getIndentation(content, bodyStart)}const ${injectorName} = inject(Injector);\n`,
+            text: `const ${injectorName} = inject(Injector);\n${getIndentation(content, bodyStart)}`,
         });
     });
     injectorDeclarations.sort((left, right) => right.position - left.position);
@@ -536,7 +596,7 @@ const transformSinglePrepareCall = (callNode, injectorReference, sourceFile, pol
     }
     nextArgumentProperties.push(`injector: ${injectorReference}`);
     const queryVariableName = findQueryVariableNameForPrepareCall(callNode, sourceFile);
-    const addDestroyOnResponse = shouldAddDestroyOnResponse(queryVariableName, pollingInfo);
+    const addDestroyOnResponse = shouldAddDestroyOnResponse(queryVariableName, pollingInfo, isDiscardedPrepareCall(callNode));
     if (existingConfig && ts.isObjectLiteralExpression(existingConfig.initializer)) {
         const configProperties = [];
         existingConfig.initializer.properties.forEach((property) => {
@@ -569,7 +629,7 @@ const transformSinglePrepareCall = (callNode, injectorReference, sourceFile, pol
             : `{\n  ${nextArgumentProperties.join(',\n  ')}\n}`;
     return `${creatorName}.prepare(${nextArgumentString})`;
 };
-const findQueryVariableNameForPrepareCall = (prepareCallNode, sourceFile) => {
+const findQueryVariableNameForPrepareCall = (prepareCallNode, _sourceFile) => {
     let parent = prepareCallNode.parent;
     while (parent) {
         if (ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name)) {
@@ -663,9 +723,9 @@ const containsInjectCall = (node) => {
     visit(node);
     return hasInject;
 };
-const detectPollingUsage = (tree) => {
+const detectPollingUsage = (tree, scope) => {
     const pollingInfo = new Map();
-    visitNotIgnoredFiles(tree, '', (filePath) => {
+    scope.visit(tree, (filePath) => {
         if (filePath.endsWith('.spec.ts')) {
             return;
         }
@@ -717,8 +777,7 @@ const getQueryVariableName = (expression) => {
             return currentExpression.text;
         }
         if (ts.isPropertyAccessExpression(currentExpression)) {
-            currentExpression = currentExpression.expression;
-            continue;
+            return currentExpression.name.text;
         }
         if (ts.isCallExpression(currentExpression)) {
             currentExpression = currentExpression.expression;
@@ -764,9 +823,39 @@ const detectPollingInTemplate = (content, filePath, pollingInfo) => {
         }
     }
 };
-const shouldAddDestroyOnResponse = (queryVariableName, pollingInfo) => {
+/**
+ * Whether the prepared query is thrown away - `legacyGetUsers.prepare().execute()` as a statement, with
+ * nothing holding on to it. Chained `.poll()` disqualifies it: that query is meant to keep running.
+ */
+const isDiscardedPrepareCall = (callNode) => {
+    let current = callNode;
+    while (current.parent) {
+        const parent = current.parent;
+        if (ts.isParenthesizedExpression(parent) || ts.isAwaitExpression(parent) || ts.isNonNullExpression(parent)) {
+            current = parent;
+            continue;
+        }
+        if (ts.isPropertyAccessExpression(parent) && parent.expression === current) {
+            if (parent.name.text === 'poll') {
+                return false;
+            }
+            current = parent;
+            continue;
+        }
+        // Only a chained call keeps it discarded; being an *argument* means something else receives the query.
+        if (ts.isCallExpression(parent) && parent.expression === current) {
+            current = parent;
+            continue;
+        }
+        return ts.isExpressionStatement(parent);
+    }
+    return false;
+};
+const shouldAddDestroyOnResponse = (queryVariableName, pollingInfo, isDiscarded) => {
     if (!queryVariableName) {
-        return false;
+        // A discarded query is the one case where nothing else can clean it up: no variable for a container
+        // to hold, no caller to destroy it. That is exactly what `destroyOnResponse` is for.
+        return isDiscarded;
     }
     return !pollingInfo.get(queryVariableName)?.hasPolling;
 };