@macalinao/codama-rename-visitor 0.1.0 → 0.2.0

package/dist/rename-visitor.d.ts

@@ -0,0 +1,35 @@
+import { rootNodeVisitor } from "codama";
+import type { ProgramRenameOptions } from "./types.js";
+/**
+ * Creates a visitor that renames accounts, instructions, and defined types in specific programs.
+ * This follows the same pattern as addPdasVisitor from Codama.
+ *
+ * @param renamesByProgram - Object mapping program names to their rename configurations
+ * @returns A root node visitor that performs all specified renames
+ *
+ * @example
+ * ```typescript
+ * const visitor = renameVisitor({
+ *   quarryMine: {
+ *     instructions: {
+ *       claimRewards: "claimRewardsMine"
+ *     },
+ *     accounts: {
+ *       miner: "minerAccount"
+ *     }
+ *   },
+ *   token: {
+ *     instructions: {
+ *       transfer: "transferTokens",
+ *       mint: "mintNft"
+ *     },
+ *     definedTypes: {
+ *       tokenData: "tokenMetadata"
+ *     }
+ *   }
+ * });
+ * codama.update(visitor);
+ * ```
+ */
+export declare function renameVisitor(renamesByProgram: Record<string, ProgramRenameOptions>): ReturnType<typeof rootNodeVisitor>;
+//# sourceMappingURL=rename-visitor.d.ts.map

package/dist/rename-visitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rename-visitor.d.ts","sourceRoot":"","sources":["../src/rename-visitor.ts"],"names":[],"mappings":"AACA,OAAO,EAA8B,eAAe,EAAS,MAAM,QAAQ,CAAC;AAI5E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,aAAa,CAC3B,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,GACrD,UAAU,CAAC,OAAO,eAAe,CAAC,CAqDpC"}

package/dist/rename-visitor.js

@@ -0,0 +1,75 @@
+import { bottomUpTransformerVisitor, rootNodeVisitor, visit } from "codama";
+import { renameAccountTransform } from "./rename-accounts-visitor.js";
+import { renameDefinedTypeTransform } from "./rename-defined-types-visitor.js";
+import { renameInstructionTransform } from "./rename-instructions-visitor.js";
+/**
+ * Creates a visitor that renames accounts, instructions, and defined types in specific programs.
+ * This follows the same pattern as addPdasVisitor from Codama.
+ *
+ * @param renamesByProgram - Object mapping program names to their rename configurations
+ * @returns A root node visitor that performs all specified renames
+ *
+ * @example
+ * ```typescript
+ * const visitor = renameVisitor({
+ *   quarryMine: {
+ *     instructions: {
+ *       claimRewards: "claimRewardsMine"
+ *     },
+ *     accounts: {
+ *       miner: "minerAccount"
+ *     }
+ *   },
+ *   token: {
+ *     instructions: {
+ *       transfer: "transferTokens",
+ *       mint: "mintNft"
+ *     },
+ *     definedTypes: {
+ *       tokenData: "tokenMetadata"
+ *     }
+ *   }
+ * });
+ * codama.update(visitor);
+ * ```
+ */
+export function renameVisitor(renamesByProgram) {
+    return rootNodeVisitor((root) => {
+        const transforms = [];
+        // Process each program's rename configuration
+        Object.entries(renamesByProgram).forEach(([programName, renameOptions]) => {
+            // Add instruction renames for this program
+            if (renameOptions.instructions) {
+                Object.entries(renameOptions.instructions).forEach(([oldName, newName]) => {
+                    transforms.push({
+                        select: `[programNode]${programName}.[instructionNode]${oldName}`,
+                        transform: (node) => renameInstructionTransform(node, { [oldName]: newName }),
+                    });
+                });
+            }
+            if (renameOptions.accounts) {
+                Object.entries(renameOptions.accounts).forEach(([oldName, newName]) => {
+                    transforms.push({
+                        select: `[programNode]${programName}.[accountNode]${oldName}`,
+                        transform: (node) => renameAccountTransform(node, { [oldName]: newName }),
+                    });
+                });
+            }
+            // Add defined type renames for this program
+            if (renameOptions.definedTypes) {
+                Object.entries(renameOptions.definedTypes ?? {}).forEach(([oldName, newName]) => {
+                    transforms.push({
+                        select: `[programNode]${programName}.[definedTypeNode]${oldName}`,
+                        transform: (node) => renameDefinedTypeTransform(node, { [oldName]: newName }),
+                    });
+                });
+            }
+        });
+        if (transforms.length === 0) {
+            return root;
+        }
+        const visitor = bottomUpTransformerVisitor(transforms);
+        return visit(root, visitor);
+    });
+}
+//# sourceMappingURL=rename-visitor.js.map

