@codama/renderers-rust 1.0.0 → 1.0.2

package/dist/index.node.mjs

@@ -1,5 +1,5 @@
 import { CodamaError, CODAMA_ERROR__RENDERERS__UNSUPPORTED_NODE, logWarn, logError, CODAMA_ERROR__UNEXPECTED_NODE_KIND } from '@codama/errors';
-import { REGISTERED_TYPE_NODE_KINDS, pascalCase, isNode, resolveNestedTypeNode, remainderCountNode, arrayTypeNode, numberTypeNode, isScalarEnum, snakeCase, isNodeFilter, VALUE_NODES, structTypeNodeFromInstructionArgumentNodes, getAllInstructionsWithSubs, getAllPrograms, getAllAccounts, getAllDefinedTypes, camelCase, kebabCase, titleCase, fixedCountNode, prefixedCountNode, numberValueNode, arrayValueNode, bytesValueNode } from '@codama/nodes';
+import { REGISTERED_TYPE_NODE_KINDS, pascalCase, isNode, resolveNestedTypeNode, remainderCountNode, arrayTypeNode, numberTypeNode, snakeCase, definedTypeNode, isNodeFilter, VALUE_NODES, structTypeNodeFromInstructionArgumentNodes, getAllInstructionsWithSubs, getAllPrograms, getAllAccounts, getAllDefinedTypes, camelCase, kebabCase, titleCase, assertIsNode, isScalarEnum, fixedCountNode, prefixedCountNode, numberValueNode, arrayValueNode, bytesValueNode } from '@codama/nodes';
 import { RenderMap, deleteDirectory, writeRenderMapVisitor } from '@codama/renderers-core';
 import { pipe, mergeVisitor, extendVisitor, visit, LinkableDictionary, staticVisitor, recordLinkablesVisitor, rootNodeVisitor } from '@codama/visitors-core';
 import { getBase64Encoder, getBase58Encoder, getBase16Encoder, getUtf8Encoder } from '@solana/codecs-strings';
@@ -149,10 +149,109 @@ var render = (template, context, options) => {
   env.addFilter("rustDocblock", rustDocblock);
   return env.render(template, context);
 };
