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

package/generators/deprecate-legacy-queries/migration.js

@@ -0,0 +1,77 @@
+import { formatFiles } from '@nx/devkit';
+import * as ts from 'typescript';
+import { createMigrationScope } from '../migrate-to-query-v3/migration-scope.js';
+import { addJsDocTag, createSourceFile, legacyQueryDeprecationTag } from '../migrate-to-query-v3/shared.js';
+const CREATOR_FN = 'createLegacyQueryCreator';
+const isMigratableFile = (filePath) => /\.(ts|mts|cts)$/.test(filePath) && !filePath.endsWith('.d.ts');
+const creatorNameOf = (call, sourceFile) => {
+    const [options] = call.arguments;
+    if (!options || !ts.isObjectLiteralExpression(options)) {
+        return undefined;
+    }
+    const property = options.properties.find((candidate) => ts.isPropertyAssignment(candidate) && candidate.name.getText(sourceFile) === 'creator');
+    if (!property || !ts.isIdentifier(property.initializer)) {
+        return undefined;
+    }
+    return property.initializer.text;
+};
+const collectWrappers = (sourceFile) => {
+    const wrappers = [];
+    const visit = (node) => {
+        if (ts.isVariableDeclaration(node) &&
+            node.initializer &&
+            ts.isCallExpression(node.initializer) &&
+            ts.isIdentifier(node.initializer.expression) &&
+            node.initializer.expression.text === CREATOR_FN) {
+            const statement = node.parent.parent;
+            // A wrapper declared inside a function body has no importable call sites to strike through.
+            if (ts.isVariableStatement(statement) && ts.isSourceFile(statement.parent)) {
+                wrappers.push({ statement, creatorName: creatorNameOf(node.initializer, sourceFile) });
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return wrappers;
+};
+export const deprecateLegacyQueries = (tree, scope) => {
+    let deprecatedWrappers = 0;
+    let touchedFiles = 0;
+    scope.visit(tree, (filePath) => {
+        if (!isMigratableFile(filePath))
+            return;
+        const content = tree.read(filePath, 'utf-8');
+        if (!content?.includes(CREATOR_FN))
+            return;
+        const sourceFile = createSourceFile(content, filePath);
+        const wrappers = collectWrappers(sourceFile);
+        let nextContent = content;
+        let tagged = 0;
+        // Back to front, so an insertion never shifts the position the next wrapper was parsed at.
+        for (const wrapper of wrappers.sort((a, b) => b.statement.getStart(sourceFile) - a.statement.getStart(sourceFile))) {
+            const updated = addJsDocTag(nextContent, sourceFile, wrapper.statement, legacyQueryDeprecationTag(wrapper.creatorName));
+            if (updated === null)
+                continue;
+            nextContent = updated;
+            tagged += 1;
+        }
+        if (tagged === 0)
+            return;
+        tree.write(filePath, nextContent);
+        deprecatedWrappers += tagged;
+        touchedFiles += 1;
+    });
+    return { deprecatedWrappers, touchedFiles };
+};
+export default async function migrate(tree, schema) {
+    console.log('\n🔄 Deprecating legacy query wrappers...');
+    const scope = createMigrationScope(tree, schema);
+    console.log(`   Scope: ${scope.describe()}`);
+    const { deprecatedWrappers, touchedFiles } = deprecateLegacyQueries(tree, scope);
+    console.log(`   Tagged ${deprecatedWrappers} wrapper${deprecatedWrappers === 1 ? '' : 's'} in ${touchedFiles} file${touchedFiles === 1 ? '' : 's'}.`);
+    if (!schema.skipFormat) {
+        await formatFiles(tree);
+    }
+    console.log('\n✅ Legacy query wrappers deprecated successfully!');
+}
+//# sourceMappingURL=migration.js.map

package/generators/deprecate-legacy-queries/schema.json

@@ -0,0 +1,26 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "$id": "deprecate-legacy-queries",
+  "title": "Deprecate legacy query wrappers",
+  "type": "object",
+  "properties": {
+    "projects": {
+      "type": "array",
+      "items": { "type": "string" },
+      "description": "Nx projects to migrate. Defaults to every project in the workspace.",
+      "alias": "project"
+    },
+    "include": {
+      "type": "array",
+      "items": { "type": "string" },
+      "description": "Path prefixes to migrate, relative to the workspace root (e.g. 'libs/queries'). Unioned with `projects`. Defaults to the whole workspace.",
+      "alias": "includePath"
+    },
+    "skipFormat": {
+      "type": "boolean",
+      "description": "Skip formatting files after migration",
+      "default": false
+    }
+  },
+  "required": []
+}

package/generators/generators.json

@@ -5,10 +5,25 @@
       "schema": "./migrate-to-query-v3/schema.json",
       "description": "Migrate from legacy query system to new query system using interop"
     },
+    "migrate-query-client-features": {
+      "factory": "./migrate-query-client-features/migration",
+      "schema": "./migrate-query-client-features/schema.json",
+      "description": "Migrate createQueryClient multiTabSync/persistence options to opt-in features"
+    },
     "prep-for-query-v3": {
       "factory": "./prep-for-query-v3/migration",
       "schema": "./prep-for-query-v3/schema.json",
       "description": "Update code to prepare for migration to query v3"
+    },
+    "deprecate-legacy-queries": {
+      "factory": "./deprecate-legacy-queries/migration",
+      "schema": "./deprecate-legacy-queries/schema.json",
+      "description": "Mark existing createLegacyQueryCreator wrappers as @deprecated so their call sites surface as still on v2"
+    },
+    "migrate-query-opt-in-features": {
+      "factory": "./migrate-query-opt-in-features/migration",
+      "schema": "./migrate-query-opt-in-features/schema.json",
+      "description": "Migrate query clients to the opt-in error pipeline and bearer auth providers to the opt-in multi-tab sync feature"
     }
   }
 }

