@trpc/upgrade 0.0.0-alpha.16 → 0.0.0-alpha.25

package/dist/cli.cjs

@@ -10,7 +10,7 @@ function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var path__default = /*#__PURE__*/_interopDefault(path);
 
-var version = "0.0.0-alpha.15";
+var version = "10.45.1";
 
 const MakeCommand = (command, ...args)=>{
     return platform.Command.make(command, ...args).pipe(platform.Command.workingDirectory(process.cwd()), platform.Command.runInShell(true));

package/dist/transforms/hooksToOptions.cjs

@@ -1,6 +1,41 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
-/* eslint-disable @typescript-eslint/no-non-null-assertion */ /* eslint-disable no-console */ const hookToOptions = {
+/**
+ * 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;
+    }
+    if (j.MemberExpression.check(expr.object)) {
+        return replaceMemberExpressionRootIndentifier(j, expr.object, id);
+    }
+    return false;
+}
+
+/**
+ * Walks the path upwards to look for the closest parent
+ * of the mentioned type
+ */ function findParentOfType(path, type) {
+    if (!type.check(path.node)) {
+        return findParentOfType(path.parentPath, type);
+    }
+    if (!path.parent) {
+        return false;
+    }
+    return path;
+}
+
+const hookToOptions = {
     useQuery: {
         lib: '@tanstack/react-query',
         fn: 'queryOptions'
@@ -155,23 +190,36 @@ function transform(file, api, options) {
                     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
                         ])));
                     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trpc/upgrade",
-  "version": "0.0.0-alpha.16",
+  "version": "0.0.0-alpha.25",
   "description": "Upgrade scripts for tRPC",
   "author": "juliusmarminge",
   "license": "MIT",
@@ -28,10 +28,10 @@
     "!**/__tests__"
   ],
   "dependencies": {
-    "@effect/cli": "0.54.4",
-    "@effect/platform": "0.75.4",
-    "@effect/platform-node": "0.71.4",
-    "effect": "3.12.10",
+    "@effect/cli": "0.55.0",
+    "@effect/platform": "0.76.0",
+    "@effect/platform-node": "0.72.0",
+    "effect": "3.12.11",
     "jscodeshift": "17.1.1",
     "typescript": "^5.6.2"
   },

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,
+) {
+  if (j.Identifier.check(expr.object)) {
+    expr.object = id;
+    return true;
+  }
+  if (j.MemberExpression.check(expr.object)) {
+    return replaceMemberExpressionRootIndentifier(j, expr.object, id);
+  }
+  return false;
+}

package/src/lib/ast/walkers.ts

@@ -0,0 +1,18 @@
+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<unknown> | false {
+  if (!type.check(path.node)) {
+    return findParentOfType(path.parentPath, type);
+  }
+  if (!path.parent) {
+    return false;
+  }
+  return path as ASTPath<TPath>;
+}

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;
@@ -205,7 +207,18 @@ 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 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 as CallExpression;
                 const memberExpr = callExpr.callee as MemberExpression;
                 if (
@@ -213,8 +226,9 @@ export default function transform(
                   !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 +236,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 +249,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]), [