+var DEFAULT_TRAIT_OPTIONS = {
+  baseDefaults: [
+    "borsh::BorshSerialize",
+    "borsh::BorshDeserialize",
+    "serde::Serialize",
+    "serde::Deserialize",
+    "Clone",
+    "Debug",
+    "Eq",
+    "PartialEq"
+  ],
+  dataEnumDefaults: [],
+  featureFlags: { serde: ["serde::Serialize", "serde::Deserialize"] },
+  overrides: {},
+  scalarEnumDefaults: ["Copy", "PartialOrd", "Hash", "num_derive::FromPrimitive"],
+  structDefaults: [],
+  useFullyQualifiedName: false
+};
+function getTraitsFromNodeFactory(options = {}) {
+  return (node) => getTraitsFromNode(node, options);
+}
+function getTraitsFromNode(node, userOptions = {}) {
+  assertIsNode(node, ["accountNode", "definedTypeNode"]);
+  const options = { ...DEFAULT_TRAIT_OPTIONS, ...userOptions };
+  const nodeType = getNodeType(node);
+  if (nodeType === "alias") {
+    return { imports: new ImportMap(), render: "" };
+  }
+  const sanitizedOverrides = Object.fromEntries(
+    Object.entries(options.overrides).map(([key, value]) => [camelCase(key), value])
+  );
+  const nodeOverrides = sanitizedOverrides[node.name];
+  const allTraits = nodeOverrides === void 0 ? getDefaultTraits(nodeType, options) : nodeOverrides;
+  const partitionedTraits = partitionTraitsInFeatures(allTraits, options.featureFlags);
+  let unfeaturedTraits = partitionedTraits[0];
+  const featuredTraits = partitionedTraits[1];
+  const imports = new ImportMap();
+  if (!options.useFullyQualifiedName) {
+    unfeaturedTraits = extractFullyQualifiedNames(unfeaturedTraits, imports);
+  }
+  const traitLines = [
+    ...unfeaturedTraits.length > 0 ? [`#[derive(${unfeaturedTraits.join(", ")})]
+`] : [],
+    ...Object.entries(featuredTraits).map(([feature, traits]) => {
+      return `#[cfg_attr(feature = "${feature}", derive(${traits.join(", ")}))]
+`;
+    })
+  ];
+  return { imports, render: traitLines.join("") };
+}
+function getNodeType(node) {
+  if (isNode(node, "accountNode")) return "struct";
+  if (isNode(node.type, "structTypeNode")) return "struct";
+  if (isNode(node.type, "enumTypeNode")) {
+    return isScalarEnum(node.type) ? "scalarEnum" : "dataEnum";
+  }
+  return "alias";
+}
+function getDefaultTraits(nodeType, options) {
+  switch (nodeType) {
+    case "dataEnum":
+      return [...options.baseDefaults, ...options.dataEnumDefaults];
+    case "scalarEnum":
+      return [...options.baseDefaults, ...options.scalarEnumDefaults];
+    case "struct":
+      return [...options.baseDefaults, ...options.structDefaults];
+  }
+}
+function partitionTraitsInFeatures(traits, featureFlags) {
+  const reverseFeatureFlags = Object.entries(featureFlags).reduce(
+    (acc, [feature, traits2]) => {
+      for (const trait of traits2) {
+        if (!acc[trait]) acc[trait] = feature;
+      }
+      return acc;
+    },
+    {}
+  );
+  const unfeaturedTraits = [];
+  const featuredTraits = {};
+  for (const trait of traits) {
+    const feature = reverseFeatureFlags[trait];
+    if (feature === void 0) {
+      unfeaturedTraits.push(trait);
+    } else {
+      if (!featuredTraits[feature]) featuredTraits[feature] = [];
+      featuredTraits[feature].push(trait);
+    }
+  }
+  return [unfeaturedTraits, featuredTraits];
+}
+function extractFullyQualifiedNames(traits, imports) {
+  return traits.map((trait) => {
+    const index = trait.lastIndexOf("::");
+    if (index === -1) return trait;
+    imports.add(trait);
+    return trait.slice(index + 2);
+  });
+}
 
 // src/getTypeManifestVisitor.ts
 function getTypeManifestVisitor(options) {
-  const { getImportFrom } = options;
+  const { getImportFrom, getTraitsFromNode: getTraitsFromNode2 } = options;
   let parentName = options.parentName ?? null;
   let nestedStruct = options.nestedStruct ?? false;
   let inlineStruct = false;
@@ -170,13 +269,12 @@ function getTypeManifestVisitor(options) {
       visitAccount(account, { self }) {
         parentName = pascalCase(account.name);
         const manifest = visit(account.data, self);
-        manifest.imports.add(["borsh::BorshSerialize", "borsh::BorshDeserialize"]);
+        const traits = getTraitsFromNode2(account);
+        manifest.imports.mergeWith(traits.imports);
         parentName = null;
         return {
           ...manifest,
-          type: `#[derive(BorshSerialize, BorshDeserialize, Clone, Debug, Eq, PartialEq)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-${manifest.type}`
+          type: traits.render + manifest.type
         };
       },
       visitArrayType(arrayType, { self }) {
@@ -249,35 +347,11 @@ ${manifest.type}`
       visitDefinedType(definedType, { self }) {
         parentName = pascalCase(definedType.name);
         const manifest = visit(definedType.type, self);
+        const traits = getTraitsFromNode2(definedType);
+        manifest.imports.mergeWith(traits.imports);
         parentName = null;
-        const traits = ["BorshSerialize", "BorshDeserialize", "Clone", "Debug", "Eq", "PartialEq"];
-        if (isNode(definedType.type, "enumTypeNode") && isScalarEnum(definedType.type)) {
-          traits.push("Copy", "PartialOrd", "Hash", "FromPrimitive");
-          manifest.imports.add(["num_derive::FromPrimitive"]);
-        }
-        const nestedStructs = manifest.nestedStructs.map(
-          (struct) => `#[derive(${traits.join(", ")})]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-${struct}`
-        );
-        if (!isNode(definedType.type, ["enumTypeNode", "structTypeNode"])) {
-          if (nestedStructs.length > 0) {
-            manifest.imports.add(["borsh::BorshSerialize", "borsh::BorshDeserialize"]);
-          }
-          return {
-            ...manifest,
-            nestedStructs,
-            type: `pub type ${pascalCase(definedType.name)} = ${manifest.type}`
-          };
-        }
-        manifest.imports.add(["borsh::BorshSerialize", "borsh::BorshDeserialize"]);
-        return {
-          ...manifest,
-          nestedStructs,
-          type: `#[derive(${traits.join(", ")})]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-${manifest.type}`
-        };
+        const renderedType = isNode(definedType.type, ["enumTypeNode", "structTypeNode"]) ? manifest.type : `pub type ${pascalCase(definedType.name)} = ${manifest.type};`;
+        return { ...manifest, type: `${traits.render}${renderedType}` };
       },
       visitDefinedTypeLink(node) {
         const pascalCaseDefinedType = pascalCase(node.name);
@@ -493,11 +567,15 @@ ${variantNames}
         const fieldTypes = fields.map((field) => field.type).join("\n");
         const mergedManifest = mergeManifests(fields);
         if (nestedStruct) {
+          const nestedTraits = getTraitsFromNode2(
+            definedTypeNode({ name: originalParentName, type: structType })
+          );
+          mergedManifest.imports.mergeWith(nestedTraits.imports);
           return {
             ...mergedManifest,
             nestedStructs: [
               ...mergedManifest.nestedStructs,
-              `pub struct ${pascalCase(originalParentName)} {
+              `${nestedTraits.render}pub struct ${pascalCase(originalParentName)} {
 ${fieldTypes}
 }`
             ],
@@ -677,7 +755,8 @@ function getRenderMapVisitor(options = {}) {
   const renderParentInstructions = options.renderParentInstructions ?? false;
   const dependencyMap = options.dependencyMap ?? {};
   const getImportFrom = getImportFromFactory(options.linkOverrides ?? {});
-  const typeManifestVisitor = getTypeManifestVisitor({ getImportFrom });
+  const getTraitsFromNode2 = getTraitsFromNodeFactory(options.traitOptions);
+  const typeManifestVisitor = getTypeManifestVisitor({ getImportFrom, getTraitsFromNode: getTraitsFromNode2 });
   return pipe(
     staticVisitor(
       () => new RenderMap(),
@@ -752,6 +831,7 @@ function getRenderMapVisitor(options = {}) {
         node.arguments.forEach((argument) => {
           const argumentVisitor = getTypeManifestVisitor({
             getImportFrom,
+            getTraitsFromNode: getTraitsFromNode2,
             nestedStruct: true,
             parentName: `${pascalCase(node.name)}InstructionData`
           });
@@ -783,6 +863,7 @@ function getRenderMapVisitor(options = {}) {
         const struct = structTypeNodeFromInstructionArgumentNodes(node.arguments);
         const structVisitor = getTypeManifestVisitor({
           getImportFrom,
+          getTraitsFromNode: getTraitsFromNode2,
           parentName: `${pascalCase(node.name)}InstructionData`
         });
         const typeManifest = visit(struct, structVisitor);