package/generators/migrate-query-client-features/migration.js

@@ -0,0 +1,142 @@
+import { formatFiles } from '@nx/devkit';
+import * as ts from 'typescript';
+import { createMigrationScope } from '../migrate-to-query-v3/migration-scope.js';
+import { createSourceFile, ensureImportFromQuery, getLineNumber } from '../migrate-to-query-v3/shared.js';
+import { QueryClientFeaturesMigrationReport } from './report.js';
+const SOURCE = 'query-client-features';
+const isMigratableFile = (filePath) => /\.(ts|mts|cts)$/.test(filePath) && !filePath.endsWith('.d.ts');
+const featureCallFor = (property, featureFn, sourceFile) => {
+    if (!property)
+        return `${featureFn}()`;
+    const value = property.initializer;
+    if (value.kind === ts.SyntaxKind.FalseKeyword)
+        return null;
+    if (value.kind === ts.SyntaxKind.TrueKeyword)
+        return `${featureFn}()`;
+    return `${featureFn}(${value.getText(sourceFile)})`;
+};
+const collectClientEdits = (filePath, sourceFile, report) => {
+    const edits = [];
+    const visit = (node) => {
+        if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === 'createQueryClient') {
+            const [config] = node.arguments;
+            const line = getLineNumber(node, sourceFile);
+            if (!config || !ts.isObjectLiteralExpression(config)) {
+                report.addManualReview({
+                    title: 'createQueryClient called with a non-literal config',
+                    summary: 'The client config is not an object literal, so the codemod cannot tell whether it sets `multiTabSync` or `persistence`.',
+                    action: 'Move the config inline, or replace the removed `multiTabSync` / `persistence` options with `features: [withMultiTabSync(), withQueryPersistence()]` by hand. Consider dropping a feature the app does not rely on instead — that removes the whole subsystem from the bundle.',
+                    locations: [{ filePath, line }],
+                    source: SOURCE,
+                    dedupeKey: 'non-literal-config',
+                });
+            }
+            else if (config.properties.some((property) => ts.isSpreadAssignment(property))) {
+                report.addManualReview({
+                    title: 'createQueryClient config spreads another object',
+                    summary: 'The spread may carry `multiTabSync` or `persistence`, which no longer exist on the client config.',
+                    action: 'Check what the spread contributes and express it as `features: [withMultiTabSync(), withQueryPersistence()]` by hand. Consider dropping a feature the app does not rely on instead — that removes the whole subsystem from the bundle.',
+                    locations: [{ filePath, line }],
+                    source: SOURCE,
+                    dedupeKey: 'spread-config',
+                });
+            }
+            else {
+                const named = (name) => config.properties.find((property) => ts.isPropertyAssignment(property) && property.name.getText(sourceFile) === name);
+                const syncProperty = named('multiTabSync');
+                const persistenceProperty = named('persistence');
+                const featuresProperty = named('features');
+                if (featuresProperty) {
+                    report.addManualReview({
+                        title: 'createQueryClient already has a features array',
+                        summary: 'The client was left untouched so an existing `features` array is not overwritten.',
+                        action: 'Fold the removed `multiTabSync` / `persistence` options into the existing `features` array.',
+                        locations: [{ filePath, line }],
+                        source: SOURCE,
+                        dedupeKey: 'existing-features',
+                    });
+                }
+                else {
+                    for (const property of [syncProperty, persistenceProperty]) {
+                        const value = property?.initializer;
+                        if (!value)
+                            continue;
+                        if (value.kind === ts.SyntaxKind.TrueKeyword ||
+                            value.kind === ts.SyntaxKind.FalseKeyword ||
+                            ts.isObjectLiteralExpression(value)) {
+                            continue;
+                        }
+                        report.addWarning({
+                            title: 'Client option value is not a literal',
+                            summary: 'A `multiTabSync` / `persistence` value that is a variable or expression was passed through as the feature config, which is wrong if it can be a boolean.',
+                            action: 'Check the value: a config object is fine as is, a boolean has to become a present or absent feature.',
+                            locations: [{ filePath, line }],
+                            source: SOURCE,
+                            dedupeKey: 'non-literal-option-value',
+                        });
+                    }
+                    const features = [
+                        featureCallFor(syncProperty, 'withMultiTabSync', sourceFile),
+                        featureCallFor(persistenceProperty, 'withQueryPersistence', sourceFile),
+                    ].filter((feature) => feature !== null);
+                    const kept = config.properties
+                        .filter((property) => property !== syncProperty && property !== persistenceProperty)
+                        .map((property) => property.getText(sourceFile));
+                    const properties = [...kept, ...(features.length > 0 ? [`features: [${features.join(', ')}]`] : [])];
+                    edits.push({
+                        start: config.getStart(sourceFile),
+                        end: config.getEnd(),
+                        text: `{ ${properties.join(', ')} }`,
+                        features,
+                    });
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return edits;
+};
+export const migrateQueryClientFeatures = (tree, report, scope) => {
+    let migratedClients = 0;
+    scope.visit(tree, (filePath) => {
+        if (!isMigratableFile(filePath))
+            return;
+        const content = tree.read(filePath, 'utf-8');
+        if (!content?.includes('createQueryClient'))
+            return;
+        const sourceFile = createSourceFile(content, filePath);
+        const edits = collectClientEdits(filePath, sourceFile, report);
+        if (edits.length === 0)
+            return;
+        let nextContent = content;
+        // Applied back to front so an earlier edit cannot shift a later one's offsets.
+        for (const edit of [...edits].sort((a, b) => b.start - a.start)) {
+            nextContent = nextContent.slice(0, edit.start) + edit.text + nextContent.slice(edit.end);
+        }
+        const importsNeeded = [...new Set(edits.flatMap((edit) => edit.features))]
+            .map((feature) => feature.slice(0, feature.indexOf('(')))
+            .sort();
+        if (importsNeeded.length > 0) {
+            nextContent = ensureImportFromQuery(nextContent, importsNeeded);
+        }
+        tree.write(filePath, nextContent);
+        migratedClients += edits.length;
+    });
+    return { migratedClients };
+};
+export default async function migrate(tree, schema) {
+    console.log('\n🔄 Migrating query clients to opt-in features...');
+    const scope = createMigrationScope(tree, schema);
+    console.log(`   Scope: ${scope.describe()}`);
+    const report = new QueryClientFeaturesMigrationReport();
+    const { migratedClients } = migrateQueryClientFeatures(tree, report, scope);
+    console.log(`   Migrated ${migratedClients} query client${migratedClients === 1 ? '' : 's'}.`);
+    report.writeToTree(tree);
+    report.printSummary();
+    if (!schema.skipFormat) {
+        await formatFiles(tree);
+    }
+    console.log('\n✅ Query client feature migration completed successfully!');
+}
+//# sourceMappingURL=migration.js.map

package/generators/migrate-query-client-features/report.js

@@ -0,0 +1,136 @@
+export const QUERY_CLIENT_FEATURES_REPORT_PATH = 'query-client-features-migration-tasks.md';
+export const MIGRATION_TASK_KIND = {
+    WARNING: 'warning',
+    MANUAL_REVIEW: 'manual-review',
+    FOLLOW_UP: 'follow-up',
+};
+const renderTaskLocations = (locations) => {
+    if (locations.length === 0) {
+        return '- None recorded';
+    }
+    return locations.map((location) => `- ${location.filePath}${location.line ? `:${location.line}` : ''}`).join('\n');
+};
+export class QueryClientFeaturesMigrationReport {
+    constructor() {
+        this.tasks = [];
+    }
+    addTask(input) {
+        const dedupeKey = input.dedupeKey ?? `${input.kind}:${input.title}:${input.summary}:${input.action}`;
+        const existing = this.tasks.find((task) => task.dedupeKey === dedupeKey);
+        if (existing) {
+            existing.locations.push(...(input.locations ?? []));
+            return;
+        }
+        this.tasks.push({
+            id: `QCF-${String(this.tasks.length + 1).padStart(3, '0')}`,
+            kind: input.kind,
+            title: input.title,
+            summary: input.summary,
+            action: input.action,
+            locations: input.locations ?? [],
+            source: input.source,
+            dedupeKey,
+        });
+    }
+    addWarning(input) {
+        this.addTask({ ...input, kind: MIGRATION_TASK_KIND.WARNING });
+    }
+    addManualReview(input) {
+        this.addTask({ ...input, kind: MIGRATION_TASK_KIND.MANUAL_REVIEW });
+    }
+    addFollowUp(input) {
+        this.addTask({ ...input, kind: MIGRATION_TASK_KIND.FOLLOW_UP });
+    }
+    printSummary() {
+        if (this.tasks.length === 0) {
+            return;
+        }
+        console.warn(`\n⚠️ Generated ${this.tasks.length} follow-up task${this.tasks.length === 1 ? '' : 's'}:`);
+        this.tasks.forEach((task) => {
+            const locations = task.locations
+                .map((location) => `${location.filePath}${location.line ? `:${location.line}` : ''}`)
+                .join(', ');
+            console.warn(` - ${task.id} [${task.kind}] ${task.title}${locations ? ` (${locations})` : ''}`);
+        });
+        console.warn(`\n📄 See ${QUERY_CLIENT_FEATURES_REPORT_PATH} for the AI-ready follow-up list.`);
+    }
+    writeToTree(tree) {
+        tree.write(QUERY_CLIENT_FEATURES_REPORT_PATH, renderMigrationReportMarkdown(this.tasks));
+    }
+}
+export const renderMigrationReportMarkdown = (tasks) => {
+    const header = [
+        '# Query Client Features Migration Follow-Up',
+        '',
+        'This file is generated by the `migrate-query-client-features` generator.',
+        '',
+        '## Context',
+        '',
+        'Multi-tab sync and query persistence used to be on by default and are now opt-in features of',
+        '`createQueryClient`. The codemod is **behavior preserving**: every client that did not opt out',
+        'gets `withMultiTabSync()` / `withQueryPersistence()` so it keeps working exactly as before.',
+        'That is rarely what an app wants long term — dropping a feature it never relied on removes the',
+        'whole subsystem from the bundle, so review each added feature and delete the ones you do not need.',
+        '',
+        '## AI Instructions',
+        '',
+        '1. Re-read the referenced files before changing anything. The migration output is only a starting point.',
+        '2. Prefer minimal fixes that align with the current runtime APIs in `@ethlete/query`.',
+        '3. Update or remove a task only after the code and tests confirm that it is resolved.',
+        '4. If a task is still ambiguous after inspection, keep it open and append a short note instead of guessing.',
+        '',
+        '## Task Format',
+        '',
+        '- `Status`: always treat generated tasks as `open` until verified manually or by tests.',
+        '- `Kind`: `warning`, `manual-review`, or `follow-up`.',
+        '- `Source`: which migration phase raised the task.',
+        '',
+    ].join('\n');
+    if (tasks.length === 0) {
+        return `${header}## Tasks\n\nNo open follow-up tasks were recorded during this migration run.\n`;
+    }
+    const tasksSection = tasks
+        .map((task) => [
+        `### ${task.id} - ${task.title}`,
+        '',
+        '- Status: open',
+        `- Kind: ${task.kind}`,
+        `- Source: ${task.source}`,
+        `- Summary: ${task.summary}`,
+        `- Suggested action: ${task.action}`,
+        '- Locations:',
+        renderTaskLocations(task.locations),
+        '',
+    ].join('\n'))
+        .join('');
+    const machineSection = [
+        '## Machine Summary',
+        '',
+        '```yaml',
+        'tasks:',
+        ...tasks.flatMap((task) => {
+            const nestedLocations = task.locations.flatMap((location) => {
+                const lines = [`      - filePath: ${location.filePath}`];
+                if (location.line) {
+                    lines.push(`        line: ${location.line}`);
+                }
+                return lines;
+            });
+            return [
+                `  - id: ${task.id}`,
+                `    status: open`,
+                `    kind: ${task.kind}`,
+                `    source: ${task.source}`,
+                `    title: ${task.title}`,
+                `    summary: ${task.summary}`,
+                `    action: ${task.action}`,
+                `    locations:`,
+                ...(nestedLocations.length > 0 ? nestedLocations : ['      []']),
+            ];
+        }),
+        '```',
+        '',
+    ].join('\n');
+    return `${header}## Tasks\n\n${tasksSection}${machineSection}`;
+};
+//# sourceMappingURL=report.js.map

package/generators/migrate-query-client-features/schema.json

@@ -0,0 +1,26 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "$id": "migrate-query-client-features",
+  "title": "Migrate query clients to opt-in features",
+  "type": "object",
+  "properties": {
+    "projects": {
+      "type": "array",
+      "items": { "type": "string" },
+      "description": "Nx projects to migrate. Defaults to every project in the workspace.",
+      "alias": "project"
+    },
+    "include": {
+      "type": "array",
+      "items": { "type": "string" },
+      "description": "Path prefixes to migrate, relative to the workspace root (e.g. 'libs/queries'). Unioned with `projects`. Defaults to the whole workspace.",
+      "alias": "includePath"
+    },
+    "skipFormat": {
+      "type": "boolean",
+      "description": "Skip formatting files after migration",
+      "default": false
+    }
+  },
+  "required": []
+}

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

@@ -0,0 +1,194 @@
+import { formatFiles } from '@nx/devkit';
+import * as ts from 'typescript';
+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';
+const AUTH_FEATURE = 'withBearerAuthMultiTabSync';
+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) => {
+    const features = propertyNamed(config, sourceFile, 'features')?.initializer;
+    return (!!features &&
+        ts.isArrayLiteralExpression(features) &&
+        features.elements.some((element) => ts.isCallExpression(element) && ts.isIdentifier(element.expression) && element.expression.text === feature));
+};
+/** `{ enabled: false, channelName: 'x' }` -> `withBearerAuthMultiTabSync({ channelName: 'x' })`, or `null` when off. */
+const authFeatureCallFor = (property, sourceFile) => {
+    if (!property)
+        return `${AUTH_FEATURE}()`;
+    const value = property.initializer;
+    if (value.kind === ts.SyntaxKind.FalseKeyword)
+        return null;
+    if (value.kind === ts.SyntaxKind.TrueKeyword)
+        return `${AUTH_FEATURE}()`;
+    if (ts.isObjectLiteralExpression(value)) {
+        const enabled = propertyNamed(value, sourceFile, 'enabled');
+        if (enabled?.initializer.kind === ts.SyntaxKind.FalseKeyword)
+            return null;
+        const kept = value.properties.filter((entry) => entry !== enabled).map((entry) => entry.getText(sourceFile));
+        return kept.length > 0 ? `${AUTH_FEATURE}({ ${kept.join(', ')} })` : `${AUTH_FEATURE}()`;
+    }
+    return `${AUTH_FEATURE}(${value.getText(sourceFile)})`;
+};
+const withFeatureAdded = (config, sourceFile, removed, feature) => {
+    const featuresProperty = propertyNamed(config, sourceFile, 'features');
+    const properties = [];
+    for (const property of config.properties) {
+        if (property === removed)
+            continue;
+        if (property === featuresProperty && feature) {
+            const existing = featuresProperty.initializer;
+            const entries = ts.isArrayLiteralExpression(existing)
+                ? existing.elements.map((element) => element.getText(sourceFile))
+                : [`...${existing.getText(sourceFile)}`];
+            properties.push(`features: [${[...entries, feature].join(', ')}]`);
+            continue;
+        }
+        properties.push(property.getText(sourceFile));
+    }
+    if (!featuresProperty && feature)
+        properties.push(`features: [${feature}]`);
+    return `{ ${properties.join(', ')} }`;
+};
+const collectEdits = (filePath, sourceFile, report) => {
+    const edits = [];
+    const visit = (node) => {
+        if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
+            const callee = node.expression.text;
+            const isClient = callee === 'createQueryClient';
+            const isAuth = callee === 'createBearerAuthProvider';
+            if (isClient || isAuth) {
+                const [config] = node.arguments;
+                const line = getLineNumber(node, sourceFile);
+                if (!config || !ts.isObjectLiteralExpression(config)) {
+                    report.addManualReview({
+                        title: `${callee} called with a non-literal config`,
+                        summary: 'The config is not an object literal, so the codemod cannot add the opt-in feature to it.',
+                        action: `Add \`${isClient ? CLIENT_FEATURE : AUTH_FEATURE}()\` to the config's \`features\` array by hand, or drop the behavior if the app does not rely on it.`,
+                        locations: [{ filePath, line }],
+                        source: SOURCE,
+                        dedupeKey: `non-literal-config:${callee}`,
+                    });
+                }
+                else if (config.properties.some((property) => ts.isSpreadAssignment(property))) {
+                    report.addManualReview({
+                        title: `${callee} config spreads another object`,
+                        summary: 'The spread may already carry `features`, or the removed `multiTabSync` option.',
+                        action: `Check what the spread contributes and add \`${isClient ? CLIENT_FEATURE : AUTH_FEATURE}()\` to the resulting \`features\` array by hand.`,
+                        locations: [{ filePath, line }],
+                        source: SOURCE,
+                        dedupeKey: `spread-config:${callee}`,
+                    });
+                }
+                else if (isClient && hasFeature(config, sourceFile, CLIENT_FEATURE)) {
+                    return;
+                }
+                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',
+                    });
+                    edits.push({
+                        start: config.getStart(sourceFile),
+                        end: config.getEnd(),
+                        text: withFeatureAdded(config, sourceFile, undefined, feature),
+                        features: [feature],
+                    });
+                }
+                else {
+                    const syncProperty = propertyNamed(config, sourceFile, 'multiTabSync');
+                    const alreadyAdded = hasFeature(config, sourceFile, AUTH_FEATURE);
+                    if (alreadyAdded && !syncProperty)
+                        return;
+                    const value = syncProperty?.initializer;
+                    if (value &&
+                        value.kind !== ts.SyntaxKind.TrueKeyword &&
+                        value.kind !== ts.SyntaxKind.FalseKeyword &&
+                        !ts.isObjectLiteralExpression(value)) {
+                        report.addWarning({
+                            title: 'multiTabSync value is not a literal',
+                            summary: 'A `multiTabSync` value that is a variable or expression was passed through as the feature config, which is wrong if it can be a boolean.',
+                            action: 'Check the value: a config object is fine as is, a boolean has to become a present or absent feature.',
+                            locations: [{ filePath, line }],
+                            source: SOURCE,
+                            dedupeKey: 'non-literal-multi-tab-sync',
+                        });
+                    }
+                    const feature = alreadyAdded ? null : authFeatureCallFor(syncProperty, sourceFile);
+                    if (feature) {
+                        report.addFollowUp({
+                            title: 'Auth provider kept multi-tab sync',
+                            summary: `\`${AUTH_FEATURE}()\` was added so cross-tab login/logout and leader election keep working as before.`,
+                            action: 'Drop it if the app is only ever open in one tab (a kiosk, an embedded webview) - that removes the BroadcastChannel sync and the Web Locks leader election from the bundle.',
+                            locations: [{ filePath, line }],
+                            source: SOURCE,
+                            dedupeKey: 'auth-multi-tab-sync',
+                        });
+                    }
+                    edits.push({
+                        start: config.getStart(sourceFile),
+                        end: config.getEnd(),
+                        text: withFeatureAdded(config, sourceFile, syncProperty, feature),
+                        features: feature ? [feature] : [],
+                    });
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return edits;
+};
+export const migrateQueryOptInFeatures = (tree, report, scope, { reportOnly = false } = {}) => {
+    let migratedSites = 0;
+    scope.visit(tree, (filePath) => {
+        if (!isMigratableFile(filePath))
+            return;
+        const content = tree.read(filePath, 'utf-8');
+        if (!content?.includes('createQueryClient') && !content?.includes('createBearerAuthProvider'))
+            return;
+        const sourceFile = createSourceFile(content, filePath);
+        const edits = collectEdits(filePath, sourceFile, report);
+        if (edits.length === 0)
+            return;
+        migratedSites += edits.length;
+        if (reportOnly)
+            return;
+        let nextContent = content;
+        // Applied back to front so an earlier edit cannot shift a later one's offsets.
+        for (const edit of [...edits].sort((a, b) => b.start - a.start)) {
+            nextContent = nextContent.slice(0, edit.start) + edit.text + nextContent.slice(edit.end);
+        }
+        const importsNeeded = [...new Set(edits.flatMap((edit) => edit.features))]
+            .map((feature) => feature.slice(0, feature.indexOf('(')))
+            .sort();
+        if (importsNeeded.length > 0) {
+            nextContent = ensureImportFromQuery(nextContent, importsNeeded);
+        }
+        tree.write(filePath, nextContent);
+    });
+    return { migratedSites };
+};
+export default async function migrate(tree, schema) {
+    const reportOnly = schema.reportOnly ?? false;
+    console.log(`\n🔄 ${reportOnly ? 'Reporting' : 'Migrating'} query clients and auth providers to opt-in features...`);
+    const scope = createMigrationScope(tree, schema);
+    console.log(`   Scope: ${scope.describe()}`);
+    const report = new QueryOptInFeaturesMigrationReport();
+    const { migratedSites } = migrateQueryOptInFeatures(tree, report, scope, { reportOnly });
+    console.log(`   ${reportOnly ? 'Found' : 'Migrated'} ${migratedSites} call site${migratedSites === 1 ? '' : 's'}.${reportOnly ? ' No files were changed.' : ''}`);
+    report.writeToTree(tree);
+    report.printSummary();
+    if (!schema.skipFormat && !reportOnly) {
+        await formatFiles(tree);
+    }
+    console.log('\n✅ Query opt-in feature migration completed successfully!');
+}
+//# sourceMappingURL=migration.js.map