@trpc/upgrade 0.0.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Alex Johansson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,15 @@
+run locally with source files
+
+```sh
+DEV=1 pnpx tsx path/to/cli.ts
+```
+
+or compiled
+
+```sh
+cd packages/upgrade
+pnpm build && pnpm link .
+
+# in an app somewhere
+pnpm link @trpc/upgrade && pnpm trpc-upgrade
+```

package/dist/cli.cjs

@@ -0,0 +1,77 @@
+#!/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 ignore = require('ignore');
+var typescript = require('typescript');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var path__default = /*#__PURE__*/_interopDefault(path);
+var ignore__default = /*#__PURE__*/_interopDefault(ignore);
+
+var version = "0.0.0-alpha.0";
+
+platform.Command.string(platform.Command.make('git', 'status')).pipe(effect.Effect.filterOrFail((status)=>status.includes('nothing to commit'), ()=>'Git tree is not clean, please commit your changes before running the migrator'));
+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 fs = yield* platform.FileSystem.FileSystem;
+        const ignores = yield* fs.readFileString(path__default.default.join(process.cwd(), '.gitignore')).pipe(effect.Effect.map((content)=>content.split('\n')), effect.Effect.map((patterns)=>ignore__default.default().add(patterns)));
+        // Ignore "common files"
+        const relativeFilePaths = files.filter((source)=>!source.fileName.includes('node_modules') && !source.fileName.includes('packages/')).map((file)=>path__default.default.relative(process.cwd(), file.fileName));
+        // As well as gitignored?
+        return ignores.filter(relativeFilePaths);
+    });
+const Program = 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
+    })));
+const transformPath = (path)=>process.env.DEV ? path : path.replace('../', './').replace('.ts', '.cjs');
+const prompts = cli$1.Command.prompt('transforms', 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'))
+        }
+    ]
+}), (_)=>effect.Effect.gen(function*() {
+        // yield* assertCleanGitTree;
+        const program = yield* Program;
+        const sourceFiles = program.getSourceFiles();
+        // Make sure provider transform runs first if it's selected
+        _.sort((a, b)=>a.includes('provider.ts') ? -1 : b.includes('provider.ts') ? 1 : 0);
+        /**
+       * TODO: Detect these automatically
+       */ const appRouterImportFile = '~/server/routers/_app';
+        const appRouterImportName = 'AppRouter';
+        const trpcFile = '~/lib/trpc';
+        const trpcImportName = 'trpc';
+        const commitedFiles = yield* filterIgnored(sourceFiles);
+        yield* effect.Effect.forEach(_, (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.replace('file://', ''), commitedFiles, {
+                            appRouterImportFile,
+                            appRouterImportName,
+                            trpcFile,
+                            trpcImportName
+                        })))), effect.Effect.map((res)=>effect.Effect.log('Transform result', res)));
+        });
+        yield* effect.Effect.log('Installing @trpc/tanstack-react-query');
+        yield* installPackage('@trpc/tanstack-react-query');
+    // TODO: Format project
+    }));
+const cli = cli$1.Command.run(prompts, {
+    name: 'tRPC Upgrade CLI',
+    version: `v${version}`
+});
+cli(process.argv).pipe(effect.Effect.provide(platformNode.NodeContext.layer), platformNode.NodeRuntime.runMain);

package/dist/transforms/hooksToOptions.cjs

