@codama/renderers-rust 1.2.6 → 1.2.7

package/dist/index.node.mjs

@@ -392,6 +392,10 @@ var render = (template, context, options) => {
   env.addFilter("kebabCase", kebabCase);
   env.addFilter("titleCase", 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);
 };
 
@@ -501,14 +505,51 @@ function extractFullyQualifiedNames(traits, imports) {
     return trait.slice(index + 2);
   });
 }
+function getSerdeFieldAttribute(serdeWith, node, userOptions = {}) {
+  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]) => [camelCase3(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 pipe(
     mergeVisitor(
       () => ({ imports: new ImportMap(), nestedStructs: [], type: "" }),
@@ -521,10 +562,12 @@ function getTypeManifestVisitor(options) {
     (v) => extendVisitor(v, {
       visitAccount(account, { self }) {
         parentName = pascalCase3(account.name);
+        parentNode = account;
         const manifest = visit3(account.data, self);
         const traits = getTraitsFromNode2(account);
         manifest.imports.mergeWith(traits.imports);
         parentName = null;
+        parentNode = null;
         return {
           ...manifest,
           type: traits.render + manifest.type
@@ -599,10 +642,12 @@ function getTypeManifestVisitor(options) {
       },
       visitDefinedType(definedType, { self }) {
         parentName = pascalCase3(definedType.name);
+        parentNode = definedType;
         const manifest = visit3(definedType.type, self);
         const traits = getTraitsFromNode2(definedType);
         manifest.imports.mergeWith(traits.imports);
         parentName = null;
+        parentNode = null;
         const renderedType = isNode4(definedType.type, ["enumTypeNode", "structTypeNode"]) ? manifest.type : `pub type ${pascalCase3(definedType.name)} = ${manifest.type};`;
         return { ...manifest, type: `${traits.render}${renderedType}` };
       },
@@ -649,10 +694,18 @@ function getTypeManifestVisitor(options) {
         const childManifest = visit3(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,
@@ -799,14 +852,28 @@ ${variantNames}
         const docblock = rustDocblock(parseDocs(structFieldType.docs));
         const resolvedNestedType = 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 (isNode4(resolvedNestedType, "arrayTypeNode") && isNode4(resolvedNestedType.count, "fixedCountNode") && resolvedNestedType.count.value > 32) {
-          derive = '#[cfg_attr(feature = "serde", serde(with = "serde_big_array::BigArray"))]\n';
-        } else if (isNode4(resolvedNestedType, ["bytesTypeNode", "stringTypeNode"]) && isNode4(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 (isNode4(resolvedNestedType, "arrayTypeNode") && isNode4(resolvedNestedType.count, "fixedCountNode") && resolvedNestedType.count.value > 32) {
+            derive = getSerdeFieldAttribute("serde_big_array::BigArray", parentNode, traitOptions);
+          } else if (isNode4(resolvedNestedType, ["bytesTypeNode", "stringTypeNode"]) && isNode4(structFieldType.type, "fixedSizeTypeNode") && structFieldType.type.size > 32) {
+            derive = getSerdeFieldAttribute(
+              "serde_with::As::<serde_with::Bytes>",
+              parentNode,
+              traitOptions
+            );
+          }
         }
         return {
           ...fieldManifest,
@@ -879,7 +946,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 pipe2(
     staticVisitor(() => createRenderMap(), {
@@ -1102,8 +1173,13 @@ function renderVisitor(path, options = {}) {
     visit5(root, 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 {
         logWarn2("No crate folder specified, skipping formatting.");
       }