@storm-software/workspace-tools 1.269.0 → 1.270.0

package/src/generators/release-version/untyped.ts

@@ -0,0 +1,156 @@
+import { defineUntypedSchema } from "untyped";
+
+export default defineUntypedSchema({
+  $schema: {
+    id: "ReleaseVersionGeneratorSchema",
+    title: "Release Version Generator",
+    description: "A type definition for a release version generator schema",
+    required: ["projects", "releaseGroup", "projectGraph", "specifier"]
+  },
+  projects: {
+    $schema: {
+      title: "Projects",
+      type: "array",
+      items: {
+        type: "object"
+      },
+      description: "The projects to release"
+    }
+  },
+  releaseGroup: {
+    $schema: {
+      title: "Release Group",
+      type: "object",
+      description: "The release group"
+    }
+  },
+  projectGraph: {
+    $schema: {
+      title: "Project Graph",
+      type: "object",
+      description: "The project graph"
+    }
+  },
+  specifier: {
+    $schema: {
+      title: "Specifier",
+      type: "string",
+      description: "The specifier"
+    }
+  },
+  specifierSource: {
+    $schema: {
+      title: "Specifier Source",
+      type: "string",
+      description: "The specifier source"
+    }
+  },
+  preid: {
+    $schema: {
+      title: "Preid",
+      type: "string",
+      description: "The preid"
+    }
+  },
+  packageRoot: {
+    $schema: {
+      title: "Package Root",
+      type: "string",
+      description: "The package root"
+    }
+  },
+  currentVersionResolver: {
+    $schema: {
+      title: "Current Version Resolver",
+      type: "string",
+      description: "The current version resolver"
+    },
+    $default: "git-tag"
+  },
+  currentVersionResolverMetadata: {
+    $schema: {
+      title: "Current Version Resolver Metadata",
+      type: "object",
+      description: "The current version resolver metadata"
+    }
+  },
+  fallbackCurrentVersionResolver: {
+    $schema: {
+      title: "Fallback Current Version Resolver",
+      type: "string",
+      description: "The fallback current version resolver"
+    },
+    $default: "disk"
+  },
+  firstRelease: {
+    $schema: {
+      title: "First Release",
+      type: "boolean",
+      description: "Release the first version"
+    }
+  },
+  versionPrefix: {
+    $schema: {
+      title: "Version Prefix",
+      type: "string",
+      description: "The version prefix",
+      enum: ["", "auto", "~", "^", "="]
+    }
+  },
+  skipLockFileUpdate: {
+    $schema: {
+      title: "Skip Lock File Update",
+      type: "boolean",
+      description: "Skip lock file update"
+    }
+  },
+  installArgs: {
+    $schema: {
+      title: "Install Args",
+      type: "string",
+      description: "The install arguments"
+    }
+  },
+  installIgnoreScripts: {
+    $schema: {
+      title: "Install Ignore Scripts",
+      type: "boolean",
+      description: "Ignore scripts"
+    }
+  },
+  conventionalCommitsConfig: {
+    $schema: {
+      title: "Conventional Commits Config",
+      type: "object",
+      description: "The conventional commits config"
+    }
+  },
+  deleteVersionPlans: {
+    $schema: {
+      title: "Delete Version Plans",
+      type: "boolean",
+      description: "Delete version plans"
+    }
+  },
+  updateDependents: {
+    $schema: {
+      title: "Update Dependents",
+      type: "string",
+      description: "Update dependents"
+    }
+  },
+  logUnchangedProjects: {
+    $schema: {
+      title: "Log Unchanged Projects",
+      type: "boolean",
+      description: "Log unchanged projects"
+    }
+  },
+  preserveLocalDependencyProtocols: {
+    $schema: {
+      title: "Preserve Local Dependency Protocols",
+      type: "boolean",
+      description: "Preserve local dependency protocols"
+    }
+  }
+});

package/src/plugins/rust/cargo-toml.ts

