@codama/renderers-rust 1.2.9 → 2.0.1

package/README.md

@@ -17,14 +17,14 @@ pnpm install @codama/renderers-rust
 
 ## Usage
 
-Add the following script to your Codama configuration file.
+Add the following script to your Codama configuration file. The first argument is the crate folder (where `Cargo.toml` lives) and the generated code will be output to `src/generated` within that folder by default.
 
 ```json
 {
     "scripts": {
         "rust": {
             "from": "@codama/renderers-rust",
-            "args": ["clients/rust/src/generated"]
+            "args": ["clients/rust"]
         }
     }
 }
@@ -36,17 +36,19 @@ An object can be passed as a second argument to further configure the renderer.
 
 The `renderVisitor` accepts the following options.
 
-| Name                          | Type                                                                                                                    | Default                 | Description                                                                                                                                                                                      |
-| ----------------------------- | ----------------------------------------------------------------------------------------------------------------------- | ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `deleteFolderBeforeRendering` | `boolean`                                                                                                               | `true`                  | Whether the base directory should be cleaned before generating new files.                                                                                                                        |
-| `formatCode`                  | `boolean`                                                                                                               | `false`                 | Whether we should use `cargo fmt` to format the generated code. When set to `true`, the `crateFolder` option must be provided.                                                                   |
-| `toolchain`                   | `string`                                                                                                                | `"+stable"`             | The toolchain to use when formatting the generated code.                                                                                                                                         |
-| `crateFolder`                 | `string`                                                                                                                | none                    | The path to the root folder of the Rust crate. This option is required when `formatCode` is set to `true`.                                                                                       |
-| `linkOverrides`               | `Record<'accounts' \| 'definedTypes' \| 'instructions' \| 'pdas' \| 'programs' \| 'resolvers', Record<string, string>>` | `{}`                    | A object that overrides the import path of link nodes. For instance, `{ definedTypes: { counter: 'hooked' } }` uses the `hooked` folder to import any link node referring to the `counter` type. |
-| `dependencyMap`               | `Record<string, string>`                                                                                                | `{}`                    | A mapping between import aliases and their actual crate name or path in Rust.                                                                                                                    |
-| `renderParentInstructions`    | `boolean`                                                                                                               | `false`                 | When using nested instructions, whether the parent instructions should also be rendered. When set to `false` (default), only the instruction leaves are being rendered.                          |
-| `traitOptions`                | [`TraitOptions`](#trait-options)                                                                                        | `DEFAULT_TRAIT_OPTIONS` | A set of options that can be used to configure how traits are rendered for every Rust types. See [documentation below](#trait-options) for more information.                                     |
-| `anchorTraits`                | `boolean`                                                                                                               | `true`                  | Whether to generate Anchor traits `impl` for account types.                                                                                                                                      |
+| Name                          | Type                                                                                                                    | Default                 | Description                                                                                                                                                                                                                                                                                                                                         |
+| ----------------------------- | ----------------------------------------------------------------------------------------------------------------------- | ----------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `deleteFolderBeforeRendering` | `boolean`                                                                                                               | `true`                  | Whether the base directory should be cleaned before generating new files.                                                                                                                                                                                                                                                                           |
+| `formatCode`                  | `boolean`                                                                                                               | `false`                 | Whether we should use `cargo fmt` to format the generated code.                                                                                                                                                                                                                                                                                     |
+| `generatedFolder`             | `string`                                                                                                                | `'src/generated'`       | The path to the generated folder, relative to the crate folder provided as the first argument.                                                                                                                                                                                                                                                      |
+| `toolchain`                   | `string`                                                                                                                | `"+stable"`             | The toolchain to use when formatting the generated code.                                                                                                                                                                                                                                                                                            |
+| `linkOverrides`               | `Record<'accounts' \| 'definedTypes' \| 'instructions' \| 'pdas' \| 'programs' \| 'resolvers', Record<string, string>>` | `{}`                    | A object that overrides the import path of link nodes. For instance, `{ definedTypes: { counter: 'hooked' } }` uses the `hooked` folder to import any link node referring to the `counter` type.                                                                                                                                                    |
+| `dependencyMap`               | `Record<string, string>`                                                                                                | `{}`                    | A mapping between import aliases and their actual crate name or path in Rust.                                                                                                                                                                                                                                                                       |
+| `dependencyVersions`          | `Record<string, CargoDependency>`                                                                                       | `{}`                    | A mapping between external crates — e.g. `solana-pubkey` — and the version range we should use for them — e.g. `^3.0` or the equivalent dependency object — e.g. `{ version: "^3.0" }`. The renderer offers default values for all external dependencies it relies on but this option may be used to override some of these values or add new ones. |
+| `renderParentInstructions`    | `boolean`                                                                                                               | `false`                 | When using nested instructions, whether the parent instructions should also be rendered. When set to `false` (default), only the instruction leaves are being rendered.                                                                                                                                                                             |
+| `traitOptions`                | [`TraitOptions`](#trait-options)                                                                                        | `DEFAULT_TRAIT_OPTIONS` | A set of options that can be used to configure how traits are rendered for every Rust types. See [documentation below](#trait-options) for more information.                                                                                                                                                                                        |
+| `anchorTraits`                | `boolean`                                                                                                               | `true`                  | Whether to generate Anchor traits `impl` for account types.                                                                                                                                                                                                                                                                                         |
+| `syncCargoToml`               | `boolean`                                                                                                               | `false`                 | Whether to update the dependencies of the existing `Cargo.toml` — or create a new `Cargo.toml` when missing — at the crate folder provided as the first argument.                                                                                                                                                                                   |
 
 ## Trait Options
 

package/dist/index.node.cjs

@@ -6,6 +6,8 @@ var errors = require('@codama/errors');
 var nodes = require('@codama/nodes');
 var renderersCore = require('@codama/renderers-core');
 var visitorsCore = require('@codama/visitors-core');
+var toml = require('@iarna/toml');
+var semver = require('semver');
 var codecsStrings = require('@solana/codecs-strings');
 var path = require('path');
 require('url');
@@ -17,6 +19,7 @@ function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 var nunjucks__default = /*#__PURE__*/_interopDefault(nunjucks);
 
 // src/ImportMap.ts
+var RUST_CORE_IMPORTS = /* @__PURE__ */ new Set(["std", "crate", "super", "self", "core", "alloc", "clippy"]);
 var DEFAULT_MODULE_MAP = {
   generated: "crate::generated",
   generatedAccounts: "crate::generated::accounts",
@@ -76,6 +79,10 @@ var ImportMap = class _ImportMap {
     this._aliases.forEach((alias, i) => newImportMap.addAlias(resolveDependency(i), alias));
     return newImportMap;
   }
+  getExternalDependencies(dependencyMap) {
+    const resolvedMap = this.resolveDependencyMap(dependencyMap);
+    return new Set([...resolvedMap._imports].map((i) => i.split("::")[0]).filter((i) => !RUST_CORE_IMPORTS.has(i)));
+  }
   toString(dependencies) {
     const resolvedMap = this.resolveDependencyMap(dependencies);
     const importStatements = [...resolvedMap.imports].map((i) => {
@@ -86,6 +93,254 @@ var ImportMap = class _ImportMap {
     return importStatements.join("\n");
   }
 };
+var DEFAULT_DEPENDENCY_VERSIONS = {
+  "anchor-lang": { optional: true, version: "~0.31" },
+  borsh: "^0.10",
+  kaigan: { features: ["serde"], version: "^0.3" },
+  "num-derive": "^0.4",
+  "num-traits": "^0.2",
+  serde: { features: ["derive"], optional: true, version: "^1.0" },
+  "serde-big-array": "^0.5",
+  serde_with: { optional: true, version: "^3.0" },
+  "solana-account": "~2.2",
+  "solana-account-info": "~2.3",
+  "solana-client": { optional: true, version: "^2.2" },
+  "solana-cpi": "~2.2",
+  "solana-decode-error": "~2.3",
+  "solana-instruction": "~2.3",
+  "solana-program-error": "~2.2",
+  "solana-pubkey": { features: ["curve25519", "borsh"], version: "~2.3" },
+  "solana-sdk": { optional: true, version: "^2.3" },
+  thiserror: "^1.0"
+};
+function syncCargoToml(renderMap, crateFolder, options) {
+  const shouldSyncCargoToml = options.syncCargoToml ?? false;
+  const cargoTomlPath = renderersCore.joinPath(crateFolder, "Cargo.toml");
+  const usedDependencies = getUsedDependencyVersions(
+    renderMap,
+    options.dependencyMap ?? {},
+    options.dependencyVersions ?? {}
+  );
+  if (!shouldSyncCargoToml) {
+    if (renderersCore.fileExists(cargoTomlPath)) {
+      checkExistingCargoToml(readCargoToml(cargoTomlPath), usedDependencies);
+    }
+    return;
+  }
+  if (renderersCore.fileExists(cargoTomlPath)) {
+    const cargoToml = updateExistingCargoToml(readCargoToml(cargoTomlPath), usedDependencies);
+    renderersCore.writeFile(cargoTomlPath, toml.stringify(cargoToml) + "\n");
+  } else {
+    const cargoToml = createNewCargoToml(usedDependencies);
+    renderersCore.writeFile(cargoTomlPath, toml.stringify(cargoToml) + "\n");
+  }
+}
+function createNewCargoToml(usedDependencies) {
+  return updateExistingCargoToml(
+    {
+      name: "rust-client",
+      // eslint-disable-next-line sort-keys-fix/sort-keys-fix
+      description: "",
+      version: "1.0.0",
+      // eslint-disable-next-line sort-keys-fix/sort-keys-fix
+      repository: { workspace: true },
+      // eslint-disable-next-line sort-keys-fix/sort-keys-fix
+      edition: { workspace: true },
+      license: { workspace: true },
+      // eslint-disable-next-line sort-keys-fix/sort-keys-fix
+      features: {
+        anchor: ["dep:anchor-lang"],
+        "anchor-idl-build": ["anchor", "anchor-lang?/idl-build"],
+        fetch: ["dep:solana-client", "dep:solana-sdk"],
+        serde: ["dep:serde", "dep:serde_with"]
+      },
+      // eslint-disable-next-line sort-keys-fix/sort-keys-fix
+      dependencies: {}
+    },
+    usedDependencies
+  );
+}
+function updateExistingCargoToml(cargoToml, usedDependencies) {
+  const foundUsedDependencies = /* @__PURE__ */ new Set();
+  const updatedCargoToml = updateCargoDependencies(cargoToml, (dependencyGroup) => {
+    return Object.fromEntries(
+      Object.entries(dependencyGroup).map(([dependencyKey, dependency]) => {
+        const foundUsedDependency = findCargoDependencyByImportName(
+          usedDependencies,
+          getCargoDependencyImportName(dependencyKey)
+        );
+        if (!foundUsedDependency) {
+          return [dependencyKey, dependency];
+        }
+        const [usedDependencyKey, usedDependency] = foundUsedDependency;
+        foundUsedDependencies.add(usedDependencyKey);
+        const usedDependencyCrateName = getCargoDependencyCrateName(usedDependencyKey, usedDependency);
+        if (!shouldUpdateDependency(usedDependencyCrateName, dependency, usedDependency)) {
+          return [dependencyKey, dependency];
+        }
+        const newVersion = getCargoDependencyVersion(usedDependency);
+        return [
+          dependencyKey,
+          typeof dependency === "string" ? newVersion : { ...dependency, version: newVersion }
+        ];
+      })
+    );
+  });
+  const usedDependenciesToAdd = Object.entries(usedDependencies).filter(
+    ([usedDependencyKey]) => !foundUsedDependencies.has(usedDependencyKey)
+  );
+  for (const [usedDependencyKey, usedDependency] of usedDependenciesToAdd) {
+    updatedCargoToml.dependencies = updatedCargoToml.dependencies ?? {};
+    updatedCargoToml.dependencies[usedDependencyKey] = usedDependency;
+  }
+  return updatedCargoToml;
+}
+function checkExistingCargoToml(cargoToml, usedDependencies) {
+  const missingDependencies = [];
+  const dependenciesToUpdate = [];
+  const existingDependencies = {
+    ...cargoToml["build-dependencies"],
+    ...cargoToml["dev-dependencies"],
+    ...cargoToml.dependencies,
+    ...cargoToml.workspace?.dependencies,
+    ...Object.values(cargoToml.target ?? {}).reduce((acc, target) => {
+      return {
+        ...acc,
+        ...target["build-dependencies"],
+        ...target["dev-dependencies"],
+        ...target.dependencies
+      };
+    }, {})
+  };
+  for (const [usedDependencyKey, usedDependency] of Object.entries(usedDependencies)) {
+    const foundExistingDependency = findCargoDependencyByImportName(
+      existingDependencies,
+      getCargoDependencyImportName(usedDependencyKey)
+    );
+    if (!foundExistingDependency) {
+      missingDependencies.push(usedDependencyKey);
+    } else if (shouldUpdateDependency(foundExistingDependency[0], foundExistingDependency[1], usedDependency)) {
+      dependenciesToUpdate.push(usedDependencyKey);
+    }
+  }
+  if (missingDependencies.length === 0 && dependenciesToUpdate.length === 0) return;
+  const missingList = missingDependencies.map((d) => `- ${d} missing: ${getCargoDependencyVersion(usedDependencies[d])}
+`).join("");
+  const outdatedList = dependenciesToUpdate.map(
+    (d) => `- ${d} outdated: ${getCargoDependencyVersion(existingDependencies[d])} -> ${getCargoDependencyVersion(usedDependencies[d])}
+`
+  ).join("");
+  errors.logWarn(
+    `The following dependencies in your \`Cargo.toml\` are out-of-date or missing:
+${missingList}${outdatedList}`
+  );
+}
+function getUsedDependencyVersions(renderMap, dependencyMap, dependencyVersions) {
+  const usedImportNames = getUsedImportNames(renderMap, dependencyMap);
+  const dependencyVersionsWithDefaults = {
+    ...DEFAULT_DEPENDENCY_VERSIONS,
+    ...dependencyVersions
+  };
+  const [usedDependencyVersion, missingDependencies] = [...usedImportNames].reduce(
+    ([acc, missingDependencies2], usedImportName) => {
+      const usedDependency = findCargoDependencyByImportName(dependencyVersionsWithDefaults, usedImportName);
+      if (usedDependency) {
+        acc[usedDependency[0]] = usedDependency[1];
+      } else {
+        missingDependencies2.add(usedImportName);
+      }
+      return [acc, missingDependencies2];
+    },
+    [{}, /* @__PURE__ */ new Set()]
+  );
+  if (missingDependencies.size > 0) {
+    throw new errors.CodamaError(errors.CODAMA_ERROR__RENDERERS__MISSING_DEPENDENCY_VERSIONS, {
+      dependencies: [...missingDependencies],
+      message: "Please add these dependencies to the `dependencyVersions` option."
+    });
+  }
+  return usedDependencyVersion;
+}
+function getUsedImportNames(renderMap, dependencyMap) {
+  const fragments = [...renderMap.values()];
+  const fromImportMap = new ImportMap().mergeWith(...fragments.map(({ imports }) => imports)).getExternalDependencies(dependencyMap);
+  const PATH_REGEX = /\b(?:::)?([a-z_][a-z0-9_]*)(?:::[a-zA-Z0-9_]+)+/g;
+  const fromContent = fragments.flatMap(({ content }) => {
+    return [...content.matchAll(PATH_REGEX)].map((match) => match[1]).filter((crateName) => !RUST_CORE_IMPORTS.has(crateName));
+  });
+  return /* @__PURE__ */ new Set([...fromImportMap, ...fromContent]);
+}
+function shouldUpdateDependency(dependency, currentDependency, requiredDependency) {
+  const currentRange = getCargoDependencyVersion(currentDependency);
+  const requiredRange = getCargoDependencyVersion(requiredDependency);
+  return !!currentRange && !!requiredRange && shouldUpdateRange(dependency, currentRange, requiredRange);
+}
+function shouldUpdateRange(dependency, currentRange, requiredRange) {
+  currentRange = cargoToNpmSemver(currentRange);
+  requiredRange = cargoToNpmSemver(requiredRange);
+  try {
+    if (semver.subset(currentRange, requiredRange)) {
+      return false;
+    }
+    const minRequiredVersion = semver.minVersion(requiredRange);
+    const minCurrentVersion = semver.minVersion(currentRange);
+    if (!minCurrentVersion || !minRequiredVersion) {
+      throw new Error("Could not determine minimum versions.");
+    }
+    if (semver.lt(minCurrentVersion, minRequiredVersion)) {
+      return true;
+    }
+    return false;
+  } catch (error) {
+    console.warn(
+      `Could not parse the following ranges for dependency "${dependency}": [${currentRange}] and/or [${requiredRange}]. Caused by: ${error.message}`
+    );
+    return false;
+  }
+}
+function updateCargoDependencies(cargoToml, updateFn) {
+  const updatedCargoToml = JSON.parse(JSON.stringify(cargoToml));
+  const standardSections = ["dependencies", "dev-dependencies", "build-dependencies"];
+  for (const section of standardSections) {
+    if (updatedCargoToml[section]) {
+      updatedCargoToml[section] = updateFn(updatedCargoToml[section]);
+    }
+  }
+  if (updatedCargoToml.target) {
+    for (const targetKey of Object.keys(updatedCargoToml.target)) {
+      for (const section of standardSections) {
+        if (updatedCargoToml.target[targetKey][section]) {
+          updatedCargoToml.target[targetKey][section] = updateFn(updatedCargoToml.target[targetKey][section]);
+        }
+      }
+    }
+  }
+  if (updatedCargoToml.workspace?.dependencies) {
+    updatedCargoToml.workspace.dependencies = updateFn(updatedCargoToml.workspace.dependencies);
+  }
+  return updatedCargoToml;
+}
+function cargoToNpmSemver(cargoVersion) {
+  const version = cargoVersion.trim();
+  return /^\d+(\.\d+)?(\.\d+)?/.test(version) ? `^${version}` : version;
+}
+function getCargoDependencyVersion(dependency) {
+  return typeof dependency === "string" ? dependency : dependency.version;
+}
+function getCargoDependencyCrateName(key, dependency) {
+  return typeof dependency !== "string" && dependency.package ? dependency.package : key;
+}
+function getCargoDependencyImportName(key) {
+  return key.replace(/-/g, "_");
+}
+function findCargoDependencyByImportName(dependencies, importName) {
+  return Object.entries(dependencies).find(([key]) => {
+    return getCargoDependencyImportName(key) === importName;
+  });
+}
+function readCargoToml(path) {
+  return toml.parse(renderersCore.readFile(path));
+}
 function getBytesFromBytesValueNode(node) {
   switch (node.encoding) {
     case "utf8":
@@ -921,10 +1176,7 @@ function getRenderMapVisitor(options = {}) {
         });
         const hasVariableSeeds = pdaSeeds.filter(nodes.isNodeFilter("variablePdaSeedNode")).length > 0;
         const constantSeeds = seeds.filter(nodes.isNodeFilter("constantPdaSeedNode")).filter((seed) => !nodes.isNode(seed.value, "programIdValueNode"));
-        const { imports } = typeManifest;
-        if (hasVariableSeeds) {
-          imports.mergeWith(seedsImports);
-        }
+        const imports = typeManifest.imports.mergeWith(...hasVariableSeeds ? [seedsImports] : []).mergeWith(discriminatorConstants.imports).remove(`generatedAccounts::${nodes.pascalCase(node.name)}`);
         return renderersCore.createRenderMap(`accounts/${nodes.snakeCase(node.name)}.rs`, {
           content: render("accountsPage.njk", {
             account: node,
@@ -932,23 +1184,25 @@ function getRenderMapVisitor(options = {}) {
             constantSeeds,
             discriminatorConstants: discriminatorConstants.render,
             hasVariableSeeds,
-            imports: imports.mergeWith(discriminatorConstants.imports).remove(`generatedAccounts::${nodes.pascalCase(node.name)}`).toString(dependencyMap),
+            imports: imports.toString(dependencyMap),
             pda,
             program,
             seeds,
             typeManifest
-          })
+          }),
+          imports
         });
       },
       visitDefinedType(node) {
         const typeManifest = visitorsCore.visit(node, typeManifestVisitor);
-        const imports = new ImportMap().mergeWithManifest(typeManifest);
+        const imports = new ImportMap().mergeWithManifest(typeManifest).remove(`generatedTypes::${nodes.pascalCase(node.name)}`);
         return renderersCore.createRenderMap(`types/${nodes.snakeCase(node.name)}.rs`, {
           content: render("definedTypesPage.njk", {
             definedType: node,
-            imports: imports.remove(`generatedTypes::${nodes.pascalCase(node.name)}`).toString(dependencyMap),
+            imports: imports.toString(dependencyMap),
             typeManifest
-          })
+          }),
+          imports
         });
       },
       visitInstruction(node) {
@@ -1009,19 +1263,20 @@ function getRenderMapVisitor(options = {}) {
         });
         const typeManifest = visitorsCore.visit(struct, structVisitor);
         const dataTraits = getTraitsFromNode2(node);
