@ethlete/query 6.0.0-next.3 → 6.0.0-next.30

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

@@ -0,0 +1,608 @@
+import * as ts from 'typescript';
+import { collectV2BearerAuthConfigs, renderAuthProviderBody } from './auth-provider-scaffold.js';
+import { createModuleGraph } from './module-graph.js';
+import { pruneUnusedNamedImports, renameImportedReferences } from './rename-symbols.js';
+import { capitalizeFirstLetter, createSourceFile, ensureConfigSuffix, ensureImportFromEthleteCore, ensureImportFromQuery, legacyQueryDeprecationTag, } from './shared.js';
+const LEGACY_HTTP_METHOD = {
+    GET: 'get',
+    POST: 'post',
+    PUT: 'put',
+    PATCH: 'patch',
+    DELETE: 'delete',
+};
+const isLegacyHttpMethod = (value) => {
+    return Object.values(LEGACY_HTTP_METHOD).includes(value);
+};
+export const createNewQueryCreators = (tree, queryClientFiles, report, scope) => {
+    const createdFiles = [];
+    const authProvidersNeeded = new Map();
+    const clientNameToFilePath = new Map();
+    const creatorToClient = new Map();
+    queryClientFiles.forEach((configNames, filePath) => {
+        configNames.forEach((configName) => {
+            clientNameToFilePath.set(configName, filePath);
+        });
+    });
+    scope.visit(tree, (filePath) => {
+        if (!filePath.endsWith('.ts') || filePath.endsWith('.spec.ts')) {
+            return;
+        }
+        const content = tree.read(filePath, 'utf-8');
+        if (!content) {
+            return;
+        }
+        const legacyCreators = analyzeLegacyQueryCreators(content, queryClientFiles, filePath, report);
+        if (legacyCreators.length === 0) {
+            return;
+        }
+        legacyCreators.forEach((creator) => {
+            creatorToClient.set(creator.name, creator.clientName);
+            if (!creator.secure) {
+                return;
+            }
+            const clientFilePath = clientNameToFilePath.get(creator.clientName);
+            if (clientFilePath) {
+                authProvidersNeeded.set(creator.clientName, clientFilePath);
+            }
+        });
+        const nextContent = transformLegacyQueryCreators(content, legacyCreators);
+        if (nextContent !== content) {
+            tree.write(filePath, nextContent);
+            createdFiles.push(filePath);
+        }
+    });
+    if (authProvidersNeeded.size > 0) {
+        createAuthProviders({
+            tree,
+            authProvidersNeeded,
+            report,
+            v2Configs: collectV2BearerAuthConfigs(tree, scope),
+            creatorToClient,
+        });
+    }
+    if (createdFiles.length > 0) {
+        console.log('\n✅ Created new query creators in:');
+        createdFiles.forEach((filePath) => console.log(`   - ${filePath}`));
+    }
+};
+export const updateLegacyCreatorImportsAndUsages = (tree, scope, report) => {
+    const legacyCreators = new Map();
+    const updatedFiles = [];
+    scope.visit(tree, (filePath) => {
+        if (!filePath.endsWith('.ts') || filePath.endsWith('.spec.ts')) {
+            return;
+        }
+        const content = tree.read(filePath, 'utf-8');
+        if (!content) {
+            return;
+        }
+        findLegacyWrappers(content).forEach((legacyName, originalName) => {
+            legacyCreators.set(originalName, { legacyName, definedIn: filePath });
+        });
+    });
+    if (legacyCreators.size === 0) {
+        return;
+    }
+    console.log(`\n✅ Found ${legacyCreators.size} legacy query creator wrappers`);
+    const moduleGraph = createModuleGraph(tree);
+    scope.visit(tree, (filePath) => {
+        if (!filePath.endsWith('.ts') || filePath.endsWith('.spec.ts')) {
+            return;
+        }
+        const content = tree.read(filePath, 'utf-8');
+        if (!content || containsLegacyWrapperDefinitions(content)) {
+            return;
+        }
+        const nextContent = pointFileAtLegacyWrappers({
+            content,
+            filePath,
+            legacyCreators,
+            moduleGraph,
+            report,
+        });
+        if (nextContent !== content) {
+            tree.write(filePath, nextContent);
+            updatedFiles.push(filePath);
+        }
+    });
+    if (updatedFiles.length > 0) {
+        console.log('\n✅ Updated legacy creator imports and usages in:');
+        updatedFiles.forEach((filePath) => console.log(`   - ${filePath}`));
+    }
+};
+/**
+ * Rewrites this file's imports of migrated creators to the `legacy*` wrappers.
+ *
+ * Two rules keep the rewrite honest, and both exist because the first version of this pass did not
+ * have them:
+ *
+ * - An import is only touched when the module it comes from really does resolve to the file that
+ *   defines the wrapper. A same-named export from an unrelated package stays as it is.
+ * - An alias is preserved (`legacyGetPerson as getPersonQuery`) instead of being dropped, so the
+ *   call sites using that alias keep compiling.
+ */
+const pointFileAtLegacyWrappers = ({ content, filePath, legacyCreators, moduleGraph, report, }) => {
+    const sourceFile = createSourceFile(content, filePath);
+    const replacements = [];
+    const referenceRenames = new Map();
+    const resolvesToWrapper = (specifier, importedName, registration) => moduleGraph.findDeclaringFile(filePath, specifier, importedName) === registration.definedIn;
+    const rewriteSpecifiers = (elements, moduleSpecifier) => {
+        let changed = false;
+        const nextElements = elements.map((element) => {
+            const importedName = element.propertyName?.text ?? element.name.text;
+            const registration = legacyCreators.get(importedName);
+            if (!registration || !resolvesToWrapper(moduleSpecifier, importedName, registration)) {
+                return element.getText(sourceFile);
+            }
+            changed = true;
+            // Aliased: only the imported half changes, so nothing in the file body has to move.
+            if (element.propertyName) {
+                return `${registration.legacyName} as ${element.name.text}`;
+            }
+            referenceRenames.set(element.name.text, registration.legacyName);
+            return registration.legacyName;
+        });
+        return changed ? nextElements : null;
+    };
+    for (const node of sourceFile.statements) {
+        if (ts.isImportDeclaration(node) &&
+            ts.isStringLiteral(node.moduleSpecifier) &&
+            node.importClause?.namedBindings &&
+            ts.isNamedImports(node.importClause.namedBindings)) {
+            const nextElements = rewriteSpecifiers(node.importClause.namedBindings.elements, node.moduleSpecifier.text);
+            if (nextElements) {
+                replacements.push({
+                    start: node.getStart(sourceFile),
+                    end: node.getEnd(),
+                    replacement: `import { ${nextElements.join(', ')} } from '${node.moduleSpecifier.text}';`,
+                });
+            }
+            continue;
+        }
+        // Re-exports need the same treatment, or a barrel keeps pointing at the v3 creator.
+        if (ts.isExportDeclaration(node) &&
+            node.moduleSpecifier &&
+            ts.isStringLiteral(node.moduleSpecifier) &&
+            node.exportClause &&
+            ts.isNamedExports(node.exportClause)) {
+            const nextElements = rewriteSpecifiers(node.exportClause.elements, node.moduleSpecifier.text);
+            if (nextElements) {
+                replacements.push({
+                    start: node.getStart(sourceFile),
+                    end: node.getEnd(),
+                    replacement: `export { ${nextElements.join(', ')} } from '${node.moduleSpecifier.text}';`,
+                });
+            }
+        }
+    }
+    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);
+    });
+    const renamed = renameImportedReferences(result, referenceRenames);
+    renamed.shadowed.forEach((name) => {
+        report.addManualReview({
+            title: `Point ${name} at its legacy wrapper by hand`,
+            summary: `${filePath} imports the migrated creator \`${name}\` but also declares something with that name, so the migration left its usages alone to avoid rewriting the wrong symbol.`,
+            action: `Rename the local declaration or the import alias, then point the query usages at \`${legacyCreators.get(name)?.legacyName ?? `legacy${capitalizeFirstLetter(name)}`}\`.`,
+            locations: [{ filePath }],
+            source: 'legacy-query-creator-migration',
+            dedupeKey: `shadowed-rename:${filePath}:${name}`,
+        });
+    });
+    return renamed.content;
+};
+const toLegacyName = (name) => `legacy${capitalizeFirstLetter(name)}`;
+const analyzeLegacyQueryCreators = (content, queryClientFiles, filePath, report) => {
+    const sourceFile = createSourceFile(content, filePath);
+    const creators = [];
+    const oldClientNames = new Set();
+    queryClientFiles.forEach((configNames) => {
+        configNames.forEach((configName) => oldClientNames.add(configName));
+    });
+    const visit = (node) => {
+        if (ts.isVariableDeclaration(node) &&
+            ts.isIdentifier(node.name) &&
+            node.initializer &&
+            ts.isCallExpression(node.initializer) &&
+            ts.isPropertyAccessExpression(node.initializer.expression)) {
+            const objectExpression = node.initializer.expression.expression;
+            const methodExpression = node.initializer.expression.name;
+            if (!ts.isIdentifier(objectExpression) || !ts.isIdentifier(methodExpression)) {
+                ts.forEachChild(node, visit);
+                return;
+            }
+            if (!oldClientNames.has(objectExpression.text) || !isLegacyHttpMethod(methodExpression.text)) {
+                ts.forEachChild(node, visit);
+                return;
+            }
+            const creatorName = node.name.text;
+            const info = {
+                name: creatorName,
+                clientName: objectExpression.text,
+                method: methodExpression.text,
+                route: '',
+                secure: false,
+                httpOptions: new Map(),
+            };
+            const configObject = node.initializer.arguments[0];
+            if (configObject && ts.isObjectLiteralExpression(configObject)) {
+                configObject.properties.forEach((property) => {
+                    if (!ts.isPropertyAssignment(property) || !ts.isIdentifier(property.name)) {
+                        return;
+                    }
+                    if (property.name.text === 'route') {
+                        info.route = property.initializer.getText(sourceFile);
+                    }
+                    if (property.name.text === 'secure' && property.initializer.kind === ts.SyntaxKind.TrueKeyword) {
+                        info.secure = true;
+                    }
+                    if (property.name.text === 'types' && ts.isObjectLiteralExpression(property.initializer)) {
+                        property.initializer.properties.forEach((typeProperty) => {
+                            if (!ts.isPropertyAssignment(typeProperty) || !ts.isIdentifier(typeProperty.name)) {
+                                return;
+                            }
+                            const extractedType = extractTypeFromDef(typeProperty.initializer, sourceFile);
+                            if (!extractedType) {
+                                report.addManualReview({
+                                    title: `Verify generated types for ${creatorName}`,
+                                    summary: `The migration could not extract the \`${typeProperty.name.text}\` type for ${creatorName} automatically.`,
+                                    action: 'Check the generated creator type arguments and restore any missing args/body/response types manually.',
+                                    locations: [
+                                        {
+                                            filePath,
+                                            line: sourceFile.getLineAndCharacterOfPosition(typeProperty.getStart(sourceFile)).line + 1,
+                                        },
+                                    ],
+                                    source: 'legacy-query-creator-migration',
+                                    dedupeKey: `type-extraction:${filePath}:${creatorName}:${typeProperty.name.text}`,
+                                });
+                                return;
+                            }
+                            if (typeProperty.name.text === 'args') {
+                                info.typeArgs = extractedType;
+                            }
+                            if (typeProperty.name.text === 'response') {
+                                info.typeResponse = extractedType;
+                            }
+                            if (typeProperty.name.text === 'body') {
+                                info.typeBody = extractedType;
+                            }
+                        });
+                    }
+                    if (['reportProgress', 'responseType', 'transferCache', 'withCredentials'].includes(property.name.text)) {
+                        info.httpOptions.set(property.name.text, property.initializer.getText(sourceFile));
+                    }
+                });
+            }
+            if (info.route) {
+                creators.push(info);
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return creators;
+};
+const extractTypeFromDef = (node, sourceFile) => {
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === 'def') {
+        if (node.typeArguments && node.typeArguments.length > 0) {
+            return node.typeArguments[0].getText(sourceFile);
+        }
+    }
+    return undefined;
+};
+const transformLegacyQueryCreators = (content, legacyCreators) => {
+    const sourceFile = createSourceFile(content);
+    const creatorsByClient = new Map();
+    const replacements = [];
+    legacyCreators.forEach((creator) => {
+        if (!creatorsByClient.has(creator.clientName)) {
+            creatorsByClient.set(creator.clientName, []);
+        }
+        creatorsByClient.get(creator.clientName).push(creator);
+    });
+    legacyCreators.forEach((creator) => {
+        const nextCreator = generateNewQueryCreator(creator);
+        const legacyWrapper = generateLegacyWrapper(creator);
+        let variableStatement;
+        const visit = (node) => {
+            if (ts.isVariableStatement(node)) {
+                const declaration = node.declarationList.declarations[0];
+                if (declaration && ts.isIdentifier(declaration.name) && declaration.name.text === creator.name) {
+                    variableStatement = node;
+                }
+            }
+            ts.forEachChild(node, visit);
+        };
+        visit(sourceFile);
+        if (variableStatement) {
+            replacements.push({
+                start: variableStatement.getStart(sourceFile),
+                end: variableStatement.getEnd(),
+                replacement: `${nextCreator}\n${legacyWrapper}`,
+            });
+        }
+    });
+    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);
+    });
+    result = ensureImportFromQuery(result, ['createLegacyQueryCreator']);
+    result = addCreatorImports(result, creatorsByClient);
+    // The rewritten creators no longer go through `def<T>()` or the v2 client object, so whatever is
+    // left over from those constructs would land as a lint error the moment `formatFiles` runs.
+    return pruneUnusedNamedImports(result, 'all');
+};
+const addCreatorImports = (content, creatorsByClient) => {
+    const sourceFile = createSourceFile(content);
+    const replacements = [];
+    const importsByClient = new Map();
+    creatorsByClient.forEach((creators, clientName) => {
+        const clientBaseName = clientName.replace(/Client$/, '');
+        const importsNeeded = new Set([ensureConfigSuffix(clientName)]);
+        let hasSecureCreators = false;
+        creators.forEach((creator) => {
+            hasSecureCreators ||= creator.secure;
+            const capitalizedMethod = capitalizeFirstLetter(creator.method);
+            importsNeeded.add(`${clientBaseName}${capitalizedMethod}`);
+            if (creator.secure) {
+                importsNeeded.add(`${clientBaseName}${capitalizedMethod}Secure`);
+            }
+        });
+        if (hasSecureCreators) {
+            ['Get', 'Post', 'Put', 'Patch', 'Delete'].forEach((methodName) => {
+                const secureImport = `${clientBaseName}${methodName}Secure`;
+                if (creators.some((creator) => capitalizeFirstLetter(creator.method) === methodName && creator.secure)) {
+                    importsNeeded.add(secureImport);
+                }
+            });
+        }
+        importsByClient.set(clientName, importsNeeded);
+    });
+    const visit = (node) => {
+        if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) {
+            const clientsInImport = [];
+            const existingImports = new Set();
+            if (node.importClause?.namedBindings && ts.isNamedImports(node.importClause.namedBindings)) {
+                node.importClause.namedBindings.elements.forEach((element) => {
+                    existingImports.add(element.name.text);
+                    if (importsByClient.has(element.name.text)) {
+                        clientsInImport.push(element.name.text);
+                    }
+                });
+            }
+            if (clientsInImport.length === 0) {
+                ts.forEachChild(node, visit);
+                return;
+            }
+            const nextImports = new Set();
+            clientsInImport.forEach((clientName) => {
+                importsByClient.get(clientName)?.forEach((importName) => nextImports.add(importName));
+            });
+            existingImports.forEach((importName) => {
+                if (!clientsInImport.includes(importName)) {
+                    nextImports.add(importName);
+                }
+            });
+            replacements.push({
+                start: node.getStart(sourceFile),
+                end: node.getEnd(),
+                replacement: `import { ${Array.from(nextImports).sort().join(', ')} } from '${node.moduleSpecifier.text}';`,
+            });
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    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 generateNewQueryCreator = (creator) => {
+    const clientBaseName = creator.clientName.replace(/Client$/, '');
+    const capitalizedMethod = capitalizeFirstLetter(creator.method);
+    const creatorFunction = creator.secure
+        ? `${clientBaseName}${capitalizedMethod}Secure`
+        : `${clientBaseName}${capitalizedMethod}`;
+    const typeParameter = getTypeParameter(creator);
+    const options = Array.from(creator.httpOptions.entries()).map(([key, value]) => `${key}: ${value}`);
+    const optionsBlock = options.length > 0 ? `, {\n  ${options.join(',\n  ')}\n}` : '';
+    return `export const ${creator.name} = ${creatorFunction}${typeParameter}(${creator.route}${optionsBlock});`;
+};
+const getTypeParameter = (creator) => {
+    if (creator.typeArgs && (creator.typeBody || creator.typeResponse)) {
+        const additionalTypes = [];
+        if (creator.typeBody) {
+            additionalTypes.push(`body: ${creator.typeBody}`);
+        }
+        if (creator.typeResponse) {
+            additionalTypes.push(`response: ${creator.typeResponse}`);
+        }
+        return `<${creator.typeArgs} & { ${additionalTypes.join('; ')} }>`;
+    }
+    if (creator.typeArgs) {
+        return `<${creator.typeArgs}>`;
+    }
+    if (creator.typeBody || creator.typeResponse) {
+        const typeProperties = [];
+        if (creator.typeBody) {
+            typeProperties.push(`body: ${creator.typeBody}`);
+        }
+        if (creator.typeResponse) {
+            typeProperties.push(`response: ${creator.typeResponse}`);
+        }
+        return `<{ ${typeProperties.join('; ')} }>`;
+    }
+    return '';
+};
+const generateLegacyWrapper = (creator) => {
+    // `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 */\nexport const ${toLegacyName(creator.name)} = createLegacyQueryCreator({ name: '${toLegacyName(creator.name)}', creator: ${creator.name} });`;
+};
+const createAuthProviders = ({ tree, authProvidersNeeded, report, v2Configs, creatorToClient, }) => {
+    const createdProviders = [];
+    authProvidersNeeded.forEach((filePath, clientName) => {
+        const content = tree.read(filePath, 'utf-8');
+        if (!content) {
+            return;
+        }
+        const authProviderName = `${clientName}AuthProvider`;
+        if (content.includes(`export const ${authProviderName} = createBearerAuthProvider(`)) {
+            return;
+        }
+        // Match on the refresh creator: it is the one thing a v2 provider config always names, and it
+        // belongs to exactly one client.
+        const v2Config = v2Configs.find((candidate) => candidate.refreshCreatorName && creatorToClient.get(candidate.refreshCreatorName) === clientName);
+        const body = renderAuthProviderBody(v2Config);
+        const nextContent = generateSecureQueryCreators(addAuthProviderToFile(content, clientName, body), clientName);
+        if (nextContent === content) {
+            return;
+        }
+        tree.write(filePath, nextContent);
+        createdProviders.push(filePath);
+        if (body.isScaffolded) {
+            report.addFollowUp({
+                title: `Finish the scaffolded auth provider ${authProviderName}`,
+                summary: `${authProviderName} was scaffolded from the v2 BearerAuthProvider at ${v2Config?.filePath}:${v2Config?.line}. The refresh query and cookie config carried over; the adapters were copied verbatim and their parameter shapes changed between v2 and v3.`,
+                action: 'Resolve the TODO(query-v3) comments in the generated provider, add the login query via withAuthenticationQuery, and delete the v2 provider once the app logs in again.',
+                locations: [{ filePath }, ...(v2Config ? [{ filePath: v2Config.filePath, line: v2Config.line }] : [])],
+                source: 'legacy-query-creator-migration',
+                dedupeKey: `auth-provider:${filePath}:${authProviderName}`,
+            });
+        }
+        else {
+            report.addFollowUp({
+                title: `Configure auth queries for ${authProviderName}`,
+                summary: `The migration created ${authProviderName} with an empty \`queries\` array because no v2 BearerAuthProvider config could be matched to this client.`,
+                action: 'Add authQuery/tokenRefreshQuery builders, verify token extraction, and remove the placeholder empty array once the provider is configured.',
+                locations: [{ filePath }],
+                source: 'legacy-query-creator-migration',
+                dedupeKey: `auth-provider:${filePath}:${authProviderName}`,
+            });
+        }
+        // The generated layout only works if the auth queries live next to the provider: the provider
+        // needs the login/refresh creators, and the secure creators need the provider. Leaving them in
+        // an `auth.queries.ts` that imports the client's `post` creator closes the loop.
+        report.addManualReview({
+            title: `Keep the auth queries in ${filePath}`,
+            summary: `${authProviderName} needs the login and refresh creators, and the secure creators below it need the provider. If those creators stay in a separate auth queries file that imports this client, the two files form an import cycle.`,
+            action: `Move the login/refresh creators into ${filePath} above the provider, and have the auth queries file import them back for its legacy* wrappers.`,
+            locations: [{ filePath }],
+            source: 'legacy-query-creator-migration',
+            dedupeKey: `auth-provider-cycle:${filePath}`,
+        });
+    });
+    if (createdProviders.length > 0) {
+        console.log('\n✅ Created auth providers in:');
+        createdProviders.forEach((filePath) => console.log(`   - ${filePath}`));
+    }
+};
+const addAuthProviderToFile = (content, clientName, body) => {
+    const nextContent = ensureImportFromEthleteCore(ensureImportFromQuery(content, ['createBearerAuthProvider', ...body.importsNeeded]), ['toInjectFn', 'toProvideFn']);
+    const sourceFile = createSourceFile(nextContent);
+    const configName = ensureConfigSuffix(clientName);
+    const configPosition = findVariableStatementEnd(sourceFile, configName, 'createQueryClient');
+    if (!configPosition) {
+        return content;
+    }
+    const authProviderName = `${clientName}AuthProvider`;
+    const capitalizedClientName = capitalizeFirstLetter(clientName);
+    const authProviderBlock = [
+        '',
+        `export const ${authProviderName} = createBearerAuthProvider({`,
+        `  name: '${clientName}',`,
+        `  queryClientRef: ${configName},`,
+        body.queries,
+        ...(body.features ? [body.features] : []),
+        '});',
+        '',
+        `export const provide${capitalizedClientName}AuthProvider = toProvideFn(${authProviderName});`,
+        `export const inject${capitalizedClientName}AuthProvider = toInjectFn(${authProviderName});`,
+    ].join('\n');
+    return nextContent.slice(0, configPosition) + authProviderBlock + nextContent.slice(configPosition);
+};
+const findVariableStatementEnd = (sourceFile, variableName, initializerName) => {
+    let variableStatementEnd;
+    const visit = (node) => {
+        if (ts.isVariableDeclaration(node) &&
+            ts.isIdentifier(node.name) &&
+            node.name.text === variableName &&
+            node.initializer &&
+            ts.isCallExpression(node.initializer) &&
+            ts.isIdentifier(node.initializer.expression) &&
+            node.initializer.expression.text === initializerName) {
+            let parent = node.parent;
+            while (parent && !ts.isVariableStatement(parent)) {
+                parent = parent.parent;
+            }
+            if (parent && ts.isVariableStatement(parent)) {
+                variableStatementEnd = parent.getEnd();
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return variableStatementEnd;
+};
+const generateSecureQueryCreators = (content, clientName) => {
+    const nextContent = ensureImportFromQuery(content, [
+        'createSecureDeleteQuery',
+        'createSecureGetQuery',
+        'createSecurePatchQuery',
+        'createSecurePostQuery',
+        'createSecurePutQuery',
+    ]);
+    const sourceFile = createSourceFile(nextContent);
+    const authProviderName = `${clientName}AuthProvider`;
+    const authProviderPosition = findVariableStatementEnd(sourceFile, authProviderName, 'createBearerAuthProvider');
+    if (!authProviderPosition) {
+        return content;
+    }
+    const clientBaseName = clientName.replace(/Client$/, '');
+    const configName = ensureConfigSuffix(clientName);
+    const secureCreatorBlock = [
+        `export const ${clientBaseName}GetSecure = createSecureGetQuery(${configName}, ${authProviderName});`,
+        `export const ${clientBaseName}PostSecure = createSecurePostQuery(${configName}, ${authProviderName});`,
+        `export const ${clientBaseName}PutSecure = createSecurePutQuery(${configName}, ${authProviderName});`,
+        `export const ${clientBaseName}PatchSecure = createSecurePatchQuery(${configName}, ${authProviderName});`,
+        `export const ${clientBaseName}DeleteSecure = createSecureDeleteQuery(${configName}, ${authProviderName});`,
+    ].join('\n');
+    return (nextContent.slice(0, authProviderPosition) + `\n\n${secureCreatorBlock}` + nextContent.slice(authProviderPosition));
+};
+const containsLegacyWrapperDefinitions = (content) => content.includes('createLegacyQueryCreator');
+const findLegacyWrappers = (content) => {
+    const wrappers = new Map();
+    const sourceFile = createSourceFile(content);
+    const visit = (node) => {
+        if (ts.isVariableDeclaration(node) &&
+            ts.isIdentifier(node.name) &&
+            node.name.text.startsWith('legacy') &&
+            node.initializer &&
+            ts.isCallExpression(node.initializer) &&
+            ts.isIdentifier(node.initializer.expression) &&
+            node.initializer.expression.text === 'createLegacyQueryCreator') {
+            const legacyWrapperName = node.name.text;
+            const configObject = node.initializer.arguments[0];
+            if (configObject && ts.isObjectLiteralExpression(configObject)) {
+                configObject.properties.forEach((property) => {
+                    if (ts.isPropertyAssignment(property) &&
+                        ts.isIdentifier(property.name) &&
+                        property.name.text === 'creator' &&
+                        ts.isIdentifier(property.initializer)) {
+                        wrappers.set(property.initializer.text, legacyWrapperName);
+                    }
+                });
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return wrappers;
+};
+//# sourceMappingURL=legacy-query-creator-migration.js.map

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

@@ -0,0 +1,41 @@
+import { getProjects, visitNotIgnoredFiles } from '@nx/devkit';
+const stripTrailingSlash = (value) => (value.endsWith('/') ? value.slice(0, -1) : value);
+/**
+ * Limits the migration to a set of projects or paths.
+ *
+ * Rewriting every app in a monorepo in one run is rarely how adoption actually goes, and a 300-file
+ * diff is not reviewable. Note the one coupling that cannot be split: a query client and the
+ * creators built on it have to be migrated together, because the creators are rewritten in terms of
+ * the client's generated `xGet` / `xPostSecure` helpers.
+ */
+export const createMigrationScope = (tree, options) => {
+    const roots = [];
+    for (const projectName of options.projects ?? []) {
+        const project = getProjects(tree).get(projectName);
+        if (!project) {
+            throw new Error(`Unknown project "${projectName}". Pass names as they appear in \`nx show projects\`, or use --include with a path prefix.`);
+        }
+        roots.push(stripTrailingSlash(project.root));
+    }
+    for (const includePath of options.include ?? []) {
+        roots.push(stripTrailingSlash(includePath));
+    }
+    if (roots.length === 0) {
+        return {
+            visit: (targetTree, callback) => visitNotIgnoredFiles(targetTree, '', callback),
+            includes: () => true,
+            describe: () => 'the whole workspace',
+        };
+    }
+    const includes = (filePath) => roots.some((root) => filePath === root || filePath.startsWith(`${root}/`));
+    return {
+        visit: (targetTree, callback) => {
+            for (const root of roots) {
+                visitNotIgnoredFiles(targetTree, root, callback);
+            }
+        },
+        includes,
+        describe: () => roots.join(', '),
+    };
+};
+//# sourceMappingURL=migration-scope.js.map