@codama/renderers-rust 1.2.6 → 1.2.8

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(), {
@@ -921,9 +992,8 @@ function getRenderMapVisitor(options = {}) {
         if (hasVariableSeeds) {
           imports.mergeWith(seedsImports);
         }
-        return createRenderMap(
-          `accounts/${snakeCase4(node.name)}.rs`,
-          render("accountsPage.njk", {
+        return createRenderMap(`accounts/${snakeCase4(node.name)}.rs`, {
+          content: render("accountsPage.njk", {
             account: node,
             anchorTraits,
             constantSeeds,
@@ -935,19 +1005,18 @@ function getRenderMapVisitor(options = {}) {
             seeds,
             typeManifest
           })
-        );
+        });
       },
       visitDefinedType(node) {
         const typeManifest = visit4(node, typeManifestVisitor);
         const imports = new ImportMap().mergeWithManifest(typeManifest);
-        return createRenderMap(
-          `types/${snakeCase4(node.name)}.rs`,
-          render("definedTypesPage.njk", {
+        return createRenderMap(`types/${snakeCase4(node.name)}.rs`, {
+          content: render("definedTypesPage.njk", {
             definedType: node,
             imports: imports.remove(`generatedTypes::${pascalCase4(node.name)}`).toString(dependencyMap),
             typeManifest
           })
-        );
+        });
       },
       visitInstruction(node) {
         const imports = new ImportMap();
@@ -1008,9 +1077,8 @@ function getRenderMapVisitor(options = {}) {
         const typeManifest = visit4(struct, structVisitor);
         const dataTraits = getTraitsFromNode2(node);
         imports.mergeWith(dataTraits.imports);
-        return createRenderMap(
-          `instructions/${snakeCase4(node.name)}.rs`,
-          render("instructionsPage.njk", {
+        return createRenderMap(`instructions/${snakeCase4(node.name)}.rs`, {
+          content: render("instructionsPage.njk", {
             dataTraits: dataTraits.render,
             discriminatorConstants: discriminatorConstants.render,
             hasArgs,
@@ -1021,7 +1089,7 @@ function getRenderMapVisitor(options = {}) {
             program,
             typeManifest
           })
-        );
+        });
       },
       visitProgram(node, { self }) {
         program = node;
@@ -1033,15 +1101,13 @@ function getRenderMapVisitor(options = {}) {
           }).map((ix) => visit4(ix, self))
         ]);
         if (node.errors.length > 0) {
-          renders = addToRenderMap(
-            renders,
-            `errors/${snakeCase4(node.name)}.rs`,
-            render("errorsPage.njk", {
+          renders = addToRenderMap(renders, `errors/${snakeCase4(node.name)}.rs`, {
+            content: render("errorsPage.njk", {
               errors: node.errors,
               imports: new ImportMap().toString(dependencyMap),
               program: node
             })
-          );
+          });
         }
         program = null;
         return renders;
@@ -1064,13 +1130,13 @@ function getRenderMapVisitor(options = {}) {
         };
         return mergeRenderMaps([
           createRenderMap({
-            ["accounts/mod.rs"]: accountsToExport.length > 0 ? render("accountsMod.njk", ctx) : void 0,
-            ["errors/mod.rs"]: programsToExport.length > 0 ? render("errorsMod.njk", ctx) : void 0,
-            ["instructions/mod.rs"]: instructionsToExport.length > 0 ? render("instructionsMod.njk", ctx) : void 0,
-            ["mod.rs"]: render("rootMod.njk", ctx),
-            ["programs.rs"]: programsToExport.length > 0 ? render("programsMod.njk", ctx) : void 0,
-            ["shared.rs"]: accountsToExport.length > 0 ? render("sharedPage.njk", ctx) : void 0,
-            ["types/mod.rs"]: definedTypesToExport.length > 0 ? render("definedTypesMod.njk", ctx) : void 0
+            ["accounts/mod.rs"]: accountsToExport.length > 0 ? { content: render("accountsMod.njk", ctx) } : void 0,
+            ["errors/mod.rs"]: programsToExport.length > 0 ? { content: render("errorsMod.njk", ctx) } : void 0,
+            ["instructions/mod.rs"]: instructionsToExport.length > 0 ? { content: render("instructionsMod.njk", ctx) } : void 0,
+            ["mod.rs"]: { content: render("rootMod.njk", ctx) },
+            ["programs.rs"]: programsToExport.length > 0 ? { content: render("programsMod.njk", ctx) } : void 0,
+            ["shared.rs"]: accountsToExport.length > 0 ? { content: render("sharedPage.njk", ctx) } : void 0,
+            ["types/mod.rs"]: definedTypesToExport.length > 0 ? { content: render("definedTypesMod.njk", ctx) } : void 0
           }),
           ...getAllPrograms(node).map((p) => visit4(p, self))
         ]);
@@ -1102,8 +1168,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.");
       }