@@ -0,0 +1,221 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/* eslint-disable @typescript-eslint/no-non-null-assertion */ /* eslint-disable no-console */ const hookToOptions = {
+    useQuery: {
+        lib: '@tanstack/react-query',
+        fn: 'queryOptions'
+    },
+    useSuspenseQuery: {
+        lib: '@tanstack/react-query',
+        fn: 'queryOptions'
+    },
+    useInfiniteQuery: {
+        lib: '@tanstack/react-query',
+        fn: 'infiniteQueryOptions'
+    },
+    useSuspenseInfiniteQuery: {
+        lib: '@tanstack/react-query',
+        fn: 'infiniteQueryOptions'
+    },
+    useMutation: {
+        lib: '@tanstack/react-query',
+        fn: 'mutationOptions'
+    },
+    useSubscription: {
+        lib: '@trpc/tanstack-react-query',
+        fn: 'subscriptionOptions'
+    }
+};
+const utilMap = {
+    fetch: 'fetchQuery',
+    fetchInfinite: 'fetchInfiniteQuery',
+    prefetch: 'prefetchQuery',
+    prefetchInfinite: 'prefetchInfiniteQuery',
+    ensureData: 'ensureQueryData',
+    invalidate: 'invalidateQueries',
+    reset: 'resetQueries',
+    refetch: 'refetchQueries',
+    cancel: 'cancelQuery',
+    setData: 'setQueryData',
+    setQueriesData: 'setQueriesData',
+    setInfiniteData: 'setInfiniteQueryData',
+    getData: 'getQueryData',
+    getInfiniteData: 'getInfiniteQueryData'
+};
+function transform(file, api, options) {
+    const { trpcFile, trpcImportName } = options;
+    if (!trpcFile || !trpcImportName) {
+        throw new Error('trpcFile and trpcImportName are required');
+    }
+    const j = api.jscodeshift;
+    const root = j(file.source);
+    let dirtyFlag = false;
+    // Traverse all functions, and _do stuff_
+    root.find(j.FunctionDeclaration).forEach((path)=>{
+        if (j(path).find(j.Identifier, {
+            name: trpcImportName
+        }).size() > 0) {
+            updateTRPCImport(path);
+        }
+        replaceHooksWithOptions(path);
+        removeSuspenseDestructuring(path);
+        migrateUseUtils(path);
+    });
+    root.find(j.ArrowFunctionExpression).forEach((path)=>{
+        if (j(path).find(j.Identifier, {
+            name: trpcImportName
+        }).size() > 0) {
+            updateTRPCImport(path);
+        }
+        replaceHooksWithOptions(path);
+        removeSuspenseDestructuring(path);
+        migrateUseUtils(path);
+    });
+    /**
+   * === HELPER FUNCTIONS BELOW ===
+   */ function updateTRPCImport(path) {
+        const specifier = root.find(j.ImportDeclaration, {
+            source: {
+                value: trpcFile
+            }
+        }).find(j.ImportSpecifier, {
+            imported: {
+                name: trpcImportName
+            }
+        });
+        if (specifier.size() === 0) {
+            return;
+        }
+        specifier.replaceWith(j.importSpecifier(j.identifier('useTRPC')));
+        dirtyFlag = true;
+        const variableDeclaration = j.variableDeclaration('const', [
+            j.variableDeclarator(j.identifier(trpcImportName), j.callExpression(j.identifier('useTRPC'), []))
+        ]);
+        if (j.FunctionDeclaration.check(path.node)) {
+            const body = path.node.body.body;
+            body.unshift(variableDeclaration);
+        } else if (j.BlockStatement.check(path.node.body)) {
+            path.node.body.body.unshift(variableDeclaration);
+        }
+    }
+    function ensureImported(lib, specifier) {
+        if (root.find(j.ImportDeclaration, {
+            source: {
+                value: lib
+            }
+        }).find(j.ImportSpecifier, {
+            imported: {
+                name: specifier
+            }
+        }).size() === 0) {
+            root.find(j.ImportDeclaration).at(-1).insertAfter(j.importDeclaration([
+                j.importSpecifier(j.identifier(specifier))
+            ], j.literal(lib)));
+            dirtyFlag = true;
+        }
+    }
+    function replaceHooksWithOptions(path) {
+        // REplace proxy-hooks with useX(options())
+        for (const [hook, { fn, lib }] of Object.entries(hookToOptions)){
+            j(path).find(j.CallExpression, {
+                callee: {
+                    property: {
+                        name: hook
+                    }
+                }
+            }).forEach((path)=>{
+                const memberExpr = path.node.callee;
+                if (!j.MemberExpression.check(memberExpr) || !j.Identifier.check(memberExpr.property)) {
+                    console.warn('Failed to identify hook call expression', path.node);
+                    return;
+                }
+                // Rename the hook to the options function
+                memberExpr.property.name = fn;
+                // Wrap it in the hook call
+                j(path).replaceWith(j.callExpression(j.identifier(hook), [
+                    path.node
+                ]));
+                ensureImported(lib, hook);
+                dirtyFlag = true;
+            });
+        }
+    }
+    // Migrate trpc.useUtils() to useQueryClient()
+    function migrateUseUtils(path) {
+        j(path).find(j.CallExpression, {
+            callee: {
+                property: {
+                    name: (name)=>[
+                            'useContext',
+                            'useUtils'
+                        ].includes(name)
+                }
+            }
+        }).forEach((path)=>{
+            if (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 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);
+                            return;
+                        }
+                        if (!(j.MemberExpression.check(memberExpr.object) && j.Identifier.check(memberExpr.object.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('trpc');
+                        memberExpr.property = j.identifier('queryFilter');
+                        // Wrap it in queryClient.utilMethod()
+                        j(callExprPath).replaceWith(j.memberExpression(j.identifier('queryClient'), j.callExpression(j.identifier(utilMap[proxyMethod]), [
+                            callExpr
+                        ])));
+                    }
+                });
+                // Replace `const utils = trpc.useUtils()` with `const queryClient = useQueryClient()`
+                j(path).replaceWith(j.callExpression(j.identifier('useQueryClient'), []));
+                path.parentPath.node.id = j.identifier('queryClient');
+                ensureImported('@tanstack/react-query', 'useQueryClient');
+            }
+            dirtyFlag = true;
+        });
+    }
+    function removeSuspenseDestructuring(path) {
+        // Remove suspense query destructuring
+        j(path).find(j.VariableDeclaration).forEach((path)=>{
+            const declarator = j.VariableDeclarator.check(path.node.declarations[0]) ? path.node.declarations[0] : null;
+            if (!j.CallExpression.check(declarator?.init) || !j.Identifier.check(declarator.init.callee) || ![
+                'useSuspenseQuery',
+                'useSuspenseInfiniteQuery'
+            ].includes(declarator.init.callee.name)) {
+                return;
+            }
+            console.log(declarator.init.callee.name);
+            const tuple = j.ArrayPattern.check(declarator?.id) ? declarator.id : null;
+            const dataName = j.Identifier.check(tuple?.elements?.[0]) ? tuple.elements[0].name : null;
+            const queryName = j.Identifier.check(tuple?.elements?.[1]) ? tuple.elements[1].name : null;
+            if (declarator && queryName) {
+                declarator.id = j.identifier(queryName);
+                dirtyFlag = true;
+                if (dataName) {
+                    j(path).insertAfter(j.variableDeclaration('const', [
+                        j.variableDeclarator(j.identifier(dataName), j.memberExpression(declarator.id, j.identifier('data')))
+                    ]));
+                }
+            }
+        });
+    }
+    return dirtyFlag ? root.toSource() : undefined;
+}
+const parser = 'tsx'; // https://go.codemod.com/ddX54TM
+
+exports.default = transform;
+exports.parser = parser;

