Add JS spec generator for codama-nodes link nodes

.github/workflows/main.yml

@@ -44,3 +44,51 @@ jobs:
 
       - name: Run Cargo test
         run: cargo +${{ env.RUST_TOOLCHAIN }} test --all-features
+
+  spec-generators:
+    name: Verify Generated Code Is Up To Date
+    runs-on: ubuntu-latest
+    steps:
+      - name: Git Checkout
+        uses: actions/checkout@v4
+
+      - name: Install pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          version: 10
+
+      - name: Install Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          cache: pnpm
+          cache-dependency-path: spec-generators/pnpm-lock.yaml
+
+      - name: Install Rust Toolchain
+        uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: ${{ env.RUST_TOOLCHAIN }}
+          components: rustfmt
+
+      - name: Install JS dependencies
+        working-directory: spec-generators
+        run: pnpm install --frozen-lockfile
+
+      - name: Lint JS generator
+        working-directory: spec-generators
+        run: pnpm lint
+
+      - name: Type-check + unit-test JS generator
+        working-directory: spec-generators
+        run: pnpm test
+
+      - name: Regenerate Rust sources from spec
+        working-directory: spec-generators
+        run: pnpm generate
+
+      - name: Fail if generated sources are out of date
+        run: |
+          if ! git diff --exit-code; then
+            echo "::error::Generated sources are out of date. Run \`pnpm generate\` inside spec-generators/ and commit the diff."
+            exit 1
+          fi

codama-nodes/src/generated/link_nodes/account_link_node.rs

@@ -0,0 +1,24 @@
+use crate::{CamelCaseString, HasName, ProgramLinkNode};
+use codama_nodes_derive::node;
+
+#[node]
+pub struct AccountLinkNode {
+    // Data.
+    pub name: CamelCaseString,
+
+    // Children.
+    #[serde(skip_serializing_if = "crate::is_default")]
+    pub program: Option<ProgramLinkNode>,
+}
+
+impl From<AccountLinkNode> for crate::Node {
+    fn from(val: AccountLinkNode) -> Self {
+        crate::Node::Link(val.into())
+    }
+}
+
+impl HasName for AccountLinkNode {
+    fn name(&self) -> &CamelCaseString {
+        &self.name
+    }
+}

codama-nodes/src/generated/link_nodes/defined_type_link_node.rs

@@ -0,0 +1,24 @@
+use crate::{CamelCaseString, HasName, ProgramLinkNode};
+use codama_nodes_derive::node;
+
+#[node]
+pub struct DefinedTypeLinkNode {
+    // Data.
+    pub name: CamelCaseString,
+
+    // Children.
+    #[serde(skip_serializing_if = "crate::is_default")]
+    pub program: Option<ProgramLinkNode>,
+}
+
+impl From<DefinedTypeLinkNode> for crate::Node {
+    fn from(val: DefinedTypeLinkNode) -> Self {
+        crate::Node::Link(val.into())
+    }
+}
+
+impl HasName for DefinedTypeLinkNode {
+    fn name(&self) -> &CamelCaseString {
+        &self.name
+    }
+}

codama-nodes/src/generated/link_nodes/instruction_account_link_node.rs

@@ -0,0 +1,24 @@
+use crate::{CamelCaseString, HasName, InstructionLinkNode};
+use codama_nodes_derive::node;
+
+#[node]
+pub struct InstructionAccountLinkNode {
+    // Data.
+    pub name: CamelCaseString,
+
+    // Children.
+    #[serde(skip_serializing_if = "crate::is_default")]
+    pub instruction: Option<InstructionLinkNode>,
+}
+
+impl From<InstructionAccountLinkNode> for crate::Node {
+    fn from(val: InstructionAccountLinkNode) -> Self {
+        crate::Node::Link(val.into())
+    }
+}
+
+impl HasName for InstructionAccountLinkNode {
+    fn name(&self) -> &CamelCaseString {
+        &self.name
+    }
+}

codama-nodes/src/generated/link_nodes/instruction_argument_link_node.rs

