@ethlete/query 6.0.0-next.46 → 6.0.0-next.49

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

@@ -17,8 +17,6 @@ const isNamePosition = (node) => {
     // Object literal / type member keys, enum members, JSX-ish attribute names.
     if (ts.isPropertyAssignment(parent) && parent.name === node)
         return true;
-    if (ts.isShorthandPropertyAssignment(parent) && parent.name === node)
-        return true;
     if (ts.isPropertySignature(parent) && parent.name === node)
         return true;
     if (ts.isMethodSignature(parent) && parent.name === node)
@@ -57,12 +55,24 @@ const isNamePosition = (node) => {
     if (ts.isLabeledStatement(parent) && parent.label === node)
         return true;
     // Import / export clauses are rewritten by the caller, never by the reference pass.
-    if (ts.isImportSpecifier(parent) || ts.isExportSpecifier(parent))
+    if (ts.isImportSpecifier(parent))
+        return true;
+    if (ts.isExportSpecifier(parent) &&
+        (parent.parent.parent.moduleSpecifier || (parent.propertyName && parent.name === node))) {
         return true;
+    }
     if (ts.isImportClause(parent) || ts.isNamespaceImport(parent))
         return true;
     return false;
 };
+const renamedReference = (node, nextName) => {
+    const parent = node.parent;
+    if (ts.isShorthandPropertyAssignment(parent))
+        return `${node.text}: ${nextName}`;
+    if (ts.isExportSpecifier(parent) && !parent.propertyName)
+        return `${nextName} as ${node.text}`;
+    return nextName;
+};
 /** Every name the file declares itself - a local by the same name means the import is shadowed. */
 const collectLocalDeclarations = (sourceFile) => {
     const declared = new Set();
@@ -115,7 +125,11 @@ export const renameImportedReferences = (content, renames) => {
         if (ts.isIdentifier(node)) {
             const nextName = applicable.get(node.text);
             if (nextName && !isNamePosition(node)) {
-                replacements.push({ start: node.getStart(sourceFile), end: node.getEnd(), replacement: nextName });
+                replacements.push({
+                    start: node.getStart(sourceFile),
+                    end: node.getEnd(),
+                    replacement: renamedReference(node, nextName),
+                });
             }
         }
         ts.forEachChild(node, visit);
@@ -136,7 +150,7 @@ export const renameImportedReferences = (content, renames) => {
  * the same generator invocation so they land that way. Identifiers inside template strings count as
  * usage too - a component referenced only from an inline template must not be pruned.
  */
-export const pruneUnusedNamedImports = (content, moduleSpecifiers) => {
+export const pruneUnusedNamedImports = (content) => {
     const sourceFile = createSourceFile(content);
     const used = new Set();
     const addWordsFrom = (text) => {
@@ -162,7 +176,6 @@ export const pruneUnusedNamedImports = (content, moduleSpecifiers) => {
     for (const node of sourceFile.statements) {
         if (!ts.isImportDeclaration(node) ||
             !ts.isStringLiteral(node.moduleSpecifier) ||
-            (moduleSpecifiers !== 'all' && !moduleSpecifiers.includes(node.moduleSpecifier.text)) ||
             !node.importClause?.namedBindings ||
             !ts.isNamedImports(node.importClause.namedBindings)) {
             continue;

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

@@ -17,9 +17,13 @@ export const ensureNamedImports = ({ content, importsNeeded, moduleSpecifier })
     const sourceFile = createSourceFile(content);
     let importNode;
     ts.forEachChild(sourceFile, (node) => {
-        if (ts.isImportDeclaration(node) &&
+        if (!importNode &&
+            ts.isImportDeclaration(node) &&
             ts.isStringLiteral(node.moduleSpecifier) &&
-            node.moduleSpecifier.text === moduleSpecifier) {
+            node.moduleSpecifier.text === moduleSpecifier &&
+            !node.importClause?.isTypeOnly &&
+            node.importClause?.namedBindings &&
+            ts.isNamedImports(node.importClause.namedBindings)) {
             importNode = node;
         }
     });

package/generators/prep-for-query-v3/migration.js

@@ -76,7 +76,18 @@ function renameSymbolsInFile(content, filePath, symbolUsageCounts) {
     const replacements = [];
     // Track which symbols are imported from @ethlete/query
     const importedSymbols = new Set();
+    const namespaceAliases = collectQueryNamespaceAliases(sourceFile);
     function visit(node) {
+        const namespaceMember = getNamespaceMember(node, namespaceAliases)?.member;
+        const renamedMember = namespaceMember && (TYPE_RENAMES.get(namespaceMember.text) || FUNCTION_RENAMES.get(namespaceMember.text));
+        if (namespaceMember && renamedMember) {
+            replacements.push({
+                start: namespaceMember.getStart(sourceFile),
+                end: namespaceMember.getEnd(),
+                replacement: renamedMember,
+                oldName: namespaceMember.text,
+            });
+        }
         // Track imports from @ethlete/query
         if (ts.isImportDeclaration(node)) {
             const moduleSpecifier = node.moduleSpecifier;
@@ -107,7 +118,9 @@ function renameSymbolsInFile(content, filePath, symbolUsageCounts) {
                 return;
             }
             // Skip if it's the imported name in an import specifier (we'll handle that separately)
-            if (ts.isImportSpecifier(parent) && (parent.propertyName === node || parent.name === node)) {
+            if ((ts.isImportSpecifier(parent) && (parent.propertyName === node || parent.name === node)) ||
+                (ts.isPropertyAccessExpression(parent) && parent.name === node) ||
+                (ts.isQualifiedName(parent) && parent.right === node)) {
                 ts.forEachChild(node, visit);
                 return;
             }
@@ -138,6 +151,33 @@ function renameSymbolsInFile(content, filePath, symbolUsageCounts) {
     }
     return result;
 }
+function collectQueryNamespaceAliases(sourceFile) {
+    const aliases = new Set();
+    sourceFile.statements.forEach((statement) => {
+        if (!ts.isImportDeclaration(statement)) {
+            return;
+        }
+        const namedBindings = statement.importClause?.namedBindings;
+        if (namedBindings &&
+            ts.isNamespaceImport(namedBindings) &&
+            ts.isStringLiteral(statement.moduleSpecifier) &&
+            statement.moduleSpecifier.text === '@ethlete/query') {
+            aliases.add(namedBindings.name.text);
+        }
+    });
+    return aliases;
+}
+function getNamespaceMember(node, namespaceAliases) {
+    const [namespace, member] = ts.isPropertyAccessExpression(node)
+        ? [node.expression, node.name]
+        : ts.isQualifiedName(node)
+            ? [node.left, node.right]
+            : [];
+    if (!namespace || !member || !ts.isIdentifier(namespace) || !ts.isIdentifier(member)) {
+        return undefined;
+    }
+    return namespaceAliases.has(namespace.text) ? { namespace, member } : undefined;
+}
 function updateImports(sourceFile) {
     const replacements = [];
     function visit(node) {
@@ -232,9 +272,11 @@ function replaceNamespaceInFile(content, filePath) {
         ts.forEachChild(node, collectImport);
     }
     collectImport(sourceFile);
+    const namespaceAliases = collectQueryNamespaceAliases(sourceFile);
+    const namespaceReplacements = collectNamespacedExperimentalQueryReplacements(sourceFile, namespaceAliases);
     // If no ExperimentalQuery import found, return unchanged
     if (!hasExperimentalQueryImport || !experimentalQueryAlias) {
-        return { content, modified: false, replacementCount: 0 };
+        return applyReplacements(content, namespaceReplacements, namespaceReplacements.length);
     }
     // Second pass: collect used symbols
     function findUsages(node) {
@@ -313,17 +355,32 @@ function replaceNamespaceInFile(content, filePath) {
         ts.forEachChild(node, createReplacements);
     }
     createReplacements(sourceFile);
-    // Apply replacements in reverse order
+    // Subtract 1 for the import replacement
+    return applyReplacements(content, [...replacements, ...namespaceReplacements], replacements.length - 1 + namespaceReplacements.length);
+}
+function collectNamespacedExperimentalQueryReplacements(sourceFile, namespaceAliases) {
+    const replacements = [];
+    if (namespaceAliases.size === 0) {
+        return replacements;
+    }
+    function visit(node) {
+        const access = getNamespaceMember(node, namespaceAliases);
+        if (access?.member.text === 'ExperimentalQuery') {
+            replacements.push({ start: node.getStart(sourceFile), end: node.getEnd(), replacement: access.namespace.text });
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return replacements;
+}
+function applyReplacements(content, replacements, replacementCount) {
     let result = content;
-    replacements.sort((a, b) => b.start - a.start);
-    for (const { start, end, replacement } of replacements) {
+    [...replacements]
+        .sort((a, b) => b.start - a.start)
+        .forEach(({ start, end, replacement }) => {
         result = result.slice(0, start) + replacement + result.slice(end);
-    }
-    return {
-        content: result,
-        modified: replacements.length > 0,
-        replacementCount: replacements.length - 1, // Subtract 1 for the import replacement
-    };
+    });
+    return { content: result, modified: replacements.length > 0, replacementCount };
 }
 //#endregion
 //# sourceMappingURL=migration.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ethlete/query",
-  "version": "6.0.0-next.46",
+  "version": "6.0.0-next.49",
   "license": "MIT",
   "sideEffects": false,
   "peerDependencies": {

package/types/ethlete-query-testing.d.ts

@@ -283,6 +283,8 @@ type WebSocketTestDouble = {
     } | null;
     /** The `withCredentials` the client asked the factory for, or `null` until it called it. */
     withCredentials: () => boolean | null;
+    /** The auth payload of every handshake, oldest first - `null` for one made without `auth`. */
+    handshakes: () => (object | null)[];
     /** Every message the client emitted, newest last - room joins and leaves included, buffered ones too. */
     sent: () => {
         event: string;