@trpc/upgrade 0.0.0-alpha.3 → 0.0.0-alpha.31

package/README.md

@@ -2,6 +2,9 @@ run locally with source files
 
 ```sh
 DEV=1 pnpx tsx path/to/cli.ts
+
+# example
+cd examples/minimal-react/client && DEV=1 pnpx tsx ../../../packages/upgrade/src/bin/cli.ts --force --skipTanstackQuery --verbose
 ```
 
 or compiled

package/dist/bin.js

@@ -0,0 +1,227 @@
+#!/usr/bin/env node
+import { parse } from '@bomb.sh/args';
+import * as p from '@clack/prompts';
+import { intro, log, multiselect, isCancel, outro } from '@clack/prompts';
+import * as ts from 'typescript';
+import * as Path from 'path';
+import * as CP from 'node:child_process';
+import * as Util from 'node:util';
+import __node_cjsModule from 'node:module';
+
+var version = "0.0.0-alpha.30";
+
+function getProgram(args) {
+    const configFile = ts.findConfigFile(process.cwd(), (filepath)=>ts.sys.fileExists(filepath));
+    if (!configFile) {
+        p.log.error('No tsconfig found');
+        process.exit(1);
+    }
+    if (args.verbose) {
+        p.log.info(`Using tsconfig: ${configFile}`);
+    }
+    const { config } = ts.readConfigFile(configFile, (filepath)=>ts.sys.readFile(filepath));
+    const parsedConfig = ts.parseJsonConfigFileContent(config, ts.sys, process.cwd());
+    const program = ts.createProgram({
+        options: parsedConfig.options,
+        rootNames: parsedConfig.fileNames,
+        configFileParsingDiagnostics: parsedConfig.errors
+    });
+    return program;
+}
+function findSourceAndImportName(program) {
+    const files = program.getSourceFiles().filter((sourceFile)=>{
+        if (sourceFile.isDeclarationFile) return false;
+        let found = false;
+        ts.forEachChild(sourceFile, (node)=>{
+            if (!found && ts.isImportDeclaration(node)) {
+                const { moduleSpecifier } = node;
+                if (ts.isStringLiteral(moduleSpecifier) && moduleSpecifier.text.includes('@trpc/react-query')) {
+                    found = true;
+                }
+            }
+        });
+        return found;
+    });
+    let importName = 'trpc';
+    files.forEach((sourceFile)=>{
+        ts.forEachChild(sourceFile, (node)=>{
+            if (ts.isVariableStatement(node) && node.modifiers?.some((mod)=>mod.getText(sourceFile) === 'export')) {
+                node.declarationList.declarations.forEach((declaration)=>{
+                    if (ts.isVariableDeclaration(declaration) && declaration.initializer && ts.isCallExpression(declaration.initializer) && ts.isIdentifier(declaration.initializer.expression) && declaration.initializer.expression.getText(sourceFile) === 'createTRPCReact') {
+                        importName = declaration.name.getText(sourceFile);
+                    }
+                });
+            }
+        });
+    });
+    return {
+        files: files.map((d)=>d.fileName),
+        importName
+    };
+}
+function findTRPCImportReferences(program) {
+    const { files: filesImportingTRPC, importName } = findSourceAndImportName(program);
+    const trpcReferenceSpecifiers = new Map();
+    program.getSourceFiles().forEach((sourceFile)=>{
+        if (sourceFile.isDeclarationFile) return;
+        ts.forEachChild(sourceFile, (node)=>{
+            if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) {
+                const resolved = ts.resolveModuleName(node.moduleSpecifier.text, sourceFile.fileName, program.getCompilerOptions(), ts.sys);
+                if (resolved.resolvedModule && filesImportingTRPC.includes(resolved.resolvedModule.resolvedFileName)) {
+                    trpcReferenceSpecifiers.set(resolved.resolvedModule.resolvedFileName, node.moduleSpecifier.text);
+                }
+            }
+        });
+    });
+    const counts = {};
+    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())
+    };
+}
+
+const execa = Util.promisify(CP.exec);
+
+async function assertCleanGitTree() {
+    const { stdout } = await execa('git status');
+    if (!stdout.includes('nothing to commit')) {
+        p.cancel('Git tree is not clean, please commit your changes and try again, or run with `--force`');
+        process.exit(1);
+    }
+}
+async function filterIgnored(files) {
+    const { stdout } = await execa('git check-ignore **/*');
+    const ignores = stdout.split('\n');
+    if (process.env.VERBOSE) {
+        p.log.info(`cwd: ${process.cwd()}`);
+        p.log.info(`All files in program: ${files.map((file)=>file.fileName).join(', ')}`);
+        p.log.info(`Ignored files: ${ignores.join(', ')}`);
+    }
+    // Ignore "common files"
+    const filteredSourcePaths = files.filter((source)=>source.fileName.startsWith(Path.resolve()) && // only look ahead of current directory
+        !source.fileName.includes('/trpc/packages/') && // relative paths when running codemod locally
+        !source.fileName.includes('/node_modules/') && // always ignore node_modules
+        !ignores.includes(source.fileName)).map((source)=>source.fileName);
+    if (process.env.VERBOSE) {
+        p.log.info(`Filtered files: ${filteredSourcePaths.join(', ')}`);
+    }
+    return filteredSourcePaths;
+}
+
+function getPackageManager() {
+    const userAgent = process.env.npm_config_user_agent;
+    if (userAgent?.startsWith('pnpm')) return 'pnpm';
+    if (userAgent?.startsWith('yarn')) return 'yarn';
+    if (userAgent?.startsWith('bun')) return 'bun';
+    return 'npm';
+}
+async function installPackage(packageName) {
+    const packageManager = getPackageManager();
+    const installCmd = packageManager === 'yarn' ? 'add' : 'install';
+    const { stdout, stderr } = await execa(`${packageManager} ${installCmd} ${packageName}`);
+    if (stderr) {
+        p.log.error(stderr);
+    }
+    p.log.info(stdout);
+}
+async function uninstallPackage(packageName) {
+    const packageManager = getPackageManager();
+    const uninstallCmd = packageManager === 'yarn' ? 'remove' : 'uninstall';
+    const { stdout, stderr } = await execa(`${packageManager} ${uninstallCmd} ${packageName}`);
+    if (stderr) {
+        p.log.error(stderr);
+    }
+    p.log.info(stdout);
+}
+
+const require = __node_cjsModule.createRequire(import.meta.url);
+
+const args = parse(process.argv.slice(2), {
+    default: {
+        force: false,
+        skipTanstackQuery: false,
+        verbose: false
+    },
+    alias: {
+        f: 'force',
+        h: 'help',
+        v: 'verbose',
+        q: 'skipTanstackQuery'
+    },
+    boolean: true
+});
+intro(`tRPC Upgrade CLI v${version}`);
+if (args.help) {
+    log.info(`
+Usage: upgrade [options]
+
+Options:
+  -f, --force             Skip git status check, use with caution
+  -q, --skipTanstackQuery Skip installing @trpc/tanstack-react-query package
+  -v, --verbose           Enable verbose logging
+  -h, --help              Show help
+      `.trim());
+    process.exit(0);
+}
+if (args.verbose) {
+    log.info(`Running upgrade with args: ${JSON.stringify(args, null, 2)}`);
+}
+if (!args.force) {
+    await assertCleanGitTree();
+}
+const transforms = await multiselect({
+    message: 'Select transforms to run',
+    options: [
+        {
+            value: require.resolve('@trpc/upgrade/transforms/hooksToOptions'),
+            label: 'Migrate Hooks to xxxOptions API'
+        },
+        {
+            value: require.resolve('@trpc/upgrade/transforms/provider'),
+            label: 'Migrate context provider setup'
+        }
+    ]
+});
+if (isCancel(transforms)) process.exit(0);
+// Make sure provider transform runs first if it's selected
+const sortedTransforms = transforms.sort((a)=>a.includes('provider') ? -1 : 1);
+const program = getProgram(args);
+const sourceFiles = program.getSourceFiles();
+const possibleReferences = findTRPCImportReferences(program);
+const trpcFile = possibleReferences.mostUsed.file;
+const trpcImportName = possibleReferences.importName;
+const commitedFiles = await filterIgnored(sourceFiles);
+for (const transform of sortedTransforms){
+    log.info(`Running transform: ${transform}`);
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const { run } = require('jscodeshift/src/Runner.js');
+    await run(transform, commitedFiles, {
+        ...args,
+        trpcFile,
+        trpcImportName
+    });
+    log.info(`Transform ${transform} completed`);
+}
+if (!args.skipTanstackQuery) {
+    log.info('Installing @trpc/tanstack-react-query');
+    await installPackage('@trpc/tanstack-react-query');
+    log.success('@trpc/tanstack-react-query installed');
+    log.info('Uninstalling @trpc/react-query');
+    await uninstallPackage('@trpc/react-query');
+    log.success('@trpc/react-query uninstalled');
+}
+outro('Upgrade complete! 🎉');

