@codama/renderers-rust 1.2.6 → 1.2.7

package/dist/index.node.cjs

@@ -386,6 +386,10 @@ var render = (template, context, options) => {
   env.addFilter("kebabCase", import_nodes3.kebabCase);
   env.addFilter("titleCase", import_nodes3.titleCase);
   env.addFilter("rustDocblock", rustDocblock);
+  env.addFilter("hasTrait", (traits, ...traitNames) => {
+    if (typeof traits !== "string") return false;
+    return traitNames.some((traitName) => traits.includes(traitName));
+  });
   return env.render(template, context);
 };
 
@@ -490,14 +494,51 @@ function extractFullyQualifiedNames(traits, imports) {
     return trait.slice(index + 2);
   });
 }
+function getSerdeFieldAttribute(serdeWith, node, userOptions = {}) {
+  (0, import_nodes4.assertIsNode)(node, ["accountNode", "definedTypeNode", "instructionNode"]);
+  const options = { ...DEFAULT_TRAIT_OPTIONS, ...userOptions };
+  const nodeType = getNodeType(node);
+  if (nodeType === "alias") {
+    return "";
+  }
+  const sanitizedOverrides = Object.fromEntries(
+    Object.entries(options.overrides).map(([key, value]) => [(0, import_nodes4.camelCase)(key), value])
+  );
+  const nodeOverrides = sanitizedOverrides[node.name];
+  const allTraits = nodeOverrides === void 0 ? getDefaultTraits(nodeType, options) : nodeOverrides;
+  const hasSerdeSerialize = allTraits.some((t) => t === "serde::Serialize" || t === "Serialize");
+  const hasSerdeDeserialize = allTraits.some((t) => t === "serde::Deserialize" || t === "Deserialize");
+  if (!hasSerdeSerialize && !hasSerdeDeserialize) {
+    return "";
+  }
+  const partitionedTraits = partitionTraitsInFeatures(allTraits, options.featureFlags);
+  const featuredTraits = partitionedTraits[1];
+  let serdeFeatureName;
+  for (const [feature, traits] of Object.entries(featuredTraits)) {
+    if (traits.some(
+      (t) => t === "serde::Serialize" || t === "serde::Deserialize" || t === "Serialize" || t === "Deserialize"
+    )) {
+      serdeFeatureName = feature;
+      break;
+    }
+  }
+  if (serdeFeatureName) {
+    return `#[cfg_attr(feature = "${serdeFeatureName}", serde(with = "${serdeWith}"))]
+`;
+  } else {
+    return `#[serde(with = "${serdeWith}")]
+`;
+  }
+}
 
 // src/getTypeManifestVisitor.ts
 function getTypeManifestVisitor(options) {
-  const { getImportFrom, getTraitsFromNode: getTraitsFromNode2 } = options;
+  const { getImportFrom, getTraitsFromNode: getTraitsFromNode2, traitOptions } = options;
   let parentName = options.parentName ?? null;
   let nestedStruct = options.nestedStruct ?? false;
   let inlineStruct = false;
   let parentSize = null;
+  let parentNode = null;
   return (0, import_visitors_core3.pipe)(
     (0, import_visitors_core3.mergeVisitor)(
       () => ({ imports: new ImportMap(), nestedStructs: [], type: "" }),
@@ -510,10 +551,12 @@ function getTypeManifestVisitor(options) {
     (v) => (0, import_visitors_core3.extendVisitor)(v, {
       visitAccount(account, { self }) {
         parentName = (0, import_nodes5.pascalCase)(account.name);
+        parentNode = account;
         const manifest = (0, import_visitors_core3.visit)(account.data, self);
         const traits = getTraitsFromNode2(account);
         manifest.imports.mergeWith(traits.imports);
         parentName = null;
+        parentNode = null;
         return {
           ...manifest,
           type: traits.render + manifest.type
@@ -588,10 +631,12 @@ function getTypeManifestVisitor(options) {
       },
       visitDefinedType(definedType, { self }) {
         parentName = (0, import_nodes5.pascalCase)(definedType.name);
+        parentNode = definedType;
         const manifest = (0, import_visitors_core3.visit)(definedType.type, self);
         const traits = getTraitsFromNode2(definedType);
         manifest.imports.mergeWith(traits.imports);
         parentName = null;
+        parentNode = null;
         const renderedType = (0, import_nodes5.isNode)(definedType.type, ["enumTypeNode", "structTypeNode"]) ? manifest.type : `pub type ${(0, import_nodes5.pascalCase)(definedType.name)} = ${manifest.type};`;
         return { ...manifest, type: `${traits.render}${renderedType}` };
       },
@@ -638,10 +683,18 @@ function getTypeManifestVisitor(options) {
         const childManifest = (0, import_visitors_core3.visit)(enumTupleVariantType.tuple, self);
         parentName = originalParentName;
         let derive = "";
-        if (childManifest.type === "(Pubkey)") {
-          derive = '#[cfg_attr(feature = "serde", serde(with = "serde_with::As::<serde_with::DisplayFromStr>"))]\n';
-        } else if (childManifest.type === "(Vec<Pubkey>)") {
-          derive = '#[cfg_attr(feature = "serde", serde(with = "serde_with::As::<Vec<serde_with::DisplayFromStr>>"))]\n';
+        if (parentNode && childManifest.type === "(Pubkey)") {
+          derive = getSerdeFieldAttribute(
+            "serde_with::As::<serde_with::DisplayFromStr>",
+            parentNode,
+            traitOptions
+          );
+        } else if (parentNode && childManifest.type === "(Vec<Pubkey>)") {
+          derive = getSerdeFieldAttribute(
+            "serde_with::As::<Vec<serde_with::DisplayFromStr>>",
+            parentNode,
+            traitOptions
+          );
         }
         return {
           ...childManifest,
@@ -788,14 +841,28 @@ ${variantNames}
         const docblock = rustDocblock((0, import_nodes5.parseDocs)(structFieldType.docs));
         const resolvedNestedType = (0, import_nodes5.resolveNestedTypeNode)(structFieldType.type);
         let derive = "";
-        if (fieldManifest.type === "Pubkey") {
-          derive = '#[cfg_attr(feature = "serde", serde(with = "serde_with::As::<serde_with::DisplayFromStr>"))]\n';
-        } else if (fieldManifest.type === "Vec<Pubkey>") {
-          derive = '#[cfg_attr(feature = "serde", serde(with = "serde_with::As::<Vec<serde_with::DisplayFromStr>>"))]\n';
-        } else if ((0, import_nodes5.isNode)(resolvedNestedType, "arrayTypeNode") && (0, import_nodes5.isNode)(resolvedNestedType.count, "fixedCountNode") && resolvedNestedType.count.value > 32) {
-          derive = '#[cfg_attr(feature = "serde", serde(with = "serde_big_array::BigArray"))]\n';
-        } else if ((0, import_nodes5.isNode)(resolvedNestedType, ["bytesTypeNode", "stringTypeNode"]) && (0, import_nodes5.isNode)(structFieldType.type, "fixedSizeTypeNode") && structFieldType.type.size > 32) {
-          derive = '#[cfg_attr(feature = "serde", serde(with = "serde_with::As::<serde_with::Bytes>"))]\n';
+        if (parentNode) {
+          if (fieldManifest.type === "Pubkey") {
+            derive = getSerdeFieldAttribute(
+              "serde_with::As::<serde_with::DisplayFromStr>",
+              parentNode,
+              traitOptions
+            );
+          } else if (fieldManifest.type === "Vec<Pubkey>") {
+            derive = getSerdeFieldAttribute(
+              "serde_with::As::<Vec<serde_with::DisplayFromStr>>",
+              parentNode,
+              traitOptions
+            );
+          } else if ((0, import_nodes5.isNode)(resolvedNestedType, "arrayTypeNode") && (0, import_nodes5.isNode)(resolvedNestedType.count, "fixedCountNode") && resolvedNestedType.count.value > 32) {
+            derive = getSerdeFieldAttribute("serde_big_array::BigArray", parentNode, traitOptions);
+          } else if ((0, import_nodes5.isNode)(resolvedNestedType, ["bytesTypeNode", "stringTypeNode"]) && (0, import_nodes5.isNode)(structFieldType.type, "fixedSizeTypeNode") && structFieldType.type.size > 32) {
+            derive = getSerdeFieldAttribute(
+              "serde_with::As::<serde_with::Bytes>",
+              parentNode,
+              traitOptions
+            );
+          }
         }
         return {
           ...fieldManifest,
@@ -868,7 +935,11 @@ function getRenderMapVisitor(options = {}) {
   const dependencyMap = options.dependencyMap ?? {};
   const getImportFrom = getImportFromFactory(options.linkOverrides ?? {});
   const getTraitsFromNode2 = getTraitsFromNodeFactory(options.traitOptions);
-  const typeManifestVisitor = getTypeManifestVisitor({ getImportFrom, getTraitsFromNode: getTraitsFromNode2 });
+  const typeManifestVisitor = getTypeManifestVisitor({
+    getImportFrom,
+    getTraitsFromNode: getTraitsFromNode2,
+    traitOptions: options.traitOptions
+  });
   const anchorTraits = options.anchorTraits ?? true;
   return (0, import_visitors_core4.pipe)(
     (0, import_visitors_core4.staticVisitor)(() => (0, import_renderers_core.createRenderMap)(), {
@@ -1091,8 +1162,13 @@ function renderVisitor(path, options = {}) {
     (0, import_visitors_core5.visit)(root, (0, import_renderers_core2.writeRenderMapVisitor)(getRenderMapVisitor(options), path));
     if (options.formatCode) {
       if (options.crateFolder) {
-        const toolchain = options.toolchain ?? "+stable";
-        runFormatter("cargo", [toolchain, "fmt", "--manifest-path", `${options.crateFolder}/Cargo.toml`]);
+        const removeFalsy = (arg) => Boolean(arg);
+        runFormatter(
+          "cargo",
+          [options.toolchain, "fmt", "--manifest-path", `${options.crateFolder}/Cargo.toml`].filter(
+            removeFalsy
+          )
+        );
       } else {
         (0, import_errors4.logWarn)("No crate folder specified, skipping formatting.");
       }