package/dist/rename-visitor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rename-visitor.js","sourceRoot":"","sources":["../src/rename-visitor.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,0BAA0B,EAAE,eAAe,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAC5E,OAAO,EAAE,sBAAsB,EAAE,MAAM,8BAA8B,CAAC;AACtE,OAAO,EAAE,0BAA0B,EAAE,MAAM,mCAAmC,CAAC;AAC/E,OAAO,EAAE,0BAA0B,EAAE,MAAM,kCAAkC,CAAC;AAG9E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,UAAU,aAAa,CAC3B,gBAAsD;IAEtD,OAAO,eAAe,CAAC,CAAC,IAAI,EAAE,EAAE;QAC9B,MAAM,UAAU,GAGV,EAAE,CAAC;QAET,8CAA8C;QAC9C,MAAM,CAAC,OAAO,CAAC,gBAAgB,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,WAAW,EAAE,aAAa,CAAC,EAAE,EAAE;YACxE,2CAA2C;YAC3C,IAAI,aAAa,CAAC,YAAY,EAAE,CAAC;gBAC/B,MAAM,CAAC,OAAO,CAAC,aAAa,CAAC,YAAY,CAAC,CAAC,OAAO,CAChD,CAAC,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,EAAE;oBACrB,UAAU,CAAC,IAAI,CAAC;wBACd,MAAM,EAAE,gBAAgB,WAAW,qBAAqB,OAAO,EAAE;wBACjE,SAAS,EAAE,CAAC,IAAI,EAAE,EAAE,CAClB,0BAA0B,CAAC,IAAI,EAAE,EAAE,CAAC,OAAO,CAAC,EAAE,OAAO,EAAE,CAAC;qBAC3D,CAAC,CAAC;gBACL,CAAC,CACF,CAAC;YACJ,CAAC;YAED,IAAI,aAAa,CAAC,QAAQ,EAAE,CAAC;gBAC3B,MAAM,CAAC,OAAO,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,EAAE;oBACpE,UAAU,CAAC,IAAI,CAAC;wBACd,MAAM,EAAE,gBAAgB,WAAW,iBAAiB,OAAO,EAAE;wBAC7D,SAAS,EAAE,CAAC,IAAI,EAAE,EAAE,CAClB,sBAAsB,CAAC,IAAI,EAAE,EAAE,CAAC,OAAO,CAAC,EAAE,OAAO,EAAE,CAAC;qBACvD,CAAC,CAAC;gBACL,CAAC,CAAC,CAAC;YACL,CAAC;YAED,4CAA4C;YAC5C,IAAI,aAAa,CAAC,YAAY,EAAE,CAAC;gBAC/B,MAAM,CAAC,OAAO,CAAC,aAAa,CAAC,YAAY,IAAI,EAAE,CAAC,CAAC,OAAO,CACtD,CAAC,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,EAAE;oBACrB,UAAU,CAAC,IAAI,CAAC;wBACd,MAAM,EAAE,gBAAgB,WAAW,qBAAqB,OAAO,EAAE;wBACjE,SAAS,EAAE,CAAC,IAAI,EAAE,EAAE,CAClB,0BAA0B,CAAC,IAAI,EAAE,EAAE,CAAC,OAAO,CAAC,EAAE,OAAO,EAAE,CAAC;qBAC3D,CAAC,CAAC;gBACL,CAAC,CACF,CAAC;YACJ,CAAC;QACH,CAAC,CAAC,CAAC;QAEH,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC5B,OAAO,IAAI,CAAC;QACd,CAAC;QAED,MAAM,OAAO,GAAG,0BAA0B,CAAC,UAAU,CAAC,CAAC;QACvD,OAAO,KAAK,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IAC9B,CAAC,CAAC,CAAC;AACL,CAAC","sourcesContent":["import type { Node } from \"codama\";\nimport { bottomUpTransformerVisitor, rootNodeVisitor, visit } from \"codama\";\nimport { renameAccountTransform } from \"./rename-accounts-visitor.js\";\nimport { renameDefinedTypeTransform } from \"./rename-defined-types-visitor.js\";\nimport { renameInstructionTransform } from \"./rename-instructions-visitor.js\";\nimport type { ProgramRenameOptions } from \"./types.js\";\n\n/**\n * Creates a visitor that renames accounts, instructions, and defined types in specific programs.\n * This follows the same pattern as addPdasVisitor from Codama.\n *\n * @param renamesByProgram - Object mapping program names to their rename configurations\n * @returns A root node visitor that performs all specified renames\n *\n * @example\n * ```typescript\n * const visitor = renameVisitor({\n *   quarryMine: {\n *     instructions: {\n *       claimRewards: \"claimRewardsMine\"\n *     },\n *     accounts: {\n *       miner: \"minerAccount\"\n *     }\n *   },\n *   token: {\n *     instructions: {\n *       transfer: \"transferTokens\",\n *       mint: \"mintNft\"\n *     },\n *     definedTypes: {\n *       tokenData: \"tokenMetadata\"\n *     }\n *   }\n * });\n * codama.update(visitor);\n * ```\n */\nexport function renameVisitor(\n  renamesByProgram: Record<string, ProgramRenameOptions>,\n): ReturnType<typeof rootNodeVisitor> {\n  return rootNodeVisitor((root) => {\n    const transforms: {\n      select: string;\n      transform: (node: Node) => Node | null;\n    }[] = [];\n\n    // Process each program's rename configuration\n    Object.entries(renamesByProgram).forEach(([programName, renameOptions]) => {\n      // Add instruction renames for this program\n      if (renameOptions.instructions) {\n        Object.entries(renameOptions.instructions).forEach(\n          ([oldName, newName]) => {\n            transforms.push({\n              select: `[programNode]${programName}.[instructionNode]${oldName}`,\n              transform: (node) =>\n                renameInstructionTransform(node, { [oldName]: newName }),\n            });\n          },\n        );\n      }\n\n      if (renameOptions.accounts) {\n        Object.entries(renameOptions.accounts).forEach(([oldName, newName]) => {\n          transforms.push({\n            select: `[programNode]${programName}.[accountNode]${oldName}`,\n            transform: (node) =>\n              renameAccountTransform(node, { [oldName]: newName }),\n          });\n        });\n      }\n\n      // Add defined type renames for this program\n      if (renameOptions.definedTypes) {\n        Object.entries(renameOptions.definedTypes ?? {}).forEach(\n          ([oldName, newName]) => {\n            transforms.push({\n              select: `[programNode]${programName}.[definedTypeNode]${oldName}`,\n              transform: (node) =>\n                renameDefinedTypeTransform(node, { [oldName]: newName }),\n            });\n          },\n        );\n      }\n    });\n\n    if (transforms.length === 0) {\n      return root;\n    }\n\n    const visitor = bottomUpTransformerVisitor(transforms);\n    return visit(root, visitor);\n  });\n}\n"]}

