@storm-software/workspace-tools 1.269.0 → 1.270.0

package/src/executors/cargo-build/executor.ts

@@ -0,0 +1,28 @@
+import { ExecutorContext, PromiseExecutor } from "@nx/devkit";
+import { withRunExecutor } from "../../base/base-executor";
+import { buildCargoCommand, cargoCommand } from "../../utils/cargo";
+import { CargoBuildExecutorSchema } from "./schema.d";
+
+export async function cargoBuildExecutor(
+  options: CargoBuildExecutorSchema,
+  context: ExecutorContext,
+) {
+  const command = buildCargoCommand("build", options, context);
+  return await cargoCommand(...command);
+}
+
+export default withRunExecutor<CargoBuildExecutorSchema>(
+  "Cargo Build",
+  cargoBuildExecutor,
+  {
+    skipReadingConfig: false,
+    hooks: {
+      applyDefaultOptions: (options: CargoBuildExecutorSchema) => {
+        options.outputPath ??= "dist/target/{projectRoot}";
+        options.toolchain ??= "stable";
+
+        return options as CargoBuildExecutorSchema;
+      },
+    },
+  },
+) as PromiseExecutor<CargoBuildExecutorSchema>;

package/src/executors/cargo-build/untyped.ts

@@ -0,0 +1,18 @@
+import { defineUntypedSchema } from "untyped";
+import cargoBaseExecutorSchema from "../../base/cargo-base-executor.untyped";
+
+export default defineUntypedSchema({
+  ...cargoBaseExecutorSchema,
+  $schema: {
+    id: "CargoBuildExecutorSchema",
+    title: "Cargo Build Executor",
+    description: "A type definition for a Cargo/rust build executor schema",
+  },
+  outputPath: {
+    $schema: {
+      title: "Output Path",
+      type: "string",
+      description: "The path to the output directory",
+    },
+  },
+});

package/src/executors/cargo-check/executor.spec.ts

@@ -0,0 +1,18 @@
+import { ExecutorContext } from "@nx/devkit";
+
+import executor from "./executor";
+import { CargoCheckExecutorSchema } from "./schema.d";
+
+const options: CargoCheckExecutorSchema = {};
+const context: ExecutorContext = {
+  root: "",
+  cwd: process.cwd(),
+  isVerbose: false,
+};
+
+describe("CargoCheck Executor", () => {
+  it("can run", async () => {
+    const output = await executor(options, context);
+    expect(output.success).toBe(true);
+  });
+});

package/src/executors/cargo-check/executor.ts

@@ -0,0 +1,27 @@
+import { ExecutorContext, PromiseExecutor } from "@nx/devkit";
+import { withRunExecutor } from "../../base/base-executor";
+import { buildCargoCommand, cargoCommand } from "../../utils/cargo";
+import { CargoCheckExecutorSchema } from "./schema.d";
+
+export async function cargoCheckExecutor(
+  options: CargoCheckExecutorSchema,
+  context: ExecutorContext,
+) {
+  const command = buildCargoCommand("check", options, context);
+  return await cargoCommand(...command);
+}
+
+export default withRunExecutor<CargoCheckExecutorSchema>(
+  "Cargo Check",
+  cargoCheckExecutor,
+  {
+    skipReadingConfig: false,
+    hooks: {
+      applyDefaultOptions: (options: CargoCheckExecutorSchema) => {
+        options.toolchain ??= "stable";
+
+        return options as CargoCheckExecutorSchema;
+      },
+    },
+  },
+) as PromiseExecutor<CargoCheckExecutorSchema>;

package/src/executors/cargo-check/untyped.ts

@@ -0,0 +1,11 @@
+import { defineUntypedSchema } from "untyped";
+import cargoBaseExecutorSchema from "../../base/cargo-base-executor.untyped";
+
+export default defineUntypedSchema({
+  ...cargoBaseExecutorSchema,
+  $schema: {
+    id: "CargoCheckExecutorSchema",
+    title: "Cargo Check Executor",
+    description: "A type definition for a Cargo/rust check executor schema",
+  },
+});

package/src/executors/cargo-clippy/executor.spec.ts

