@ethlete/query 6.0.0-next.51 → 6.0.0-next.53

package/generators/migrate-from-ngrx-toolkit/ts-edits.js

@@ -0,0 +1,128 @@
+import * as ts from 'typescript';
+import { pruneUnusedNamedImports } from '../migrate-to-query-v3/rename-symbols.js';
+import { createSourceFile } from '../migrate-to-query-v3/shared.js';
+/** Applies edits back to front. An edit nested inside an already applied one is dropped. */
+export const applyEdits = (content, edits) => {
+    const sorted = [...edits].sort((left, right) => right.start - left.start || right.end - left.end);
+    let result = content;
+    let floor = Number.POSITIVE_INFINITY;
+    for (const edit of sorted) {
+        if (edit.end > floor)
+            continue;
+        result = result.slice(0, edit.start) + edit.text + result.slice(edit.end);
+        floor = edit.start;
+    }
+    return result;
+};
+/** Removes `nodes[index]` from a comma separated list, together with the comma that belongs to it. */
+export const removeListElement = (nodes, index, sourceFile) => {
+    const node = nodes[index];
+    if (index < nodes.length - 1) {
+        return { start: node.getStart(sourceFile), end: nodes[index + 1].getStart(sourceFile), text: '' };
+    }
+    if (index > 0) {
+        return { start: nodes[index - 1].getEnd(), end: node.getEnd(), text: '' };
+    }
+    return { start: node.getStart(sourceFile), end: node.getEnd(), text: '' };
+};
+/** Removes a whole statement or class member, including its leading comments and the line break after it. */
+export const removeStatement = (node, content) => {
+    const comments = ts.getLeadingCommentRanges(content, node.getFullStart()) ?? [];
+    let start = comments[0]?.pos ?? node.getStart();
+    while (start > 0 && (content[start - 1] === ' ' || content[start - 1] === '\t'))
+        start -= 1;
+    let end = node.getEnd();
+    while (content[end] === ' ' || content[end] === '\t')
+        end += 1;
+    if (content[end] === '\r')
+        end += 1;
+    if (content[end] === '\n')
+        end += 1;
+    return { start, end, text: '' };
+};
+export const lineOf = (sourceFile, position) => sourceFile.getLineAndCharacterOfPosition(position).line + 1;
+export const collectUsedIdentifiers = (sourceFile) => {
+    const used = new Set();
+    const visit = (node) => {
+        if (ts.isImportDeclaration(node))
+            return;
+        if (ts.isIdentifier(node))
+            used.add(node.text);
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return used;
+};
+/** Collapses runs of blank lines left behind by removed statements, outside template literals. */
+export const collapseBlankLines = (content) => {
+    const sourceFile = createSourceFile(content);
+    const templates = [];
+    const visit = (node) => {
+        if (ts.isTemplateExpression(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
+            templates.push([node.getStart(sourceFile), node.getEnd()]);
+            return;
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return content.replace(/\n[ \t]*\n(?:[ \t]*\n)+/g, (match, offset) => templates.some(([start, end]) => offset >= start && offset < end) ? match : '\n\n');
+};
+/** Drops unused namespace, default and named imports. Side-effect imports stay. */
+export const pruneUnusedImports = (content) => {
+    const sourceFile = createSourceFile(content);
+    const used = collectUsedIdentifiers(sourceFile);
+    const edits = [];
+    for (const statement of sourceFile.statements) {
+        if (!ts.isImportDeclaration(statement) || !statement.importClause)
+            continue;
+        const { name, namedBindings } = statement.importClause;
+        if (namedBindings && ts.isNamespaceImport(namedBindings) && !used.has(namedBindings.name.text)) {
+            if (!name || !used.has(name.text))
+                edits.push(removeStatement(statement, content));
+            continue;
+        }
+        if (!namedBindings && name && !used.has(name.text)) {
+            edits.push(removeStatement(statement, content));
+        }
+    }
+    return pruneUnusedNamedImports(applyEdits(content, edits));
+};
+/** A relative module specifier from one workspace file to another, without the `.ts` extension. */
+export const relativeSpecifier = (fromFile, toFile) => {
+    const fromSegments = fromFile.split('/').slice(0, -1);
+    const toSegments = toFile.replace(/\.ts$/, '').split('/');
+    let shared = 0;
+    while (shared < fromSegments.length &&
+        shared < toSegments.length - 1 &&
+        fromSegments[shared] === toSegments[shared]) {
+        shared += 1;
+    }
+    const ups = fromSegments.length - shared;
+    const rest = toSegments.slice(shared).join('/');
+    return ups === 0 ? `./${rest}` : `${'../'.repeat(ups)}${rest}`;
+};
+export const hasExportModifier = (node) => ts.canHaveModifiers(node) &&
+    !!ts.getModifiers(node)?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword);
+/** The names a top-level statement declares. */
+export const declaredNames = (statement) => {
+    if (ts.isVariableStatement(statement)) {
+        return statement.declarationList.declarations.flatMap((declaration) => {
+            if (ts.isIdentifier(declaration.name))
+                return [declaration.name.text];
+            if (ts.isObjectBindingPattern(declaration.name)) {
+                return declaration.name.elements.flatMap((element) => ts.isIdentifier(element.name) ? [element.name.text] : []);
+            }
+            return [];
+        });
+    }
+    if ((ts.isFunctionDeclaration(statement) ||
+        ts.isClassDeclaration(statement) ||
+        ts.isInterfaceDeclaration(statement) ||
+        ts.isTypeAliasDeclaration(statement) ||
+        ts.isEnumDeclaration(statement)) &&
+        statement.name) {
+        return [statement.name.text];
+    }
+    return [];
+};
+//# sourceMappingURL=ts-edits.js.map

package/generators/migrate-query-opt-in-features/migration.js

@@ -4,8 +4,16 @@ import { createMigrationScope } from '../migrate-to-query-v3/migration-scope.js'
 import { createSourceFile, ensureImportFromQuery, getLineNumber } from '../migrate-to-query-v3/shared.js';
 import { QueryOptInFeaturesMigrationReport } from './report.js';
 const SOURCE = 'query-opt-in-features';
-const CLIENT_FEATURE = 'withEthleteApiErrors';
+export const CLIENT_FEATURE = 'withEthleteApiErrors';
 const AUTH_FEATURE = 'withBearerAuthMultiTabSync';
+export const reportClientErrorPipelineAdded = (report, location, source, summary = `\`${CLIENT_FEATURE}()\` was added so error parsing and retrying keep working exactly as before.`) => report.addFollowUp({
+    title: 'Client kept the full error pipeline',
+    summary,
+    action: 'Narrow it: `withHtmlErrorParsing()` only for an API behind a proxy that answers HTML, `withSymfonyErrors()` only for violation-list responses, `withDefaultRetry()` only if failed requests should retry themselves.',
+    locations: [location],
+    source,
+    dedupeKey: 'client-error-pipeline',
+});
 const isMigratableFile = (filePath) => /\.(ts|mts|cts)$/.test(filePath) && !filePath.endsWith('.d.ts');
 const propertyNamed = (config, sourceFile, name) => config.properties.find((property) => ts.isPropertyAssignment(property) && property.name.getText(sourceFile) === name);
 const hasFeature = (config, sourceFile, feature) => {
@@ -87,14 +95,7 @@ const collectEdits = (filePath, sourceFile, report) => {
                 }
                 else if (isClient) {
                     const feature = `${CLIENT_FEATURE}()`;
-                    report.addFollowUp({
-                        title: 'Client kept the full error pipeline',
-                        summary: `\`${CLIENT_FEATURE}()\` was added so error parsing and retrying keep working exactly as before.`,
-                        action: 'Narrow it: `withHtmlErrorParsing()` only for an API behind a proxy that answers HTML, `withSymfonyErrors()` only for violation-list responses, `withDefaultRetry()` only if failed requests should retry themselves.',
-                        locations: [{ filePath, line }],
-                        source: SOURCE,
-                        dedupeKey: 'client-error-pipeline',
-                    });
+                    reportClientErrorPipelineAdded(report, { filePath, line }, SOURCE);
                     edits.push({
                         start: config.getStart(sourceFile),
                         end: config.getEnd(),

package/generators/migrate-to-query-v3/auth-provider-scaffold.js

@@ -8,6 +8,10 @@ const REFRESH_CONFIG_KEYS = new Set([
     'cookieDomain',
     'cookieExpiresInDays',
     'expiresInPropertyName',
+    'cookiePath',
+    'cookieSameSite',
+    'cookieEnabled',
+    'refreshBuffer',
 ]);
 export const collectV2BearerAuthConfigs = (tree, scope) => {
     const configs = [];
@@ -77,12 +81,14 @@ const REFRESH_QUERY_KEY = 'tokenRefresh';
  * than presented as finished.
  */
 export const renderAuthProviderBody = (config) => {
+    const warnings = [];
     if (!config?.refreshCreatorName) {
         return {
             queries: '  queries: [],',
             features: '',
             importsNeeded: [],
             isScaffolded: false,
+            warnings,
         };
     }
     const refreshEntries = [`      queryCreator: ${config.refreshCreatorName},`];
@@ -95,6 +101,16 @@ export const renderAuthProviderBody = (config) => {
     if (config.expiresInPropertyName) {
         refreshEntries.push(`      expiresInPropertyName: ${config.expiresInPropertyName},`);
     }
+    if (config.refreshBuffer) {
+        refreshEntries.push(`      refreshStrategy: ${renderRefreshStrategy(config.refreshBuffer)},`);
+    }
+    if (config.cookieName && config.cookieEnabled && config.cookieEnabled !== 'true') {
+        warnings.push({
+            title: 'Replace the v2 cookieEnabled switch',
+            summary: `The v2 provider set \`cookieEnabled: ${config.cookieEnabled}\`. \`withPersistentAuth\` has no switch for it: it always keeps the refresh token in the cookie, and \`setRememberMe(false)\` only turns that cookie into a session cookie. v2's \`enableCookie()\` / \`disableCookie()\` have no v3 counterpart either.`,
+            action: 'If the cookie was only written after an opt-in (a "remember me" box), drive `setRememberMe()` from it. If it was never written, remove `withPersistentAuth` from the scaffold.',
+        });
+    }
     const queries = [
         '  queries: [',
         `    // Derived from the v2 BearerAuthProvider in ${config.filePath}:${config.line}. Verify before shipping.`,
@@ -106,13 +122,17 @@ export const renderAuthProviderBody = (config) => {
     ].join('\n');
     const importsNeeded = ['withRefreshQuery'];
     if (!config.cookieName) {
-        return { queries, features: '', importsNeeded, isScaffolded: true };
+        return { queries, features: '', importsNeeded, isScaffolded: true, warnings };
     }
     const cookieEntries = [`      name: ${config.cookieName},`];
     if (config.cookieDomain)
         cookieEntries.push(`      domain: ${config.cookieDomain},`);
     if (config.cookieExpiresInDays)
         cookieEntries.push(`      expiresInDays: ${config.cookieExpiresInDays},`);
+    if (config.cookiePath)
+        cookieEntries.push(`      path: ${config.cookiePath},`);
+    if (config.cookieSameSite)
+        cookieEntries.push(`      sameSite: ${config.cookieSameSite},`);
     const features = [
         '  features: [',
         '    withPersistentAuth({',
@@ -128,6 +148,13 @@ export const renderAuthProviderBody = (config) => {
         '  ],',
     ].join('\n');
     importsNeeded.push('withPersistentAuth');
-    return { queries, features, importsNeeded, isScaffolded: true };
+    return { queries, features, importsNeeded, isScaffolded: true, warnings };
+};
+// A v3 `refreshStrategy` number from 0 to 1 is a fraction of the token lifetime, not milliseconds.
+const renderRefreshStrategy = (refreshBuffer) => {
+    const value = Number(refreshBuffer.replace(/_/g, ''));
+    return Number.isFinite(value) && value > 1
+        ? refreshBuffer
+        : `{ minBufferMs: ${refreshBuffer}, maxBufferMs: ${refreshBuffer} }`;
 };
 //# sourceMappingURL=auth-provider-scaffold.js.map

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

@@ -1,5 +1,28 @@
 import * as ts from 'typescript';
-import { createSourceFile, ensureImportFromQuery, ensureNamedImports } 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')) {
+            return;
+        }
+        const content = tree.read(filePath, 'utf-8');
+        if (!content?.includes('@ethlete/query')) {
+            return;
+        }
+        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.
  *
@@ -69,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;
@@ -79,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);
@@ -90,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()`.
@@ -123,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);
@@ -169,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);
@@ -224,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),
                 });
             }
         }
@@ -249,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/legacy-query-creator-migration.js

@@ -10,6 +10,7 @@ const LEGACY_HTTP_METHOD = {
     PATCH: 'patch',
     DELETE: 'delete',
 };
+const LEGACY_GQL_METHODS = ['gqlQuery', 'gqlMutate'];
 const HTTP_OPTION_NAMES = ['reportProgress', 'responseType', 'transferCache', 'withCredentials'];
 const isLegacyHttpMethod = (value) => {
     return Object.values(LEGACY_HTTP_METHOD).includes(value);
@@ -219,6 +220,16 @@ const analyzeLegacyQueryCreators = (content, queryClientFiles, filePath, report)
                 ts.forEachChild(node, visit);
                 return;
             }
+            if (oldClientNames.has(objectExpression.text) && LEGACY_GQL_METHODS.includes(methodExpression.text)) {
+                report.addManualReview({
+                    title: `Rewrite the GraphQL creator ${node.name.text} by hand`,
+                    summary: `${node.name.text} is built with \`${objectExpression.text}.${methodExpression.text}()\`. The migration only rewrites REST creators, so this one still calls a method the migrated client no longer has.`,
+                    action: `Rebuild it on the v3 client with \`${methodExpression.text === 'gqlQuery' ? 'createGqlQueryViaPost' : 'createGqlMutationViaPost'}\` (or the \`ViaGet\` variant) and a \`gql\` document, then wrap it in \`createLegacyQueryCreator\` if its call sites stay on v2. See https://ethlete-sdk-docs.web.app/query/gql.`,
+                    locations: [{ filePath, line: sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1 }],
+                    source: 'legacy-query-creator-migration',
+                    dedupeKey: `gql-creator:${filePath}:${node.name.text}`,
+                });
+            }
             if (!oldClientNames.has(objectExpression.text) || !isLegacyHttpMethod(methodExpression.text)) {
                 ts.forEachChild(node, visit);
                 return;
@@ -270,7 +281,10 @@ const analyzeLegacyQueryCreators = (content, queryClientFiles, filePath, report)
                         if (HTTP_OPTION_NAMES.includes(property.name.text)) {
                             info.httpOptions.set(property.name.text, property.name.text);
                         }
-                        if (property.name.text !== 'route' && !HTTP_OPTION_NAMES.includes(property.name.text)) {
+                        if (property.name.text === 'entity') {
+                            info.entity = property.name.text;
+                        }
+                        if (!['route', 'entity'].includes(property.name.text) && !HTTP_OPTION_NAMES.includes(property.name.text)) {
                             warnUnreadableConfigValue(property, 'as a shorthand property');
                         }
                         return;
@@ -281,6 +295,9 @@ const analyzeLegacyQueryCreators = (content, queryClientFiles, filePath, report)
                     if (property.name.text === 'route') {
                         info.route = property.initializer.getText(sourceFile);
                     }
+                    if (property.name.text === 'entity') {
+                        info.entity = property.initializer.getText(sourceFile);
+                    }
                     if (property.name.text === 'secure') {
                         if (property.initializer.kind === ts.SyntaxKind.TrueKeyword) {
                             info.secure = true;
@@ -329,6 +346,18 @@ const analyzeLegacyQueryCreators = (content, queryClientFiles, filePath, report)
             }
             if (info.route) {
                 creators.push(info);
+                if (info.entity) {
+                    report.addFollowUp({
+                        title: `Check the entity config carried onto ${toLegacyName(creatorName)}`,
+                        summary: `${creatorName} had an \`entity\` config. It was moved onto the \`${toLegacyName(creatorName)}\` interop wrapper, which still writes to the EntityStore; the v3 creator \`${creatorName}\` does not, and v3 has no EntityStore.`,
+                        action: 'Keep the call sites that rely on the store on the legacy wrapper. `set` now only runs on a real response, never on `prepare()` or a failure.',
+                        locations: [
+                            { filePath, line: sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1 },
+                        ],
+                        source: 'legacy-query-creator-migration',
+                        dedupeKey: `entity-config:${filePath}:${creatorName}`,
+                    });
+                }
             }
         }
         ts.forEachChild(node, visit);
@@ -509,7 +538,7 @@ const getTypeParameter = (creator) => {
 const generateLegacyWrapper = (creator, exportPrefix) => {
     // `name` is what lets a `prepare()` called outside an injection context name itself in the error
     // instead of surfacing as a bare NG0203.
-    return `/**\n * ${legacyQueryDeprecationTag(creator.name)}\n */\n${exportPrefix}const ${toLegacyName(creator.name)} = createLegacyQueryCreator({ name: '${toLegacyName(creator.name)}', creator: ${creator.name} });`;
+    return `/**\n * ${legacyQueryDeprecationTag(creator.name)}\n */\n${exportPrefix}const ${toLegacyName(creator.name)} = createLegacyQueryCreator({ name: '${toLegacyName(creator.name)}', creator: ${creator.name}${creator.entity ? `, entity: ${creator.entity}` : ''} });`;
 };
 const createAuthProviders = ({ tree, authProvidersNeeded, report, v2Configs, creatorToClient, }) => {
     const createdProviders = [];
@@ -532,6 +561,14 @@ const createAuthProviders = ({ tree, authProvidersNeeded, report, v2Configs, cre
         }
         tree.write(filePath, nextContent);
         createdProviders.push(filePath);
+        body.warnings.forEach((warning) => {
+            report.addWarning({
+                ...warning,
+                locations: [{ filePath }, ...(v2Config ? [{ filePath: v2Config.filePath, line: v2Config.line }] : [])],
+                source: 'legacy-query-creator-migration',
+                dedupeKey: `auth-provider-warning:${filePath}:${authProviderName}:${warning.title}`,
+            });
+        });
         if (body.isScaffolded) {
             report.addFollowUp({
                 title: `Finish the scaffolded auth provider ${authProviderName}`,

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