Add Link nodes

.changeset/angry-badgers-shop.md

@@ -0,0 +1,5 @@
+---
+'@metaplex-foundation/kinobi': minor
+---
+
+Add Link nodes

src/nodes/AccountDataNode.ts

@@ -1,18 +1,18 @@
 import { InvalidKinobiTreeError, MainCaseString, mainCase } from '../shared';
-import { LinkTypeNode } from './typeNodes/LinkTypeNode';
-import { StructTypeNode } from './typeNodes/StructTypeNode';
+import { DefinedTypeLinkNode } from './linkNodes';
+import { StructTypeNode } from './typeNodes';
 
 export type AccountDataNode = {
   readonly kind: 'accountDataNode';
   readonly name: MainCaseString;
   readonly struct: StructTypeNode;
-  readonly link?: LinkTypeNode;
+  readonly link?: DefinedTypeLinkNode;
 };
 
 export type AccountDataNodeInput = {
   readonly name: string;
   readonly struct: StructTypeNode;
-  readonly link?: LinkTypeNode;
+  readonly link?: DefinedTypeLinkNode;
 };
 
 export function accountDataNode(input: AccountDataNodeInput): AccountDataNode {

src/nodes/InstructionDataArgsNode.ts

@@ -1,12 +1,12 @@
 import { InvalidKinobiTreeError, MainCaseString, mainCase } from '../shared';
-import { LinkTypeNode } from './typeNodes/LinkTypeNode';
-import { StructTypeNode } from './typeNodes/StructTypeNode';
+import { DefinedTypeLinkNode } from './linkNodes';
+import { StructTypeNode } from './typeNodes';
 
 export type InstructionDataArgsNode = {
   readonly kind: 'instructionDataArgsNode';
   readonly name: MainCaseString;
   readonly struct: StructTypeNode;
-  readonly link?: LinkTypeNode;
+  readonly link?: DefinedTypeLinkNode;
 };
 
 export type InstructionDataArgsNodeInput = Omit<

src/nodes/InstructionExtraArgsNode.ts

@@ -1,12 +1,12 @@
 import { InvalidKinobiTreeError, MainCaseString, mainCase } from '../shared';
-import { LinkTypeNode } from './typeNodes/LinkTypeNode';
-import { StructTypeNode } from './typeNodes/StructTypeNode';
+import { DefinedTypeLinkNode } from './linkNodes';
+import { StructTypeNode } from './typeNodes';
 
 export type InstructionExtraArgsNode = {
   readonly kind: 'instructionExtraArgsNode';
   readonly name: MainCaseString;
   readonly struct: StructTypeNode;
-  readonly link?: LinkTypeNode;
+  readonly link?: DefinedTypeLinkNode;
 };
 
 export type InstructionExtraArgsNodeInput = Omit<

src/nodes/Node.ts

@@ -9,6 +9,7 @@ import type { InstructionNode } from './InstructionNode';
 import type { PdaNode } from './PdaNode';
 import type { ProgramNode } from './ProgramNode';
 import type { RootNode } from './RootNode';
+import { REGISTERED_LINK_NODES } from './linkNodes';
 import { REGISTERED_PDA_SEED_NODES } from './pdaSeedNodes';
 import { REGISTERED_SIZE_NODES } from './sizeNodes';
 import { REGISTERED_TYPE_NODES } from './typeNodes';
@@ -30,6 +31,7 @@ const REGISTERED_NODES = {
   definedTypeNode: {} as DefinedTypeNode,
 
   // Groups.
+  ...REGISTERED_LINK_NODES,
   ...REGISTERED_PDA_SEED_NODES,
   ...REGISTERED_SIZE_NODES,
   ...REGISTERED_TYPE_NODES,

src/nodes/index.ts

@@ -11,6 +11,7 @@ export * from './PdaNode';
 export * from './ProgramNode';
 export * from './RootNode';
 
+export * from './linkNodes';
 export * from './pdaSeedNodes';
 export * from './sizeNodes';
 export * from './typeNodes';

src/nodes/linkNodes/AccountLinkNode.ts

@@ -0,0 +1,18 @@
+import { ImportFrom, MainCaseString, mainCase } from '../../shared';
+
+export type AccountLinkNode = {
+  readonly kind: 'accountLinkNode';
+  readonly name: MainCaseString;
+  readonly importFrom?: ImportFrom;
+};
+
+export function accountLinkNode(
+  name: string,
+  importFrom?: ImportFrom
+): AccountLinkNode {
+  return {
+    kind: 'accountLinkNode',
+    name: mainCase(name),
+    importFrom,
+  };
+}

src/nodes/linkNodes/DefinedTypeLinkNode.ts

@@ -0,0 +1,18 @@
+import { ImportFrom, MainCaseString, mainCase } from '../../shared';
+
+export type DefinedTypeLinkNode = {
+  readonly kind: 'definedTypeLinkNode';
+  readonly name: MainCaseString;
+  readonly importFrom?: ImportFrom;
+};
+
+export function definedTypeLinkNode(
+  name: string,
+  importFrom?: ImportFrom
+): DefinedTypeLinkNode {
+  return {
+    kind: 'definedTypeLinkNode',
+    name: mainCase(name),
+    importFrom,
+  };
+}

src/nodes/linkNodes/LinkNode.ts

@@ -0,0 +1,25 @@
+import type { ProgramLinkNode } from './ProgramLinkNode';
+import type { PdaLinkNode } from './PdaLinkNode';
+import type { AccountLinkNode } from './AccountLinkNode';
+import type { DefinedTypeLinkNode } from './DefinedTypeLinkNode';
+
+// Node Group Registration.
+
+export const REGISTERED_LINK_NODES = {
+  programLinkNode: {} as ProgramLinkNode,
+  pdaLinkNode: {} as PdaLinkNode,
+  accountLinkNode: {} as AccountLinkNode,
+  definedTypeLinkNode: {} as DefinedTypeLinkNode,
+};
+
+export const REGISTERED_LINK_NODE_KEYS = Object.keys(
+  REGISTERED_LINK_NODES
+) as (keyof typeof REGISTERED_LINK_NODES)[];
+
+export type RegisteredLinkNodes = typeof REGISTERED_LINK_NODES;
+
+// Node Group Helpers.
+
+export type LinkNode = RegisteredLinkNodes[keyof RegisteredLinkNodes];
+
+export const LINK_NODES = REGISTERED_LINK_NODE_KEYS;

src/nodes/linkNodes/PdaLinkNode.ts

@@ -0,0 +1,18 @@
+import { ImportFrom, MainCaseString, mainCase } from '../../shared';
+
+export type PdaLinkNode = {
+  readonly kind: 'pdaLinkNode';
+  readonly name: MainCaseString;
+  readonly importFrom?: ImportFrom;
+};
+
+export function pdaLinkNode(
+  name: string,
+  importFrom?: ImportFrom
+): PdaLinkNode {
+  return {
+    kind: 'pdaLinkNode',
+    name: mainCase(name),
+    importFrom,
+  };
+}

src/nodes/linkNodes/ProgramLinkNode.ts

@@ -0,0 +1,18 @@
+import { ImportFrom, MainCaseString, mainCase } from '../../shared';
+
+export type ProgramLinkNode = {
+  readonly kind: 'programLinkNode';
+  readonly name: MainCaseString;
+  readonly importFrom?: ImportFrom;
+};
+
+export function programLinkNode(
+  name: string,
+  importFrom?: ImportFrom
+): ProgramLinkNode {
+  return {
+    kind: 'programLinkNode',
+    name: mainCase(name),
+    importFrom,
+  };
+}

src/nodes/linkNodes/index.ts

@@ -0,0 +1,5 @@
+export * from './AccountLinkNode';
+export * from './DefinedTypeLinkNode';
+export * from './LinkNode';
+export * from './PdaLinkNode';
+export * from './ProgramLinkNode';

src/nodes/typeNodes/EnumVariantTypeNode.ts

@@ -1,3 +1,4 @@
+import type { Mutable } from '../../shared';
 import type { EnumEmptyVariantTypeNode } from './EnumEmptyVariantTypeNode';
 import type { EnumStructVariantTypeNode } from './EnumStructVariantTypeNode';
 import type { EnumTupleVariantTypeNode } from './EnumTupleVariantTypeNode';
@@ -7,12 +8,13 @@ export type EnumVariantTypeNode =
   | EnumStructVariantTypeNode
   | EnumTupleVariantTypeNode;
 
-export const ENUM_VARIANT_TYPE_NODES = [
+const ENUM_VARIANT_TYPE_NODES_INTERNAL = [
   'enumEmptyVariantTypeNode',
   'enumStructVariantTypeNode',
   'enumTupleVariantTypeNode',
-] as [
-  'enumEmptyVariantTypeNode',
-  'enumStructVariantTypeNode',
-  'enumTupleVariantTypeNode'
-];
+] as const;
+
+export const ENUM_VARIANT_TYPE_NODES =
+  ENUM_VARIANT_TYPE_NODES_INTERNAL as Mutable<
+    typeof ENUM_VARIANT_TYPE_NODES_INTERNAL
+  >;

src/nodes/typeNodes/TypeNode.ts

@@ -1,4 +1,7 @@
+import type { Mutable } from '../../shared';
 import { IDL_TYPE_LEAVES, IdlType } from '../../idl';
+import { RegisteredNodes } from '../Node';
+import { definedTypeLinkNode } from '../linkNodes';
 import { prefixedSizeNode } from '../sizeNodes';
 import { AmountTypeNode } from './AmountTypeNode';
 import { ArrayTypeNode, arrayTypeNodeFromIdl } from './ArrayTypeNode';
@@ -9,7 +12,6 @@ import { EnumEmptyVariantTypeNode } from './EnumEmptyVariantTypeNode';
 import { EnumStructVariantTypeNode } from './EnumStructVariantTypeNode';
 import { EnumTupleVariantTypeNode } from './EnumTupleVariantTypeNode';
 import { EnumTypeNode, enumTypeNodeFromIdl } from './EnumTypeNode';
-import { LinkTypeNode, linkTypeNode } from './LinkTypeNode';
 import { MapTypeNode, mapTypeNodeFromIdl } from './MapTypeNode';
 import { NumberTypeNode, numberTypeNode } from './NumberTypeNode';
 import { OptionTypeNode, optionTypeNodeFromIdl } from './OptionTypeNode';
@@ -21,18 +23,15 @@ import { StructFieldTypeNode } from './StructFieldTypeNode';
 import { StructTypeNode, structTypeNodeFromIdl } from './StructTypeNode';
 import { TupleTypeNode, tupleTypeNodeFromIdl } from './TupleTypeNode';
 
-// Type Node Registration.
-// This only includes type nodes that can be used as standalone types.
-// E.g. this excludes structFieldTypeNode, enumEmptyVariantTypeNode, etc.
+// Node Group Registration.
 
-export const STANDALONE_TYPE_NODES = {
+export const REGISTERED_TYPE_NODES = {
   amountTypeNode: {} as AmountTypeNode,
   arrayTypeNode: {} as ArrayTypeNode,
   booleanTypeNode: {} as BooleanTypeNode,
   bytesTypeNode: {} as BytesTypeNode,
   dateTimeTypeNode: {} as DateTimeTypeNode,
   enumTypeNode: {} as EnumTypeNode,
-  linkTypeNode: {} as LinkTypeNode,
   mapTypeNode: {} as MapTypeNode,
   numberTypeNode: {} as NumberTypeNode,
   optionTypeNode: {} as OptionTypeNode,
@@ -42,20 +41,6 @@ export const STANDALONE_TYPE_NODES = {
   stringTypeNode: {} as StringTypeNode,
   structTypeNode: {} as StructTypeNode,
   tupleTypeNode: {} as TupleTypeNode,
-};
-
-export const TYPE_NODES = Object.keys(
-  STANDALONE_TYPE_NODES
-) as (keyof typeof STANDALONE_TYPE_NODES)[];
-
-export type TypeNode =
-  typeof STANDALONE_TYPE_NODES[keyof typeof STANDALONE_TYPE_NODES];
-
-// Node Group Registration.
-// This includes all type nodes.
-
-export const REGISTERED_TYPE_NODES = {
-  ...STANDALONE_TYPE_NODES,
 
   // The following are not valid standalone types.
   structFieldTypeNode: {} as StructFieldTypeNode,
@@ -70,6 +55,39 @@ export const REGISTERED_TYPE_NODE_KEYS = Object.keys(
 
 export type RegisteredTypeNodes = typeof REGISTERED_TYPE_NODES;
 
+// Type Node Helpers.
+// This only includes type nodes that can be used as standalone types.
+// E.g. this excludes structFieldTypeNode, enumEmptyVariantTypeNode, etc.
+// It also includes the definedTypeLinkNode to compose types.
+
+const TYPE_NODES_INTERNAL = [
+  // Standalone types.
+  'amountTypeNode',
+  'arrayTypeNode',
+  'booleanTypeNode',
+  'bytesTypeNode',
+  'dateTimeTypeNode',
+  'enumTypeNode',
+  'mapTypeNode',
+  'numberTypeNode',
+  'optionTypeNode',
+  'publicKeyTypeNode',
+  'setTypeNode',
+  'solAmountTypeNode',
+  'stringTypeNode',
+  'structTypeNode',
+  'tupleTypeNode',
+
+  // Link types.
+  'definedTypeLinkNode',
+] as const;
+
+export const TYPE_NODES = TYPE_NODES_INTERNAL as Mutable<
+  typeof TYPE_NODES_INTERNAL
+>;
+
+export type TypeNode = RegisteredNodes[typeof TYPE_NODES[number]];
+
 // Node Group Helpers.
 
 function isArrayOfSize(array: any, size: number): boolean {
@@ -104,7 +122,7 @@ export const createTypeNodeFromIdl = (idlType: IdlType): TypeNode => {
 
   // Defined link.
   if ('defined' in idlType && typeof idlType.defined === 'string') {
-    return linkTypeNode(idlType.defined);
+    return definedTypeLinkNode(idlType.defined);
   }
 
   // Enum.

src/nodes/typeNodes/index.ts

@@ -8,7 +8,6 @@ export * from './EnumStructVariantTypeNode';
 export * from './EnumTupleVariantTypeNode';
 export * from './EnumTypeNode';
 export * from './EnumVariantTypeNode';
-export * from './LinkTypeNode';
 export * from './MapTypeNode';
 export * from './NumberTypeNode';
 export * from './OptionTypeNode';

src/renderers/js-experimental/fragments/accountPdaHelpers.ts

@@ -15,7 +15,10 @@ import { getValueNodeFragment } from './valueNode';
 export function getAccountPdaHelpersFragment(scope: {
   accountNode: AccountNode;
   programNode: ProgramNode;
-  typeManifestVisitor: Visitor<TypeManifest, keyof RegisteredTypeNodes>;
+  typeManifestVisitor: Visitor<
+    TypeManifest,
+    keyof RegisteredTypeNodes | 'definedTypeLinkNode'
+  >;
   nameApi: NameApi;
 }): Fragment {
   const { accountNode, programNode, typeManifestVisitor, nameApi } = scope;

src/renderers/js-experimental/fragments/instructionBytesCreatedOnChain.ts

@@ -27,8 +27,7 @@ export function getInstructionBytesCreatedOnChainFragment(scope: {
 
   if (bytes?.kind === 'account') {
     const functionName = scope.nameApi.accountGetSizeFunction(bytes.name);
-    const importFrom =
-      bytes.importFrom === 'generated' ? 'generatedAccounts' : bytes.importFrom;
+    const importFrom = bytes.importFrom ?? 'generatedAccounts';
     bytesFragment.addImports(importFrom, functionName);
   } else if (bytes?.kind === 'resolver') {
     const functionName = scope.nameApi.resolverFunction(bytes.name);