@@ -0,0 +1,18 @@
+import { ExecutorContext } from "@nx/devkit";
+
+import executor from "./executor";
+import { CargoCheckExecutorSchema } from "./schema.d";
+
+const options: CargoCheckExecutorSchema = {};
+const context: ExecutorContext = {
+  root: "",
+  cwd: process.cwd(),
+  isVerbose: false,
+};
+
+describe("CargoCheck Executor", () => {
+  it("can run", async () => {
+    const output = await executor(options, context);
+    expect(output.success).toBe(true);
+  });
+});

package/src/executors/cargo-clippy/executor.ts

@@ -0,0 +1,28 @@
+import { ExecutorContext, PromiseExecutor } from "@nx/devkit";
+import { withRunExecutor } from "../../base/base-executor";
+import { buildCargoCommand, cargoCommand } from "../../utils/cargo";
+import { CargoClippyExecutorSchema } from "./schema.d";
+
+export async function cargoClippyExecutor(
+  options: CargoClippyExecutorSchema,
+  context: ExecutorContext,
+) {
+  const command = buildCargoCommand("clippy", options, context);
+  return await cargoCommand(...command);
+}
+
+export default withRunExecutor<CargoClippyExecutorSchema>(
+  "Cargo Clippy",
+  cargoClippyExecutor,
+  {
+    skipReadingConfig: false,
+    hooks: {
+      applyDefaultOptions: (options: CargoClippyExecutorSchema) => {
+        options.toolchain ??= "stable";
+        options.fix ??= false;
+
+        return options as CargoClippyExecutorSchema;
+      },
+    },
+  },
+) as PromiseExecutor<CargoClippyExecutorSchema>;

package/src/executors/cargo-clippy/untyped.ts

@@ -0,0 +1,18 @@
+import { defineUntypedSchema } from "untyped";
+import cargoBaseExecutorSchema from "../../base/cargo-base-executor.untyped";
+
+export default defineUntypedSchema({
+  ...cargoBaseExecutorSchema,
+  $schema: {
+    id: "CargoClippyExecutorSchema",
+    title: "Cargo Clippy Executor",
+    description: "A type definition for a Cargo/rust clippy executor schema",
+  },
+  fix: {
+    $schema: {
+      title: "Fix",
+      type: "boolean",
+      description: "Automatically fix issues",
+    },
+  },
+});

package/src/executors/cargo-doc/executor.spec.ts

@@ -0,0 +1,18 @@
+import { ExecutorContext } from "@nx/devkit";
+
+import executor from "./executor";
+import { CargoDocExecutorSchema } from "./schema.d";
+
+const options: CargoDocExecutorSchema = {};
+const context: ExecutorContext = {
+  root: "",
+  cwd: process.cwd(),
+  isVerbose: false,
+};
+
+describe("CargoDoc Executor", () => {
+  it("can run", async () => {
+    const output = await executor(options, context);
+    expect(output.success).toBe(true);
+  });
+});

package/src/executors/cargo-doc/executor.ts

@@ -0,0 +1,39 @@
+import { ExecutorContext, PromiseExecutor } from "@nx/devkit";
+import { withRunExecutor } from "../../base/base-executor";
+import { buildCargoCommand, cargoCommand } from "../../utils/cargo";
+import { CargoDocExecutorSchema } from "./schema.d";
+
+export async function cargoDocExecutor(
+  options: CargoDocExecutorSchema,
+  context: ExecutorContext,
+) {
+  const opts = { ...options };
+
+  opts["no-deps"] = opts.noDeps;
+  delete opts.noDeps;
+
+  const command = buildCargoCommand("doc", options, context);
+  return await cargoCommand(...command);
+}
+
+export default withRunExecutor<CargoDocExecutorSchema>(
+  "Cargo Doc",
+  cargoDocExecutor,
+  {
+    skipReadingConfig: false,
+    hooks: {
+      applyDefaultOptions: (options: CargoDocExecutorSchema) => {
+        options.outputPath ??= "dist/docs/{projectRoot}";
+        options.toolchain ??= "stable";
+        options.release ??= options.profile ? false : true;
+        options.allFeatures ??= true;
+        options.lib ??= true;
+        options.bins ??= true;
+        options.examples ??= true;
+        options.noDeps ??= false;
+
+        return options as CargoDocExecutorSchema;
+      },
+    },
+  },
+) as PromiseExecutor<CargoDocExecutorSchema>;