@@ -0,0 +1,24 @@
+use crate::{CamelCaseString, HasName, InstructionLinkNode};
+use codama_nodes_derive::node;
+
+#[node]
+pub struct InstructionArgumentLinkNode {
+    // Data.
+    pub name: CamelCaseString,
+
+    // Children.
+    #[serde(skip_serializing_if = "crate::is_default")]
+    pub instruction: Option<InstructionLinkNode>,
+}
+
+impl From<InstructionArgumentLinkNode> for crate::Node {
+    fn from(val: InstructionArgumentLinkNode) -> Self {
+        crate::Node::Link(val.into())
+    }
+}
+
+impl HasName for InstructionArgumentLinkNode {
+    fn name(&self) -> &CamelCaseString {
+        &self.name
+    }
+}

codama-nodes/src/generated/link_nodes/instruction_link_node.rs

@@ -0,0 +1,24 @@
+use crate::{CamelCaseString, HasName, ProgramLinkNode};
+use codama_nodes_derive::node;
+
+#[node]
+pub struct InstructionLinkNode {
+    // Data.
+    pub name: CamelCaseString,
+
+    // Children.
+    #[serde(skip_serializing_if = "crate::is_default")]
+    pub program: Option<ProgramLinkNode>,
+}
+
+impl From<InstructionLinkNode> for crate::Node {
+    fn from(val: InstructionLinkNode) -> Self {
+        crate::Node::Link(val.into())
+    }
+}
+
+impl HasName for InstructionLinkNode {
+    fn name(&self) -> &CamelCaseString {
+        &self.name
+    }
+}

codama-nodes/src/generated/link_nodes/link_node.rs

@@ -0,0 +1,30 @@
+use crate::{
+    AccountLinkNode, CamelCaseString, DefinedTypeLinkNode, HasName, InstructionAccountLinkNode,
+    InstructionArgumentLinkNode, InstructionLinkNode, PdaLinkNode, ProgramLinkNode,
+};
+use codama_nodes_derive::node_union;
+
+#[node_union]
+pub enum LinkNode {
+    Account(AccountLinkNode),
+    DefinedType(DefinedTypeLinkNode),
+    Instruction(InstructionLinkNode),
+    InstructionAccount(InstructionAccountLinkNode),
+    InstructionArgument(InstructionArgumentLinkNode),
+    Pda(PdaLinkNode),
+    Program(ProgramLinkNode),
+}
+
+impl HasName for LinkNode {
+    fn name(&self) -> &CamelCaseString {
+        match self {
+            LinkNode::Account(node) => node.name(),
+            LinkNode::DefinedType(node) => node.name(),
+            LinkNode::Instruction(node) => node.name(),
+            LinkNode::InstructionAccount(node) => node.name(),
+            LinkNode::InstructionArgument(node) => node.name(),
+            LinkNode::Pda(node) => node.name(),
+            LinkNode::Program(node) => node.name(),
+        }
+    }
+}

codama-nodes/src/generated/link_nodes/mod.rs

@@ -0,0 +1,17 @@
+mod account_link_node;
+mod defined_type_link_node;
+mod instruction_account_link_node;
+mod instruction_argument_link_node;
+mod instruction_link_node;
+mod link_node;
+mod pda_link_node;
+mod program_link_node;
+
+pub use account_link_node::*;
+pub use defined_type_link_node::*;
+pub use instruction_account_link_node::*;
+pub use instruction_argument_link_node::*;
+pub use instruction_link_node::*;
+pub use link_node::*;
+pub use pda_link_node::*;
+pub use program_link_node::*;

codama-nodes/src/generated/link_nodes/pda_link_node.rs

@@ -0,0 +1,24 @@
+use crate::{CamelCaseString, HasName, ProgramLinkNode};
+use codama_nodes_derive::node;
+
+#[node]
+pub struct PdaLinkNode {
+    // Data.
+    pub name: CamelCaseString,
+
+    // Children.
+    #[serde(skip_serializing_if = "crate::is_default")]
+    pub program: Option<ProgramLinkNode>,
+}
+
+impl From<PdaLinkNode> for crate::Node {
+    fn from(val: PdaLinkNode) -> Self {
+        crate::Node::Link(val.into())
+    }
+}
+
+impl HasName for PdaLinkNode {
+    fn name(&self) -> &CamelCaseString {
+        &self.name
+    }
+}