-        imports.mergeWith(dataTraits.imports);
+        imports.mergeWith(dataTraits.imports).mergeWith(discriminatorConstants.imports).remove(`generatedInstructions::${nodes.pascalCase(node.name)}`);
         return renderersCore.createRenderMap(`instructions/${nodes.snakeCase(node.name)}.rs`, {
           content: render("instructionsPage.njk", {
             dataTraits: dataTraits.render,
             discriminatorConstants: discriminatorConstants.render,
             hasArgs,
             hasOptional,
-            imports: imports.mergeWith(discriminatorConstants.imports).remove(`generatedInstructions::${nodes.pascalCase(node.name)}`).toString(dependencyMap),
+            imports: imports.toString(dependencyMap),
             instruction: node,
             instructionArgs,
             program,
             typeManifest
-          })
+          }),
+          imports
         });
       },
       visitProgram(node, { self }) {
@@ -1039,7 +1294,8 @@ function getRenderMapVisitor(options = {}) {
               errors: node.errors,
               imports: new ImportMap().toString(dependencyMap),
               program: node
-            })
+            }),
+            imports: new ImportMap()
           });
         }
         program = null;
@@ -1063,13 +1319,13 @@ function getRenderMapVisitor(options = {}) {
         };
         return renderersCore.mergeRenderMaps([
           renderersCore.createRenderMap({
-            ["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
+            ["accounts/mod.rs"]: accountsToExport.length > 0 ? { content: render("accountsMod.njk", ctx), imports: new ImportMap() } : void 0,
+            ["errors/mod.rs"]: programsToExport.length > 0 ? { content: render("errorsMod.njk", ctx), imports: new ImportMap() } : void 0,
+            ["instructions/mod.rs"]: instructionsToExport.length > 0 ? { content: render("instructionsMod.njk", ctx), imports: new ImportMap() } : void 0,
+            ["mod.rs"]: { content: render("rootMod.njk", ctx), imports: new ImportMap() },
+            ["programs.rs"]: programsToExport.length > 0 ? { content: render("programsMod.njk", ctx), imports: new ImportMap() } : void 0,
+            ["shared.rs"]: accountsToExport.length > 0 ? { content: render("sharedPage.njk", ctx), imports: new ImportMap() } : void 0,
+            ["types/mod.rs"]: definedTypesToExport.length > 0 ? { content: render("definedTypesMod.njk", ctx), imports: new ImportMap() } : void 0
           }),
           ...nodes.getAllPrograms(node).map((p) => visitorsCore.visit(p, self))
         ]);
@@ -1087,24 +1343,21 @@ function getConflictsForInstructionAccountsAndArgs(instruction) {
   const duplicates = allNames.filter((e, i, a) => a.indexOf(e) !== i);
   return [...new Set(duplicates)];
 }
-function renderVisitor(path, options = {}) {
+function renderVisitor(crateFolder, options = {}) {
   return visitorsCore.rootNodeVisitor((root) => {
+    const generatedFolder = renderersCore.joinPath(crateFolder, options.generatedFolder ?? "src/generated");
     if (options.deleteFolderBeforeRendering ?? true) {
-      renderersCore.deleteDirectory(path);
+      renderersCore.deleteDirectory(generatedFolder);
     }
-    visitorsCore.visit(root, renderersCore.writeRenderMapVisitor(getRenderMapVisitor(options), path));
+    const renderMap = visitorsCore.visit(root, getRenderMapVisitor(options));
+    renderersCore.writeRenderMap(renderMap, generatedFolder);
+    syncCargoToml(renderMap, crateFolder, options);
     if (options.formatCode) {
-      if (options.crateFolder) {
-        const removeFalsy = (arg) => Boolean(arg);
-        runFormatter(
-          "cargo",
-          [options.toolchain, "fmt", "--manifest-path", `${options.crateFolder}/Cargo.toml`].filter(
-            removeFalsy
-          )
-        );
-      } else {
-        errors.logWarn("No crate folder specified, skipping formatting.");
-      }
+      const removeFalsy = (arg) => Boolean(arg);
+      runFormatter(
+        "cargo",
+        [options.toolchain, "fmt", "--manifest-path", `${crateFolder}/Cargo.toml`].filter(removeFalsy)
+      );
     }
   });
 }
@@ -1123,6 +1376,7 @@ function runFormatter(cmd, args) {
 }
 
 exports.ImportMap = ImportMap;
+exports.RUST_CORE_IMPORTS = RUST_CORE_IMPORTS;
 exports.default = renderVisitor;
 exports.getRenderMapVisitor = getRenderMapVisitor;
 exports.getTypeManifestVisitor = getTypeManifestVisitor;