package/dist/transforms/provider.cjs

@@ -0,0 +1,130 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function transform(file, api, options) {
+    const { trpcFile, trpcImportName, appRouterImportFile, appRouterImportName } = options;
+    const j = api.jscodeshift;
+    const root = j(file.source);
+    let dirtyFlag = false;
+    function upsertAppRouterImport() {
+        if (root.find(j.ImportDeclaration, {
+            source: {
+                value: appRouterImportFile
+            }
+        }).size() === 0) {
+            root.find(j.ImportDeclaration).at(-1).insertAfter(j.importDeclaration([
+                j.importSpecifier(j.identifier(appRouterImportName))
+            ], j.literal(appRouterImportFile), 'type'));
+        }
+    }
+    // Find the variable declaration for `trpc`
+    root.find(j.VariableDeclaration).forEach((path)=>{
+        const declaration = path.node.declarations[0];
+        if (j.Identifier.check(declaration.id) && declaration.id.name === trpcImportName) {
+            if (j.CallExpression.check(declaration.init) && j.Identifier.check(declaration.init.callee) && declaration.init.callee.name === 'createTRPCReact') {
+                // Replace the `createTRPCReact` call with `createTRPCContext`
+                declaration.init.callee.name = 'createTRPCContext';
+                // Destructure the result into `TRPCProvider` and `useTRPC`
+                declaration.id = j.objectPattern([
+                    j.property.from({
+                        kind: 'init',
+                        key: j.identifier('TRPCProvider'),
+                        value: j.identifier('TRPCProvider'),
+                        shorthand: true
+                    }),
+                    j.property.from({
+                        kind: 'init',
+                        key: j.identifier('useTRPC'),
+                        value: j.identifier('useTRPC'),
+                        shorthand: true
+                    })
+                ]);
+                dirtyFlag = true;
+            }
+        }
+    });
+    // Update the import statement if transformation was successful
+    if (dirtyFlag) {
+        root.find(j.ImportDeclaration, {
+            source: {
+                value: '@trpc/react-query'
+            }
+        }).forEach((path)=>{
+            path.node.source.value = '@trpc/tanstack-react-query';
+            path.node.specifiers?.forEach((specifier)=>{
+                if (j.ImportSpecifier.check(specifier) && specifier.imported.name === 'createTRPCReact') {
+                    specifier.imported.name = 'createTRPCContext';
+                }
+            });
+        });
+    }
+    // Replace trpc.createClient with createTRPCClient
+    root.find(j.CallExpression, {
+        callee: {
+            object: {
+                name: trpcImportName
+            },
+            property: {
+                name: 'createClient'
+            }
+        }
+    }).forEach((path)=>{
+        path.node.callee = j.identifier('createTRPCClient');
+        // Add the type parameter `<AppRouter>`
+        path.node.typeParameters = j.tsTypeParameterInstantiation([
+            j.tsTypeReference(j.identifier(appRouterImportName))
+        ]);
+        upsertAppRouterImport();
+        dirtyFlag = true;
+    });
+    // Replace <trpc.Provider client={...} with <TRPCProvider trpcClient={...}
+    root.find(j.JSXElement, {
+        openingElement: {
+            name: {
+                object: {
+                    name: trpcImportName
+                },
+                property: {
+                    name: 'Provider'
+                }
+            }
+        }
+    }).forEach((path)=>{
+        path.node.openingElement.name = j.jsxIdentifier('TRPCProvider');
+        if (path.node.closingElement) {
+            path.node.closingElement.name = j.jsxIdentifier('TRPCProvider');
+        }
+        path.node.openingElement.attributes?.forEach((attr)=>{
+            if (j.JSXAttribute.check(attr) && attr.name.name === 'client') {
+                attr.name.name = 'trpcClient';
+            }
+        });
+        dirtyFlag = true;
+    });
+    // Update imports if transformations were applied
+    if (dirtyFlag) {
+        // Add createTRPCClient to the import from '@trpc/client'
+        root.find(j.ImportDeclaration, {
+            source: {
+                value: '@trpc/client'
+            }
+        }).forEach((path)=>{
+            const createTRPCClientImport = j.importSpecifier(j.identifier('createTRPCClient'));
+            path.node.specifiers?.push(createTRPCClientImport);
+        });
+        // Replace trpc import with TRPCProvider
+        root.find(j.ImportDeclaration, {
+            source: {
+                value: trpcFile
+            }
+        }).forEach((path)=>{
+            path.node.specifiers = [
+                j.importSpecifier(j.identifier('TRPCProvider'))
+            ];
+        });
+    }
+    return dirtyFlag ? root.toSource() : undefined;
+}
+const parser = 'tsx';
+
+exports.default = transform;
+exports.parser = parser;

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@trpc/upgrade",
+  "version": "0.0.0-alpha.0",
+  "description": "Upgrade scripts for tRPC",
+  "author": "juliusmarminge",
+  "license": "MIT",
+  "bin": "./dist/cli.cjs",
+  "homepage": "https://trpc.io",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/trpc/trpc.git",
+    "directory": "packages/upgrade"
+  },
+  "exports": {
+    "./transforms/hooksToOptions": {
+      "require": "./dist/transforms/hooksToOptions.cjs"
+    },
+    "./transforms/provider": {
+      "require": "./dist/transforms/provider.cjs"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "package.json",
+    "!**/*.test.*",
+    "!**/__tests__"
+  ],
+  "dependencies": {
+    "@effect/cli": "0.48.25",
+    "@effect/platform": "0.69.25",
+    "@effect/platform-node": "0.64.27",
+    "effect": "3.10.16",
+    "ignore": "^6.0.2",
+    "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",
+    "tsx": "^4.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "funding": [
+    "https://trpc.io/sponsor"
+  ],
+  "scripts": {
+    "build": "bunchee",
+    "run": "tsx src/cli.ts"
+  }
+}

