@trpc/upgrade 11.0.0-rc.795 → 11.0.0-rc.797

package/dist/transforms/hooksToOptions.cjs

@@ -177,7 +177,8 @@ function transform(file, api, options) {
                 }
             }
         }).forEach((path)=>{
-            if (j.VariableDeclarator.check(path.parentPath.node) && j.Identifier.check(path.parentPath.node.id)) {
+            const isTRPCContextUtil = j.MemberExpression.check(path.value.callee) && j.Identifier.check(path.value.callee.object) && path.value.callee.object.name == trpcImportName;
+            if (isTRPCContextUtil && j.VariableDeclarator.check(path.parentPath.node) && j.Identifier.check(path.parentPath.node.id)) {
                 const oldIdentifier = path.parentPath.node.id;
                 // Find all the references to `utils` and replace with `queryClient[helperMap](trpc.PATH.queryFilter())`
                 root.find(j.Identifier, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trpc/upgrade",
-  "version": "11.0.0-rc.795+394b0f5cc",
+  "version": "11.0.0-rc.797+8374c3b18",
   "description": "Upgrade scripts for tRPC",
   "author": "juliusmarminge",
   "license": "MIT",
@@ -52,5 +52,5 @@
   "funding": [
     "https://trpc.io/sponsor"
   ],
-  "gitHead": "394b0f5cc328937156cc75a772b3280231d4a2e2"
+  "gitHead": "8374c3b1869538c8a32c2ea266c9762c98a8b91c"
 }

package/src/bin/cli.ts

@@ -25,6 +25,7 @@ import {
   sys,
 } from 'typescript';
 import { version } from '../../package.json';
+import { findTRPCImportReferences } from '../lib/ast/scanners';
 
 const MakeCommand = (command: string, ...args: string[]) => {
   return Command.make(command, ...args).pipe(
@@ -203,6 +204,10 @@ const rootComamnd = CLICommand.make(
       const program = yield* TSProgram;
       const sourceFiles = program.getSourceFiles();
 
+      const possibleReferences = findTRPCImportReferences(program);
+      const trpcFile = possibleReferences.mostUsed.file;
+      const trpcImportName = possibleReferences.importName;
+
       const commitedFiles = yield* filterIgnored(sourceFiles);
       yield* Effect.forEach(transforms, (transform) => {
         return pipe(
@@ -210,7 +215,11 @@ const rootComamnd = CLICommand.make(
           Effect.flatMap(() =>
             Effect.tryPromise(async () =>
               import('jscodeshift/src/Runner.js').then(({ run }) =>
-                run(transform, commitedFiles, args),
+                run(transform, commitedFiles, {
+                  ...args,
+                  trpcFile: trpcFile,
+                  trpcImportName: trpcImportName,
+                }),
               ),
             ),
           ),

package/src/lib/ast/scanners.ts

@@ -0,0 +1,106 @@
+import {
+  forEachChild,
+  isCallExpression,
+  isIdentifier,
+  isImportDeclaration,
+  isStringLiteral,
+  isVariableDeclaration,
+  isVariableStatement,
+  resolveModuleName,
+  sys,
+  type Program,
+} from 'typescript';
+
+export function findSourceAndImportName(program: Program) {
+  const files = program.getSourceFiles().filter((sourceFile) => {
+    if (sourceFile.isDeclarationFile) return false;
+    let found = false;
+    forEachChild(sourceFile, (node) => {
+      if (!found && isImportDeclaration(node)) {
+        const { moduleSpecifier } = node;
+        if (
+          isStringLiteral(moduleSpecifier) &&
+          moduleSpecifier.text.includes('@trpc/react-query')
+        ) {
+          found = true;
+        }
+      }
+    });
+    return found;
+  });
+
+  let importName = 'trpc';
+  files.forEach((sourceFile) => {
+    forEachChild(sourceFile, (node) => {
+      if (
+        isVariableStatement(node) &&
+        node.modifiers?.some((mod) => mod.getText(sourceFile) === 'export')
+      ) {
+        node.declarationList.declarations.forEach((declaration) => {
+          if (
+            isVariableDeclaration(declaration) &&
+            declaration.initializer &&
+            isCallExpression(declaration.initializer) &&
+            isIdentifier(declaration.initializer.expression) &&
+            declaration.initializer.expression.getText(sourceFile) ===
+              'createTRPCReact'
+          ) {
+            importName = declaration.name.getText(sourceFile);
+          }
+        });
+      }
+    });
+  });
+
+  return {
+    files: files.map((d) => d.fileName),
+    importName,
+  };
+}
+
+export function findTRPCImportReferences(program: Program) {
+  const { files: filesImportingTRPC, importName } =
+    findSourceAndImportName(program);
+  const trpcReferenceSpecifiers = new Map<string, string>();
+
+  program.getSourceFiles().forEach((sourceFile) => {
+    if (sourceFile.isDeclarationFile) return;
+    forEachChild(sourceFile, (node) => {
+      if (isImportDeclaration(node) && isStringLiteral(node.moduleSpecifier)) {
+        const resolved = resolveModuleName(
+          node.moduleSpecifier.text,
+          sourceFile.fileName,
+          program.getCompilerOptions(),
+          sys,
+        );
+        if (
+          resolved.resolvedModule &&
+          filesImportingTRPC.includes(resolved.resolvedModule.resolvedFileName)
+        ) {
+          trpcReferenceSpecifiers.set(
+            resolved.resolvedModule.resolvedFileName,
+            node.moduleSpecifier.text,
+          );
+        }
+      }
+    });
+  });
+
+  const counts: Record<string, number> = {};
+  let currentMax = 0;
+  const mostUsed = { file: '' };
+
+  [...trpcReferenceSpecifiers.values()].forEach((specifier) => {
+    counts[specifier] = (counts[specifier] || 0) + 1;
+    if (counts[specifier] > currentMax) {
+      currentMax = counts[specifier];
+      mostUsed.file = specifier;
+    }
+  });
+
+  return {
+    importName,
+    mostUsed,
+    all: Object.fromEntries(trpcReferenceSpecifiers.entries()),
+  };
+}

package/src/transforms/hooksToOptions.ts

@@ -196,7 +196,13 @@ export default function transform(
         },
       })
       .forEach((path) => {
+        const isTRPCContextUtil =
+          j.MemberExpression.check(path.value.callee) &&
+          j.Identifier.check(path.value.callee.object) &&
+          path.value.callee.object.name == trpcImportName;
+
         if (
+          isTRPCContextUtil &&
           j.VariableDeclarator.check(path.parentPath.node) &&
           j.Identifier.check(path.parentPath.node.id)
         ) {
@@ -252,7 +258,7 @@ export default function transform(
                 const replacedPath = replaceMemberExpressionRootIndentifier(
                   j,
                   memberExpr,
-                  j.identifier(trpcImportName!),
+                  j.identifier(trpcImportName),
                 );
                 if (!replacedPath) {
                   console.warn(