@storm-software/workspace-tools 1.228.1 → 1.229.0

package/dist/chunk-GZPCM2GI.mjs

@@ -0,0 +1,413 @@
+import {
+  cargoMetadata,
+  isExternal
+} from "./chunk-QZHIWK5Z.mjs";
+import {
+  ProjectTagConstants,
+  addProjectTag,
+  setDefaultProjectTags
+} from "./chunk-66TYTM73.mjs";
+import {
+  __name
+} from "./chunk-XUV4U54K.mjs";
+
+// src/plugins/rust/cargo-toml.ts
+import { createNodesFromFiles, joinPathFragments, readJsonFile, workspaceRoot } from "@nx/devkit";
+import { existsSync } from "node:fs";
+import { dirname } from "node:path";
+import { DependencyType } from "nx/src/config/project-graph";
+var name = "storm-software/rust";
+var description = "Plugin for parsing Cargo.toml files";
+var DefaultCargoPluginProfileMap = {
+  development: "dev",
+  production: "prod"
+};
+var DEFAULT_ERROR_MESSAGE = "An error occurred in the Storm Rust Nx plugin.";
+var createNodesV2 = [
+  "*/**/Cargo.toml",
+  async (configFiles, options, context) => {
+    return await createNodesFromFiles((configFile, options2, context2) => {
+      try {
+        console.log(`Processing Cargo.toml file: ${configFile}`);
+        const profiles = options2?.profiles ?? {};
+        const includeApps = options2?.includeApps ?? true;
+        const toolchain = options2?.toolchain;
+        const skipDocs = options2?.skipDocs ?? false;
+        const metadata = cargoMetadata();
+        if (!metadata) {
+          return {};
+        }
+        const { packages: cargoPackages } = metadata;
+        const externalNodes = {};
+        const projects = {};
+        const profs = {
+          ...DefaultCargoPluginProfileMap,
+          ...profiles
+        };
+        const configurations = Object.keys(profs).reduce((ret, key) => {
+          ret[key] = {
+            profile: profs[key]
+          };
+          return ret;
+        }, {});
+        const cargoPackageMap = cargoPackages.reduce((acc, p) => {
+          if (!acc.has(p.name)) {
+            acc.set(p.name, p);
+          }
+          return acc;
+        }, /* @__PURE__ */ new Map());
+        for (const cargoPackage of cargoPackages) {
+          if (!isExternal(cargoPackage, context2.workspaceRoot)) {
+            const root = dirname(configFile);
+            const project = {
+              root,
+              name: cargoPackage.name
+            };
+            if (existsSync(joinPathFragments(root, "project.json"))) {
+              const projectJson = readJsonFile(joinPathFragments(root, "project.json"));
+              if (projectJson) {
+                Object.keys(projectJson).forEach((key) => {
+                  if (!project[key]) {
+                    project[key] = projectJson[key];
+                  }
+                });
+              }
+            }
+            if (includeApps === false && project.projectType === "application") {
+              continue;
+            }
+            project.targets = {
+              "lint-ls": {
+                cache: true,
+                inputs: [
+                  "linting",
+                  "rust",
+                  "^production"
+                ],
+                dependsOn: [
+                  "^lint-ls"
+                ],
+                options: {
+                  command: 'pnpm exec ls-lint --config="./node_modules/@storm-software/linting-tools/ls-lint/.ls-lint.yml" ',
+                  color: true
+                }
+              },
+              lint: {
+                cache: true,
+                inputs: [
+                  "linting",
+                  "rust",
+                  "^production"
+                ],
+                dependsOn: [
+                  "^lint"
+                ],
+                executor: "@storm-software/workspace-tools:cargo-clippy",
+                options: {
+                  toolchain,
+                  fix: false
+                },
+                defaultConfiguration: "development",
+                configurations
+              },
+              check: {
+                cache: true,
+                inputs: [
+                  "linting",
+                  "rust",
+                  "^production"
+                ],
+                dependsOn: [
+                  "lint",
+                  "^check"
+                ],
+                executor: "@storm-software/workspace-tools:cargo-check",
+                options: {
+                  toolchain
+                },
+                defaultConfiguration: "development",
+                configurations
+              },
+              "format-readme": {
+                cache: true,
+                inputs: [
+                  "linting",
+                  "documentation",
+                  "rust",
+                  "^production"
+                ],
+                dependsOn: [
+                  "^format-readme"
+                ]
+              },
+              "format-toml": {
+                cache: true,
+                inputs: [
+                  "linting",
+                  "rust",
+                  "^production"
+                ],
+                dependsOn: [
+                  "^format-toml"
+                ]
+              },
+              "format-clippy": {
+                cache: true,
+                inputs: [
+                  "linting",
+                  "rust",
+                  "^production"
+                ],
+                dependsOn: [
+                  "^format-clippy"
+                ],
+                executor: "@storm-software/workspace-tools:cargo-clippy",
+                options: {
+                  toolchain,
+                  fix: true
+                },
+                defaultConfiguration: "development",
+                configurations
+              },
+              format: {
+                cache: true,
+                inputs: [
+                  "linting",
+                  "documentation",
+                  "rust",
+                  "^production"
+                ],
+                dependsOn: [
+                  "format-readme",
+                  "format-clippy",
+                  "format-toml",
+                  "^format"
+                ],
+                executor: "@storm-software/workspace-tools:cargo-format",
+                options: {
+                  toolchain,
+                  fix: true
+                },
+                defaultConfiguration: "development",
+                configurations
+              },
+              clean: {
+                cache: true,
+                inputs: [
+                  "rust",
+                  "^production"
+                ],
+                outputs: [
+                  `{workspaceRoot}/dist/target/{projectRoot}`
+                ],
+                executor: "nx:run-commands",
+                options: {
+                  command: `pnpm exec rimraf dist/target/crates/${cargoPackage.name}`,
+                  color: true,
+                  cwd: "{workspaceRoot}"
+                }
+              },
+              build: {
+                cache: true,
+                inputs: [
+                  "rust",
+                  "^production"
+                ],
+                dependsOn: [
+                  "build-base",
+                  "^build"
+                ],
+                executor: "@storm-software/workspace-tools:cargo-build",
+                outputs: [
+                  `{workspaceRoot}/dist/target/{projectRoot}`
+                ],
+                options: {
+                  toolchain
+                },
+                defaultConfiguration: "development",
+                configurations
+              },
+              rebuild: {
+                cache: false,
+                inputs: [
+                  "rust",
+                  "^production"
+                ],
+                dependsOn: [
+                  "clean",
+                  "^build"
+                ],
+                executor: "@storm-software/workspace-tools:cargo-build",
+                outputs: [
+                  `{workspaceRoot}/dist/target/{projectRoot}`
+                ],
+                options: {
+                  toolchain
+                },
+                defaultConfiguration: "development",
+                configurations
+              },
+              test: {
+                cache: true,
+                inputs: [
+                  "testing",
+                  "rust",
+                  "^production"
+                ],
+                dependsOn: [
+                  "build",
+                  "^test"
+                ],
+                executor: "@monodon/rust:test",
+                outputs: [
+                  "{options.target-dir}"
+                ],
+                options: {
+                  "target-dir": `{workspaceRoot}/dist/target/{projectRoot}`
+                },
+                defaultConfiguration: "development",
+                configurations
+              }
+            };
+            if (skipDocs != true) {
+              project.targets.docs = {
+                cache: true,
+                inputs: [
+                  "linting",
+                  "documentation",
+                  "default",
+                  "^production"
+                ],
+                dependsOn: [
+                  "format-readme",
+                  "lint-docs",
+                  "^docs"
+                ],
+                outputs: [
+                  `{workspaceRoot}/dist/docs/{projectRoot}`
+                ],
+                executor: "@storm-software/workspace-tools:cargo-doc",
+                options: {
+                  toolchain
+                },
+                defaultConfiguration: "production",
+                configurations
+              };
+            }
+            if (cargoPackage.publish === null || cargoPackage.publish === void 0 || cargoPackage.publish === true || Array.isArray(cargoPackage.publish) && cargoPackage.publish.length > 0) {
+              addProjectTag(project, ProjectTagConstants.Registry.TAG_ID, ProjectTagConstants.Registry.CARGO, {
+                overwrite: true
+              });
+              project.targets["nx-release-publish"] = {
+                cache: true,
+                inputs: [
+                  "linting",
+                  "testing",
+                  "documentation",
+                  "rust",
+                  "^production"
+                ],
+                dependsOn: [
+                  "build",
+                  "^nx-release-publish"
+                ],
+                executor: "@storm-software/workspace-tools:cargo-publish",
+                options: {
+                  packageRoot: root
+                },
+                defaultConfiguration: "production",
+                configurations
+              };
+            }
+            addProjectTag(project, ProjectTagConstants.Language.TAG_ID, ProjectTagConstants.Language.RUST, {
+              overwrite: true
+            });
+            setDefaultProjectTags(project, name);
+            projects[root] = {
+              ...project,
+              release: {
+                ...project.release,
+                version: {
+                  ...project.release?.version,
+                  generator: "@storm-software/workspace-tools:release-version"
+                }
+              }
+            };
+          }
+          for (const dep of cargoPackage.dependencies) {
+            if (isExternal(dep, context2.workspaceRoot)) {
+              const externalDepName = `cargo:${dep.name}`;
+              if (!externalNodes?.[externalDepName]) {
+                externalNodes[externalDepName] = {
+                  type: "cargo",
+                  name: externalDepName,
+                  data: {
+                    packageName: dep.name,
+                    version: cargoPackageMap.get(dep.name)?.version ?? "0.0.0"
+                  }
+                };
+              }
+            }
+          }
+        }
+        return {
+          projects,
+          externalNodes
+        };
+      } catch (e) {
+        console.error(DEFAULT_ERROR_MESSAGE);
+        console.error(e);
+        throw new Error(DEFAULT_ERROR_MESSAGE, {
+          cause: e
+        });
+      }
+    }, configFiles, options, context);
+  }
+];
+var createDependencies = /* @__PURE__ */ __name((_, context) => {
+  const metadata = cargoMetadata();
+  if (!metadata) {
+    return [];
+  }
+  const { packages: cargoPackages } = metadata;
+  const dependencies = [];
+  for (const pkg of cargoPackages) {
+    if (context.projects[pkg.name]) {
+      console.debug(`Local Cargo package found: ${pkg.name}`);
+      for (const deps of pkg.dependencies) {
+        if (!cargoPackages.find((p) => p.name === deps.name)) {
+          console.debug(`Dependency ${deps.name} not found in the cargo metadata.`);
+          continue;
+        }
+        if (context.projects[deps.name]) {
+          dependencies.push(createDependency(pkg, deps.name, DependencyType.static));
+        } else {
+          const externalDepName = `cargo:${deps.name}`;
+          if (externalDepName in (context.externalNodes ?? {})) {
+            dependencies.push(createDependency(pkg, externalDepName, DependencyType.static));
+          }
+        }
+      }
+    }
+  }
+  return dependencies;
+}, "createDependencies");
+function createDependency(pkg, depName, type) {
+  const target = pkg.manifest_path.replace(/\\/g, "/");
+  return {
+    type,
+    source: pkg.name,
+    target: depName,
+    sourceFile: target.replace(`${workspaceRoot.replace(/\\/g, "/")}/`, "")
+  };
+}
+__name(createDependency, "createDependency");
+
+export {
+  name,
+  description,
+  DefaultCargoPluginProfileMap,
+  DEFAULT_ERROR_MESSAGE,
+  createNodesV2,
+  createDependencies
+};