package/src/executors/cargo-doc/untyped.ts

@@ -0,0 +1,44 @@
+import { defineUntypedSchema } from "untyped";
+import cargoBaseExecutorSchema from "../../base/cargo-base-executor.untyped";
+
+export default defineUntypedSchema({
+  ...cargoBaseExecutorSchema,
+  $schema: {
+    id: "CargoDocExecutorSchema",
+    title: "Cargo Doc Executor",
+    description:
+      "A type definition for a Cargo/rust documentation executor schema",
+  },
+  lib: {
+    $schema: {
+      title: "Library",
+      type: "boolean",
+      description: "Generate documentation for the library",
+    },
+    default: true,
+  },
+  bins: {
+    $schema: {
+      title: "Bins",
+      type: "boolean",
+      description: "Generate documentation for the bins",
+    },
+    default: true,
+  },
+  examples: {
+    $schema: {
+      title: "Examples",
+      type: "boolean",
+      description: "Generate documentation for the examples",
+    },
+    default: true,
+  },
+  noDeps: {
+    $schema: {
+      title: "No Dependencies",
+      type: "boolean",
+      description: "Do not generate documentation for dependencies",
+    },
+    default: false,
+  },
+});

package/src/executors/cargo-format/executor.spec.ts

@@ -0,0 +1,18 @@
+import { ExecutorContext } from "@nx/devkit";
+
+import executor from "./executor";
+import { CargoCheckExecutorSchema } from "./schema.d";
+
+const options: CargoCheckExecutorSchema = {};
+const context: ExecutorContext = {
+  root: "",
+  cwd: process.cwd(),
+  isVerbose: false,
+};
+
+describe("CargoCheck Executor", () => {
+  it("can run", async () => {
+    const output = await executor(options, context);
+    expect(output.success).toBe(true);
+  });
+});

package/src/executors/cargo-format/executor.ts

@@ -0,0 +1,28 @@
+import { ExecutorContext, PromiseExecutor } from "@nx/devkit";
+import { withRunExecutor } from "../../base/base-executor";
+import { buildCargoCommand, cargoCommand } from "../../utils/cargo";
+import { CargoFormatExecutorSchema } from "./schema.d";
+
+export async function cargoFormatExecutor(
+  options: CargoFormatExecutorSchema,
+  context: ExecutorContext,
+) {
+  const command = buildCargoCommand("fmt", options, context);
+  return await cargoCommand(...command);
+}
+
+export default withRunExecutor<CargoFormatExecutorSchema>(
+  "Cargo Format",
+  cargoFormatExecutor,
+  {
+    skipReadingConfig: false,
+    hooks: {
+      applyDefaultOptions: (options: CargoFormatExecutorSchema) => {
+        options.outputPath ??= "dist/target/{projectRoot}";
+        options.toolchain ??= "stable";
+
+        return options as CargoFormatExecutorSchema;
+      },
+    },
+  },
+) as PromiseExecutor<CargoFormatExecutorSchema>;

package/src/executors/cargo-format/untyped.ts

@@ -0,0 +1,11 @@
+import { defineUntypedSchema } from "untyped";
+import cargoBaseExecutorSchema from "../../base/cargo-base-executor.untyped";
+
+export default defineUntypedSchema({
+  ...cargoBaseExecutorSchema,
+  $schema: {
+    id: "CargoFormatExecutorSchema",
+    title: "Cargo Format Executor",
+    description: "A type definition for a Cargo/rust format executor schema",
+  },
+});

package/src/executors/cargo-publish/executor.spec.ts

@@ -0,0 +1,11 @@
+// import { CargoReleasePublishExecutorSchema } from "./schema.d";
+// import executor from "./executor";
+
+// const options: CargoReleasePublishExecutorSchema = {};
+
+// describe("CargoReleasePublish Executor", () => {
+//   it("can run", async () => {
+//     const output = await executor(options);
+//     expect(output.success).toBe(true);
+//   });
+// });

package/src/executors/cargo-publish/executor.ts

