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

package/generators/migrate-to-query-v3/rename-symbols.js

@@ -1,11 +1,11 @@
 import * as ts from 'typescript';
-import { createSourceFile } from './shared.js';
+import { createSourceFile, printImportDeclaration } from './shared.js';
 /**
  * Whether an identifier is a *name* rather than a *reference* - a declaration, a property key, the
  * right-hand side of a member access. Renaming those is what turned `PeopleDetailDataSource.getPerson`
  * and the `postLogin` property of a config type into `legacy…` during the first migration run.
  */
-const isNamePosition = (node) => {
+export const isNamePosition = (node) => {
     const parent = node.parent;
     if (!parent)
         return false;
@@ -65,7 +65,7 @@ const isNamePosition = (node) => {
         return true;
     return false;
 };
-const renamedReference = (node, nextName) => {
+export const renamedReference = (node, nextName) => {
     const parent = node.parent;
     if (ts.isShorthandPropertyAssignment(parent))
         return `${node.text}: ${nextName}`;
@@ -73,6 +73,38 @@ const renamedReference = (node, nextName) => {
         return `${nextName} as ${node.text}`;
     return nextName;
 };
+const bindingDeclares = (name, text) => ts.isIdentifier(name)
+    ? name.text === text
+    : name.elements.some((element) => !ts.isOmittedExpression(element) && bindingDeclares(element.name, text));
+const statementDeclares = (statement, text) => (ts.isVariableStatement(statement) &&
+    statement.declarationList.declarations.some((declaration) => bindingDeclares(declaration.name, text))) ||
+    ((ts.isFunctionDeclaration(statement) || ts.isClassDeclaration(statement) || ts.isEnumDeclaration(statement)) &&
+        statement.name?.text === text);
+export const isShadowedInNestedScope = (identifier) => {
+    const text = identifier.text;
+    for (let scope = identifier.parent; scope && !ts.isSourceFile(scope); scope = scope.parent) {
+        if (ts.isFunctionLike(scope) && scope.parameters.some((parameter) => bindingDeclares(parameter.name, text))) {
+            return true;
+        }
+        if ((ts.isFunctionExpression(scope) || ts.isClassExpression(scope)) && scope.name?.text === text) {
+            return true;
+        }
+        if ((ts.isBlock(scope) || ts.isModuleBlock(scope) || ts.isCaseClause(scope) || ts.isDefaultClause(scope)) &&
+            scope.statements.some((statement) => statementDeclares(statement, text))) {
+            return true;
+        }
+        if ((ts.isForStatement(scope) || ts.isForInStatement(scope) || ts.isForOfStatement(scope)) &&
+            scope.initializer &&
+            ts.isVariableDeclarationList(scope.initializer) &&
+            scope.initializer.declarations.some((declaration) => bindingDeclares(declaration.name, text))) {
+            return true;
+        }
+        if (ts.isCatchClause(scope) && scope.variableDeclaration && bindingDeclares(scope.variableDeclaration.name, text)) {
+            return true;
+        }
+    }
+    return false;
+};
 /** Every name the file declares itself - a local by the same name means the import is shadowed. */
 const collectLocalDeclarations = (sourceFile) => {
     const declared = new Set();
@@ -183,18 +215,13 @@ export const pruneUnusedNamedImports = (content) => {
         const kept = node.importClause.namedBindings.elements.filter((element) => used.has(element.name.text));
         if (kept.length === node.importClause.namedBindings.elements.length)
             continue;
-        const hasDefaultImport = !!node.importClause.name;
-        if (kept.length === 0 && !hasDefaultImport) {
+        const nextImport = printImportDeclaration(node, sourceFile, kept.map((element) => element.getText(sourceFile)));
+        if (!nextImport) {
             const end = content[node.getEnd()] === '\n' ? node.getEnd() + 1 : node.getEnd();
             replacements.push({ start: node.getStart(sourceFile), end, replacement: '' });
             continue;
         }
-        const defaultPart = hasDefaultImport ? `${node.importClause.name.text}, ` : '';
-        replacements.push({
-            start: node.getStart(sourceFile),
-            end: node.getEnd(),
-            replacement: `import ${defaultPart}{ ${kept.map((element) => element.getText(sourceFile)).join(', ')} } from '${node.moduleSpecifier.text}';`,
-        });
+        replacements.push({ start: node.getStart(sourceFile), end: node.getEnd(), replacement: nextImport });
     }
     let result = content;
     replacements.sort((left, right) => right.start - left.start);

package/generators/migrate-to-query-v3/report.js

@@ -25,7 +25,7 @@ export class QueryV3MigrationReport {
             return;
         }
         const nextTask = {
-            id: `QV3-${String(this.tasks.length + 1).padStart(3, '0')}`,
+            id: formatTaskId(this.tasks.length + 1),
             kind: input.kind,
             title: input.title,
             summary: input.summary,
@@ -58,11 +58,37 @@ export class QueryV3MigrationReport {
         });
         console.warn(`\n📄 See ${QUERY_V3_MIGRATION_REPORT_PATH} for the AI-ready follow-up list.`);
     }
-    writeToTree(tree) {
-        tree.write(QUERY_V3_MIGRATION_REPORT_PATH, renderMigrationReportMarkdown(this.tasks));
+    /**
+     * Writes the report. A scoped run (`scopeLabel` set) replaces its own section of an existing report
+     * or appends one, so the tasks of earlier runs over other projects survive.
+     */
+    writeToTree(tree, scopeLabel) {
+        const existing = scopeLabel ? tree.read(QUERY_V3_MIGRATION_REPORT_PATH, 'utf-8') : null;
+        if (!scopeLabel || !existing) {
+            tree.write(QUERY_V3_MIGRATION_REPORT_PATH, renderMigrationReportMarkdown(this.tasks, scopeLabel));
+            return;
+        }
+        tree.write(QUERY_V3_MIGRATION_REPORT_PATH, mergeScopedSection(existing, this.tasks, scopeLabel));
     }
 }
-export const renderMigrationReportMarkdown = (tasks) => {
+const sectionStart = (scopeLabel) => `<!-- migrate-to-query-v3 scope: ${scopeLabel} -->`;
+const SECTION_END = '<!-- /migrate-to-query-v3 scope -->';
+const mergeScopedSection = (existing, tasks, scopeLabel) => {
+    const start = sectionStart(scopeLabel);
+    const startIndex = existing.indexOf(start);
+    const endIndex = startIndex === -1 ? -1 : existing.indexOf(SECTION_END, startIndex);
+    const [before, after] = startIndex === -1 || endIndex === -1
+        ? [existing.trimEnd(), '']
+        : [existing.slice(0, startIndex).trimEnd(), existing.slice(endIndex + SECTION_END.length).trimStart()];
+    const highestId = Math.max(0, ...Array.from(`${before}\n${after}`.matchAll(/QV3-(\d+)/g), (match) => Number(match[1])));
+    const renumbered = tasks.map((task, index) => ({ ...task, id: formatTaskId(highestId + index + 1) }));
+    return [before, renderTasksSection(renumbered, scopeLabel), after]
+        .filter((part) => part.length > 0)
+        .join('\n\n')
+        .concat('\n');
+};
+const formatTaskId = (index) => `QV3-${String(index).padStart(3, '0')}`;
+export const renderMigrationReportMarkdown = (tasks, scopeLabel) => {
     const header = [
         '# Query V3 Migration Follow-Up',
         '',
@@ -83,8 +109,16 @@ export const renderMigrationReportMarkdown = (tasks) => {
         '- `Source`: which migration phase raised the task.',
         '',
     ].join('\n');
+    return `${header}${renderTasksSection(tasks, scopeLabel)}\n`;
+};
+const renderTasksSection = (tasks, scopeLabel) => {
+    const heading = scopeLabel ? `## Tasks (scope: ${scopeLabel})` : '## Tasks';
+    const body = renderTasksBody(tasks);
+    return scopeLabel ? `${sectionStart(scopeLabel)}\n${heading}\n\n${body}\n${SECTION_END}` : `${heading}\n\n${body}`;
+};
+const renderTasksBody = (tasks) => {
     if (tasks.length === 0) {
-        return `${header}## Tasks\n\nNo open follow-up tasks were recorded during this migration run.\n`;
+        return 'No open follow-up tasks were recorded during this migration run.';
     }
     const tasksSection = tasks
         .map((task) => {
@@ -129,8 +163,7 @@ export const renderMigrationReportMarkdown = (tasks) => {
             ];
         }),
         '```',
-        '',
     ].join('\n');
-    return `${header}## Tasks\n\n${tasksSection}${machineSection}`;
+    return `${tasksSection}${machineSection}`;
 };
 //# sourceMappingURL=report.js.map

package/generators/migrate-to-query-v3/shared.js

@@ -13,6 +13,23 @@ export const ensureConfigSuffix = (name) => {
     }
     return `${name}Config`;
 };
+const importSpecifierText = (element) => element.propertyName ? `${element.propertyName.text} as ${element.name.text}` : element.name.text;
+/**
+ * Prints `node` with `namedElements` as its named bindings, keeping the default import, the
+ * `import type` modifier, the quote style and any import attributes. Returns an empty string when
+ * nothing would be left to import.
+ */
+export const printImportDeclaration = (node, sourceFile, namedElements) => {
+    const clause = node.importClause;
+    const defaultName = clause?.name?.text;
+    const bindings = [defaultName, namedElements.length > 0 ? `{ ${namedElements.join(', ')} }` : undefined].filter((part) => !!part);
+    if (bindings.length === 0) {
+        return '';
+    }
+    const typePrefix = clause?.isTypeOnly ? 'type ' : '';
+    const attributes = node.attributes ? ` ${node.attributes.getText(sourceFile)}` : '';
+    return `import ${typePrefix}${bindings.join(', ')} from ${node.moduleSpecifier.getText(sourceFile)}${attributes};`;
+};
 export const ensureNamedImports = ({ content, importsNeeded, moduleSpecifier }) => {
     const sourceFile = createSourceFile(content);
     let importNode;
@@ -32,13 +49,14 @@ export const ensureNamedImports = ({ content, importsNeeded, moduleSpecifier })
         const namedBindings = importNode.importClause.namedBindings;
         namedBindings.elements.forEach((element) => {
             missingImports.delete(element.name.text);
+            missingImports.delete(importSpecifierText(element));
         });
         if (missingImports.size === 0) {
             return content;
         }
         const existingImports = namedBindings.elements.map((element) => element.getText(sourceFile));
         const nextImports = [...existingImports, ...Array.from(missingImports).sort()].sort();
-        const nextImportStatement = `import { ${nextImports.join(', ')} } from '${moduleSpecifier}';`;
+        const nextImportStatement = printImportDeclaration(importNode, sourceFile, nextImports);
         return content.slice(0, importNode.getStart(sourceFile)) + nextImportStatement + content.slice(importNode.getEnd());
     }
     let lastImportEnd = 0;
@@ -143,4 +161,31 @@ export const addJsDocTag = (content, sourceFile, node, tag) => {
     const indentation = ' '.repeat(sourceFile.getLineAndCharacterOfPosition(start).character);
     return (content.slice(0, start) + `/**\n${indentation} * ${tag}\n${indentation} */\n${indentation}` + content.slice(start));
 };
+const TUPLE_PROVIDER_ACTION = 'Delete the call: a v3 client, auth provider or socket is root-provided the moment something injects it. For a test or an override, provide it with `toProvideFn(ref)` from `@ethlete/core`.';
+export const REMOVED_EXPERIMENTAL_QUERY_HELPERS = {
+    createQueryClientConfig: 'Replace it with `createQueryClient({ name, baseUrl })`, which returns the provider tuple, and derive `toProvideFn` / `toInjectFn` from it.',
+    createBearerAuthProviderConfig: 'Replace it with `createBearerAuthProvider({ name, queryClientRef, queries, features })`, which returns the provider tuple, and derive `toProvideFn` / `toInjectFn` from it.',
+    provideQueryClient: TUPLE_PROVIDER_ACTION,
+    provideBearerAuthProvider: TUPLE_PROVIDER_ACTION,
+    provideWebSocketClient: `Build the socket with \`createWebSocketClient({ name, url, io })\`. ${TUPLE_PROVIDER_ACTION}`,
+};
+export const findRemovedExperimentalQueryHelpers = (sourceFile) => {
+    const found = [];
+    sourceFile.statements.forEach((statement) => {
+        if (!ts.isImportDeclaration(statement) ||
+            !ts.isStringLiteral(statement.moduleSpecifier) ||
+            statement.moduleSpecifier.text !== '@ethlete/query' ||
+            !statement.importClause?.namedBindings ||
+            !ts.isNamedImports(statement.importClause.namedBindings)) {
+            return;
+        }
+        statement.importClause.namedBindings.elements.forEach((element) => {
+            const name = (element.propertyName ?? element.name).text;
+            if (name in REMOVED_EXPERIMENTAL_QUERY_HELPERS) {
+                found.push({ name, line: getLineNumber(element, sourceFile) });
+            }
+        });
+    });
+    return found;
+};
 //# sourceMappingURL=shared.js.map