@codama/renderers-rust 1.2.5 → 1.2.7

package/README.md

@@ -15,24 +15,23 @@ This package generates Rust clients from your Codama IDLs.
 pnpm install @codama/renderers-rust
 ```
 
-> [!NOTE]
-> This package is **not** included in the main [`codama`](../library) package.
->
-> However, note that the [`renderers`](../renderers) package re-exports the `renderVisitor` function of this package as `renderRustVisitor`.
-
 ## Usage
 
-Once you have a Codama IDL, you can use the `renderVisitor` of this package to generate Rust clients. You will need to provide the base directory where the generated files will be saved and an optional set of options to customize the output.
-
-```ts
-// node ./codama.mjs
-import { renderVisitor } from '@codama/renderers-rust';
-
-const pathToGeneratedFolder = path.join(__dirname, 'clients', 'rust', 'src', 'generated');
-const options = {}; // See below.
-codama.accept(renderVisitor(pathToGeneratedFolder, options));
+Add the following script to your Codama configuration file.
+
+```json
+{
+    "scripts": {
+        "rust": {
+            "from": "@codama/renderers-rust",
+            "args": ["clients/rust/src/generated"]
+        }
+    }
+}
 ```
 
+An object can be passed as a second argument to further configure the renderer. See the [Options](#options) section below for more details.
+
 ## Options
 
 The `renderVisitor` accepts the following options.

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.");
       }