package/dist/types.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Rename mapping for a single program
+ */
+export interface ProgramRenameOptions {
+    /** Mapping of old account names to new account names */
+    accounts?: Record<string, string>;
+    /** Mapping of old instruction names to new instruction names */
+    instructions?: Record<string, string>;
+    /** Mapping of old defined type names to new defined type names */
+    definedTypes?: Record<string, string>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,wDAAwD;IACxD,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClC,gEAAgE;IAChE,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,kEAAkE;IAClE,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACvC"}

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Rename mapping for a single program\n */\nexport interface ProgramRenameOptions {\n  /** Mapping of old account names to new account names */\n  accounts?: Record<string, string>;\n  /** Mapping of old instruction names to new instruction names */\n  instructions?: Record<string, string>;\n  /** Mapping of old defined type names to new defined type names */\n  definedTypes?: Record<string, string>;\n}\n"]}

package/package.json

@@ -1,20 +1,22 @@
 {
   "name": "@macalinao/codama-rename-visitor",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Codama visitor for renaming instructions and events within a program",
   "type": "module",
   "sideEffects": false,
   "author": "Ian Macalinao <me@ianm.com>",
   "homepage": "https://github.com/macalinao/coda",
-  "license": "MIT",
+  "license": "Apache-2.0",
   "keywords": [
     "codama",
+    "coda",
     "solana",
     "anchor",
     "idl",
     "rename",
     "visitor",
-    "typescript"
+    "typescript",
+    "ian-macalinao"
   ],
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -40,10 +42,10 @@
     "build": "tsc",
     "clean": "rm -fr dist/",
     "lint": "eslint . --cache",
-    "test": "bun test"
+    "test": "bun test src/"
   },
   "dependencies": {
-    "codama": "*"
+    "codama": "^1.3.3"
   },
   "devDependencies": {
     "@macalinao/eslint-config": "^5",

package/src/index.ts

@@ -1,291 +1,14 @@
-import type { DefinedTypeNode, InstructionNode, Node, RootNode } from "codama";
-import {
-  assertIsNode,
-  bottomUpTransformerVisitor,
-  camelCase,
-  rootNodeVisitor,
-  visit,
-} from "codama";
-
-/**
- * Rename mapping for a single program
- */
-export interface ProgramRenameOptions {
-  /** Mapping of old instruction names to new instruction names */
-  instructions?: Record<string, string>;
-  /** Mapping of old event names (as defined types) to new event names */
-  events?: Record<string, string>;
-  /** Mapping of old defined type names to new defined type names */
-  definedTypes?: Record<string, string>;
-}
-
-/**
- * Options for the rename visitor (legacy interface)
- */
-export type RenameVisitorOptions = ProgramRenameOptions;
-
-/**
- * Creates a visitor that renames instructions in a Codama IDL.
- *
- * @param mapping - Object mapping old instruction names to new instruction names
- * @returns A root node visitor that renames instructions
- *
- * @example
- * ```typescript
- * const visitor = renameInstructionsVisitor({
- *   "transfer": "transferTokens",
- *   "mint": "mintNft"
- * });
- * codama.update(visitor);
- * ```
- */
-export function renameInstructionsVisitor(
-  mapping: Record<string, string>,
-): ReturnType<typeof rootNodeVisitor> {
-  return rootNodeVisitor((root) => {
-    const instructionVisitor = bottomUpTransformerVisitor([
-      {
-        select: "[instructionNode]",
-        transform: (node) => {
-          assertIsNode(node, "instructionNode");
-          const newName = mapping[node.name];
-          if (!newName) {
-            return node;
-          }
-          return {
-            ...node,
-            name: camelCase(newName),
-          } as InstructionNode;
-        },
-      },
-    ]);
-    return visit(root, instructionVisitor);
-  });
-}
-
-/**
- * Creates a visitor that renames events (as defined types) in a Codama IDL.
- *
- * Events in Anchor IDLs are typically converted to defined types in Codama,
- * so this visitor renames specific defined types that represent events.
- *
- * @param mapping - Object mapping old event names to new event names
- * @param eventSuffix - Optional suffix to identify event types (default: "Event")
- * @returns A root node visitor that renames events
- *
- * @example
- * ```typescript
- * const visitor = renameEventsVisitor({
- *   "tokenMinted": "nftMinted",
- *   "transferComplete": "transferFinished"
- * });
- * codama.update(visitor);
- * ```
- */
-export function renameEventsVisitor(
-  mapping: Record<string, string>,
-  eventSuffix = "Event",
-): ReturnType<typeof rootNodeVisitor> {
-  return rootNodeVisitor((root) => {
-    const eventVisitor = bottomUpTransformerVisitor([
-      {
-        select: "[definedTypeNode]",
-        transform: (node) => {
-          assertIsNode(node, "definedTypeNode");
-
-          // Check if this is an event type (by suffix or by being in the mapping)
-          const isEventBySuffix = node.name.endsWith(eventSuffix);
-          const isEventInMapping = mapping[node.name] !== undefined;
-
-          if (!(isEventBySuffix || isEventInMapping)) {
-            return node;
-          }
-
-          const newName = mapping[node.name];
-          if (!newName) {
-            return node;
-          }
-
-          return {
-            ...node,
-            name: camelCase(newName),
-          } as DefinedTypeNode;
-        },
-      },
-    ]);
-    return visit(root, eventVisitor);
-  });
-}
-
-/**
- * Creates a visitor that renames defined types in a Codama IDL.
- *
- * @param mapping - Object mapping old defined type names to new defined type names
- * @returns A root node visitor that renames defined types
- *
- * @example
- * ```typescript
- * const visitor = renameDefinedTypesVisitor({
- *   "counter": "counterAccount",
- *   "config": "programConfig"
- * });
- * codama.update(visitor);
- * ```
- */
-export function renameDefinedTypesVisitor(
-  mapping: Record<string, string>,
-): ReturnType<typeof rootNodeVisitor> {
-  return rootNodeVisitor((root) => {
-    const typeVisitor = bottomUpTransformerVisitor([
-      {
-        select: "[definedTypeNode]",
-        transform: (node) => {
-          assertIsNode(node, "definedTypeNode");
-          const newName = mapping[node.name];
-          if (!newName) {
-            return node;
-          }
-          return {
-            ...node,
-            name: camelCase(newName),
-          } as DefinedTypeNode;
-        },
-      },
-    ]);
-    return visit(root, typeVisitor);
-  });
-}
-
-/**
- * Creates a visitor that renames instructions, events, and defined types in specific programs.
- * This follows the same pattern as addPdasVisitor from Codama.
- *
- * @param renamesByProgram - Object mapping program names to their rename configurations
- * @returns A root node visitor that performs all specified renames
- *
- * @example
- * ```typescript
- * const visitor = renameVisitor({
- *   quarryMine: {
- *     instructions: {
- *       claimRewards: "claimRewardsMine"
- *     }
- *   },
- *   token: {
- *     instructions: {
- *       transfer: "transferTokens",
- *       mint: "mintNft"
- *     },
- *     events: {
- *       tokenMinted: "nftMinted"
- *     }
- *   }
- * });
- * codama.update(visitor);
- * ```
- */
-export function renameVisitor(
-  renamesByProgram: Record<string, ProgramRenameOptions>,
-): ReturnType<typeof rootNodeVisitor> {
-  return rootNodeVisitor((root) => {
-    // Check if this is the legacy single-program format
-    // (has instructions, events, or definedTypes at the top level)
-    const isLegacyFormat =
-      "instructions" in renamesByProgram ||
-      "events" in renamesByProgram ||
-      "definedTypes" in renamesByProgram;
-
-    if (isLegacyFormat) {
-      // Legacy support: treat as single program renames
-      const options = renamesByProgram as unknown as RenameVisitorOptions;
-      let transformedRoot = root;
-
-      // Apply instruction renaming
-      if (
-        options.instructions &&
-        Object.keys(options.instructions).length > 0
-      ) {
-        transformedRoot = visit(
-          transformedRoot,
-          renameInstructionsVisitor(options.instructions),
-        ) as RootNode;
-      }
-
-      // Apply event renaming
-      if (options.events && Object.keys(options.events).length > 0) {
-        transformedRoot = visit(
-          transformedRoot,
-          renameEventsVisitor(options.events),
-        ) as RootNode;
-      }
-
-      // Apply defined type renaming
-      if (
-        options.definedTypes &&
-        Object.keys(options.definedTypes).length > 0
-      ) {
-        transformedRoot = visit(
-          transformedRoot,
-          renameDefinedTypesVisitor(options.definedTypes),
-        ) as RootNode;
-      }
-
-      return transformedRoot;
-    }
-
-    // New format: program-specific renames
-    const transforms: {
-      select: string;
-      transform: (node: Node) => Node | null;
-    }[] = [];
-
-    // Process each program's rename configuration
-    Object.entries(renamesByProgram).forEach(([programName, renameOptions]) => {
-      // Add instruction renames for this program
-      if (renameOptions.instructions) {
-        Object.entries(renameOptions.instructions).forEach(
-          ([oldName, newName]) => {
-            transforms.push({
-              select: `[programNode]${programName}.[instructionNode]${oldName}`,
-              transform: (node) => {
-                assertIsNode(node, "instructionNode");
-                return {
-                  ...node,
-                  name: camelCase(newName),
-                } as InstructionNode;
-              },
-            });
-          },
-        );
-      }
-
-      // Add event/defined type renames for this program
-      if (renameOptions.events || renameOptions.definedTypes) {
-        const allTypeRenames = {
-          ...(renameOptions.events ?? {}),
-          ...(renameOptions.definedTypes ?? {}),
-        };
-
-        Object.entries(allTypeRenames).forEach(([oldName, newName]) => {
-          transforms.push({
-            select: `[programNode]${programName}.[definedTypeNode]${oldName}`,
-            transform: (node) => {
-              assertIsNode(node, "definedTypeNode");
-              return {
-                ...node,
-                name: camelCase(newName),
-              } as DefinedTypeNode;
-            },
-          });
-        });
-      }
-    });
-
-    if (transforms.length === 0) {
-      return root;
-    }
-
-    const visitor = bottomUpTransformerVisitor(transforms);
-    return visit(root, visitor);
-  });
-}
+export {
+  renameAccountsVisitor,
+  renameAccountTransform,
+} from "./rename-accounts-visitor.js";
+export {
+  renameDefinedTypesVisitor,
+  renameDefinedTypeTransform,
+} from "./rename-defined-types-visitor.js";
+export {
+  renameInstructionsVisitor,
+  renameInstructionTransform,
+} from "./rename-instructions-visitor.js";
+export { renameVisitor } from "./rename-visitor.js";
+export type { ProgramRenameOptions } from "./types.js";

package/src/rename-accounts-visitor.ts

@@ -0,0 +1,50 @@
+import type { AccountNode, Node, rootNodeVisitor } from "codama";
+import { assertIsNode, bottomUpTransformerVisitor, camelCase } from "codama";
+
+/**
+ * Transform function that renames an account node based on a mapping.
+ *
+ * @param node - The node to transform
+ * @param mapping - Object mapping old account names to new account names
+ * @returns The transformed account node
+ */
+export function renameAccountTransform(
+  node: Node,
+  mapping: Record<string, string>,
+): AccountNode {
+  assertIsNode(node, "accountNode");
+  const newName = mapping[node.name];
+  if (!newName) {
+    return node;
+  }
+  return {
+    ...node,
+    name: camelCase(newName),
+  };
+}
+
+/**
+ * Creates a visitor that renames accounts in a Codama IDL.
+ *
+ * @param mapping - Object mapping old account names to new account names
+ * @returns A root node visitor that renames accounts
+ *
+ * @example
+ * ```typescript
+ * const visitor = renameAccountsVisitor({
+ *   "userAccount": "user",
+ *   "configAccount": "config"
+ * });
+ * codama.update(visitor);
+ * ```
+ */
+export function renameAccountsVisitor(
+  mapping: Record<string, string>,
+): ReturnType<typeof rootNodeVisitor> {
+  return bottomUpTransformerVisitor([
+    {
+      select: "[accountNode]",
+      transform: (node) => renameAccountTransform(node, mapping),
+    },
+  ]);
+}

package/src/rename-defined-types-visitor.test.ts

@@ -0,0 +1,44 @@
+/// <reference types="bun-types" />
+import { describe, expect, it } from "bun:test";
+import type { ProgramNode, RootNode } from "codama";
+import {
+  camelCase,
+  definedTypeNode,
+  numberTypeNode,
+  programNode,
+  publicKeyTypeNode,
+  rootNode,
+  visit,
+} from "codama";
+import { renameDefinedTypesVisitor } from "./rename-defined-types-visitor.js";
+
+describe("renameDefinedTypesVisitor", () => {
+  it("should rename defined types based on the mapping", () => {
+    const program: ProgramNode = programNode({
+      name: camelCase("testProgram"),
+      publicKey: "11111111111111111111111111111111",
+      definedTypes: [
+        definedTypeNode({
+          name: camelCase("counter"),
+          type: numberTypeNode("u64"),
+        }),
+        definedTypeNode({
+          name: camelCase("config"),
+          type: publicKeyTypeNode(),
+        }),
+      ],
+    });
+
+    const root = rootNode(program);
+    const visitor = renameDefinedTypesVisitor({
+      counter: "counterAccount",
+      config: "programConfig",
+    });
+
+    const updatedRoot = visit(root, visitor) as RootNode;
+    const types = updatedRoot.program.definedTypes;
+
+    expect(types[0].name.toString()).toBe("counterAccount");
+    expect(types[1].name.toString()).toBe("programConfig");
+  });
+});

package/src/rename-defined-types-visitor.ts

@@ -0,0 +1,59 @@
+import type { DefinedTypeNode, Node } from "codama";
+import {
+  assertIsNode,
+  bottomUpTransformerVisitor,
+  camelCase,
+  rootNodeVisitor,
+  visit,
+} from "codama";
+
+/**
+ * Transform function that renames a defined type node based on a mapping.
+ *
+ * @param node - The node to transform
+ * @param mapping - Object mapping old defined type names to new defined type names
+ * @returns The transformed defined type node
+ */
+export function renameDefinedTypeTransform(
+  node: Node,
+  mapping: Record<string, string>,
+): DefinedTypeNode {
+  assertIsNode(node, "definedTypeNode");
+  const newName = mapping[node.name];
+  if (!newName) {
+    return node;
+  }
+  return {
+    ...node,
+    name: camelCase(newName),
+  };
+}
+
+/**
+ * Creates a visitor that renames defined types in a Codama IDL.
+ *
+ * @param mapping - Object mapping old defined type names to new defined type names
+ * @returns A root node visitor that renames defined types
+ *
+ * @example
+ * ```typescript
+ * const visitor = renameDefinedTypesVisitor({
+ *   "counter": "counterAccount",
+ *   "config": "programConfig"
+ * });
+ * codama.update(visitor);
+ * ```
+ */
+export function renameDefinedTypesVisitor(
+  mapping: Record<string, string>,
+): ReturnType<typeof rootNodeVisitor> {
+  return rootNodeVisitor((root) => {
+    const typeVisitor = bottomUpTransformerVisitor([
+      {
+        select: "[definedTypeNode]",
+        transform: (node) => renameDefinedTypeTransform(node, mapping),
+      },
+    ]);
+    return visit(root, typeVisitor);
+  });
+}