@macalinao/codama-rename-visitor 0.1.1 → 0.2.1

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);
+  });
+}

package/src/rename-instructions-visitor.test.ts

@@ -0,0 +1,83 @@
+/// <reference types="bun-types" />
+import { describe, expect, it } from "bun:test";
+import type { ProgramNode, RootNode } from "codama";
+import {
+  camelCase,
+  instructionAccountNode,
+  instructionNode,
+  programNode,
+  rootNode,
+  visit,
+} from "codama";
+import { renameInstructionsVisitor } from "./rename-instructions-visitor.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");
+  });
+});

package/src/rename-instructions-visitor.ts

@@ -0,0 +1,50 @@
+import type { InstructionNode, Node, NodeKind, Visitor } from "codama";
+import { assertIsNode, bottomUpTransformerVisitor, camelCase } from "codama";
+
+/**
+ * Transform function that renames an instruction node based on a mapping.
+ *
+ * @param node - The node to transform
+ * @param mapping - Object mapping old instruction names to new instruction names
+ * @returns The transformed instruction node
+ */
+export function renameInstructionTransform(
+  node: Node,
+  mapping: Record<string, string>,
+): InstructionNode {
+  assertIsNode(node, "instructionNode");
+  const newName = mapping[node.name];
+  if (!newName) {
+    return node;
+  }
+  return {
+    ...node,
+    name: camelCase(newName),
+  };
+}
+
+/**
+ * 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<
+  TNodeKind extends NodeKind = NodeKind,
+>(mapping: Record<string, string>): Visitor<Node | null, TNodeKind> {
+  return bottomUpTransformerVisitor([
+    {
+      select: "[instructionNode]",
+      transform: (node) => renameInstructionTransform(node, mapping),
+    },
+  ]);
+}

package/src/rename-visitor.test.ts

@@ -0,0 +1,175 @@
+/// <reference types="bun-types" />
+import { describe, expect, it } from "bun:test";
+import type { ProgramNode, RootNode } from "codama";
+import {
+  camelCase,
+  definedTypeNode,
+  instructionNode,
+  numberTypeNode,
+  programNode,
+  rootNode,
+  visit,
+} from "codama";
+import { renameVisitor } from "./rename-visitor.js";
+
+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 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: {
+        definedTypes: {
+          counter: "counterAccount",
+          tokenMintedEvent: "nftMintedEvent",
+        },
+      },
+    });
+
+    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",
+        },
+      },
+    });
+
+    const updatedRoot = visit(root, visitor) as RootNode;
+    const instructions = updatedRoot.program.instructions;
+
+    expect(instructions[0].name.toString()).toBe("sendTokens");
+  });
+});

package/src/rename-visitor.ts

@@ -0,0 +1,94 @@
+import type { Node } from "codama";
+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";
+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 function renameVisitor(
+  renamesByProgram: Record<string, ProgramRenameOptions>,
+): ReturnType<typeof rootNodeVisitor> {
+  return rootNodeVisitor((root) => {
+    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) =>
+                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);
+  });
+}

package/src/types.ts

@@ -0,0 +1,11 @@
+/**
+ * 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>;
+}