package/src/bin/cli.ts

@@ -0,0 +1,158 @@
+/* eslint-disable @typescript-eslint/unbound-method */
+import path from 'path';
+import { Command as CLICommand, Prompt } from '@effect/cli';
+import { Command, FileSystem } from '@effect/platform';
+import { NodeContext, NodeRuntime } from '@effect/platform-node';
+import {
+  Console,
+  Effect,
+  Match,
+  pipe,
+  Predicate,
+  Stream,
+  String,
+} from 'effect';
+import ignore from 'ignore';
+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(
+    (status) => status.includes('nothing to commit'),
+    () =>
+      'Git tree is not clean, please commit your changes before running the migrator',
+  ),
+);
+
+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 fs = yield* FileSystem.FileSystem;
+    const ignores = yield* fs
+      .readFileString(path.join(process.cwd(), '.gitignore'))
+      .pipe(
+        Effect.map((content) => content.split('\n')),
+        Effect.map((patterns) => ignore().add(patterns)),
+      );
+
+    // Ignore "common files"
+    const relativeFilePaths = files
+      .filter(
+        (source) =>
+          !source.fileName.includes('node_modules') &&
+          !source.fileName.includes('packages/'),
+      )
+      .map((file) => path.relative(process.cwd(), file.fileName));
+
+    // As well as gitignored?
+    return ignores.filter(relativeFilePaths);
+  });
+
+const Program = 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,
+    }),
+  ),
+);
+
+const transformPath = (path: string) =>
+  process.env.DEV ? path : path.replace('../', './').replace('.ts', '.cjs');
+
+const prompts = CLICommand.prompt(
+  'transforms',
+  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')),
+      },
+    ],
+  }),
+  (_) =>
+    Effect.gen(function* () {
+      // yield* assertCleanGitTree;
+      const program = yield* Program;
+      const sourceFiles = program.getSourceFiles();
+
+      // Make sure provider transform runs first if it's selected
+      _.sort((a, b) =>
+        a.includes('provider.ts') ? -1 : b.includes('provider.ts') ? 1 : 0,
+      );
+
+      /**
+       * TODO: Detect these automatically
+       */
+      const appRouterImportFile = '~/server/routers/_app';
+      const appRouterImportName = 'AppRouter';
+      const trpcFile = '~/lib/trpc';
+      const trpcImportName = 'trpc';
+
+      const commitedFiles = yield* filterIgnored(sourceFiles);
+      yield* Effect.forEach(_, (transform) => {
+        return pipe(
+          Effect.log('Running transform', transform),
+          Effect.flatMap(() =>
+            Effect.tryPromise(async () =>
+              import('jscodeshift/src/Runner.js').then(({ run }) =>
+                run(transform.replace('file://', ''), commitedFiles, {
+                  appRouterImportFile,
+                  appRouterImportName,
+                  trpcFile,
+                  trpcImportName,
+                }),
+              ),
+            ),
+          ),
+          Effect.map((res) => Effect.log('Transform result', res)),
+        );
+      });
+
+      yield* Effect.log('Installing @trpc/tanstack-react-query');
+      yield* installPackage('@trpc/tanstack-react-query');
+
+      // TODO: Format project
+    }),
+);
+
+const cli = CLICommand.run(prompts, {
+  name: 'tRPC Upgrade CLI',
+  version: `v${version}`,
+});
+
+cli(process.argv).pipe(Effect.provide(NodeContext.layer), NodeRuntime.runMain);