@@ -0,0 +1,139 @@
+import { type ExecutorContext, joinPathFragments } from "@nx/devkit";
+import { execSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import https from "node:https";
+import { parseCargoToml } from "../../utils/toml";
+import type { CargoPublishExecutorSchema } from "./schema.d";
+
+const LARGE_BUFFER = 1024 * 1000000;
+
+export default async function runExecutor(
+  options: CargoPublishExecutorSchema,
+  context: ExecutorContext,
+) {
+  /**
+   * We need to check both the env var and the option because the executor may have been triggered
+   * indirectly via dependsOn, in which case the env var will be set, but the option will not.
+   */
+  const isDryRun = process.env.NX_DRY_RUN === "true" || options.dryRun || false;
+
+  if (!context.projectName) {
+    throw new Error("The executor requires a projectName.");
+  }
+
+  console.info(
+    `🚀  Running Storm Cargo Publish executor on the ${context.projectName} crate`,
+  );
+
+  if (
+    !context.projectName ||
+    !context.projectsConfigurations?.projects ||
+    !context.projectsConfigurations.projects[context.projectName] ||
+    !context.projectsConfigurations.projects[context.projectName]?.root
+  ) {
+    throw new Error("The executor requires projectsConfigurations.");
+  }
+
+  const registry = options.registry
+    ? options.registry
+    : process.env.STORM_REGISTRY_CARGO
+      ? process.env.STORM_REGISTRY_CARGO
+      : "https://crates.io";
+
+  const root =
+    context.projectsConfigurations.projects[context.projectName]?.root;
+  const packageRoot = joinPathFragments(
+    context.root,
+    (options.packageRoot ? options.packageRoot : root) as string,
+  );
+
+  const cargoToml = parseCargoToml(
+    readFileSync(joinPathFragments(packageRoot, "Cargo.toml"), "utf-8"),
+  );
+
+  try {
+    const result = await getRegistryVersion(
+      cargoToml.package.name,
+      cargoToml.package.version,
+      registry,
+    );
+    if (result) {
+      console.warn(
+        `Skipped package "${cargoToml.package.name}" from project "${context.projectName}" because v${cargoToml.package.version} already exists in ${registry} with tag "latest"`,
+      );
+
+      return {
+        success: true,
+      };
+    }
+  } catch (_: any) {
+    // Do nothing
+  }
+
+  const cargoPublishCommandSegments = [
+    `cargo publish --allow-dirty -p ${cargoToml.package.name}`,
+  ];
+  if (isDryRun) {
+    cargoPublishCommandSegments.push("--dry-run");
+  }
+
+  try {
+    const cargoPublishCommand = cargoPublishCommandSegments.join(" ");
+    console.log("");
+    console.log(`Running "${cargoPublishCommand}"...`);
+    console.log("");
+
+    execSync(cargoPublishCommand, {
+      maxBuffer: LARGE_BUFFER,
+      env: {
+        ...process.env,
+        FORCE_COLOR: "true",
+      },
+      cwd: packageRoot,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+
+    console.log("");
+
+    if (isDryRun) {
+      console.log(`Would publish to ${registry}, but [dry-run] was set`);
+    } else {
+      console.log(`Published to ${registry}`);
+    }
+
+    return {
+      success: true,
+    };
+  } catch (error: any) {
+    console.error(`Failed to publish to ${registry}`);
+    console.error(error);
+    console.log("");
+
+    return {
+      success: false,
+    };
+  }
+}
+
+export const getRegistryVersion = (
+  name: string,
+  version: string,
+  registry: string,
+): Promise<string> => {
+  return new Promise((resolve: (value: string) => void) =>
+    https
+      .get(
+        `${registry}/api/v1/crates/${encodeURIComponent(name)}/${encodeURIComponent(
+          version,
+        )}`,
+        (res) => {
+          res.on("data", (d) => {
+            resolve(d);
+          });
+        },
+      )
+      .on("error", (e) => {
+        throw e;
+      }),
+  );
+};

package/src/executors/cargo-publish/untyped.ts

@@ -0,0 +1,33 @@
+import { defineUntypedSchema } from "untyped";
+import cargoBaseExecutorSchema from "../../base/cargo-base-executor.untyped";
+
+export default defineUntypedSchema({
+  ...cargoBaseExecutorSchema,
+  $schema: {
+    id: "CargoPublishExecutorSchema",
+    title: "Cargo Publish Executor",
+    description: "A type definition for a Cargo/rust Publish executor schema",
+  },
+  registry: {
+    $schema: {
+      title: "Registry",
+      type: "string",
+      description: "The registry to publish to",
+    },
+  },
+  packageRoot: {
+    $schema: {
+      title: "Package Root",
+      type: "string",
+      format: "path",
+      description: "The path to the package root",
+    },
+  },
+  dryRun: {
+    $schema: {
+      title: "Dry Run",
+      type: "boolean",
+      description: "Perform a dry run",
+    },
+  },
+});

package/src/executors/clean-package/constants.ts

@@ -0,0 +1,99 @@
+export const IGNORE_FILES = [
+  ".circleci",
+  ".DS_Store",
+  ".editorconfig",
+  ".eslintignore",
+  ".flowconfig",
+  ".git",
+  ".github",
+  ".travis.yml",
+  ".vscode",
+  ".watchmanconfig",
+  ".yarnrc",
+  "appveyor.yml",
+  "karma.conf.js",
+  "node_modules",
+  "package-lock.json",
+  "pnpm-debug.log",
+  "pnpm-lock.yaml",
+  ".devcontainer.json",
+  "test",
+  "yarn-error.log",
+  "yarn.lock",
+  /^(babel|commitlint|jest|vitest)\.config\.[cm]?(j|t)s$/,
+  /^\.?nano-staged\.(c|m)?js(on)?$/,
+  /^\.?simple-git-hooks.js(on)?$/,
+  /^\.?simple-pre-commit.js(on)?$/,
+  /^\.babelrc/,
+  /^\.clean-publish/,
+  /^\.commitlintrc/,
+  /^\.eslintrc/,
+  /^\.jsconfig/,
+  /^\.jsdocrc/,
+  /^\.lintstagedrc/,
+  /^\.nanostagedrc/,
+  /^\.prettierrc/,
+  /^\.remarkrc/,
+  /^\.renovaterc/,
+  /^\.size-limit/,
+  /^\.yaspellerrc/,
+  /^changelog/i,
+  /eslint.config.(c|m)?js/,
+  /README\.[\w-]+\.md/,
+];
+
+export const IGNORE_FIELDS = [
+  "babel",
+  "browserslist",
+  "c8",
+  "clean-publish",
+  "commitlint",
+  "devDependencies",
+  "eslintConfig",
+  "eslintIgnore",
+  "husky",
+  "jest",
+  "lint-staged",
+  "nano-staged",
+  "pre-commit",
+  "prettier",
+  "pwmetrics",
+  "remarkConfig",
+  "renovate",
+  "resolutions",
+  "sharec",
+  "simple-git-hooks",
+  "simple-pre-commit",
+  "size-limit",
+  "typeCoverage",
+  "yaspeller",
+];
+
+export const NPM_SCRIPTS = [
+  "postinstall",
+  "postpack",
+  "postpublish",
+  "postversion",
+  "prepublish",
+  "publish",
+  "uninstall",
+  "version",
+];
+
+// https://pnpm.io/package_json#publishconfig
+export const PUBLISH_CONFIG_FIELDS = [
+  "bin",
+  "main",
+  "exports",
+  "types",
+  "typings",
+  "module",
+  "browser",
+  "esnext",
+  "es2015",
+  "unpkg",
+  "umd:main",
+  "typesVersions",
+  "cpu",
+  "os",
+];

package/src/executors/clean-package/executor.spec.ts

@@ -0,0 +1,18 @@
+import { ExecutorContext } from "@nx/devkit";
+
+import executor from "./executor";
+import { CleanPublishExecutorSchema } from "./schema.d";
+
+const options: CleanPublishExecutorSchema = {};
+const context: ExecutorContext = {
+  root: "",
+  cwd: process.cwd(),
+  isVerbose: false,
+};
+
+describe("CleanPublish Executor", () => {
+  it("can run", async () => {
+    const output = await executor(options, context);
+    expect(output.success).toBe(true);
+  });
+});