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

package/generators/migrate-from-ngrx-toolkit/args-assignability.js

@@ -18,6 +18,12 @@ export type ToolkitSide = OptionalNullAsUndefined<{
 export type CreatorSide = OptionalNullAsUndefined<{
   [K in keyof CreatorArgs as K extends 'queryParams' | 'body' ? K : never]: CreatorArgs[K];
 }>;
+export type ToolkitRaw = {
+  [K in keyof ToolkitArgs as K extends 'params' ? 'queryParams' : K extends 'body' ? K : never]: ToolkitArgs[K];
+};
+export type CreatorRaw = {
+  [K in keyof CreatorArgs as K extends 'queryParams' | 'body' ? K : never]: CreatorArgs[K];
+};
 `;
 const COMPILER_OPTIONS = {
     strict: true,
@@ -59,14 +65,46 @@ const hasEveryKey = (checker, source, target, seen, depth) => {
         return true;
     seen.add(from);
     return checker.getPropertiesOfType(from).every((property) => {
-        const counterpart = checker.getPropertyOfType(to, property.name);
+        const counterpart = checker.getPropertiesOfType(to).find((each) => each.escapedName === property.escapedName);
         return (!!counterpart &&
             hasEveryKey(checker, checker.getTypeOfSymbol(property), checker.getTypeOfSymbol(counterpart), seen, depth + 1));
     });
 };
-export const toolkitArgsFitCreator = (tree, graph, toolkit, creator) => {
+const isOptional = (property) => !!(property.flags & ts.SymbolFlags.Optional);
+const describeType = (checker, type) => {
+    const text = `\`${checker.typeToString(type, undefined, ts.TypeFormatFlags.NoTruncation)}\``;
+    const declaration = (type.aliasSymbol ?? type.getSymbol())?.declarations?.[0];
+    return declaration ? `${text} from ${toTreePath(declaration.getSourceFile().fileName)}` : text;
+};
+const firstDifference = (checker, toolkit, creator, path, depth) => {
+    const from = checker.getNonNullableType(toolkit);
+    const to = checker.getNonNullableType(creator);
+    if (depth > MAX_DEPTH)
+        return null;
+    if (!isRecord(checker, from) || !isRecord(checker, to)) {
+        return checker.isTypeAssignableTo(from, to)
+            ? null
+            : `\`${path}\` is ${describeType(checker, to)} there and ${describeType(checker, from)} in the action`;
+    }
+    const creatorProperties = checker.getPropertiesOfType(to);
+    const toolkitProperties = checker.getPropertiesOfType(from);
+    for (const property of toolkitProperties) {
+        const name = `${path ? `${path}.` : ''}${property.name}`;
+        const counterpart = creatorProperties.find((each) => each.escapedName === property.escapedName);
+        if (!counterpart)
+            return `\`${name}\` is sent by the action but missing there`;
+        if (isOptional(property) && !isOptional(counterpart))
+            return `\`${name}\` is required there and optional in the action`;
+        const nested = firstDifference(checker, checker.getTypeOfSymbol(property), checker.getTypeOfSymbol(counterpart), name, depth + 1);
+        if (nested)
+            return nested;
+    }
+    const extra = creatorProperties.find((property) => !isOptional(property) && !toolkitProperties.some((each) => each.escapedName === property.escapedName));
+    return extra ? `\`${path ? `${path}.` : ''}${extra.name}\` is required there but not sent by the action` : null;
+};
+export const compareToolkitArgs = (tree, graph, toolkit, creator) => {
     if (toolkit.file === creator.file)
-        return false;
+        return { fits: false, difference: null };
     const appended = new Map([
         [toolkit.file, `\nexport type ${TOOLKIT_PROBE} = ${toolkit.typeText ?? '{}'};\n`],
         [creator.file, `\nexport type ${CREATOR_PROBE} = ${creator.typeText ?? '{}'};\n`],
@@ -125,16 +163,25 @@ export const toolkitArgsFitCreator = (tree, graph, toolkit, creator) => {
     const toolkitSide = typeOf('ToolkitSide');
     const creatorSide = typeOf('CreatorSide');
     if (!toolkitSide || !creatorSide)
-        return false;
-    if (containsAny(checker, toolkitSide, new Set(), 0) || containsAny(checker, creatorSide, new Set(), 0))
-        return false;
+        return { fits: false, difference: null };
+    if (containsAny(checker, toolkitSide, new Set(), 0) || containsAny(checker, creatorSide, new Set(), 0)) {
+        return { fits: false, difference: null };
+    }
     const keys = (type) => checker
         .getPropertiesOfType(type)
         .map((property) => property.name)
         .sort()
         .join(',');
-    return (keys(toolkitSide) === keys(creatorSide) &&
+    const fits = keys(toolkitSide) === keys(creatorSide) &&
         checker.isTypeAssignableTo(toolkitSide, creatorSide) &&
-        hasEveryKey(checker, toolkitSide, creatorSide, new Set(), 0));
+        hasEveryKey(checker, toolkitSide, creatorSide, new Set(), 0);
+    if (fits)
+        return { fits, difference: null };
+    const toolkitRaw = typeOf('ToolkitRaw');
+    const creatorRaw = typeOf('CreatorRaw');
+    return {
+        fits,
+        difference: toolkitRaw && creatorRaw ? firstDifference(checker, toolkitRaw, creatorRaw, '', 0) : null,
+    };
 };
 //# sourceMappingURL=args-assignability.js.map

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

@@ -17,7 +17,7 @@ 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. 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.',
+        action: 'A `MappedEntityState` / `ActionCallArgs` type names an action group whose feature was not converted. In a file that also names converted creators, only these types stay on the toolkit, as `ToolkitMappedEntityState` / `ToolkitActionCallArgs`. Otherwise the whole file was left on `@tomtomb/ngrx-toolkit`. 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',
@@ -96,34 +96,47 @@ const namedImportOf = (sourceFile, local) => {
 const isToolkitActionsFile = (tree, filePath) => !!filePath && filePath.endsWith('.actions.ts') && !!tree.read(filePath, 'utf-8')?.includes('createHttpActionGroup');
 const unconvertedTypeQueries = (tree, graph, filePath, sourceFile, handleTypeNames) => {
     const unconverted = [];
+    const unconvertedReferences = [];
+    let convertedReferences = 0;
     const resolveQuery = (query) => {
         const name = query.exprName;
         const local = ts.isIdentifier(name) ? name.text : ts.isIdentifier(name.left) ? name.left.text : null;
         const origin = local ? namedImportOf(sourceFile, local) : null;
         if (!origin || origin.namespace === ts.isIdentifier(name))
-            return;
+            return false;
         const declaringFile = origin.namespace
             ? graph.resolveFile(filePath, origin.specifier)
             : graph.findDeclaringFile(filePath, origin.specifier, origin.imported);
-        if (isToolkitActionsFile(tree, declaringFile))
-            unconverted.push(name.getText(sourceFile));
+        if (!isToolkitActionsFile(tree, declaringFile))
+            return false;
+        unconverted.push(name.getText(sourceFile));
+        return true;
     };
     const visit = (node) => {
         if (ts.isTypeReferenceNode(node) &&
             ts.isIdentifier(node.typeName) &&
             handleTypeNames.has(node.typeName.text) &&
             node.typeArguments) {
+            let queries = 0;
+            let unconvertedQueries = 0;
             const visitArgument = (inner) => {
-                if (ts.isTypeQueryNode(inner))
-                    resolveQuery(inner);
+                if (ts.isTypeQueryNode(inner)) {
+                    queries += 1;
+                    if (resolveQuery(inner))
+                        unconvertedQueries += 1;
+                }
                 ts.forEachChild(inner, visitArgument);
             };
             node.typeArguments.forEach(visitArgument);
+            if (unconvertedQueries > 0)
+                unconvertedReferences.push(node);
+            else if (queries > 0)
+                convertedReferences += 1;
         }
         ts.forEachChild(node, visit);
     };
     visit(sourceFile);
-    return unconverted;
+    return { names: unconverted, references: unconvertedReferences, convertedReferences };
 };
 const isCall = (node, name) => ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === name;
 const readActionId = (node, createActionId) => {
@@ -191,15 +204,9 @@ const injectorOf = (classNode) => {
     }
     return null;
 };
-const planRefreshSites = (filePath, sourceFile, content, createActionId) => {
-    const plan = { edits: [], rewritten: 0, needsInjectorImport: false, tasks: [] };
-    const consumedActionIds = new Set();
+const classInjectorResolver = (sourceFile) => {
     const classInjectors = new Map();
-    const task = (node, summary) => plan.tasks.push({
-        id: CONSUMER_TASK.SELECT_BY_ACTION_ID,
-        summary,
-        locations: [{ filePath, line: lineOf(sourceFile, node.getStart(sourceFile)) }],
-    });
+    const edits = [];
     const injectorFor = (node) => {
         let current = node.parent;
         while (current && !ts.isClassLike(current))
@@ -215,14 +222,25 @@ const planRefreshSites = (filePath, sourceFile, content, createActionId) => {
         const taken = classNode.members.some((member) => member.name?.getText(sourceFile) === 'injector');
         const name = taken ? 'toolkitInjector' : 'injector';
         classInjectors.set(classNode, name);
-        plan.needsInjectorImport = true;
-        plan.edits.push({
+        edits.push({
             start: classNode.members.pos,
             end: classNode.members.pos,
             text: `\n  private ${name} = inject(Injector);\n`,
         });
         return name;
     };
+    return { injectorFor, edits };
+};
+const planRefreshSites = (filePath, sourceFile, content, createActionId) => {
+    const plan = { edits: [], rewritten: 0, needsInjectorImport: false, tasks: [] };
+    const consumedActionIds = new Set();
+    const task = (node, summary) => plan.tasks.push({
+        id: CONSUMER_TASK.SELECT_BY_ACTION_ID,
+        summary,
+        locations: [{ filePath, line: lineOf(sourceFile, node.getStart(sourceFile)) }],
+    });
+    const injectors = classInjectorResolver(sourceFile);
+    const injectorFor = injectors.injectorFor;
     const localActionId = (select, identifier) => {
         let block = select.parent;
         while (block && !ts.isBlock(block))
@@ -275,6 +293,8 @@ const planRefreshSites = (filePath, sourceFile, content, createActionId) => {
     };
     visit(sourceFile);
     visitActionIds(sourceFile);
+    plan.edits.push(...injectors.edits);
+    plan.needsInjectorImport = injectors.edits.length > 0;
     return plan;
 };
 /** Moves one consumer file from `@tomtomb/ngrx-toolkit` to `@ethlete/query/ngrx-toolkit`. */
@@ -290,7 +310,12 @@ export const rewriteConsumer = (tree, graph, filePath, content) => {
         return null;
     const handleTypeNames = new Set(elements.filter((element) => HANDLE_TYPES.has(element.imported)).map((element) => element.local));
     const unconverted = unconvertedTypeQueries(tree, graph, filePath, sourceFile, handleTypeNames);
-    if (unconverted.length > 0) {
+    const unconvertedTask = {
+        id: CONSUMER_TASK.UNCONVERTED_ACTION_GROUP,
+        summary: `${[...new Set(unconverted.names)].map((name) => `\`${name}\``).join(', ')} still name toolkit action groups.`,
+        locations: [{ filePath }],
+    };
+    if (unconverted.names.length > 0 && (hasStoreSide || unconverted.convertedReferences === 0)) {
         if (hasStoreSide)
             return null;
         return {
@@ -298,18 +323,23 @@ export const rewriteConsumer = (tree, graph, filePath, content) => {
             rewritten: false,
             leftOnToolkit: true,
             refreshSitesRewritten: 0,
-            tasks: [
-                {
-                    id: CONSUMER_TASK.UNCONVERTED_ACTION_GROUP,
-                    summary: `${[...new Set(unconverted)].map((name) => `\`${name}\``).join(', ')} still name toolkit action groups.`,
-                    locations: [{ filePath }],
-                },
-            ],
+            tasks: [unconvertedTask],
         };
     }
+    const importedOf = new Map(elements.map((element) => [element.local, element.imported]));
+    const aliased = new Set();
+    const aliasEdits = unconverted.references.map((reference) => {
+        const imported = importedOf.get(reference.typeName.getText(sourceFile));
+        aliased.add(imported);
+        return {
+            start: reference.typeName.getStart(sourceFile),
+            end: reference.typeName.getEnd(),
+            text: `Toolkit${imported}`,
+        };
+    });
     const createActionId = elements.find((element) => element.imported === 'createActionId')?.local ?? null;
     const refresh = planRefreshSites(filePath, sourceFile, content, createActionId);
-    let result = applyEdits(content, refresh.edits);
+    let result = applyEdits(content, [...refresh.edits, ...aliasEdits]);
     const rewrittenSource = createSourceFile(result, filePath);
     const used = collectUsedIdentifiers(rewrittenSource);
     const moved = [];
@@ -333,7 +363,9 @@ export const rewriteConsumer = (tree, graph, filePath, content) => {
         statement.moduleSpecifier.text === INTEROP_MODULE);
     const replacement = [
         moved.length > 0 && !hasInteropImport ? `import { ${moved.join(', ')} } from '${INTEROP_MODULE}';` : null,
-        kept.length > 0 ? `import { ${kept.join(', ')} } from '${TOOLKIT_MODULE}';` : null,
+        kept.length + aliased.size > 0
+            ? `import { ${[...kept, ...[...aliased].map((name) => `${name} as Toolkit${name}`)].join(', ')} } from '${TOOLKIT_MODULE}';`
+            : null,
     ].filter((line) => line !== null);
     const importEdits = toolkitImportsOf(rewrittenSource).map((statement, index) => index === 0 && replacement.length > 0
         ? { start: statement.getStart(rewrittenSource), end: statement.getEnd(), text: replacement.join('\n') }
@@ -350,6 +382,8 @@ export const rewriteConsumer = (tree, graph, filePath, content) => {
         result = ensureNamedImports({ content: result, importsNeeded: moved, moduleSpecifier: INTEROP_MODULE });
     }
     const tasks = [...refresh.tasks];
+    if (aliased.size > 0)
+        tasks.push(unconvertedTask);
     if (kept.length > 0) {
         tasks.push({
             id: CONSUMER_TASK.UNSUPPORTED_IMPORT,
@@ -360,12 +394,12 @@ export const rewriteConsumer = (tree, graph, filePath, content) => {
     return {
         content: result,
         rewritten: result !== content,
-        leftOnToolkit: kept.length > 0,
+        leftOnToolkit: kept.length + aliased.size > 0,
         refreshSitesRewritten: refresh.rewritten,
         tasks,
     };
 };
-const isInterceptor = (node, sourceFile) => {
+export const isInterceptor = (node, sourceFile) => {
     if (ts.isClassDeclaration(node)) {
         return !!node.heritageClauses?.some((clause) => clause.types.some((type) => type.expression.getText(sourceFile) === 'HttpInterceptor'));
     }
@@ -438,13 +472,14 @@ const migratedFacadeNames = (graph, migratedFacades, filePath, sourceFile) => {
     }
     return names;
 };
-const findFacadeEventCalls = (graph, migratedFacades, filePath, content) => {
+const rewriteFacadeEventCalls = (tree, graph, migratedFacades, filePath, content) => {
+    const unchanged = { content, rewritten: 0, tasks: [] };
     if (!/\.(on|once)\s*\(/.test(content))
-        return [];
+        return unchanged;
     const sourceFile = createSourceFile(content, filePath);
     const facadeNames = migratedFacadeNames(graph, migratedFacades, filePath, sourceFile);
     if (facadeNames.size === 0)
-        return [];
+        return unchanged;
     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();
@@ -466,12 +501,50 @@ const findFacadeEventCalls = (graph, migratedFacades, filePath, content) => {
             receiver.expression.kind === ts.SyntaxKind.ThisKeyword &&
             bound.has(receiver.name.text));
     };
+    const isConvertedCreator = (local) => {
+        const origin = namedImportOf(sourceFile, local);
+        if (!origin || origin.namespace)
+            return false;
+        const declaringFile = graph.findDeclaringFile(filePath, origin.specifier, origin.imported);
+        return !!declaringFile && !isToolkitActionsFile(tree, declaringFile);
+    };
+    const successCreatorsText = (call) => {
+        const argument = call.arguments[0];
+        if (call.arguments.length !== 1 || !argument)
+            return null;
+        const items = ts.isArrayLiteralExpression(argument) ? [...argument.elements] : [argument];
+        const creators = [];
+        for (const item of items) {
+            if (!ts.isPropertyAccessExpression(item) ||
+                item.name.text !== 'success' ||
+                !ts.isIdentifier(item.expression) ||
+                !isConvertedCreator(item.expression.text)) {
+                return null;
+            }
+            creators.push(item.expression.text);
+        }
+        if (creators.length === 0)
+            return null;
+        return ts.isArrayLiteralExpression(argument) ? `[${creators.join(', ')}]` : creators[0];
+    };
+    const injectors = classInjectorResolver(sourceFile);
+    const edits = [];
     const tasks = [];
     const visit = (node) => {
         if (ts.isCallExpression(node) &&
             ts.isPropertyAccessExpression(node.expression) &&
             ['on', 'once'].includes(node.expression.name.text) &&
             isFacade(node.expression.expression)) {
+            const creators = node.expression.name.text === 'on' ? successCreatorsText(node) : null;
+            const injector = creators ? injectors.injectorFor(node) : null;
+            if (creators && injector) {
+                edits.push({
+                    start: node.getStart(sourceFile),
+                    end: node.getEnd(),
+                    text: `toolkitOnSuccess(${creators}, { injector: this.${injector} })`,
+                });
+                return;
+            }
             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.`,
@@ -481,7 +554,22 @@ const findFacadeEventCalls = (graph, migratedFacades, filePath, content) => {
         ts.forEachChild(node, visit);
     };
     visit(sourceFile);
-    return tasks;
+    if (edits.length === 0)
+        return { ...unchanged, tasks };
+    let result = applyEdits(content, [...edits, ...injectors.edits]);
+    result = ensureNamedImports({
+        content: result,
+        importsNeeded: ['toolkitOnSuccess'],
+        moduleSpecifier: INTEROP_MODULE,
+    });
+    if (injectors.edits.length > 0) {
+        result = ensureNamedImports({
+            content: result,
+            importsNeeded: ['inject', 'Injector'],
+            moduleSpecifier: '@angular/core',
+        });
+    }
+    return { content: result, rewritten: edits.length, 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, migratedFacades) => {
@@ -490,6 +578,7 @@ export const migrateToolkitConsumers = (tree, graph, inScope, report, migratedFa
         filesRewritten: 0,
         filesLeftOnToolkit: 0,
         refreshSitesRewritten: 0,
+        facadeListenersRewritten: 0,
         interceptorsFound: 0,
     };
     for (const filePath of inScope) {
@@ -501,16 +590,23 @@ export const migrateToolkitConsumers = (tree, graph, inScope, report, migratedFa
         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))
+        const events = rewriteFacadeEventCalls(tree, graph, migratedFacades, filePath, content);
+        events.tasks.forEach((task) => report.add(task));
+        stats.facadeListenersRewritten += events.rewritten;
+        if (events.rewritten > 0) {
+            tree.write(filePath, events.content);
+            stats.filesRewritten += 1;
+        }
+        if (!events.content.includes(TOOLKIT_MODULE))
             continue;
-        const result = rewriteConsumer(tree, graph, filePath, content);
+        const result = rewriteConsumer(tree, graph, filePath, events.content);
         if (!result)
             continue;
         result.tasks.forEach((task) => report.add(task));
         if (result.rewritten) {
             tree.write(filePath, result.content);
-            stats.filesRewritten += 1;
+            if (events.rewritten === 0)
+                stats.filesRewritten += 1;
         }
         if (result.leftOnToolkit)
             stats.filesLeftOnToolkit += 1;

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

@@ -1,6 +1,6 @@
 import { getProjects } from '@nx/devkit';
 import * as ts from 'typescript';
-import { toolkitArgsFitCreator } from './args-assignability.js';
+import { compareToolkitArgs } from './args-assignability.js';
 import { capitalizeFirstLetter, createSourceFile } from '../migrate-to-query-v3/shared.js';
 import { HTTP_VERBS, findTypeDeclaration } from './feature.js';
 import { TOOLKIT_TASK } from './report.js';
@@ -226,8 +226,8 @@ const decideReuse = (tree, graph, feature, call, existing) => {
     const response = call.responseType ? normalizeType(call.responseType) : null;
     const argTexts = toolkitArgTexts(call);
     const argMismatch = (creator) => COMPARED_ARG_KEYS.find((key) => creator.args?.[key] !== argTexts[key]) ?? null;
-    const argsFit = (creator) => argMismatch(creator) === null ||
-        toolkitArgsFitCreator(tree, graph, { file: feature.files.actions, typeText: call.args?.typeText ?? null }, { file: creator.filePath, typeText: creator.argsTypeText });
+    const compare = (creator) => compareToolkitArgs(tree, graph, { file: feature.files.actions, typeText: call.args?.typeText ?? null }, { file: creator.filePath, typeText: creator.argsTypeText });
+    const argsFit = (creator) => argMismatch(creator) === null || compare(creator).fits;
     const match = sameRoute.find((creator) => creator.responseType === response &&
         creator.pathParams.join(',') === call.route.pathParams.join(',') &&
         argsFit(creator));
@@ -240,6 +240,10 @@ const decideReuse = (tree, graph, feature, call, existing) => {
             const type = text.replace(/^\?/, '');
             return `\`${type.length > 120 ? `${type.slice(0, 120)}…` : type}\``;
         };
+        const argsDifference = (creator) => {
+            const difference = differingKey ? compare(creator).difference : null;
+            return difference ? `: ${difference}` : '';
+        };
         const reason = other.pathParams.join(',') !== call.route.pathParams.join(',')
             ? 'its path params are named differently'
             : other.responseType === null
@@ -248,7 +252,7 @@ const decideReuse = (tree, graph, feature, call, existing) => {
                     ? `its response is \`${other.responseType}\`, not \`${response ?? 'unknown'}\``
                     : other.args === null
                         ? 'its args type is not an interface or type literal, so it cannot be compared'
-                        : `its ${differingKey === 'body' ? 'body' : 'query params'} are ${describe(other.args[differingKey])}, not ${describe(argTexts[differingKey])}`;
+                        : `its ${differingKey === 'body' ? 'body' : 'query params'} are ${describe(other.args[differingKey])}, not ${describe(argTexts[differingKey])}${argsDifference(other)}`;
         return {
             mismatch: `\`${call.name}\` got its own creator: \`${other.name}\` (${other.filePath}:${other.line}) has the same ${call.verb.toUpperCase()} route, but ${reason}.`,
         };

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

@@ -245,6 +245,27 @@ const parseRoute = (node, sourceFile) => {
     }
     return { text, normalized, pathParams, staticPrefix: body.head.text };
 };
+const isEmptyValue = (node) => node.kind === ts.SyntaxKind.NullKeyword || (ts.isIdentifier(node) && node.text === 'undefined');
+const describeHeaders = (value, method, sourceFile) => {
+    const text = value.getText(sourceFile);
+    const owner = method.parent;
+    const property = ts.isPropertyAccessExpression(value) && value.expression.kind === ts.SyntaxKind.ThisKeyword && ts.isClassLike(owner)
+        ? owner.members.find((member) => ts.isPropertyDeclaration(member) && member.name.getText(sourceFile) === value.name.text)
+        : undefined;
+    const resolved = property?.initializer ?? value;
+    const source = property ? ` (from \`${text}\`)` : '';
+    if (ts.isConditionalExpression(resolved)) {
+        const condition = resolved.condition.getText(sourceFile);
+        if (isEmptyValue(resolved.whenFalse)) {
+            return `\`${resolved.whenTrue.getText(sourceFile)}\`${source} only when \`${condition}\``;
+        }
+        if (isEmptyValue(resolved.whenTrue)) {
+            return `\`${resolved.whenFalse.getText(sourceFile)}\`${source} only when \`${condition}\` is false`;
+        }
+        return `\`${resolved.whenTrue.getText(sourceFile)}\` or \`${resolved.whenFalse.getText(sourceFile)}\`${source} depending on \`${condition}\``;
+    }
+    return `\`${resolved.getText(sourceFile)}\`${source}`;
+};
 const parseServiceMethod = (method, sourceFile) => {
     const statements = method.body?.statements ?? [];
     const statement = statements[0];
@@ -265,7 +286,7 @@ const parseServiceMethod = (method, sourceFile) => {
         return 'The request options are not an object literal.';
     }
     let route = 'The method has no `apiRoute`.';
-    let headers = false;
+    let headers = null;
     let cacheExpiry = false;
     for (const property of options.properties) {
         if (!ts.isPropertyAssignment(property))
@@ -288,7 +309,13 @@ const parseServiceMethod = (method, sourceFile) => {
                     (ts.isPropertyAssignment(element) && element.name.getText(sourceFile) === 'headers'));
             if (!spreadsArgs)
                 return `Unsupported \`httpOpts\`: \`${value.getText(sourceFile)}\`.`;
-            headers = true;
+            const header = value.properties.find((element) => ts.isPropertyAssignment(element) && element.name.getText(sourceFile) === 'headers');
+            if (header) {
+                headers = {
+                    line: lineOf(sourceFile, header.getStart(sourceFile)),
+                    description: describeHeaders(header.initializer, method, sourceFile),
+                };
+            }
         }
         else if (name === 'extras') {
             if (!ts.isObjectLiteralExpression(value))
@@ -450,8 +477,8 @@ const analyzeFeature = (tree, graph, input) => {
         if (method.headers) {
             warnings.push({
                 id: TOOLKIT_TASK.SERVICE_HEADERS,
-                summary: `\`${serviceMethod}\` added headers to the request; the creator \`${group.name}\` does not.`,
-                locations: [{ filePath: files.service }],
+                summary: `\`${serviceMethod}\` added the headers ${method.headers.description}; the creator \`${group.name}\` does not.`,
+                locations: [{ filePath: files.service, line: method.headers.line }],
             });
         }
         if (method.cacheExpiry) {

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

@@ -6,6 +6,7 @@ import { migrateToolkitConsumers } from './consumers.js';
 import { rewriteFacade } from './facade.js';
 import { discoverFeatures } from './feature.js';
 import { TOOLKIT_TASK, ToolkitMigrationReport } from './report.js';
+import { reportLegacyModuleResolution } from './module-resolution.js';
 import { removeFeatureStores } from './store-removal.js';
 const parsePublicRoutes = (value) => {
     if (value === undefined)
@@ -114,6 +115,7 @@ export const migrateToolkitStores = (tree, options, report) => {
     const removal = removeFeatureStores(tree, graph, inScope, ready, report);
     const migratedFacades = new Set(ready.map((feature) => feature.files.facade).filter((file) => !!file));
     const consumers = migrateToolkitConsumers(tree, createModuleGraph(tree), inScope, report, migratedFacades);
+    reportLegacyModuleResolution(tree, createModuleGraph(tree), inScope, report);
     return {
         featuresFound: discovered.features.length,
         featuresConverted: ready.length,
@@ -130,7 +132,7 @@ export default async function migrate(tree, schema) {
     const report = new ToolkitMigrationReport();
     const stats = migrateToolkitStores(tree, schema, report);
     console.log(`   ${stats.featuresConverted}/${stats.featuresFound} features converted, ${stats.creatorsWritten} creators written, ${stats.creatorsReused} reused, ${stats.deletedFiles.length} files deleted.`);
-    console.log(`   ${stats.consumers.filesRewritten} consumer files moved to @ethlete/query/ngrx-toolkit, ${stats.consumers.refreshSitesRewritten} refresh sites rewritten.`);
+    console.log(`   ${stats.consumers.filesRewritten} consumer files moved to @ethlete/query/ngrx-toolkit, ${stats.consumers.refreshSitesRewritten} refresh sites and ${stats.consumers.facadeListenersRewritten} facade listeners rewritten.`);
     report.writeToTree(tree);
     report.printSummary();
     if (!schema.skipFormat) {

package/generators/migrate-from-ngrx-toolkit/module-resolution.js

@@ -0,0 +1,23 @@
+import { findLegacyModuleResolutions } from '../migrate-to-query-v3/module-resolution.js';
+import { INTEROP_MODULE } from './facade.js';
+export const MODULE_RESOLUTION_TASK = 'NTK-MODULE-RESOLUTION';
+/**
+ * Records a task for every project tsconfig that resolves modules with `node` / `node10` while the project imports
+ * `@ethlete/query/ngrx-toolkit`, directly or through a workspace path alias.
+ */
+export const reportLegacyModuleResolution = (tree, graph, files, report) => {
+    report.define(MODULE_RESOLUTION_TASK, {
+        title: 'Project resolves modules with `node`, which cannot find `@ethlete/query/ngrx-toolkit`',
+        action: '`moduleResolution: node` (`node10`) ignores the `exports` map of `@ethlete/query`, so the `@ethlete/query/ngrx-toolkit` import does not resolve - also when it sits in another project this one imports through a path alias. Set `moduleResolution` to `bundler` in the listed tsconfig (or the base config it inherits it from).',
+    });
+    for (const { configPath, resolution, alias } of findLegacyModuleResolutions(tree, graph, files, (specifier) => specifier === INTEROP_MODULE)) {
+        report.add({
+            id: MODULE_RESOLUTION_TASK,
+            summary: alias
+                ? `${configPath} resolves modules with \`${resolution}\` and reaches \`${INTEROP_MODULE}\` through \`${alias}\`.`
+                : `${configPath} resolves modules with \`${resolution}\`.`,
+            locations: [{ filePath: configPath }],
+        });
+    }
+};
+//# sourceMappingURL=module-resolution.js.map