package/src/transforms/hooksToOptions.ts

@@ -0,0 +1,323 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+/* eslint-disable no-console */
+import type {
+  API,
+  ArrowFunctionExpression,
+  ASTPath,
+  CallExpression,
+  FileInfo,
+  FunctionDeclaration,
+  Identifier,
+  MemberExpression,
+  Options,
+} from 'jscodeshift';
+
+interface TransformOptions extends Options {
+  trpcFile?: string;
+  trpcImportName?: string;
+}
+
+const hookToOptions = {
+  useQuery: { lib: '@tanstack/react-query', fn: 'queryOptions' },
+  useSuspenseQuery: { lib: '@tanstack/react-query', fn: 'queryOptions' },
+  useInfiniteQuery: {
+    lib: '@tanstack/react-query',
+    fn: 'infiniteQueryOptions',
+  },
+  useSuspenseInfiniteQuery: {
+    lib: '@tanstack/react-query',
+    fn: 'infiniteQueryOptions',
+  },
+  useMutation: { lib: '@tanstack/react-query', fn: 'mutationOptions' },
+  useSubscription: {
+    lib: '@trpc/tanstack-react-query',
+    fn: 'subscriptionOptions',
+  },
+} as const;
+
+const utilMap = {
+  fetch: 'fetchQuery',
+  fetchInfinite: 'fetchInfiniteQuery',
+  prefetch: 'prefetchQuery',
+  prefetchInfinite: 'prefetchInfiniteQuery',
+  ensureData: 'ensureQueryData',
+  invalidate: 'invalidateQueries',
+  reset: 'resetQueries',
+  refetch: 'refetchQueries',
+  cancel: 'cancelQuery',
+  setData: 'setQueryData',
+  setQueriesData: 'setQueriesData',
+  setInfiniteData: 'setInfiniteQueryData',
+  getData: 'getQueryData',
+  getInfiniteData: 'getInfiniteQueryData',
+  // setMutationDefaults: 'setMutationDefaults',
+  // getMutationDefaults: 'getMutationDefaults',
+  // isMutating: 'isMutating',
+} as const;
+type ProxyMethod = keyof typeof utilMap;
+
+export default function transform(
+  file: FileInfo,
+  api: API,
+  options: TransformOptions,
+) {
+  const { trpcFile, trpcImportName } = options;
+  if (!trpcFile || !trpcImportName) {
+    throw new Error('trpcFile and trpcImportName are required');
+  }
+
+  const j = api.jscodeshift;
+  const root = j(file.source);
+  let dirtyFlag = false;
+
+  // Traverse all functions, and _do stuff_
+  root.find(j.FunctionDeclaration).forEach((path) => {
+    if (j(path).find(j.Identifier, { name: trpcImportName }).size() > 0) {
+      updateTRPCImport(path);
+    }
+
+    replaceHooksWithOptions(path);
+    removeSuspenseDestructuring(path);
+    migrateUseUtils(path);
+  });
+  root.find(j.ArrowFunctionExpression).forEach((path) => {
+    if (j(path).find(j.Identifier, { name: trpcImportName }).size() > 0) {
+      updateTRPCImport(path);
+    }
+
+    replaceHooksWithOptions(path);
+    removeSuspenseDestructuring(path);
+    migrateUseUtils(path);
+  });
+
+  /**
+   * === HELPER FUNCTIONS BELOW ===
+   */
+
+  function updateTRPCImport(
+    path: ASTPath<FunctionDeclaration | ArrowFunctionExpression>,
+  ) {
+    const specifier = root
+      .find(j.ImportDeclaration, {
+        source: { value: trpcFile },
+      })
+      .find(j.ImportSpecifier, { imported: { name: trpcImportName } });
+
+    if (specifier.size() === 0) {
+      return;
+    }
+
+    specifier.replaceWith(j.importSpecifier(j.identifier('useTRPC')));
+    dirtyFlag = true;
+
+    const variableDeclaration = j.variableDeclaration('const', [
+      j.variableDeclarator(
+        j.identifier(trpcImportName!),
+        j.callExpression(j.identifier('useTRPC'), []),
+      ),
+    ]);
+
+    if (j.FunctionDeclaration.check(path.node)) {
+      const body = path.node.body.body;
+      body.unshift(variableDeclaration);
+    } else if (j.BlockStatement.check(path.node.body)) {
+      path.node.body.body.unshift(variableDeclaration);
+    }
+  }
+
+  function ensureImported(lib: string, specifier: string) {
+    if (
+      root
+        .find(j.ImportDeclaration, {
+          source: { value: lib },
+        })
+        .find(j.ImportSpecifier, { imported: { name: specifier } })
+        .size() === 0
+    ) {
+      root
+        .find(j.ImportDeclaration)
+        .at(-1)
+        .insertAfter(
+          j.importDeclaration(
+            [j.importSpecifier(j.identifier(specifier))],
+            j.literal(lib),
+          ),
+        );
+      dirtyFlag = true;
+    }
+  }
+
+  function replaceHooksWithOptions(
+    path: ASTPath<FunctionDeclaration | ArrowFunctionExpression>,
+  ) {
+    // REplace proxy-hooks with useX(options())
+    for (const [hook, { fn, lib }] of Object.entries(hookToOptions)) {
+      j(path)
+        .find(j.CallExpression, {
+          callee: {
+            property: { name: hook },
+          },
+        })
+        .forEach((path) => {
+          const memberExpr = path.node.callee as MemberExpression;
+          if (
+            !j.MemberExpression.check(memberExpr) ||
+            !j.Identifier.check(memberExpr.property)
+          ) {
+            console.warn('Failed to identify hook call expression', path.node);
+            return;
+          }
+
+          // Rename the hook to the options function
+          memberExpr.property.name = fn;
+
+          // Wrap it in the hook call
+          j(path).replaceWith(
+            j.callExpression(j.identifier(hook), [path.node]),
+          );
+          ensureImported(lib, hook);
+
+          dirtyFlag = true;
+        });
+    }
+  }
+
+  // Migrate trpc.useUtils() to useQueryClient()
+  function migrateUseUtils(
+    path: ASTPath<FunctionDeclaration | ArrowFunctionExpression>,
+  ) {
+    j(path)
+      .find(j.CallExpression, {
+        callee: {
+          property: {
+            name: (name: string) => ['useContext', 'useUtils'].includes(name),
+          },
+        },
+      })
+      .forEach((path) => {
+        if (
+          j.VariableDeclarator.check(path.parentPath.node) &&
+          j.Identifier.check(path.parentPath.node.id)
+        ) {
+          const oldIdentifier = path.parentPath.node.id as Identifier;
+
+          // 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 callExpr = callExprPath.node as CallExpression;
+                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',
+                    callExpr,
+                  );
+                  return;
+                }
+
+                if (
+                  !(
+                    j.MemberExpression.check(memberExpr.object) &&
+                    j.Identifier.check(memberExpr.object.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 as ProxyMethod;
+                memberExpr.object.object = j.identifier('trpc');
+                memberExpr.property = j.identifier('queryFilter');
+
+                // Wrap it in queryClient.utilMethod()
+                j(callExprPath).replaceWith(
+                  j.memberExpression(
+                    j.identifier('queryClient'),
+                    j.callExpression(j.identifier(utilMap[proxyMethod]), [
+                      callExpr,
+                    ]),
+                  ),
+                );
+              }
+            });
+
+          // Replace `const utils = trpc.useUtils()` with `const queryClient = useQueryClient()`
+          j(path).replaceWith(
+            j.callExpression(j.identifier('useQueryClient'), []),
+          );
+          path.parentPath.node.id = j.identifier('queryClient');
+          ensureImported('@tanstack/react-query', 'useQueryClient');
+        }
+
+        dirtyFlag = true;
+      });
+  }
+
+  function removeSuspenseDestructuring(
+    path: ASTPath<FunctionDeclaration | ArrowFunctionExpression>,
+  ) {
+    // Remove suspense query destructuring
+    j(path)
+      .find(j.VariableDeclaration)
+      .forEach((path) => {
+        const declarator = j.VariableDeclarator.check(path.node.declarations[0])
+          ? path.node.declarations[0]
+          : null;
+
+        if (
+          !j.CallExpression.check(declarator?.init) ||
+          !j.Identifier.check(declarator.init.callee) ||
+          !['useSuspenseQuery', 'useSuspenseInfiniteQuery'].includes(
+            declarator.init.callee.name,
+          )
+        ) {
+          return;
+        }
+
+        console.log(declarator.init.callee.name);
+
+        const tuple = j.ArrayPattern.check(declarator?.id)
+          ? declarator.id
+          : null;
+        const dataName = j.Identifier.check(tuple?.elements?.[0])
+          ? tuple.elements[0].name
+          : null;
+        const queryName = j.Identifier.check(tuple?.elements?.[1])
+          ? tuple.elements[1].name
+          : null;
+
+        if (declarator && queryName) {
+          declarator.id = j.identifier(queryName);
+          dirtyFlag = true;
+
+          if (dataName) {
+            j(path).insertAfter(
+              j.variableDeclaration('const', [
+                j.variableDeclarator(
+                  j.identifier(dataName),
+                  j.memberExpression(declarator.id, j.identifier('data')),
+                ),
+              ]),
+            );
+          }
+        }
+      });
+  }
+
+  return dirtyFlag ? root.toSource() : undefined;
+}
+
+export const parser = 'tsx';
+
+// https://go.codemod.com/ddX54TM

