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

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

@@ -0,0 +1,513 @@
+import * as ts from 'typescript';
+import { createSourceFile } from '../migrate-to-query-v3/shared.js';
+import { TOOLKIT_TASK } from './report.js';
+import { lineOf } from './ts-edits.js';
+export const TOOLKIT_MODULE = '@tomtomb/ngrx-toolkit';
+export const HTTP_VERBS = ['get', 'post', 'put', 'patch', 'delete'];
+const TOOLKIT_ARGS_KEYS = ['queryParams', 'params', 'body'];
+const FEATURE_FILE_SUFFIX = '.actions.ts';
+const siblingFile = (tree, dir, base, kind) => {
+    const path = `${dir}/${base}.${kind}.ts`;
+    return tree.exists(path) ? path : null;
+};
+const propertyNamed = (object, name) => object.properties.find((property) => ts.isPropertyAssignment(property) && property.name.getText() === name);
+const typeLiteralMember = (literal, name) => literal.members.find((member) => ts.isPropertySignature(member) && member.name.getText() === name);
+const isNullType = (node) => node.kind === ts.SyntaxKind.NullKeyword ||
+    node.kind === ts.SyntaxKind.UndefinedKeyword ||
+    (ts.isLiteralTypeNode(node) && node.literal.kind === ts.SyntaxKind.NullKeyword);
+const parseActionGroup = (declaration, sourceFile) => {
+    const initializer = declaration.initializer;
+    if (!initializer ||
+        !ts.isCallExpression(initializer) ||
+        !ts.isIdentifier(initializer.expression) ||
+        initializer.expression.text !== 'createHttpActionGroup' ||
+        !ts.isIdentifier(declaration.name)) {
+        return null;
+    }
+    const options = initializer.arguments[0];
+    const argsTypes = options && ts.isObjectLiteralExpression(options) ? propertyNamed(options, 'argsTypes') : undefined;
+    const defineCall = argsTypes?.initializer;
+    const typeArgument = defineCall && ts.isCallExpression(defineCall) ? defineCall.typeArguments?.[0] : undefined;
+    const literal = typeArgument && ts.isTypeLiteralNode(typeArgument) ? typeArgument : undefined;
+    return {
+        name: declaration.name.text,
+        argsType: literal ? (typeLiteralMember(literal, 'args')?.type ?? null) : null,
+        responseType: literal ? (typeLiteralMember(literal, 'response')?.type ?? null) : null,
+        line: lineOf(sourceFile, declaration.getStart(sourceFile)),
+    };
+};
+const parseActionsFile = (sourceFile) => {
+    const groups = [];
+    const imports = [];
+    const foreign = [];
+    const recordCandidates = [];
+    for (const statement of sourceFile.statements) {
+        if (ts.isImportDeclaration(statement)) {
+            imports.push(statement);
+            continue;
+        }
+        if (!ts.isVariableStatement(statement) || statement.declarationList.declarations.length !== 1) {
+            foreign.push(statement);
+            continue;
+        }
+        const declaration = statement.declarationList.declarations[0];
+        const initializer = declaration.initializer;
+        const group = parseActionGroup(declaration, sourceFile);
+        if (group) {
+            groups.push(group);
+        }
+        else if (initializer && (ts.isStringLiteral(initializer) || ts.isNoSubstitutionTemplateLiteral(initializer))) {
+            continue;
+        }
+        else if (initializer && ts.isObjectLiteralExpression(initializer)) {
+            recordCandidates.push(initializer);
+        }
+        else {
+            foreign.push(statement);
+        }
+    }
+    const groupNames = new Set(groups.map((group) => group.name));
+    for (const record of recordCandidates) {
+        const onlyGroups = record.properties.every((property) => ts.isShorthandPropertyAssignment(property)
+            ? groupNames.has(property.name.text)
+            : ts.isPropertyAssignment(property) &&
+                ts.isIdentifier(property.initializer) &&
+                groupNames.has(property.initializer.text));
+        if (!onlyGroups)
+            foreign.push(record.parent.parent.parent);
+    }
+    return { groups, imports, foreign };
+};
+export const findTypeDeclaration = (sourceFile, name) => sourceFile.statements.find((statement) => (ts.isInterfaceDeclaration(statement) || ts.isTypeAliasDeclaration(statement)) && statement.name.text === name);
+const membersToArgs = (typeText, members, memberTypeText) => {
+    const mapped = new Map();
+    const extraKeys = [];
+    for (const member of members) {
+        if (!ts.isPropertySignature(member) || !member.type) {
+            extraKeys.push(member.name?.getText() ?? '?');
+            continue;
+        }
+        const key = member.name.getText();
+        if (TOOLKIT_ARGS_KEYS.includes(key)) {
+            mapped.set(key, {
+                typeText: memberTypeText(member, key),
+                declaredText: member.type.getText(),
+                optional: !!member.questionToken,
+            });
+        }
+        else {
+            extraKeys.push(key);
+        }
+    }
+    return { typeText, members: mapped, extraKeys };
+};
+const resolveArgs = (tree, graph, actionsFile, actionsSource, argsType) => {
+    const typeText = argsType.getText(actionsSource);
+    if (ts.isTypeLiteralNode(argsType)) {
+        return {
+            args: membersToArgs(typeText, argsType.members, (member) => member.type.getText(actionsSource)),
+            inherited: false,
+        };
+    }
+    if (!ts.isTypeReferenceNode(argsType) || argsType.typeArguments) {
+        return { unresolved: `\`${typeText}\` is neither a type literal nor a plain type reference.` };
+    }
+    const typeName = argsType.typeName;
+    const [namespaceName, symbolName] = ts.isQualifiedName(typeName)
+        ? [ts.isIdentifier(typeName.left) ? typeName.left.text : null, typeName.right.text]
+        : [null, typeName.text];
+    let declaringFile = null;
+    if (!namespaceName && findTypeDeclaration(actionsSource, symbolName)) {
+        declaringFile = actionsFile;
+    }
+    for (const statement of actionsSource.statements) {
+        if (declaringFile || !ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier))
+            continue;
+        const bindings = statement.importClause?.namedBindings;
+        const specifier = statement.moduleSpecifier.text;
+        if (namespaceName && bindings && ts.isNamespaceImport(bindings) && bindings.name.text === namespaceName) {
+            declaringFile = graph.findDeclaringFile(actionsFile, specifier, symbolName);
+        }
+        if (!namespaceName && bindings && ts.isNamedImports(bindings)) {
+            const element = bindings.elements.find((candidate) => candidate.name.text === symbolName);
+            if (element) {
+                declaringFile = graph.findDeclaringFile(actionsFile, specifier, element.propertyName?.text ?? symbolName);
+            }
+        }
+    }
+    const declaringContent = declaringFile ? tree.read(declaringFile, 'utf-8') : null;
+    if (!declaringFile || !declaringContent) {
+        return { unresolved: `\`${typeText}\` does not resolve to a declaration in the workspace.` };
+    }
+    const declaration = findTypeDeclaration(createSourceFile(declaringContent, declaringFile), symbolName);
+    const indexed = (_member, key) => `${typeText}['${key}']`;
+    if (declaration && ts.isInterfaceDeclaration(declaration) && !declaration.typeParameters) {
+        return {
+            args: membersToArgs(typeText, declaration.members, indexed),
+            inherited: !!declaration.heritageClauses?.length,
+        };
+    }
+    if (declaration && ts.isTypeAliasDeclaration(declaration) && ts.isTypeLiteralNode(declaration.type)) {
+        return { args: membersToArgs(typeText, declaration.type.members, indexed), inherited: false };
+    }
+    return { unresolved: `\`${typeText}\` is not an interface or type literal.` };
+};
+const actionNameOf = (expression) => {
+    if (ts.isIdentifier(expression))
+        return expression.text;
+    if (ts.isPropertyAccessExpression(expression))
+        return expression.name.text;
+    return null;
+};
+const parseEffectsFile = (sourceFile) => {
+    const serviceMethods = new Map();
+    const foreign = [];
+    for (const statement of sourceFile.statements) {
+        if (!ts.isClassDeclaration(statement))
+            continue;
+        for (const member of statement.members) {
+            if (ts.isConstructorDeclaration(member))
+                continue;
+            const initializer = ts.isPropertyDeclaration(member) ? member.initializer : undefined;
+            const callee = initializer && ts.isCallExpression(initializer) ? initializer.expression : undefined;
+            const options = initializer && ts.isCallExpression(initializer) ? initializer.arguments[0] : undefined;
+            if (!callee ||
+                !ts.isPropertyAccessExpression(callee) ||
+                callee.expression.kind !== ts.SyntaxKind.ThisKeyword ||
+                !/^onAction(Merge|Switch|Exhaust|Concat)Map$/.test(callee.name.text) ||
+                !options ||
+                !ts.isObjectLiteralExpression(options) ||
+                options.properties.length !== 2) {
+                foreign.push(member);
+                continue;
+            }
+            const action = propertyNamed(options, 'action')?.initializer;
+            const serviceCall = propertyNamed(options, 'serviceCall')?.initializer;
+            const actionName = action ? actionNameOf(action) : null;
+            if (!actionName || !serviceCall || !ts.isPropertyAccessExpression(serviceCall)) {
+                foreign.push(member);
+                continue;
+            }
+            serviceMethods.set(actionName, serviceCall.name.text);
+        }
+    }
+    return { serviceMethods, foreign };
+};
+const isReducerPlainSlice = (content) => {
+    const sourceFile = createSourceFile(content);
+    let slice = false;
+    let foreign = false;
+    const visit = (node) => {
+        if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
+            if (node.expression.text === 'createReducerSlice') {
+                slice = true;
+                const options = node.arguments[0];
+                const extra = options && ts.isObjectLiteralExpression(options) ? propertyNamed(options, 'initialStateExtra') : null;
+                if (extra && !(ts.isObjectLiteralExpression(extra.initializer) && extra.initializer.properties.length === 0)) {
+                    foreign = true;
+                }
+            }
+            if (node.expression.text === 'createReducer' || node.expression.text === 'on')
+                foreign = true;
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return slice && !foreign;
+};
+const parseRoute = (node, sourceFile) => {
+    const text = node.getText(sourceFile);
+    if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
+        return { text, normalized: node.text, pathParams: [], staticPrefix: node.text };
+    }
+    if (!ts.isArrowFunction(node) || node.parameters.length !== 1 || !ts.isIdentifier(node.parameters[0].name)) {
+        return `The route \`${text}\` is not a string or a \`(p) => \\\`…\\\`\` function.`;
+    }
+    const paramName = node.parameters[0].name.text;
+    const body = node.body;
+    if (ts.isStringLiteral(body) || ts.isNoSubstitutionTemplateLiteral(body)) {
+        return { text, normalized: body.text, pathParams: [], staticPrefix: body.text };
+    }
+    if (!ts.isTemplateExpression(body)) {
+        return `The route \`${text}\` does not return a template string.`;
+    }
+    const pathParams = [];
+    let normalized = body.head.text;
+    for (const span of body.templateSpans) {
+        const expression = span.expression;
+        if (!ts.isPropertyAccessExpression(expression) ||
+            !ts.isIdentifier(expression.expression) ||
+            expression.expression.text !== paramName) {
+            return `The route \`${text}\` reads something other than its path params.`;
+        }
+        pathParams.push(expression.name.text);
+        normalized += `{}${span.literal.text}`;
+    }
+    return { text, normalized, pathParams, staticPrefix: body.head.text };
+};
+const parseServiceMethod = (method, sourceFile) => {
+    const statements = method.body?.statements ?? [];
+    const statement = statements[0];
+    const call = statement && ts.isReturnStatement(statement) ? statement.expression : undefined;
+    const paramName = method.parameters.length === 1 && ts.isIdentifier(method.parameters[0].name)
+        ? method.parameters[0].name.text
+        : null;
+    if (statements.length !== 1 ||
+        !call ||
+        !ts.isCallExpression(call) ||
+        !ts.isPropertyAccessExpression(call.expression) ||
+        call.expression.expression.kind !== ts.SyntaxKind.ThisKeyword ||
+        !HTTP_VERBS.includes(call.expression.name.text)) {
+        return 'The method is not a single `return this.get|post|put|patch|delete({ … })`.';
+    }
+    const options = call.arguments[0];
+    if (!options || !ts.isObjectLiteralExpression(options)) {
+        return 'The request options are not an object literal.';
+    }
+    let route = 'The method has no `apiRoute`.';
+    let headers = false;
+    let cacheExpiry = false;
+    for (const property of options.properties) {
+        if (!ts.isPropertyAssignment(property))
+            return `Unsupported option \`${property.getText(sourceFile)}\`.`;
+        const name = property.name.getText(sourceFile);
+        const value = property.initializer;
+        if (name === 'apiRoute') {
+            route = parseRoute(value, sourceFile);
+        }
+        else if (name === 'responseType') {
+            continue;
+        }
+        else if (name === 'httpOpts') {
+            if (ts.isIdentifier(value) && value.text === paramName)
+                continue;
+            const spreadsArgs = ts.isObjectLiteralExpression(value) &&
+                value.properties.every((element) => (ts.isSpreadAssignment(element) &&
+                    ts.isIdentifier(element.expression) &&
+                    element.expression.text === paramName) ||
+                    (ts.isPropertyAssignment(element) && element.name.getText(sourceFile) === 'headers'));
+            if (!spreadsArgs)
+                return `Unsupported \`httpOpts\`: \`${value.getText(sourceFile)}\`.`;
+            headers = true;
+        }
+        else if (name === 'extras') {
+            if (!ts.isObjectLiteralExpression(value))
+                return `Unsupported \`extras\`: \`${value.getText(sourceFile)}\`.`;
+            for (const extra of value.properties) {
+                const extraName = extra.name?.getText(sourceFile);
+                if (extraName === 'skipCache')
+                    continue;
+                if (extraName === 'cacheExpiresIn') {
+                    cacheExpiry = true;
+                    continue;
+                }
+                if (extraName === 'apiBaseOverride')
+                    return 'apiBaseOverride';
+                return `Unsupported extra \`${extra.getText(sourceFile)}\`.`;
+            }
+        }
+        else {
+            return `Unsupported option \`${name}\`.`;
+        }
+    }
+    if (typeof route === 'string')
+        return route;
+    return { route, verb: call.expression.name.text, headers, cacheExpiry };
+};
+const parseServiceFile = (sourceFile) => {
+    const methods = new Map();
+    let apiBase = null;
+    let baseConfig = false;
+    const findSuper = (node) => {
+        if (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.SuperKeyword) {
+            apiBase = node.arguments[1]?.getText(sourceFile) ?? null;
+            baseConfig = node.arguments.length > 2;
+        }
+        ts.forEachChild(node, findSuper);
+    };
+    for (const statement of sourceFile.statements) {
+        if (!ts.isClassDeclaration(statement))
+            continue;
+        for (const member of statement.members) {
+            if (ts.isConstructorDeclaration(member))
+                findSuper(member);
+            if (ts.isMethodDeclaration(member) && ts.isIdentifier(member.name)) {
+                methods.set(member.name.text, parseServiceMethod(member, sourceFile));
+            }
+        }
+    }
+    return { apiBase, baseConfig, methods };
+};
+const hasToolkitImport = (sourceFile) => sourceFile.statements.some((statement) => ts.isImportDeclaration(statement) &&
+    ts.isStringLiteral(statement.moduleSpecifier) &&
+    statement.moduleSpecifier.text === TOOLKIT_MODULE);
+const extendsFacadeBase = (sourceFile) => sourceFile.statements.some((statement) => ts.isClassDeclaration(statement) &&
+    !!statement.heritageClauses?.some((clause) => clause.types.some((type) => type.expression.getText(sourceFile) === 'FacadeBase')));
+/** Finds every `x.actions.ts` built with `createHttpActionGroup` and reads the feature around it. */
+export const discoverFeatures = (tree, graph, visit) => {
+    const features = [];
+    const facadesWithoutHttp = [];
+    const commentedOut = [];
+    visit((filePath) => {
+        if (!filePath.endsWith(FEATURE_FILE_SUFFIX))
+            return;
+        const content = tree.read(filePath, 'utf-8');
+        if (!content)
+            return;
+        const sourceFile = createSourceFile(content, filePath);
+        const dir = filePath.slice(0, filePath.lastIndexOf('/'));
+        const base = filePath.slice(dir.length + 1, -FEATURE_FILE_SUFFIX.length);
+        const parsed = parseActionsFile(sourceFile);
+        if (parsed.groups.length === 0) {
+            const facade = siblingFile(tree, dir, base, 'facade');
+            const facadeContent = facade ? tree.read(facade, 'utf-8') : null;
+            if (facade && facadeContent && extendsFacadeBase(createSourceFile(facadeContent, facade))) {
+                facadesWithoutHttp.push(facade);
+            }
+            else if (/createHttpActionGroup/.test(content) && !hasToolkitImport(sourceFile)) {
+                commentedOut.push(filePath);
+            }
+            return;
+        }
+        features.push(analyzeFeature(tree, graph, { filePath, sourceFile, dir, base, parsed }));
+    });
+    return { features, facadesWithoutHttp, commentedOut };
+};
+const analyzeFeature = (tree, graph, input) => {
+    const { filePath, sourceFile, dir, base, parsed } = input;
+    const files = {
+        actions: filePath,
+        service: siblingFile(tree, dir, base, 'service'),
+        effects: siblingFile(tree, dir, base, 'effects'),
+        reducer: siblingFile(tree, dir, base, 'reducer'),
+        selectors: siblingFile(tree, dir, base, 'selectors'),
+        facade: siblingFile(tree, dir, base, 'facade'),
+        models: siblingFile(tree, dir, base, 'models'),
+    };
+    const blockers = [];
+    const warnings = [];
+    const calls = [];
+    for (const statement of parsed.foreign) {
+        blockers.push({
+            id: TOOLKIT_TASK.MIXED_ACTIONS,
+            summary: `\`${statement.getText(sourceFile).split('\n')[0]}\` is not an HTTP action group.`,
+            locations: [{ filePath, line: lineOf(sourceFile, statement.getStart(sourceFile)) }],
+        });
+    }
+    const readSource = (path) => {
+        const content = path ? tree.read(path, 'utf-8') : null;
+        return path && content ? createSourceFile(content, path) : null;
+    };
+    const effectsSource = readSource(files.effects);
+    const effects = effectsSource ? parseEffectsFile(effectsSource) : { serviceMethods: new Map(), foreign: [] };
+    for (const member of effects.foreign) {
+        blockers.push({
+            id: TOOLKIT_TASK.CUSTOM_EFFECT,
+            summary: `\`${member.getText(effectsSource).split('\n')[0]}\` is not a plain \`onAction*Map\` effect.`,
+            locations: [{ filePath: files.effects, line: lineOf(effectsSource, member.getStart(effectsSource)) }],
+        });
+    }
+    const reducerContent = files.reducer ? tree.read(files.reducer, 'utf-8') : null;
+    if (files.reducer && reducerContent && !isReducerPlainSlice(reducerContent)) {
+        blockers.push({
+            id: TOOLKIT_TASK.CUSTOM_REDUCER,
+            summary: `The reducer of \`${base}\` is not a plain \`createReducerSlice\` with an empty \`initialStateExtra\`.`,
+            locations: [{ filePath: files.reducer }],
+        });
+    }
+    const serviceSource = readSource(files.service);
+    const service = serviceSource ? parseServiceFile(serviceSource) : null;
+    if (service?.baseConfig) {
+        blockers.push({
+            id: TOOLKIT_TASK.SERVICE_API_BASE,
+            summary: 'The service passes a base config to `ServiceBase`.',
+            locations: [{ filePath: files.service }],
+        });
+    }
+    for (const group of parsed.groups) {
+        const location = { filePath, line: group.line };
+        const serviceMethod = effects.serviceMethods.get(group.name);
+        if (!serviceMethod) {
+            blockers.push({
+                id: TOOLKIT_TASK.ACTION_WITHOUT_EFFECT,
+                summary: `\`${group.name}\` has no effect in ${files.effects ?? `${base}.effects.ts`}.`,
+                locations: [location],
+            });
+            continue;
+        }
+        const method = service?.methods.get(serviceMethod);
+        if (!method || typeof method === 'string') {
+            const apiBaseOverride = method === 'apiBaseOverride';
+            blockers.push({
+                id: apiBaseOverride ? TOOLKIT_TASK.SERVICE_API_BASE : TOOLKIT_TASK.SERVICE_UNSUPPORTED,
+                summary: apiBaseOverride
+                    ? `\`${serviceMethod}\` overrides the API base.`
+                    : `\`${serviceMethod}\`: ${method ?? 'the service has no such method.'}`,
+                locations: [{ filePath: files.service ?? filePath }],
+            });
+            continue;
+        }
+        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 }],
+            });
+        }
+        if (method.cacheExpiry) {
+            warnings.push({
+                id: TOOLKIT_TASK.SERVICE_CACHE_EXPIRY,
+                summary: `\`${serviceMethod}\` cached its response with \`cacheExpiresIn\`.`,
+                locations: [{ filePath: files.service }],
+            });
+        }
+        let args = null;
+        if (group.argsType && !isNullType(group.argsType)) {
+            const resolution = resolveArgs(tree, graph, filePath, sourceFile, group.argsType);
+            if ('unresolved' in resolution) {
+                blockers.push({ id: TOOLKIT_TASK.ARGS_UNRESOLVED, summary: resolution.unresolved, locations: [location] });
+                continue;
+            }
+            if (resolution.inherited) {
+                warnings.push({
+                    id: TOOLKIT_TASK.ARGS_INHERITED,
+                    summary: `\`${resolution.args.typeText}\` (args of \`${group.name}\`) extends another type.`,
+                    locations: [location],
+                });
+            }
+            args = resolution.args;
+        }
+        if (method.route.pathParams.length > 0 && !args?.members.has('queryParams')) {
+            blockers.push({
+                id: TOOLKIT_TASK.ARGS_UNRESOLVED,
+                summary: `The route of \`${group.name}\` has path params, but its args have no \`queryParams\`.`,
+                locations: [location],
+            });
+            continue;
+        }
+        calls.push({
+            name: group.name,
+            verb: method.verb,
+            args,
+            responseType: group.responseType ? group.responseType.getText(sourceFile) : null,
+            route: method.route,
+            serviceMethod,
+            line: group.line,
+        });
+    }
+    const actionImports = parsed.imports
+        .filter((statement) => !ts.isStringLiteral(statement.moduleSpecifier) || statement.moduleSpecifier.text !== TOOLKIT_MODULE)
+        .map((statement) => statement.getText(sourceFile));
+    return {
+        dir,
+        base,
+        files,
+        queriesFile: `${dir}/${base}.queries.ts`,
+        calls,
+        actionImports,
+        apiBase: service?.apiBase ?? null,
+        blockers,
+        warnings,
+    };
+};
+//# sourceMappingURL=feature.js.map

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