@@ -0,0 +1,434 @@
+import {
+  createNodesFromFiles,
+  CreateNodesResultV2,
+  CreateNodesV2,
+  joinPathFragments,
+  readJsonFile,
+  workspaceRoot,
+  type CreateDependencies,
+  type ProjectConfiguration,
+  type RawProjectGraphDependency
+} from "@nx/devkit";
+import { existsSync } from "node:fs";
+import { dirname } from "node:path";
+import {
+  DependencyType,
+  type ProjectGraphExternalNode
+} from "nx/src/config/project-graph";
+import { cargoMetadata, isExternal } from "../../utils/cargo";
+import {
+  addProjectTag,
+  ProjectTagConstants,
+  setDefaultProjectTags
+} from "../../utils/project-tags";
+import type { Package } from "../../utils/toml";
+
+export const name = "storm-software/rust";
+export const description = "Plugin for parsing Cargo.toml files";
+
+export type CargoPluginProfileMap = Record<string, string> & {
+  development?: string;
+  production?: string;
+};
+export const DefaultCargoPluginProfileMap = {
+  development: "dev",
+  production: "prod"
+};
+
+export const DEFAULT_ERROR_MESSAGE =
+  "An error occurred in the Storm Rust Nx plugin.";
+
+export interface CargoPluginOptions {
+  includeApps?: boolean;
+  skipDocs?: boolean;
+  toolchain?: "stable" | "beta" | "nightly";
+  profiles?: CargoPluginProfileMap;
+}
+
+export const createNodesV2: CreateNodesV2<CargoPluginOptions | undefined> = [
+  "*/**/Cargo.toml",
+  async (configFiles, options, context): Promise<CreateNodesResultV2> => {
+    return await createNodesFromFiles(
+      (configFile, options, context) => {
+        try {
+          console.log(`Processing Cargo.toml file: ${configFile}`);
+
+          const profiles = options?.profiles ?? {};
+          const includeApps = options?.includeApps ?? true;
+          const toolchain = options?.toolchain;
+          const skipDocs = options?.skipDocs ?? false;
+
+          const metadata = cargoMetadata();
+          if (!metadata) {
+            return {};
+          }
+
+          const { packages: cargoPackages } = metadata;
+
+          const externalNodes: Record<string, ProjectGraphExternalNode> = {};
+          const projects: Record<string, ProjectConfiguration> = {};
+
+          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;
+          }, new Map<string, Package>());
+
+          for (const cargoPackage of cargoPackages) {
+            if (!isExternal(cargoPackage, context.workspaceRoot)) {
+              const root = dirname(configFile);
+
+              const project: ProjectConfiguration = {
+                root,
+                name: cargoPackage.name
+              };
+              if (existsSync(joinPathFragments(root, "project.json"))) {
+                const projectJson = readJsonFile<ProjectConfiguration>(
+                  joinPathFragments(root, "project.json")
+                );
+                if (projectJson) {
+                  Object.keys(projectJson).forEach(key => {
+                    if (!project[key]) {
+                      project[key] = projectJson[key];
+                    }
+                  });
+                }
+              }
+
+              // If the project is an application and we don't want to include apps, skip it
+              if (
+                includeApps === false &&
+                project.projectType === "application"
+              ) {
+                continue;
+              }
+
+              project.targets = {
+                "lint-markdown": {
+                  cache: true,
+                  outputs: ["{projectRoot}/**/*.md", "{projectRoot}/**/*.mdx"],
+                  inputs: [
+                    "linting",
+                    "{projectRoot}/**/*.md",
+                    "{projectRoot}/**/*.mdx"
+                  ],
+                  dependsOn: ["^lint-markdown"],
+                  executor: "nx:run-commands",
+                  options: {
+                    command:
+                      'pnpm exec markdownlint-cli2 "{projectRoot}/*.{md,mdx}" "{projectRoot}/**/*.{md,mdx}" --config "node_modules/@storm-software/markdownlint/config/base.markdownlint-cli2.jsonc" --fix'
+                  }
+                },
+                "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-ls", "lint-markdown", "^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",
+                    "{projectRoot}/{README.md,package.json,Cargo.toml,executors.json,generators.json}"
+                  ],
+                  outputs: ["{projectRoot}/README.md"],
+                  dependsOn: ["^format-readme"],
+                  executor: "nx:run-commands",
+                  options: {
+                    command:
+                      'pnpm exec storm-git readme --templates="tools/readme-templates" --project="{projectName}"'
+                  }
+                },
+                "format-toml": {
+                  cache: true,
+                  inputs: ["linting", "{projectRoot}/**/*.toml"],
+                  outputs: ["{projectRoot}/**/*.toml"],
+                  dependsOn: ["^format-toml"],
+                  executor: "nx:run-commands",
+                  options: {
+                    command:
+                      'pnpm exec taplo format --config="node_modules/@storm-software/linting-tools/taplo/config.toml" --cache-path="node_modules/.cache/taplo/{projectRoot}" --colors="always" "{projectRoot}/*.toml" "{projectRoot}/**/*.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: 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: 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: toolchain
+                  },
+                  defaultConfiguration: "production",
+                  configurations
+                };
+              }
+
+              if (
+                cargoPackage.publish === null ||
+                cargoPackage.publish === undefined ||
+                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, context.workspaceRoot)) {
+                const externalDepName = `cargo:${dep.name}`;
+                if (!externalNodes?.[externalDepName]) {
+                  externalNodes[externalDepName] = {
+                    type: "cargo" as any,
+                    name: externalDepName as any,
+                    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
+    );
+  }
+];
+
+export const createDependencies: CreateDependencies = (_, context) => {
+  const metadata = cargoMetadata();
+  if (!metadata) {
+    return [];
+  }
+
+  const { packages: cargoPackages } = metadata;
+  const dependencies: RawProjectGraphDependency[] = [];
+
+  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 the dependency is listed in nx projects, it's not an external dependency
+        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;
+};
+
+function createDependency(
+  pkg: Package,
+  depName: string,
+  type: DependencyType
+): RawProjectGraphDependency {
+  const target = pkg.manifest_path.replace(/\\/g, "/");
+
+  return {
+    type,
+    source: pkg.name,
+    target: depName,
+    sourceFile: target.replace(`${workspaceRoot.replace(/\\/g, "/")}/`, "")
+  };
+}

package/src/plugins/rust/index.ts

@@ -0,0 +1 @@
+export * from "./cargo-toml";

package/src/plugins/typescript/index.ts

@@ -0,0 +1 @@
+export * from "./project-config";