codama-nodes/src/generated/link_nodes/program_link_node.rs

@@ -0,0 +1,20 @@
+use crate::{CamelCaseString, HasName};
+use codama_nodes_derive::node;
+
+#[node]
+pub struct ProgramLinkNode {
+    // Data.
+    pub name: CamelCaseString,
+}
+
+impl From<ProgramLinkNode> for crate::Node {
+    fn from(val: ProgramLinkNode) -> Self {
+        crate::Node::Link(val.into())
+    }
+}
+
+impl HasName for ProgramLinkNode {
+    fn name(&self) -> &CamelCaseString {
+        &self.name
+    }
+}

codama-nodes/src/generated/mod.rs

@@ -0,0 +1,3 @@
+mod link_nodes;
+
+pub use link_nodes::*;

codama-nodes/src/lib.rs

@@ -8,6 +8,7 @@ mod defined_type_node;
 mod discriminator_nodes;
 mod error_node;
 mod event_node;
+mod generated;
 mod instruction_account_node;
 mod instruction_argument_node;
 mod instruction_byte_delta_node;
@@ -33,13 +34,13 @@ pub use defined_type_node::*;
 pub use discriminator_nodes::*;
 pub use error_node::*;
 pub use event_node::*;
+pub use generated::*;
 pub use instruction_account_node::*;
 pub use instruction_argument_node::*;
 pub use instruction_byte_delta_node::*;
 pub use instruction_node::*;
 pub use instruction_remaining_accounts_node::*;
 pub use instruction_status_node::*;
-pub use link_nodes::*;
 pub use node::*;
 pub use pda_node::*;
 pub use pda_seed_nodes::*;

codama-nodes/src/link_nodes/account_link_node.rs

@@ -1,21 +1,4 @@
-use crate::{CamelCaseString, HasName, ProgramLinkNode};
-use codama_nodes_derive::node;
-
-#[node]
-pub struct AccountLinkNode {
-    // Data.
-    pub name: CamelCaseString,
-
-    // Children.
-    #[serde(skip_serializing_if = "crate::is_default")]
-    pub program: Option<ProgramLinkNode>,
-}
-
-impl From<AccountLinkNode> for crate::Node {
-    fn from(val: AccountLinkNode) -> Self {
-        crate::Node::Link(val.into())
-    }
-}
+use crate::{AccountLinkNode, CamelCaseString, ProgramLinkNode};
 
 impl AccountLinkNode {
     pub fn new<T>(name: T) -> Self
@@ -51,12 +34,6 @@ impl From<&str> for AccountLinkNode {
     }
 }
 
-impl HasName for AccountLinkNode {
-    fn name(&self) -> &CamelCaseString {
-        &self.name
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

codama-nodes/src/link_nodes/defined_type_link_node.rs

@@ -1,21 +1,4 @@
-use crate::{CamelCaseString, HasName, ProgramLinkNode};
-use codama_nodes_derive::node;
-
-#[node]
-pub struct DefinedTypeLinkNode {
-    // Data.
-    pub name: CamelCaseString,
-
-    // Children.
-    #[serde(skip_serializing_if = "crate::is_default")]
-    pub program: Option<ProgramLinkNode>,
-}
-
-impl From<DefinedTypeLinkNode> for crate::Node {
-    fn from(val: DefinedTypeLinkNode) -> Self {
-        crate::Node::Link(val.into())
-    }
-}
+use crate::{CamelCaseString, DefinedTypeLinkNode, ProgramLinkNode};
 
 impl DefinedTypeLinkNode {
     pub fn new<T>(name: T) -> Self
@@ -51,12 +34,6 @@ impl From<&str> for DefinedTypeLinkNode {
     }
 }
 
-impl HasName for DefinedTypeLinkNode {
-    fn name(&self) -> &CamelCaseString {
-        &self.name
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;