@@ -0,0 +1,140 @@
+import { formatFiles } from '@nx/devkit';
+import { createMigrationScope } from '../migrate-to-query-v3/migration-scope.js';
+import { createModuleGraph } from '../migrate-to-query-v3/module-graph.js';
+import { clientBaseName, helperName, indexExistingCreators, isPublicRoute, writeQueriesFile, } from './creators.js';
+import { migrateToolkitConsumers } from './consumers.js';
+import { rewriteFacade } from './facade.js';
+import { discoverFeatures } from './feature.js';
+import { TOOLKIT_TASK, ToolkitMigrationReport } from './report.js';
+import { removeFeatureStores } from './store-removal.js';
+const parsePublicRoutes = (value) => {
+    if (value === undefined)
+        return null;
+    const routes = (Array.isArray(value) ? value : value.split(','))
+        .map((route) => route.trim())
+        .filter((route) => route.length > 0);
+    return routes.length > 0 ? routes : null;
+};
+const assertHelpersExist = (tree, graph, helpers, names) => {
+    const isFile = tree.exists(helpers.importFrom);
+    const fromFile = isFile ? helpers.importFrom : '';
+    const specifier = isFile ? `./${helpers.importFrom.split('/').pop()}` : helpers.importFrom;
+    if (!graph.resolveFile(fromFile, specifier))
+        return;
+    const missing = [...names].filter((name) => !graph.findDeclaringFile(fromFile, specifier, name));
+    if (missing.length > 0) {
+        throw new Error(`${helpers.importFrom} does not export ${missing.join(', ')}. Run \`@ethlete/query:migrate-to-query-v3\` first, or check --client and --clientImport.`);
+    }
+};
+const resolveApiBase = (features, option) => {
+    if (option)
+        return option;
+    const bases = [...new Set(features.map((feature) => feature.apiBase).filter((base) => !!base))];
+    if (bases.length > 1) {
+        throw new Error(`The toolkit services use ${bases.length} API bases: ${bases.join(', ')}. Pass the one --client points at with --serviceApiBase; features on the others are left alone.`);
+    }
+    return bases[0] ?? null;
+};
+/** Runs the migration on `tree` - store side, then consumers - and records follow-up tasks in `report`. */
+export const migrateToolkitStores = (tree, options, report) => {
+    if (!options.client || !options.clientImport) {
+        throw new Error('Pass --client (e.g. apiClient) and --clientImport (e.g. @app/queries).');
+    }
+    const scope = createMigrationScope(tree, options);
+    const graph = createModuleGraph(tree);
+    const inScope = new Set();
+    scope.visit(tree, (filePath) => {
+        if (filePath.endsWith('.ts'))
+            inScope.add(filePath);
+    });
+    const visit = (callback) => inScope.forEach(callback);
+    const helpers = {
+        baseName: clientBaseName(options.client),
+        importFrom: options.clientImport,
+        publicRoutes: parsePublicRoutes(options.publicRoutes),
+    };
+    const discovered = discoverFeatures(tree, graph, visit);
+    discovered.commentedOut.forEach((filePath) => report.add({
+        id: TOOLKIT_TASK.COMMENTED_FEATURE,
+        summary: `${filePath} only contains commented-out action groups.`,
+        locations: [{ filePath }],
+    }));
+    discovered.facadesWithoutHttp.forEach((filePath) => report.add({
+        id: TOOLKIT_TASK.FACADE_WITHOUT_HTTP,
+        summary: `${filePath} extends \`FacadeBase\` without action groups.`,
+        locations: [{ filePath }],
+    }));
+    const apiBase = resolveApiBase(discovered.features, options.serviceApiBase);
+    for (const feature of discovered.features) {
+        if (feature.apiBase && apiBase && feature.apiBase !== apiBase) {
+            feature.blockers.push({
+                id: TOOLKIT_TASK.SERVICE_API_BASE,
+                summary: `The service uses \`${feature.apiBase}\`, not \`${apiBase}\`.`,
+                locations: [{ filePath: feature.files.service }],
+            });
+        }
+    }
+    const neededHelpers = new Set(discovered.features
+        .filter((feature) => feature.blockers.length === 0)
+        .flatMap((feature) => feature.calls.map((call) => helperName(helpers, call.verb, !isPublicRoute(helpers, call.route.staticPrefix)))));
+    assertHelpersExist(tree, graph, helpers, neededHelpers);
+    const existing = indexExistingCreators(tree, graph, helpers, visit);
+    const ready = [];
+    let creatorsWritten = 0;
+    let creatorsReused = 0;
+    for (const feature of discovered.features) {
+        if (feature.blockers.length > 0) {
+            feature.blockers.forEach((blocker) => report.add(blocker));
+            continue;
+        }
+        const storeFiles = new Set([
+            feature.files.actions,
+            feature.files.reducer,
+            feature.files.effects,
+            feature.files.selectors,
+            feature.files.service,
+        ].filter((file) => !!file));
+        let facadeContent = null;
+        if (feature.files.facade) {
+            const rewrite = rewriteFacade(tree.read(feature.files.facade, 'utf-8'), feature, graph, storeFiles);
+            if ('blockers' in rewrite) {
+                rewrite.blockers.forEach((blocker) => report.add(blocker));
+                continue;
+            }
+            facadeContent = rewrite.content;
+        }
+        const written = writeQueriesFile(tree, graph, feature, helpers, existing, report);
+        creatorsWritten += written.written;
+        creatorsReused += written.reused;
+        if (feature.files.facade && facadeContent)
+            tree.write(feature.files.facade, facadeContent);
+        feature.warnings.forEach((warning) => report.add(warning));
+        ready.push(feature);
+    }
+    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);
+    return {
+        featuresFound: discovered.features.length,
+        featuresConverted: ready.length,
+        featuresSkipped: discovered.features.length - ready.length,
+        storeFilesKept: removal.keptFeatures.length,
+        creatorsWritten,
+        creatorsReused,
+        deletedFiles: removal.deletedFiles,
+        consumers,
+    };
+};
+export default async function migrate(tree, schema) {
+    console.log('\n🔄 Migrating @tomtomb/ngrx-toolkit stores to @ethlete/query...');
+    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.`);
+    report.writeToTree(tree);
+    report.printSummary();
+    if (!schema.skipFormat) {
+        await formatFiles(tree);
+    }
+}
+//# sourceMappingURL=migration.js.map