@codama/renderers-js 1.5.0 → 1.5.2

package/dist/index.node.mjs

@@ -100,6 +100,10 @@ function importMapToString(importMap, dependencyMap = {}, useGranularImports = f
     return `import { ${innerImports} } from '${module}';`;
   }).join("\n");
 }
+function getExternalDependencies(importMap, dependencyMap, useGranularImports) {
+  const resolvedImports = resolveImportMapModules(importMap, dependencyMap, useGranularImports);
+  return new Set([...resolvedImports.keys()].filter((module) => !module.startsWith(".")));
+}
 function resolveImportMapModules(importMap, dependencyMap, useGranularImports) {
   const dependencyMapWithDefaults = {
     ...useGranularImports ? DEFAULT_GRANULAR_EXTERNAL_MODULE_MAP : DEFAULT_EXTERNAL_MODULE_MAP,
@@ -471,6 +475,177 @@ function getImportFromFactory(overrides, customAccountData, customInstructionDat
   };
 }
 
+// src/utils/packageJson.ts
+import { CODAMA_ERROR__RENDERERS__MISSING_DEPENDENCY_VERSIONS, CodamaError as CodamaError2, logWarn } from "@codama/errors";
+import { fileExists, joinPath, readJson, writeFile } from "@codama/renderers-core";
+import { lt as ltVersion, minVersion, subset } from "semver";
+var DEFAULT_DEPENDENCY_VERSIONS = {
+  "@solana/accounts": "^5.0.0",
+  "@solana/addresses": "^5.0.0",
+  "@solana/codecs": "^5.0.0",
+  "@solana/errors": "^5.0.0",
+  "@solana/instructions": "^5.0.0",
+  "@solana/kit": "^5.0.0",
+  "@solana/programs": "^5.0.0",
+  "@solana/rpc-types": "^5.0.0",
+  "@solana/signers": "^5.0.0"
+};
+function syncPackageJson(renderMap, options) {
+  const shouldSyncPackageJson = options.syncPackageJson ?? false;
+  const packageFolder = options.packageFolder;
+  if (!packageFolder) {
+    if (shouldSyncPackageJson) {
+      logWarn("Cannot sync package.json. Please provide the 'packageFolder' option.");
+    }
+    return;
+  }
+  const packageJsonPath = joinPath(packageFolder, "package.json");
+  const usedDependencies = getUsedDependencyVersions(
+    renderMap,
+    options.dependencyMap ?? {},
+    options.dependencyVersions ?? {},
+    options.useGranularImports ?? false
+  );
+  if (!shouldSyncPackageJson) {
+    if (fileExists(packageJsonPath)) {
+      checkExistingPackageJson(readJson(packageJsonPath), usedDependencies);
+    }
+    return;
+  }
+  if (fileExists(packageJsonPath)) {
+    const packageJson = updateExistingPackageJson(readJson(packageJsonPath), usedDependencies);
+    writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n");
+  } else {
+    const packageJson = createNewPackageJson(usedDependencies);
+    writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n");
+  }
+}
+function createNewPackageJson(dependencyVersions) {
+  return updateExistingPackageJson(
+    {
+      name: "js-client",
+      version: "1.0.0",
+      // eslint-disable-next-line sort-keys-fix/sort-keys-fix
+      description: "",
+      main: "src/index.ts",
+      scripts: { test: 'echo "Error: no test specified" && exit 1' },
+      // eslint-disable-next-line sort-keys-fix/sort-keys-fix
+      keywords: [],
+      // eslint-disable-next-line sort-keys-fix/sort-keys-fix
+      author: ""
+    },
+    dependencyVersions
+  );
+}
+function updateExistingPackageJson(packageJson, dependencyVersions) {
+  const updatedDependencies = { ...packageJson.dependencies };
+  const updatedPeerDependencies = { ...packageJson.peerDependencies };
+  const updatedDevDependencies = { ...packageJson.devDependencies };
+  for (const [dependency, requiredRange] of Object.entries(dependencyVersions)) {
+    let found = false;
+    if (updatedDependencies[dependency]) {
+      updateDependency(updatedDependencies, dependency, requiredRange);
+      found = true;
+    }
+    if (updatedPeerDependencies[dependency]) {
+      updateDependency(updatedPeerDependencies, dependency, requiredRange);
+      found = true;
+    }
+    if (updatedDevDependencies[dependency]) {
+      updateDependency(updatedDevDependencies, dependency, requiredRange);
+      found = true;
+    }
+    if (!found) {
+      const dependencyGroupToAdd = dependency === "@solana/kit" ? updatedPeerDependencies : updatedDependencies;
+      dependencyGroupToAdd[dependency] = requiredRange;
+    }
+  }
+  return {
+    ...packageJson,
+    ...Object.entries(updatedPeerDependencies).length > 0 ? { peerDependencies: updatedPeerDependencies } : {},
+    ...Object.entries(updatedDependencies).length > 0 ? { dependencies: updatedDependencies } : {},
+    ...Object.entries(updatedDevDependencies).length > 0 ? { devDependencies: updatedDevDependencies } : {}
+  };
+}
+function checkExistingPackageJson(packageJson, dependencyVersions) {
+  const missingDependencies = [];
+  const dependenciesToUpdate = [];
+  const existingDependencies = {
+    ...packageJson.devDependencies,
+    ...packageJson.peerDependencies,
+    ...packageJson.dependencies
+  };
+  for (const [dependency, requiredRange] of Object.entries(dependencyVersions)) {
+    if (!existingDependencies[dependency]) {
+      missingDependencies.push(dependency);
+    } else if (shouldUpdateRange(dependency, existingDependencies[dependency], requiredRange)) {
+      dependenciesToUpdate.push(dependency);
+    }
+  }
+  if (missingDependencies.length === 0 && dependenciesToUpdate.length === 0) return;
+  const missingList = missingDependencies.map((d) => `- ${d} missing: ${dependencyVersions[d]}
+`).join("");
+  const outdatedList = dependenciesToUpdate.map((d) => `- ${d} outdated: ${existingDependencies[d]} -> ${dependencyVersions[d]}
+`).join("");
+  logWarn(
+    `The following dependencies in your \`package.json\` are out-of-date or missing:
+${missingList}${outdatedList}`
+  );
+}
+function getUsedDependencyVersions(renderMap, dependencyMap, dependencyVersions, useGranularImports) {
+  const dependencyVersionsWithDefaults = {
+    ...DEFAULT_DEPENDENCY_VERSIONS,
+    ...dependencyVersions
+  };
+  const fragment2 = mergeFragments([...renderMap.values()], () => "");
+  const usedDependencies = getExternalDependencies(fragment2.imports, dependencyMap, useGranularImports);
+  const [usedDependencyVersion, missingDependencies] = [...usedDependencies].reduce(
+    ([acc, missingDependencies2], dependency) => {
+      const version = dependencyVersionsWithDefaults[dependency];
+      if (version) {
+        acc[dependency] = version;
+      } else {
+        missingDependencies2.add(dependency);
+      }
+      return [acc, missingDependencies2];
+    },
+    [{}, /* @__PURE__ */ new Set()]
+  );
+  if (missingDependencies.size > 0) {
+    throw new CodamaError2(CODAMA_ERROR__RENDERERS__MISSING_DEPENDENCY_VERSIONS, {
+      dependencies: [...missingDependencies],
+      message: "Please add these dependencies to the `dependencyVersions` option."
+    });
+  }
+  return usedDependencyVersion;
+}
+function shouldUpdateRange(dependency, currentRange, 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 (ltVersion(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 updateDependency(dependencyGroup, dependency, requiredRange) {
+  const currentRange = dependencyGroup[dependency];
+  if (!shouldUpdateRange(dependency, currentRange, requiredRange)) return;
+  dependencyGroup[dependency] = requiredRange;
+}
+
 // src/fragments/accountFetchHelpers.ts
 function getAccountFetchHelpersFragment(scope) {
   const { accountPath, typeManifest: typeManifest2, nameApi, customAccountData } = scope;
@@ -1718,7 +1893,7 @@ function getInputTypeCallFragment(scope) {
 }
 
 // src/fragments/instructionPage.ts
-import { logWarn } from "@codama/errors";
+import { logWarn as logWarn2 } from "@codama/errors";
 import { camelCase as camelCase12, definedTypeNode as definedTypeNode2, structTypeNodeFromInstructionArgumentNodes as structTypeNodeFromInstructionArgumentNodes3 } from "@codama/nodes";
 import {
   findProgramNodeFromPath as findProgramNodeFromPath6,
@@ -1926,7 +2101,7 @@ function getRenamedArgsMap(instruction) {
   const allNames = [...instruction.accounts.map((account) => account.name), ...argNames];
   const duplicates = allNames.filter((e, i, a) => a.indexOf(e) !== i);
   if (duplicates.length === 0) return /* @__PURE__ */ new Map();
-  logWarn(
+  logWarn2(
     `[JavaScript] Accounts and args of instruction [${instruction.name}] have the following conflicting attributes [${duplicates.join(", ")}]. Thus, the arguments have been renamed to avoid conflicts in the input type.`
   );
   return new Map(duplicates.map((name) => [camelCase12(name), camelCase12(`${name}Arg`)]));
@@ -3109,6 +3284,7 @@ function getRenderMapVisitor(options = {}) {
     customAccountData,
     customInstructionData,
     dependencyMap: options.dependencyMap ?? {},
+    dependencyVersions: options.dependencyVersions ?? {},
     getImportFrom: getImportFromFactory(options.linkOverrides ?? {}, customAccountData, customInstructionData),
     linkables,
     nameApi: getNameApi({ ...DEFAULT_NAME_TRANSFORMERS, ...options.nameTransformers }),
@@ -3258,6 +3434,7 @@ function renderVisitor(path, options = {}) {
       const prettierOptions = { ...DEFAULT_PRETTIER_OPTIONS, ...options.prettierOptions };
       renderMap = await mapRenderMapContentAsync(renderMap, (code) => format(code, prettierOptions));
     }
+    syncPackageJson(renderMap, options);
     writeRenderMap(renderMap, path);
   });
 }
@@ -3266,6 +3443,7 @@ export {
   addToImportMap,
   createImportMap,
   renderVisitor as default,
+  getExternalDependencies,
   getNameApi,
   getRenderMapVisitor,
   getTypeManifestVisitor,