@codama/renderers-rust 1.2.9 → 2.0.1

package/dist/index.node.mjs

@@ -1,7 +1,9 @@
-import { CodamaError, CODAMA_ERROR__RENDERERS__UNSUPPORTED_NODE, logWarn, logError, CODAMA_ERROR__UNEXPECTED_NODE_KIND } from '@codama/errors';
+import { CodamaError, CODAMA_ERROR__RENDERERS__UNSUPPORTED_NODE, logWarn, logError, CODAMA_ERROR__UNEXPECTED_NODE_KIND, CODAMA_ERROR__RENDERERS__MISSING_DEPENDENCY_VERSIONS } from '@codama/errors';
 import { REGISTERED_TYPE_NODE_KINDS, definedTypeNode, pascalCase, snakeCase, parseDocs, resolveNestedTypeNode, isNode, remainderCountNode, fixedCountNode, prefixedCountNode, arrayTypeNode, numberTypeNode, getAllPrograms, getAllAccounts, getAllInstructionsWithSubs, getAllDefinedTypes, VALUE_NODES, structTypeNodeFromInstructionArgumentNodes, isNodeFilter, camelCase, kebabCase, titleCase, assertIsNode, bytesValueNode, numberValueNode, arrayValueNode, isScalarEnum } from '@codama/nodes';
-import { createRenderMap, mergeRenderMaps, addToRenderMap, deleteDirectory, writeRenderMapVisitor } from '@codama/renderers-core';
+import { createRenderMap, mergeRenderMaps, addToRenderMap, joinPath, deleteDirectory, writeRenderMap, fileExists, writeFile, readFile } from '@codama/renderers-core';
 import { pipe, mergeVisitor, extendVisitor, visit, LinkableDictionary, NodeStack, staticVisitor, recordNodeStackVisitor, recordLinkablesOnFirstVisitVisitor, rootNodeVisitor } from '@codama/visitors-core';
+import { stringify, parse } from '@iarna/toml';
+import { subset, minVersion, lt } from 'semver';
 import { getBase64Encoder, getBase58Encoder, getBase16Encoder, getUtf8Encoder } from '@solana/codecs-strings';
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
@@ -9,6 +11,7 @@ import nunjucks from 'nunjucks';
 import { spawnSync } from 'child_process';
 
 // 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",
