@macalinao/codama-rename-visitor 0.1.0

package/README.md

@@ -0,0 +1,121 @@
+# @macalinao/codama-rename-visitor
+
+A Codama visitor for renaming instructions and events within a Solana program.
+
+## Installation
+
+```bash
+npm install @macalinao/codama-rename-visitor
+```
+
+## Usage
+
+This visitor allows you to rename instructions and events in your Codama IDL. It's particularly useful when you want to change the naming conventions of your program without modifying the original IDL.
+
+### Renaming Instructions
+
+```typescript
+import { renameInstructionsVisitor } from "@macalinao/codama-rename-visitor";
+import { visit } from "codama";
+
+// Rename specific instructions
+const visitor = renameInstructionsVisitor({
+  oldInstructionName: "newInstructionName",
+  transfer: "transferTokens",
+  mint: "mintNft"
+});
+
+const updatedRoot = visit(root, visitor);
+```
+
+### Renaming Events
+
+```typescript
+import { renameEventsVisitor } from "@macalinao/codama-rename-visitor";
+import { visit } from "codama";
+
+// Rename specific events (as defined types)
+const visitor = renameEventsVisitor({
+  oldEventName: "newEventName",
+  tokenMinted: "nftMinted",
+  transferComplete: "transferFinished"
+});
+
+const updatedRoot = visit(root, visitor);
+```
+
+### Program-Specific Renaming (Recommended)
+
+The `renameVisitor` follows the same pattern as Codama's `addPdasVisitor`, where you specify renames for specific programs:
+
+```typescript
+import { renameVisitor } from "@macalinao/codama-rename-visitor";
+import { visit } from "codama";
+
+// Rename elements in specific programs
+const visitor = renameVisitor({
+  quarryMine: {
+    instructions: {
+      claimRewards: "claimRewardsMine"
+    }
+  },
+  token: {
+    instructions: {
+      transfer: "transferTokens",
+      mint: "mintNft"
+    },
+    events: {
+      tokenMinted: "nftMinted"
+    }
+  }
+});
+
+const updatedRoot = visit(root, visitor);
+```
+
+### Legacy Single-Program Renaming
+
+For backward compatibility, you can still use the legacy format for single-program renaming:
+
+```typescript
+import { renameVisitor } from "@macalinao/codama-rename-visitor";
+import { visit } from "codama";
+
+// Legacy format: rename in the current program
+const visitor = renameVisitor({
+  instructions: {
+    transfer: "transferTokens",
+    mint: "mintNft"
+  },
+  events: {
+    tokenMinted: "nftMinted",
+    transferComplete: "transferFinished"
+  }
+});
+
+const updatedRoot = visit(root, visitor);
+```
+
+## API
+
+### `renameVisitor(renamesByProgram: Record<string, ProgramRenameOptions>)`
+
+Creates a visitor that renames instructions, events, and defined types in specific programs. This is the recommended API.
+
+- `renamesByProgram`: Object mapping program names to their rename configurations
+  - Each program can specify:
+    - `instructions`: Mapping of old instruction names to new names
+    - `events`: Mapping of old event names to new names  
+    - `definedTypes`: Mapping of old defined type names to new names
+
+### `renameInstructionsVisitor(mapping: Record<string, string>)`
+
+Creates a visitor that renames instructions based on the provided mapping. Applies to all programs.
+
+### `renameEventsVisitor(mapping: Record<string, string>)`
+
+Creates a visitor that renames events (defined types) based on the provided mapping. Applies to all programs.
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,98 @@
+import { rootNodeVisitor } 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 declare function renameInstructionsVisitor(mapping: Record<string, string>): ReturnType<typeof rootNodeVisitor>;
+/**
+ * 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 declare function renameEventsVisitor(mapping: Record<string, string>, eventSuffix?: string): ReturnType<typeof rootNodeVisitor>;
+/**
+ * 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 declare function renameDefinedTypesVisitor(mapping: Record<string, string>): ReturnType<typeof rootNodeVisitor>;
+/**
+ * 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 declare function renameVisitor(renamesByProgram: Record<string, ProgramRenameOptions>): ReturnType<typeof rootNodeVisitor>;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAIL,eAAe,EAEhB,MAAM,QAAQ,CAAC;AAEhB;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,gEAAgE;IAChE,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,uEAAuE;IACvE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,kEAAkE;IAClE,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACvC;AAED;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG,oBAAoB,CAAC;AAExD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC9B,UAAU,CAAC,OAAO,eAAe,CAAC,CAoBpC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC/B,WAAW,SAAU,GACpB,UAAU,CAAC,OAAO,eAAe,CAAC,CA8BpC;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC9B,UAAU,CAAC,OAAO,eAAe,CAAC,CAoBpC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,aAAa,CAC3B,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,GACrD,UAAU,CAAC,OAAO,eAAe,CAAC,CAsGpC"}

package/dist/index.js

@@ -0,0 +1,221 @@
+import { assertIsNode, bottomUpTransformerVisitor, camelCase, rootNodeVisitor, visit, } from "codama";
+/**
+ * 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) {
+    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),
+                    };
+                },
+            },
+        ]);
+        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, eventSuffix = "Event") {
+    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),
+                    };
+                },
+            },
+        ]);
+        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) {
+    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),
+                    };
+                },
+            },
+        ]);
+        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) {
+    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;
+            let transformedRoot = root;
+            // Apply instruction renaming
+            if (options.instructions &&
+                Object.keys(options.instructions).length > 0) {
+                transformedRoot = visit(transformedRoot, renameInstructionsVisitor(options.instructions));
+            }
+            // Apply event renaming
+            if (options.events && Object.keys(options.events).length > 0) {
+                transformedRoot = visit(transformedRoot, renameEventsVisitor(options.events));
+            }
+            // Apply defined type renaming
+            if (options.definedTypes &&
+                Object.keys(options.definedTypes).length > 0) {
+                transformedRoot = visit(transformedRoot, renameDefinedTypesVisitor(options.definedTypes));
+            }
+            return transformedRoot;
+        }
+        // New format: program-specific renames
+        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) => {
+                            assertIsNode(node, "instructionNode");
+                            return {
+                                ...node,
+                                name: camelCase(newName),
+                            };
+                        },
+                    });
+                });
+            }
+            // 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),
+                            };
+                        },
+                    });
+                });
+            }
+        });
+        if (transforms.length === 0) {
+            return root;
+        }
+        const visitor = bottomUpTransformerVisitor(transforms);
+        return visit(root, visitor);
+    });
+}
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["import type { DefinedTypeNode, InstructionNode, Node, RootNode } from \"codama\";\nimport {\n  assertIsNode,\n  bottomUpTransformerVisitor,\n  camelCase,\n  rootNodeVisitor,\n  visit,\n} from \"codama\";\n\n/**\n * Rename mapping for a single program\n */\nexport interface ProgramRenameOptions {\n  /** Mapping of old instruction names to new instruction names */\n  instructions?: Record<string, string>;\n  /** Mapping of old event names (as defined types) to new event names */\n  events?: Record<string, string>;\n  /** Mapping of old defined type names to new defined type names */\n  definedTypes?: Record<string, string>;\n}\n\n/**\n * Options for the rename visitor (legacy interface)\n */\nexport type RenameVisitorOptions = ProgramRenameOptions;\n\n/**\n * Creates a visitor that renames instructions in a Codama IDL.\n *\n * @param mapping - Object mapping old instruction names to new instruction names\n * @returns A root node visitor that renames instructions\n *\n * @example\n * ```typescript\n * const visitor = renameInstructionsVisitor({\n *   \"transfer\": \"transferTokens\",\n *   \"mint\": \"mintNft\"\n * });\n * codama.update(visitor);\n * ```\n */\nexport function renameInstructionsVisitor(\n  mapping: Record<string, string>,\n): ReturnType<typeof rootNodeVisitor> {\n  return rootNodeVisitor((root) => {\n    const instructionVisitor = bottomUpTransformerVisitor([\n      {\n        select: \"[instructionNode]\",\n        transform: (node) => {\n          assertIsNode(node, \"instructionNode\");\n          const newName = mapping[node.name];\n          if (!newName) {\n            return node;\n          }\n          return {\n            ...node,\n            name: camelCase(newName),\n          } as InstructionNode;\n        },\n      },\n    ]);\n    return visit(root, instructionVisitor);\n  });\n}\n\n/**\n * Creates a visitor that renames events (as defined types) in a Codama IDL.\n *\n * Events in Anchor IDLs are typically converted to defined types in Codama,\n * so this visitor renames specific defined types that represent events.\n *\n * @param mapping - Object mapping old event names to new event names\n * @param eventSuffix - Optional suffix to identify event types (default: \"Event\")\n * @returns A root node visitor that renames events\n *\n * @example\n * ```typescript\n * const visitor = renameEventsVisitor({\n *   \"tokenMinted\": \"nftMinted\",\n *   \"transferComplete\": \"transferFinished\"\n * });\n * codama.update(visitor);\n * ```\n */\nexport function renameEventsVisitor(\n  mapping: Record<string, string>,\n  eventSuffix = \"Event\",\n): ReturnType<typeof rootNodeVisitor> {\n  return rootNodeVisitor((root) => {\n    const eventVisitor = bottomUpTransformerVisitor([\n      {\n        select: \"[definedTypeNode]\",\n        transform: (node) => {\n          assertIsNode(node, \"definedTypeNode\");\n\n          // Check if this is an event type (by suffix or by being in the mapping)\n          const isEventBySuffix = node.name.endsWith(eventSuffix);\n          const isEventInMapping = mapping[node.name] !== undefined;\n\n          if (!(isEventBySuffix || isEventInMapping)) {\n            return node;\n          }\n\n          const newName = mapping[node.name];\n          if (!newName) {\n            return node;\n          }\n\n          return {\n            ...node,\n            name: camelCase(newName),\n          } as DefinedTypeNode;\n        },\n      },\n    ]);\n    return visit(root, eventVisitor);\n  });\n}\n\n/**\n * Creates a visitor that renames defined types in a Codama IDL.\n *\n * @param mapping - Object mapping old defined type names to new defined type names\n * @returns A root node visitor that renames defined types\n *\n * @example\n * ```typescript\n * const visitor = renameDefinedTypesVisitor({\n *   \"counter\": \"counterAccount\",\n *   \"config\": \"programConfig\"\n * });\n * codama.update(visitor);\n * ```\n */\nexport function renameDefinedTypesVisitor(\n  mapping: Record<string, string>,\n): ReturnType<typeof rootNodeVisitor> {\n  return rootNodeVisitor((root) => {\n    const typeVisitor = bottomUpTransformerVisitor([\n      {\n        select: \"[definedTypeNode]\",\n        transform: (node) => {\n          assertIsNode(node, \"definedTypeNode\");\n          const newName = mapping[node.name];\n          if (!newName) {\n            return node;\n          }\n          return {\n            ...node,\n            name: camelCase(newName),\n          } as DefinedTypeNode;\n        },\n      },\n    ]);\n    return visit(root, typeVisitor);\n  });\n}\n\n/**\n * Creates a visitor that renames instructions, events, 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 *   },\n *   token: {\n *     instructions: {\n *       transfer: \"transferTokens\",\n *       mint: \"mintNft\"\n *     },\n *     events: {\n *       tokenMinted: \"nftMinted\"\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    // Check if this is the legacy single-program format\n    // (has instructions, events, or definedTypes at the top level)\n    const isLegacyFormat =\n      \"instructions\" in renamesByProgram ||\n      \"events\" in renamesByProgram ||\n      \"definedTypes\" in renamesByProgram;\n\n    if (isLegacyFormat) {\n      // Legacy support: treat as single program renames\n      const options = renamesByProgram as unknown as RenameVisitorOptions;\n      let transformedRoot = root;\n\n      // Apply instruction renaming\n      if (\n        options.instructions &&\n        Object.keys(options.instructions).length > 0\n      ) {\n        transformedRoot = visit(\n          transformedRoot,\n          renameInstructionsVisitor(options.instructions),\n        ) as RootNode;\n      }\n\n      // Apply event renaming\n      if (options.events && Object.keys(options.events).length > 0) {\n        transformedRoot = visit(\n          transformedRoot,\n          renameEventsVisitor(options.events),\n        ) as RootNode;\n      }\n\n      // Apply defined type renaming\n      if (\n        options.definedTypes &&\n        Object.keys(options.definedTypes).length > 0\n      ) {\n        transformedRoot = visit(\n          transformedRoot,\n          renameDefinedTypesVisitor(options.definedTypes),\n        ) as RootNode;\n      }\n\n      return transformedRoot;\n    }\n\n    // New format: program-specific renames\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                assertIsNode(node, \"instructionNode\");\n                return {\n                  ...node,\n                  name: camelCase(newName),\n                } as InstructionNode;\n              },\n            });\n          },\n        );\n      }\n\n      // Add event/defined type renames for this program\n      if (renameOptions.events || renameOptions.definedTypes) {\n        const allTypeRenames = {\n          ...(renameOptions.events ?? {}),\n          ...(renameOptions.definedTypes ?? {}),\n        };\n\n        Object.entries(allTypeRenames).forEach(([oldName, newName]) => {\n          transforms.push({\n            select: `[programNode]${programName}.[definedTypeNode]${oldName}`,\n            transform: (node) => {\n              assertIsNode(node, \"definedTypeNode\");\n              return {\n                ...node,\n                name: camelCase(newName),\n              } as DefinedTypeNode;\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/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@macalinao/codama-rename-visitor",
+  "version": "0.1.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",
+  "keywords": [
+    "codama",
+    "solana",
+    "anchor",
+    "idl",
+    "rename",
+    "visitor",
+    "typescript"
+  ],
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist/",
+    "src/"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/macalinao/coda.git",
+    "directory": "packages/codama-rename-visitor"
+  },
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -fr dist/",
+    "lint": "eslint . --cache",
+    "test": "bun test"
+  },
+  "dependencies": {
+    "codama": "*"
+  },
+  "devDependencies": {
+    "@macalinao/eslint-config": "^5",
+    "@macalinao/tsconfig": "^3.2.3",
+    "eslint": "^9.33.0",
+    "typescript": "^5.9.2"
+  },
+  "lint-staged": {
+    "*.{js,jsx,ts,tsx,cjs,mjs,cts,mts}": [
+      "biome check --write --no-errors-on-unmatched",
+      "eslint --fix --cache"
+    ],
+    "*.{json,jsonc,html}": "biome format --write --no-errors-on-unmatched"
+  }
+}

package/src/index.test.ts

@@ -0,0 +1,409 @@
+/// <reference types="bun-types" />
+import { describe, expect, it } from "bun:test";
+import type { ProgramNode, RootNode } from "codama";
+import {
+  camelCase,
+  definedTypeNode,
+  instructionAccountNode,
+  instructionNode,
+  numberTypeNode,
+  programNode,
+  publicKeyTypeNode,
+  rootNode,
+  visit,
+} from "codama";
+import {
+  renameDefinedTypesVisitor,
+  renameEventsVisitor,
+  renameInstructionsVisitor,
+  renameVisitor,
+} from "./index.js";
+
+describe("renameInstructionsVisitor", () => {
+  it("should rename instructions based on the mapping", () => {
+    const program: ProgramNode = programNode({
+      name: camelCase("testProgram"),
+      publicKey: "11111111111111111111111111111111",
+      instructions: [
+        instructionNode({
+          name: camelCase("transfer"),
+          accounts: [
+            instructionAccountNode({
+              name: camelCase("source"),
+              isWritable: true,
+              isSigner: false,
+            }),
+            instructionAccountNode({
+              name: camelCase("destination"),
+              isWritable: true,
+              isSigner: false,
+            }),
+          ],
+        }),
+        instructionNode({
+          name: camelCase("mint"),
+          accounts: [
+            instructionAccountNode({
+              name: camelCase("mint"),
+              isWritable: true,
+              isSigner: false,
+            }),
+          ],
+        }),
+      ],
+    });
+
+    const root = rootNode(program);
+    const visitor = renameInstructionsVisitor({
+      transfer: "transferTokens",
+      mint: "mintNft",
+    });
+
+    const updatedRoot = visit(root, visitor) as RootNode;
+    const instructions = updatedRoot.program.instructions;
+
+    expect(instructions[0].name.toString()).toBe("transferTokens");
+    expect(instructions[1].name.toString()).toBe("mintNft");
+  });
+
+  it("should leave unmapped instructions unchanged", () => {
+    const program: ProgramNode = programNode({
+      name: camelCase("testProgram"),
+      publicKey: "11111111111111111111111111111111",
+      instructions: [
+        instructionNode({
+          name: camelCase("burn"),
+          accounts: [],
+        }),
+      ],
+    });
+
+    const root = rootNode(program);
+    const visitor = renameInstructionsVisitor({
+      transfer: "transferTokens",
+    });
+
+    const updatedRoot = visit(root, visitor) as RootNode;
+    const instructions = updatedRoot.program.instructions;
+
+    expect(instructions[0].name.toString()).toBe("burn");
+  });
+});
+
+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");
+  });
+});
+
+describe("renameEventsVisitor", () => {
+  it("should rename events (as defined types with Event suffix)", () => {
+    const program: ProgramNode = programNode({
+      name: camelCase("testProgram"),
+      publicKey: "11111111111111111111111111111111",
+      definedTypes: [
+        definedTypeNode({
+          name: camelCase("tokenMintedEvent"),
+          type: numberTypeNode("u64"),
+        }),
+        definedTypeNode({
+          name: camelCase("transferCompleteEvent"),
+          type: publicKeyTypeNode(),
+        }),
+        definedTypeNode({
+          name: camelCase("regularType"),
+          type: numberTypeNode("u32"),
+        }),
+      ],
+    });
+
+    const root = rootNode(program);
+    const visitor = renameEventsVisitor({
+      tokenMintedEvent: "nftMintedEvent",
+      transferCompleteEvent: "transferFinishedEvent",
+    });
+
+    const updatedRoot = visit(root, visitor) as RootNode;
+    const types = updatedRoot.program.definedTypes;
+
+    expect(types[0].name.toString()).toBe("nftMintedEvent");
+    expect(types[1].name.toString()).toBe("transferFinishedEvent");
+    expect(types[2].name.toString()).toBe("regularType"); // Should remain unchanged
+  });
+
+  it("should rename events without suffix if explicitly in mapping", () => {
+    const program: ProgramNode = programNode({
+      name: camelCase("testProgram"),
+      publicKey: "11111111111111111111111111111111",
+      definedTypes: [
+        definedTypeNode({
+          name: camelCase("tokenMinted"),
+          type: numberTypeNode("u64"),
+        }),
+      ],
+    });
+
+    const root = rootNode(program);
+    const visitor = renameEventsVisitor({
+      tokenMinted: "nftMinted",
+    });
+
+    const updatedRoot = visit(root, visitor) as RootNode;
+    const types = updatedRoot.program.definedTypes;
+
+    expect(types[0].name.toString()).toBe("nftMinted");
+  });
+});
+
+describe("renameVisitor (legacy format)", () => {
+  it("should rename both instructions and events", () => {
+    const program: ProgramNode = programNode({
+      name: camelCase("testProgram"),
+      publicKey: "11111111111111111111111111111111",
+      instructions: [
+        instructionNode({
+          name: camelCase("transfer"),
+          accounts: [],
+        }),
+      ],
+      definedTypes: [
+        definedTypeNode({
+          name: camelCase("tokenMintedEvent"),
+          type: numberTypeNode("u64"),
+        }),
+      ],
+    });
+
+    const root = rootNode(program);
+    const visitor = renameVisitor({
+      instructions: {
+        transfer: "transferTokens",
+      },
+      events: {
+        tokenMintedEvent: "nftMintedEvent",
+      },
+    });
+
+    const updatedRoot = visit(root, visitor) as RootNode;
+    const instructions = updatedRoot.program.instructions;
+    const types = updatedRoot.program.definedTypes;
+
+    expect(instructions[0].name.toString()).toBe("transferTokens");
+    expect(types[0].name.toString()).toBe("nftMintedEvent");
+  });
+
+  it("should handle empty options gracefully", () => {
+    const program: ProgramNode = programNode({
+      name: camelCase("testProgram"),
+      publicKey: "11111111111111111111111111111111",
+      instructions: [
+        instructionNode({
+          name: camelCase("transfer"),
+          accounts: [],
+        }),
+      ],
+    });
+
+    const root = rootNode(program);
+    const visitor = renameVisitor({});
+
+    const updatedRoot = visit(root, visitor) as RootNode;
+    const instructions = updatedRoot.program.instructions;
+
+    expect(instructions[0].name.toString()).toBe("transfer");
+  });
+});
+
+describe("renameVisitor (program-specific format)", () => {
+  it("should rename instructions in specific programs", () => {
+    const quarryMineProgram: ProgramNode = programNode({
+      name: camelCase("quarryMine"),
+      publicKey: "11111111111111111111111111111111",
+      instructions: [
+        instructionNode({
+          name: camelCase("claimRewards"),
+          accounts: [],
+        }),
+        instructionNode({
+          name: camelCase("stake"),
+          accounts: [],
+        }),
+      ],
+    });
+
+    const tokenProgram: ProgramNode = programNode({
+      name: camelCase("token"),
+      publicKey: "22222222222222222222222222222222",
+      instructions: [
+        instructionNode({
+          name: camelCase("transfer"),
+          accounts: [],
+        }),
+        instructionNode({
+          name: camelCase("mint"),
+          accounts: [],
+        }),
+      ],
+    });
+
+    // Create a root with multiple programs
+    const root = rootNode(quarryMineProgram, [tokenProgram]);
+
+    const visitor = renameVisitor({
+      quarryMine: {
+        instructions: {
+          claimRewards: "claimRewardsMine",
+        },
+      },
+      token: {
+        instructions: {
+          transfer: "transferTokens",
+          mint: "mintNft",
+        },
+      },
+    });
+
+    const updatedRoot = visit(root, visitor) as RootNode;
+    const quarryInstructions = updatedRoot.program.instructions;
+    const tokenInstructions =
+      updatedRoot.additionalPrograms?.[0]?.instructions ?? [];
+
+    expect(quarryInstructions[0].name.toString()).toBe("claimRewardsMine");
+    expect(quarryInstructions[1].name.toString()).toBe("stake"); // Unchanged
+    expect(tokenInstructions[0].name.toString()).toBe("transferTokens");
+    expect(tokenInstructions[1].name.toString()).toBe("mintNft");
+  });
+
+  it("should rename events and defined types in specific programs", () => {
+    const program: ProgramNode = programNode({
+      name: camelCase("myProgram"),
+      publicKey: "11111111111111111111111111111111",
+      definedTypes: [
+        definedTypeNode({
+          name: camelCase("tokenMintedEvent"),
+          type: numberTypeNode("u64"),
+        }),
+        definedTypeNode({
+          name: camelCase("counter"),
+          type: numberTypeNode("u64"),
+        }),
+      ],
+    });
+
+    const root = rootNode(program);
+
+    const visitor = renameVisitor({
+      myProgram: {
+        events: {
+          tokenMintedEvent: "nftMintedEvent",
+        },
+        definedTypes: {
+          counter: "counterAccount",
+        },
+      },
+    });
+
+    const updatedRoot = visit(root, visitor) as RootNode;
+    const types = updatedRoot.program.definedTypes;
+
+    expect(types[0].name.toString()).toBe("nftMintedEvent");
+    expect(types[1].name.toString()).toBe("counterAccount");
+  });
+
+  it("should work with Quarry-style program names (camelCase)", () => {
+    const quarryMergeMineProgram: ProgramNode = programNode({
+      name: camelCase("quarryMergeMine"),
+      publicKey: "QMMD16kjauP5knBwxNUJRZ1Z5o3deBuFrqVjBVmmqto",
+      instructions: [
+        instructionNode({
+          name: camelCase("claimRewards"),
+          accounts: [],
+        }),
+        instructionNode({
+          name: camelCase("stake"),
+          accounts: [],
+        }),
+      ],
+    });
+
+    const root = rootNode(quarryMergeMineProgram);
+
+    const visitor = renameVisitor({
+      quarryMergeMine: {
+        instructions: {
+          claimRewards: "claimRewardsMergeMine",
+        },
+      },
+    });
+
+    const updatedRoot = visit(root, visitor) as RootNode;
+    const instructions = updatedRoot.program.instructions;
+
+    expect(instructions[0].name.toString()).toBe("claimRewardsMergeMine");
+    expect(instructions[1].name.toString()).toBe("stake"); // Unchanged
+  });
+
+  it("should handle mixed program configurations", () => {
+    const program: ProgramNode = programNode({
+      name: camelCase("testProgram"),
+      publicKey: "11111111111111111111111111111111",
+      instructions: [
+        instructionNode({
+          name: camelCase("transfer"),
+          accounts: [],
+        }),
+      ],
+      definedTypes: [
+        definedTypeNode({
+          name: camelCase("transferEvent"),
+          type: numberTypeNode("u64"),
+        }),
+      ],
+    });
+
+    const root = rootNode(program);
+
+    const visitor = renameVisitor({
+      testProgram: {
+        instructions: {
+          transfer: "sendTokens",
+        },
+        events: {
+          transferEvent: "tokenSentEvent",
+        },
+      },
+    });
+
+    const updatedRoot = visit(root, visitor) as RootNode;
+    const instructions = updatedRoot.program.instructions;
+    const types = updatedRoot.program.definedTypes;
+
+    expect(instructions[0].name.toString()).toBe("sendTokens");
+    expect(types[0].name.toString()).toBe("tokenSentEvent");
+  });
+});

package/src/index.ts

@@ -0,0 +1,291 @@
+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);
+  });
+}