package/dist/transforms/{hooksToOptions.cjs → hooksToOptions.js}

@@ -1,6 +1,33 @@
-Object.defineProperty(exports, '__esModule', { value: true });
+/**
+ * Replaces the identifier for the root path key
+ * of a member expression
+ *
+ * For dot notation like `rootKey.x.y.z` the AST
+ * is constructed with the `rootKey` being nested deep
+ * inside a wrapper MemberExpression holding `rootKey.x`
+ * and so on
+ *
+ * This function helps replace the `rootKey` identifier with
+ * the provided identifier node
+ */ function replaceMemberExpressionRootIndentifier(j, expr, id) {
+    if (j.Identifier.check(expr.object)) {
+        expr.object = id;
+        return true;
+    }
+    return !j.MemberExpression.check(expr.object) ? false : replaceMemberExpressionRootIndentifier(j, expr.object, id);
+}
+
+/**
+ * Walks the path upwards to look for the closest parent
+ * of the mentioned type
+ */ function findParentOfType(path, type) {
+    if (!path.parent) {
+        return false;
+    }
+    return type.check(path.node) ? path : findParentOfType(path.parentPath, type);
+}
 
-/* eslint-disable @typescript-eslint/no-non-null-assertion */ /* eslint-disable no-console */ const hookToOptions = {
+const hookToOptions = {
     useQuery: {
         lib: '@tanstack/react-query',
         fn: 'queryOptions'
@@ -148,30 +175,44 @@ 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, {
                     name: oldIdentifier.name
                 }).forEach((path)=>{
                     if (j.MemberExpression.check(path.parent?.parent?.node)) {
-                        const callExprPath = path.parent.parent.parent;
+                        const callExprPath = findParentOfType(path.parentPath, j.CallExpression);
+                        if (!callExprPath) {
+                            console.warn(`Failed to walk up the tree to find utilMethod call expression, on file: ${file.path}`, callExprPath, {
+                                start: path.node.loc?.start,
+                                end: path.node.loc?.end
+                            });
+                            return;
+                        }
                         const callExpr = callExprPath.node;
                         const memberExpr = callExpr.callee;
                         if (!j.CallExpression.check(callExpr) || !j.MemberExpression.check(memberExpr)) {
-                            console.warn('Failed to walk up the tree to find utilMethod call expression', callExpr);
+                            console.warn(`Failed to walk up the tree to find utilMethod with a \`trpc.PATH.<call>\`, on file: ${file.path}`, callExpr, {
+                                start: path.node.loc?.start,
+                                end: path.node.loc?.end
+                            });
                             return;
                         }
-                        if (!(j.MemberExpression.check(memberExpr.object) && j.Identifier.check(memberExpr.object.object) && j.Identifier.check(memberExpr.property) && memberExpr.property.name in utilMap)) {
+                        if (!(j.MemberExpression.check(memberExpr.object) && j.Identifier.check(memberExpr.property) && memberExpr.property.name in utilMap)) {
                             console.warn('Failed to identify utilMethod from proxy call expression', memberExpr);
                             return;
                         }
                         // Replace util.PATH.proxyMethod() with trpc.PATH.queryFilter()
                         const proxyMethod = memberExpr.property.name;
-                        memberExpr.object.object = j.identifier(trpcImportName);
+                        const replacedPath = replaceMemberExpressionRootIndentifier(j, memberExpr, j.identifier(trpcImportName));
+                        if (!replacedPath) {
+                            console.warn('Failed to wrap proxy call expression', memberExpr);
+                        }
                         memberExpr.property = j.identifier('queryFilter');
                         // Wrap it in queryClient.utilMethod()
-                        j(callExprPath).replaceWith(j.memberExpression(j.identifier('queryClient'), j.callExpression(j.identifier(utilMap[proxyMethod]), [
+                        callExprPath.replace(j.memberExpression(j.identifier('queryClient'), j.callExpression(j.identifier(utilMap[proxyMethod]), [
                             callExpr
                         ])));
                     }
@@ -218,5 +259,4 @@ function transform(file, api, options) {
 }
 const parser = 'tsx';
 
-exports.default = transform;
-exports.parser = parser;
+export { transform as default, parser };

package/dist/transforms/{provider.cjs → provider.js}

@@ -1,5 +1,3 @@
-Object.defineProperty(exports, '__esModule', { value: true });
-
 function transform(file, api, options) {
     const { trpcImportName } = options;
     let routerName = undefined;
@@ -116,5 +114,4 @@ function transform(file, api, options) {
 }
 const parser = 'tsx';
 
-exports.default = transform;
-exports.parser = parser;
+export { transform as default, parser };

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@trpc/upgrade",
-  "version": "0.0.0-alpha.3",
+  "version": "0.0.0-alpha.31",
   "description": "Upgrade scripts for tRPC",
   "author": "juliusmarminge",
   "license": "MIT",
-  "bin": "./dist/cli.cjs",
+  "type": "module",
+  "bin": "./dist/bin.js",
   "homepage": "https://trpc.io",
   "repository": {
     "type": "git",
@@ -13,10 +14,10 @@
   },
   "exports": {
     "./transforms/hooksToOptions": {
-      "require": "./dist/transforms/hooksToOptions.cjs"
+      "default": "./dist/transforms/hooksToOptions.js"
     },
     "./transforms/provider": {
-      "require": "./dist/transforms/provider.cjs"
+      "default": "./dist/transforms/provider.js"
     }
   },
   "files": [
@@ -28,18 +29,16 @@
     "!**/__tests__"
   ],
   "dependencies": {
-    "@effect/cli": "0.48.25",
-    "@effect/platform": "0.69.25",
-    "@effect/platform-node": "0.64.27",
-    "effect": "3.10.16",
+    "@bomb.sh/args": "0.3.0",
+    "@clack/prompts": "0.10.0",
     "jscodeshift": "17.1.1",
     "typescript": "^5.6.2"
   },
   "devDependencies": {
     "@types/jscodeshift": "0.12.0",
     "@types/node": "^22.9.0",
-    "bunchee": "5.6.1",
-    "esbuild": "0.19.2",
+    "bunchee": "6.4.0",
+    "esbuild": "0.25.0",
     "tsx": "^4.0.0"
   },
   "publishConfig": {

package/src/bin/index.ts

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+import { parse } from '@bomb.sh/args';
+import { intro, isCancel, log, multiselect, outro } from '@clack/prompts';
+import { version } from '../../package.json';
+import { findTRPCImportReferences, getProgram } from '../lib/ast/scanners';
+import { assertCleanGitTree, filterIgnored } from '../lib/git';
+import { installPackage, uninstallPackage } from '../lib/pkgmgr';
+
+const args = parse(process.argv.slice(2), {
+  default: {
+    force: false,
+    skipTanstackQuery: false,
+    verbose: false,
+  },
+  alias: {
+    f: 'force',
+    h: 'help',
+    v: 'verbose',
+    q: 'skipTanstackQuery',
+  },
+  boolean: true,
+});
+
+intro(`tRPC Upgrade CLI v${version}`);
+
+if (args.help) {
+  log.info(
+    `
+Usage: upgrade [options]
+
+Options:
+  -f, --force             Skip git status check, use with caution
+  -q, --skipTanstackQuery Skip installing @trpc/tanstack-react-query package
+  -v, --verbose           Enable verbose logging
+  -h, --help              Show help
+      `.trim(),
+  );
+  process.exit(0);
+}
+
+if (args.verbose) {
+  log.info(`Running upgrade with args: ${JSON.stringify(args, null, 2)}`);
+}
+
+if (!args.force) {
+  await assertCleanGitTree();
+}
+
+const transforms = await multiselect({
+  message: 'Select transforms to run',
+  options: [
+    {
+      value: require.resolve('@trpc/upgrade/transforms/hooksToOptions'),
+      label: 'Migrate Hooks to xxxOptions API',
+    },
+    {
+      value: require.resolve('@trpc/upgrade/transforms/provider'),
+      label: 'Migrate context provider setup',
+    },
+  ],
+});
+if (isCancel(transforms)) process.exit(0);
+
+// Make sure provider transform runs first if it's selected
+const sortedTransforms = transforms.sort((a) =>
+  a.includes('provider') ? -1 : 1,
+);
+
+const program = getProgram(args);
+const sourceFiles = program.getSourceFiles();
+const possibleReferences = findTRPCImportReferences(program);
+const trpcFile = possibleReferences.mostUsed.file;
+const trpcImportName = possibleReferences.importName;
+
+const commitedFiles = await filterIgnored(sourceFiles);
+
+for (const transform of sortedTransforms) {
+  log.info(`Running transform: ${transform}`);
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  const { run } = require('jscodeshift/src/Runner.js');
+  await run(transform, commitedFiles, {
+    ...args,
+    trpcFile,
+    trpcImportName,
+  });
+  log.info(`Transform ${transform} completed`);
+}
+
+if (!args.skipTanstackQuery) {
+  log.info('Installing @trpc/tanstack-react-query');
+  await installPackage('@trpc/tanstack-react-query');
+  log.success('@trpc/tanstack-react-query installed');
+
+  log.info('Uninstalling @trpc/react-query');
+  await uninstallPackage('@trpc/react-query');
+  log.success('@trpc/react-query uninstalled');
+}
+
+outro('Upgrade complete! 🎉');

package/src/lib/ast/modifiers.ts

@@ -0,0 +1,28 @@
+import type { Identifier, JSCodeshift, MemberExpression } from 'jscodeshift';
+
+/**
+ * Replaces the identifier for the root path key
+ * of a member expression
+ *
+ * For dot notation like `rootKey.x.y.z` the AST
+ * is constructed with the `rootKey` being nested deep
+ * inside a wrapper MemberExpression holding `rootKey.x`
+ * and so on
+ *
+ * This function helps replace the `rootKey` identifier with
+ * the provided identifier node
+ */
+export function replaceMemberExpressionRootIndentifier(
+  j: JSCodeshift,
+  expr: MemberExpression,
+  id: Identifier,
+): boolean {
+  if (j.Identifier.check(expr.object)) {
+    expr.object = id;
+    return true;
+  }
+
+  return !j.MemberExpression.check(expr.object)
+    ? false
+    : replaceMemberExpressionRootIndentifier(j, expr.object, id);
+}

package/src/lib/ast/scanners.ts

@@ -0,0 +1,129 @@
+import * as p from '@clack/prompts';
+import * as ts from 'typescript';
+
+export function getProgram(args: Record<string, unknown>) {
+  const configFile = ts.findConfigFile(process.cwd(), (filepath) =>
+    ts.sys.fileExists(filepath),
+  );
+  if (!configFile) {
+    p.log.error('No tsconfig found');
+    process.exit(1);
+  }
+
+  if (args.verbose) {
+    p.log.info(`Using tsconfig: ${configFile}`);
+  }
+
+  const { config } = ts.readConfigFile(configFile, (filepath) =>
+    ts.sys.readFile(filepath),
+  );
+  const parsedConfig = ts.parseJsonConfigFileContent(
+    config,
+    ts.sys,
+    process.cwd(),
+  );
+  const program = ts.createProgram({
+    options: parsedConfig.options,
+    rootNames: parsedConfig.fileNames,
+    configFileParsingDiagnostics: parsedConfig.errors,
+  });
+
+  return program;
+}
+
+export function findSourceAndImportName(program: ts.Program) {
+  const files = program.getSourceFiles().filter((sourceFile) => {
+    if (sourceFile.isDeclarationFile) return false;
+    let found = false;
+    ts.forEachChild(sourceFile, (node) => {
+      if (!found && ts.isImportDeclaration(node)) {
+        const { moduleSpecifier } = node;
+        if (
+          ts.isStringLiteral(moduleSpecifier) &&
+          moduleSpecifier.text.includes('@trpc/react-query')
+        ) {
+          found = true;
+        }
+      }
+    });
+    return found;
+  });
+
+  let importName = 'trpc';
+  files.forEach((sourceFile) => {
+    ts.forEachChild(sourceFile, (node) => {
+      if (
+        ts.isVariableStatement(node) &&
+        node.modifiers?.some((mod) => mod.getText(sourceFile) === 'export')
+      ) {
+        node.declarationList.declarations.forEach((declaration) => {
+          if (
+            ts.isVariableDeclaration(declaration) &&
+            declaration.initializer &&
+            ts.isCallExpression(declaration.initializer) &&
+            ts.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: ts.Program) {
+  const { files: filesImportingTRPC, importName } =
+    findSourceAndImportName(program);
+  const trpcReferenceSpecifiers = new Map<string, string>();
+
+  program.getSourceFiles().forEach((sourceFile) => {
+    if (sourceFile.isDeclarationFile) return;
+    ts.forEachChild(sourceFile, (node) => {
+      if (
+        ts.isImportDeclaration(node) &&
+        ts.isStringLiteral(node.moduleSpecifier)
+      ) {
+        const resolved = ts.resolveModuleName(
+          node.moduleSpecifier.text,
+          sourceFile.fileName,
+          program.getCompilerOptions(),
+          ts.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/lib/ast/walkers.ts

@@ -0,0 +1,17 @@
+import type { ASTPath, JSCodeshift } from 'jscodeshift';
+
+/**
+ * Walks the path upwards to look for the closest parent
+ * of the mentioned type
+ */
+export function findParentOfType<TPath>(
+  path: ASTPath<unknown>,
+  type: JSCodeshift['AnyType'],
+): ASTPath<TPath> | false {
+  if (!path.parent) {
+    return false;
+  }
+  return type.check(path.node)
+    ? (path as ASTPath<TPath>)
+    : findParentOfType(path.parentPath, type);
+}

package/src/lib/execa.ts

@@ -0,0 +1,4 @@
+import * as CP from 'node:child_process';
+import * as Util from 'node:util';
+
+export const execa = Util.promisify(CP.exec);

package/src/lib/git.ts

@@ -0,0 +1,44 @@
+import * as Path from 'path';
+import * as p from '@clack/prompts';
+import type { SourceFile } from 'typescript';
+import { execa } from './execa';
+
+export async function assertCleanGitTree() {
+  const { stdout } = await execa('git status');
+  if (!stdout.includes('nothing to commit')) {
+    p.cancel(
+      'Git tree is not clean, please commit your changes and try again, or run with `--force`',
+    );
+    process.exit(1);
+  }
+}
+
+export async function filterIgnored(files: readonly SourceFile[]) {
+  const { stdout } = await execa('git check-ignore **/*');
+  const ignores = stdout.split('\n');
+
+  if (process.env.VERBOSE) {
+    p.log.info(`cwd: ${process.cwd()}`);
+    p.log.info(
+      `All files in program: ${files.map((file) => file.fileName).join(', ')}`,
+    );
+    p.log.info(`Ignored files: ${ignores.join(', ')}`);
+  }
+
+  // Ignore "common files"
+  const filteredSourcePaths = files
+    .filter(
+      (source) =>
+        source.fileName.startsWith(Path.resolve()) && // only look ahead of current directory
+        !source.fileName.includes('/trpc/packages/') && // relative paths when running codemod locally
+        !source.fileName.includes('/node_modules/') && // always ignore node_modules
+        !ignores.includes(source.fileName), // ignored files
+    )
+    .map((source) => source.fileName);
+
+  if (process.env.VERBOSE) {
+    p.log.info(`Filtered files: ${filteredSourcePaths.join(', ')}`);
+  }
+
+  return filteredSourcePaths;
+}

package/src/lib/pkgmgr.ts

@@ -0,0 +1,34 @@
+import * as p from '@clack/prompts';
+import { execa } from './execa';
+
+function getPackageManager() {
+  const userAgent = process.env.npm_config_user_agent;
+  if (userAgent?.startsWith('pnpm')) return 'pnpm';
+  if (userAgent?.startsWith('yarn')) return 'yarn';
+  if (userAgent?.startsWith('bun')) return 'bun';
+  return 'npm';
+}
+
+export async function installPackage(packageName: string) {
+  const packageManager = getPackageManager();
+  const installCmd = packageManager === 'yarn' ? 'add' : 'install';
+  const { stdout, stderr } = await execa(
+    `${packageManager} ${installCmd} ${packageName}`,
+  );
+  if (stderr) {
+    p.log.error(stderr);
+  }
+  p.log.info(stdout);
+}
+
+export async function uninstallPackage(packageName: string) {
+  const packageManager = getPackageManager();
+  const uninstallCmd = packageManager === 'yarn' ? 'remove' : 'uninstall';
+  const { stdout, stderr } = await execa(
+    `${packageManager} ${uninstallCmd} ${packageName}`,
+  );
+  if (stderr) {
+    p.log.error(stderr);
+  }
+  p.log.info(stdout);
+}

package/src/transforms/hooksToOptions.ts

@@ -11,6 +11,8 @@ import type {
   MemberExpression,
   Options,
 } from 'jscodeshift';
+import { replaceMemberExpressionRootIndentifier } from '../lib/ast/modifiers';
+import { findParentOfType } from '../lib/ast/walkers';
 
 interface TransformOptions extends Options {
   trpcImportName?: string;
@@ -194,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)
         ) {
@@ -205,16 +213,28 @@ export default function transform(
             .find(j.Identifier, { name: oldIdentifier.name })
             .forEach((path) => {
               if (j.MemberExpression.check(path.parent?.parent?.node)) {
-                const callExprPath = path.parent.parent.parent;
-                const callExpr = callExprPath.node as CallExpression;
+                const callExprPath = findParentOfType<CallExpression>(
+                  path.parentPath,
+                  j.CallExpression,
+                );
+                if (!callExprPath) {
+                  console.warn(
+                    `Failed to walk up the tree to find utilMethod call expression, on file: ${file.path}`,
+                    callExprPath,
+                    { start: path.node.loc?.start, end: path.node.loc?.end },
+                  );
+                  return;
+                }
+                const callExpr = callExprPath.node;
                 const memberExpr = callExpr.callee as MemberExpression;
                 if (
                   !j.CallExpression.check(callExpr) ||
                   !j.MemberExpression.check(memberExpr)
                 ) {
                   console.warn(
-                    'Failed to walk up the tree to find utilMethod call expression',
+                    `Failed to walk up the tree to find utilMethod with a \`trpc.PATH.<call>\`, on file: ${file.path}`,
                     callExpr,
+                    { start: path.node.loc?.start, end: path.node.loc?.end },
                   );
                   return;
                 }
@@ -222,7 +242,6 @@ export default function transform(
                 if (
                   !(
                     j.MemberExpression.check(memberExpr.object) &&
-                    j.Identifier.check(memberExpr.object.object) &&
                     j.Identifier.check(memberExpr.property) &&
                     memberExpr.property.name in utilMap
                   )
@@ -236,11 +255,21 @@ export default function transform(
 
                 // Replace util.PATH.proxyMethod() with trpc.PATH.queryFilter()
                 const proxyMethod = memberExpr.property.name as ProxyMethod;
-                memberExpr.object.object = j.identifier(trpcImportName!);
+                const replacedPath = replaceMemberExpressionRootIndentifier(
+                  j,
+                  memberExpr,
+                  j.identifier(trpcImportName),
+                );
+                if (!replacedPath) {
+                  console.warn(
+                    'Failed to wrap proxy call expression',
+                    memberExpr,
+                  );
+                }
                 memberExpr.property = j.identifier('queryFilter');
 
                 // Wrap it in queryClient.utilMethod()
-                j(callExprPath).replaceWith(
+                callExprPath.replace(
                   j.memberExpression(
                     j.identifier('queryClient'),
                     j.callExpression(j.identifier(utilMap[proxyMethod]), [

package/dist/cli.cjs

@@ -1,78 +0,0 @@
-#!/usr/bin/env node
-var path = require('path');
-var cli$1 = require('@effect/cli');
-var platform = require('@effect/platform');
-var platformNode = require('@effect/platform-node');
-var effect = require('effect');
-var typescript = require('typescript');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-var path__default = /*#__PURE__*/_interopDefault(path);
-
-var version = "0.0.0-alpha.2";
-
-const assertCleanGitTree = platform.Command.string(platform.Command.make('git', 'status')).pipe(effect.Effect.filterOrFail(effect.String.includes('nothing to commit'), ()=>'Git tree is not clean, please commit your changes and try again, or run with `--force`'));
-const installPackage = (packageName)=>{
-    const packageManager = effect.Match.value(process.env.npm_config_user_agent ?? 'npm').pipe(effect.Match.when(effect.String.startsWith('pnpm'), ()=>'pnpm'), effect.Match.when(effect.String.startsWith('yarn'), ()=>'yarn'), effect.Match.when(effect.String.startsWith('bun'), ()=>'bun'), effect.Match.orElse(()=>'npm'));
-    return platform.Command.streamLines(platform.Command.make(packageManager, 'install', packageName)).pipe(effect.Stream.mapEffect(effect.Console.log), effect.Stream.runDrain);
-};
-const filterIgnored = (files)=>effect.Effect.gen(function*() {
-        const ignores = yield* platform.Command.string(platform.Command.make('git', 'check-ignore', '**/*')).pipe(effect.Effect.map((_)=>_.split('\n')));
-        yield* effect.Effect.log('All files in program:', files.map((_)=>_.fileName));
-        yield* effect.Effect.log('Ignored files:', ignores);
-        // Ignore "common files"
-        const filteredSourcePaths = files.filter((source)=>source.fileName.startsWith(path__default.default.resolve()) && // only look ahead of current directory
-            !source.fileName.includes('/trpc/packages/') && // relative paths when running codemod locally
-            !ignores.includes(source.fileName)).map((source)=>source.fileName);
-        yield* effect.Effect.log('Filtered files:', filteredSourcePaths);
-        return filteredSourcePaths;
-    });
-const TSProgram = effect.Effect.succeed(typescript.findConfigFile(process.cwd(), typescript.sys.fileExists)).pipe(effect.Effect.filterOrFail(effect.Predicate.isNotNullable, ()=>'No tsconfig found'), effect.Effect.tap((_)=>effect.Effect.logDebug('Using tsconfig', _)), effect.Effect.map((_)=>typescript.readConfigFile(_, typescript.sys.readFile)), effect.Effect.map((_)=>typescript.parseJsonConfigFileContent(_.config, typescript.sys, process.cwd())), effect.Effect.map((_)=>typescript.createProgram({
-        options: _.options,
-        rootNames: _.fileNames,
-        configFileParsingDiagnostics: _.errors
-    })));
-// FIXME :: hacky
-const transformPath = (path)=>process.env.DEV ? path : path.replace('../', './').replace('.ts', '.cjs');
-const force = cli$1.Options.boolean('force').pipe(cli$1.Options.withAlias('f'), cli$1.Options.withDefault(false), cli$1.Options.withDescription('Skip git status check, use with caution'));
-/**
- * TODO: Instead of default values these should be detected automatically from the TS program
- */ const trpcFile = cli$1.Options.text('trpcFile').pipe(cli$1.Options.withAlias('f'), cli$1.Options.withDefault('~/trpc'), cli$1.Options.withDescription('Path to the trpc import file'));
-const trpcImportName = cli$1.Options.text('trpcImportName').pipe(cli$1.Options.withAlias('i'), cli$1.Options.withDefault('trpc'), cli$1.Options.withDescription('Name of the trpc import'));
-const rootComamnd = cli$1.Command.make('upgrade', {
-    force,
-    trpcFile,
-    trpcImportName
-}, (args)=>effect.Effect.gen(function*() {
-        if (!args.force) {
-            yield* assertCleanGitTree;
-        }
-        const transforms = yield* effect.Effect.map(cli$1.Prompt.multiSelect({
-            message: 'Select transforms to run',
-            choices: [
-                {
-                    title: 'Migrate Hooks to xxxOptions API',
-                    value: require.resolve(transformPath('../transforms/hooksToOptions.ts'))
-                },
-                {
-                    title: 'Migrate context provider setup',
-                    value: require.resolve(transformPath('../transforms/provider.ts'))
-                }
-            ]
-        }), // Make sure provider transform runs first if it's selected
-        effect.Array.sortWith((a)=>!a.includes('provider.ts'), effect.Order.boolean));
-        const program = yield* TSProgram;
-        const sourceFiles = program.getSourceFiles();
-        const commitedFiles = yield* filterIgnored(sourceFiles);
-        yield* effect.Effect.forEach(transforms, (transform)=>{
-            return effect.pipe(effect.Effect.log('Running transform', transform), effect.Effect.flatMap(()=>effect.Effect.tryPromise(async ()=>import('jscodeshift/src/Runner.js').then(({ run })=>run(transform, commitedFiles, args)))), effect.Effect.map((_)=>effect.Effect.log('Transform result', _)));
-        });
-        yield* effect.Effect.log('Installing @trpc/tanstack-react-query');
-        yield* installPackage('@trpc/tanstack-react-query');
-    }));
-const cli = cli$1.Command.run(rootComamnd, {
-    name: 'tRPC Upgrade CLI',
-    version: `v${version}`
-});
-cli(process.argv).pipe(effect.Effect.provide(platformNode.NodeContext.layer), platformNode.NodeRuntime.runMain);

package/src/bin/cli.ts

@@ -1,180 +0,0 @@
-/* eslint-disable @typescript-eslint/unbound-method */
-import path from 'path';
-import { Command as CLICommand, Options, Prompt } from '@effect/cli';
-import { Command } from '@effect/platform';
-import { NodeContext, NodeRuntime } from '@effect/platform-node';
-import {
-  Array,
-  Console,
-  Effect,
-  Match,
-  Order,
-  pipe,
-  Predicate,
-  Stream,
-  String,
-} from 'effect';
-import type { SourceFile } from 'typescript';
-import {
-  createProgram,
-  findConfigFile,
-  parseJsonConfigFileContent,
-  readConfigFile,
-  sys,
-} from 'typescript';
-import { version } from '../../package.json';
-
-const assertCleanGitTree = Command.string(Command.make('git', 'status')).pipe(
-  Effect.filterOrFail(
-    String.includes('nothing to commit'),
-    () =>
-      'Git tree is not clean, please commit your changes and try again, or run with `--force`',
-  ),
-);
-
-const installPackage = (packageName: string) => {
-  const packageManager = Match.value(
-    process.env.npm_config_user_agent ?? 'npm',
-  ).pipe(
-    Match.when(String.startsWith('pnpm'), () => 'pnpm'),
-    Match.when(String.startsWith('yarn'), () => 'yarn'),
-    Match.when(String.startsWith('bun'), () => 'bun'),
-    Match.orElse(() => 'npm'),
-  );
-  return Command.streamLines(
-    Command.make(packageManager, 'install', packageName),
-  ).pipe(Stream.mapEffect(Console.log), Stream.runDrain);
-};
-
-const filterIgnored = (files: readonly SourceFile[]) =>
-  Effect.gen(function* () {
-    const ignores = yield* Command.string(
-      Command.make('git', 'check-ignore', '**/*'),
-    ).pipe(Effect.map((_) => _.split('\n')));
-
-    yield* Effect.log(
-      'All files in program:',
-      files.map((_) => _.fileName),
-    );
-    yield* Effect.log('Ignored files:', ignores);
-
-    // Ignore "common files"
-    const filteredSourcePaths = files
-      .filter(
-        (source) =>
-          source.fileName.startsWith(path.resolve()) && // only look ahead of current directory
-          !source.fileName.includes('/trpc/packages/') && // relative paths when running codemod locally
-          !ignores.includes(source.fileName), // ignored files
-      )
-      .map((source) => source.fileName);
-
-    yield* Effect.log('Filtered files:', filteredSourcePaths);
-
-    return filteredSourcePaths;
-  });
-
-const TSProgram = Effect.succeed(
-  findConfigFile(process.cwd(), sys.fileExists),
-).pipe(
-  Effect.filterOrFail(Predicate.isNotNullable, () => 'No tsconfig found'),
-  Effect.tap((_) => Effect.logDebug('Using tsconfig', _)),
-  Effect.map((_) => readConfigFile(_, sys.readFile)),
-  Effect.map((_) => parseJsonConfigFileContent(_.config, sys, process.cwd())),
-  Effect.map((_) =>
-    createProgram({
-      options: _.options,
-      rootNames: _.fileNames,
-      configFileParsingDiagnostics: _.errors,
-    }),
-  ),
-);
-
-// FIXME :: hacky
-const transformPath = (path: string) =>
-  process.env.DEV ? path : path.replace('../', './').replace('.ts', '.cjs');
-
-const force = Options.boolean('force').pipe(
-  Options.withAlias('f'),
-  Options.withDefault(false),
-  Options.withDescription('Skip git status check, use with caution'),
-);
-
-/**
- * TODO: Instead of default values these should be detected automatically from the TS program
- */
-const trpcFile = Options.text('trpcFile').pipe(
-  Options.withAlias('f'),
-  Options.withDefault('~/trpc'),
-  Options.withDescription('Path to the trpc import file'),
-);
-
-const trpcImportName = Options.text('trpcImportName').pipe(
-  Options.withAlias('i'),
-  Options.withDefault('trpc'),
-  Options.withDescription('Name of the trpc import'),
-);
-
-const rootComamnd = CLICommand.make(
-  'upgrade',
-  {
-    force,
-    trpcFile,
-    trpcImportName,
-  },
-  (args) =>
-    Effect.gen(function* () {
-      if (!args.force) {
-        yield* assertCleanGitTree;
-      }
-
-      const transforms = yield* Effect.map(
-        Prompt.multiSelect({
-          message: 'Select transforms to run',
-          choices: [
-            {
-              title: 'Migrate Hooks to xxxOptions API',
-              value: require.resolve(
-                transformPath('../transforms/hooksToOptions.ts'),
-              ),
-            },
-            {
-              title: 'Migrate context provider setup',
-              value: require.resolve(
-                transformPath('../transforms/provider.ts'),
-              ),
-            },
-          ],
-        }),
-        // Make sure provider transform runs first if it's selected
-        Array.sortWith((a) => !a.includes('provider.ts'), Order.boolean),
-      );
-
-      const program = yield* TSProgram;
-      const sourceFiles = program.getSourceFiles();
-
-      const commitedFiles = yield* filterIgnored(sourceFiles);
-      yield* Effect.forEach(transforms, (transform) => {
-        return pipe(
-          Effect.log('Running transform', transform),
-          Effect.flatMap(() =>
-            Effect.tryPromise(async () =>
-              import('jscodeshift/src/Runner.js').then(({ run }) =>
-                run(transform, commitedFiles, args),
-              ),
-            ),
-          ),
-          Effect.map((_) => Effect.log('Transform result', _)),
-        );
-      });
-
-      yield* Effect.log('Installing @trpc/tanstack-react-query');
-      yield* installPackage('@trpc/tanstack-react-query');
-    }),
-);
-
-const cli = CLICommand.run(rootComamnd, {
-  name: 'tRPC Upgrade CLI',
-  version: `v${version}`,
-});
-
-cli(process.argv).pipe(Effect.provide(NodeContext.layer), NodeRuntime.runMain);