@@ -68,6 +71,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) => {
@@ -78,6 +85,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 = joinPath(crateFolder, "Cargo.toml");
+  const usedDependencies = getUsedDependencyVersions(
+    renderMap,
+    options.dependencyMap ?? {},
+    options.dependencyVersions ?? {}
+  );
+  if (!shouldSyncCargoToml) {
+    if (fileExists(cargoTomlPath)) {
+      checkExistingCargoToml(readCargoToml(cargoTomlPath), usedDependencies);
+    }
+    return;
+  }
+  if (fileExists(cargoTomlPath)) {
+    const cargoToml = updateExistingCargoToml(readCargoToml(cargoTomlPath), usedDependencies);
+    writeFile(cargoTomlPath, stringify(cargoToml) + "\n");
+  } else {
+    const cargoToml = createNewCargoToml(usedDependencies);
+    writeFile(cargoTomlPath, 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("");
+  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 CodamaError(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 (subset(currentRange, requiredRange)) {
+      return false;
+    }
+    const minRequiredVersion = minVersion(requiredRange);
+    const minCurrentVersion = minVersion(currentRange);
+    if (!minCurrentVersion || !minRequiredVersion) {
+      throw new Error("Could not determine minimum versions.");
+    }
+    if (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 parse(readFile(path));
+}
 function getBytesFromBytesValueNode(node) {
   switch (node.encoding) {
     case "utf8":
@@ -913,10 +1168,7 @@ function getRenderMapVisitor(options = {}) {
         });
         const hasVariableSeeds = pdaSeeds.filter(isNodeFilter("variablePdaSeedNode")).length > 0;
         const constantSeeds = seeds.filter(isNodeFilter("constantPdaSeedNode")).filter((seed) => !isNode(seed.value, "programIdValueNode"));
-        const { imports } = typeManifest;
-        if (hasVariableSeeds) {
-          imports.mergeWith(seedsImports);
-        }
+        const imports = typeManifest.imports.mergeWith(...hasVariableSeeds ? [seedsImports] : []).mergeWith(discriminatorConstants.imports).remove(`generatedAccounts::${pascalCase(node.name)}`);
         return createRenderMap(`accounts/${snakeCase(node.name)}.rs`, {
           content: render("accountsPage.njk", {
             account: node,
@@ -924,23 +1176,25 @@ function getRenderMapVisitor(options = {}) {
             constantSeeds,
             discriminatorConstants: discriminatorConstants.render,
             hasVariableSeeds,
-            imports: imports.mergeWith(discriminatorConstants.imports).remove(`generatedAccounts::${pascalCase(node.name)}`).toString(dependencyMap),
+            imports: imports.toString(dependencyMap),
             pda,
             program,
             seeds,
             typeManifest
-          })
+          }),
+          imports
         });
       },
       visitDefinedType(node) {
         const typeManifest = visit(node, typeManifestVisitor);
-        const imports = new ImportMap().mergeWithManifest(typeManifest);
+        const imports = new ImportMap().mergeWithManifest(typeManifest).remove(`generatedTypes::${pascalCase(node.name)}`);
         return createRenderMap(`types/${snakeCase(node.name)}.rs`, {
           content: render("definedTypesPage.njk", {
             definedType: node,
-            imports: imports.remove(`generatedTypes::${pascalCase(node.name)}`).toString(dependencyMap),
+            imports: imports.toString(dependencyMap),
             typeManifest
-          })
+          }),
+          imports
         });
       },
       visitInstruction(node) {
@@ -1001,19 +1255,20 @@ function getRenderMapVisitor(options = {}) {
         });
         const typeManifest = visit(struct, structVisitor);
         const dataTraits = getTraitsFromNode2(node);
-        imports.mergeWith(dataTraits.imports);
+        imports.mergeWith(dataTraits.imports).mergeWith(discriminatorConstants.imports).remove(`generatedInstructions::${pascalCase(node.name)}`);
         return createRenderMap(`instructions/${snakeCase(node.name)}.rs`, {
           content: render("instructionsPage.njk", {
             dataTraits: dataTraits.render,
             discriminatorConstants: discriminatorConstants.render,
             hasArgs,
             hasOptional,
-            imports: imports.mergeWith(discriminatorConstants.imports).remove(`generatedInstructions::${pascalCase(node.name)}`).toString(dependencyMap),
+            imports: imports.toString(dependencyMap),
             instruction: node,
             instructionArgs,
             program,
             typeManifest
-          })
+          }),
+          imports
         });
       },
       visitProgram(node, { self }) {
@@ -1031,7 +1286,8 @@ function getRenderMapVisitor(options = {}) {
               errors: node.errors,
               imports: new ImportMap().toString(dependencyMap),
               program: node
-            })
+            }),
+            imports: new ImportMap()
           });
         }
         program = null;
@@ -1055,13 +1311,13 @@ function getRenderMapVisitor(options = {}) {
         };
         return mergeRenderMaps([
           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
           }),
           ...getAllPrograms(node).map((p) => visit(p, self))
         ]);
@@ -1079,24 +1335,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 rootNodeVisitor((root) => {
+    const generatedFolder = joinPath(crateFolder, options.generatedFolder ?? "src/generated");
     if (options.deleteFolderBeforeRendering ?? true) {
-      deleteDirectory(path);
+      deleteDirectory(generatedFolder);
     }
-    visit(root, writeRenderMapVisitor(getRenderMapVisitor(options), path));
+    const renderMap = visit(root, getRenderMapVisitor(options));
+    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 {
-        logWarn("No crate folder specified, skipping formatting.");
-      }
+      const removeFalsy = (arg) => Boolean(arg);
+      runFormatter(
+        "cargo",
+        [options.toolchain, "fmt", "--manifest-path", `${crateFolder}/Cargo.toml`].filter(removeFalsy)
+      );
     }
   });
 }
@@ -1114,6 +1367,6 @@ function runFormatter(cmd, args) {
   }
 }
 
-export { ImportMap, renderVisitor as default, getRenderMapVisitor, getTypeManifestVisitor, renderVisitor };
+export { ImportMap, RUST_CORE_IMPORTS, renderVisitor as default, getRenderMapVisitor, getTypeManifestVisitor, renderVisitor };
 //# sourceMappingURL=index.node.mjs.map
 //# sourceMappingURL=index.node.mjs.map