package/src/transforms/provider.ts

@@ -0,0 +1,162 @@
+import type { API, FileInfo, Options } from 'jscodeshift';
+
+interface TransformOptions extends Options {
+  trpcFile?: string;
+  trpcImportName?: string;
+}
+
+export default function transform(
+  file: FileInfo,
+  api: API,
+  options: TransformOptions,
+) {
+  const { trpcFile, trpcImportName, appRouterImportFile, appRouterImportName } =
+    options;
+
+  const j = api.jscodeshift;
+  const root = j(file.source);
+  let dirtyFlag = false;
+
+  function upsertAppRouterImport() {
+    if (
+      root
+        .find(j.ImportDeclaration, { source: { value: appRouterImportFile } })
+        .size() === 0
+    ) {
+      root
+        .find(j.ImportDeclaration)
+        .at(-1)
+        .insertAfter(
+          j.importDeclaration(
+            [j.importSpecifier(j.identifier(appRouterImportName))],
+            j.literal(appRouterImportFile),
+            'type',
+          ),
+        );
+    }
+  }
+
+  // Find the variable declaration for `trpc`
+  root.find(j.VariableDeclaration).forEach((path) => {
+    const declaration = path.node.declarations[0];
+    if (
+      j.Identifier.check(declaration.id) &&
+      declaration.id.name === trpcImportName
+    ) {
+      if (
+        j.CallExpression.check(declaration.init) &&
+        j.Identifier.check(declaration.init.callee) &&
+        declaration.init.callee.name === 'createTRPCReact'
+      ) {
+        // Replace the `createTRPCReact` call with `createTRPCContext`
+        declaration.init.callee.name = 'createTRPCContext';
+
+        // Destructure the result into `TRPCProvider` and `useTRPC`
+        declaration.id = j.objectPattern([
+          j.property.from({
+            kind: 'init',
+            key: j.identifier('TRPCProvider'),
+            value: j.identifier('TRPCProvider'),
+            shorthand: true,
+          }),
+          j.property.from({
+            kind: 'init',
+            key: j.identifier('useTRPC'),
+            value: j.identifier('useTRPC'),
+            shorthand: true,
+          }),
+        ]);
+
+        dirtyFlag = true;
+      }
+    }
+  });
+
+  // Update the import statement if transformation was successful
+  if (dirtyFlag) {
+    root
+      .find(j.ImportDeclaration, { source: { value: '@trpc/react-query' } })
+      .forEach((path) => {
+        path.node.source.value = '@trpc/tanstack-react-query';
+        path.node.specifiers?.forEach((specifier) => {
+          if (
+            j.ImportSpecifier.check(specifier) &&
+            specifier.imported.name === 'createTRPCReact'
+          ) {
+            specifier.imported.name = 'createTRPCContext';
+          }
+        });
+      });
+  }
+
+  // Replace trpc.createClient with createTRPCClient
+  root
+    .find(j.CallExpression, {
+      callee: {
+        object: { name: trpcImportName },
+        property: { name: 'createClient' },
+      },
+    })
+    .forEach((path) => {
+      path.node.callee = j.identifier('createTRPCClient');
+      // Add the type parameter `<AppRouter>`
+      path.node.typeParameters = j.tsTypeParameterInstantiation([
+        j.tsTypeReference(j.identifier(appRouterImportName)),
+      ]);
+      upsertAppRouterImport();
+      dirtyFlag = true;
+    });
+
+  // Replace <trpc.Provider client={...} with <TRPCProvider trpcClient={...}
+  root
+    .find(j.JSXElement, {
+      openingElement: {
+        name: {
+          object: { name: trpcImportName },
+          property: { name: 'Provider' },
+        },
+      },
+    })
+    .forEach((path) => {
+      path.node.openingElement.name = j.jsxIdentifier('TRPCProvider');
+      if (path.node.closingElement) {
+        path.node.closingElement.name = j.jsxIdentifier('TRPCProvider');
+      }
+      path.node.openingElement.attributes?.forEach((attr) => {
+        if (j.JSXAttribute.check(attr) && attr.name.name === 'client') {
+          attr.name.name = 'trpcClient';
+        }
+      });
+      dirtyFlag = true;
+    });
+
+  // Update imports if transformations were applied
+  if (dirtyFlag) {
+    // Add createTRPCClient to the import from '@trpc/client'
+    root
+      .find(j.ImportDeclaration, {
+        source: { value: '@trpc/client' },
+      })
+      .forEach((path) => {
+        const createTRPCClientImport = j.importSpecifier(
+          j.identifier('createTRPCClient'),
+        );
+        path.node.specifiers?.push(createTRPCClientImport);
+      });
+
+    // Replace trpc import with TRPCProvider
+    root
+      .find(j.ImportDeclaration, {
+        source: { value: trpcFile },
+      })
+      .forEach((path) => {
+        path.node.specifiers = [
+          j.importSpecifier(j.identifier('TRPCProvider')),
+        ];
+      });
+  }
+
+  return dirtyFlag ? root.toSource() : undefined;
+}
+
+export const parser = 'tsx';