@joshmossas/nx-cargo 0.6.2

package/.babelrc

@@ -0,0 +1,3 @@
+{
+	"presets": [["@nx/js/babel", { "useBuiltIns": "usage" }]]
+}

package/.eslintrc.json

@@ -0,0 +1,34 @@
+{
+	"extends": ["../../.eslintrc.json"],
+	"ignorePatterns": ["!**/*"],
+	"overrides": [
+		{
+			"files": ["*.ts", "*.tsx", "*.js", "*.jsx"],
+			"rules": {
+				"@typescript-eslint/no-explicit-any": "off"
+			}
+		},
+		{
+			"files": ["*.ts", "*.tsx"],
+			"rules": {}
+		},
+		{
+			"files": ["*.js", "*.jsx"],
+			"rules": {}
+		},
+		{
+			"files": ["*.json"],
+			"parser": "jsonc-eslint-parser",
+			"rules": {
+				"@nx/dependency-checks": "error"
+			}
+		},
+		{
+			"files": ["./package.json", "./executors.json"],
+			"parser": "jsonc-eslint-parser",
+			"rules": {
+				"@nx/nx-plugin-checks": "error"
+			}
+		}
+	]
+}

package/README.md

@@ -0,0 +1,39 @@
+# @nxrs/cargo
+
+[![npm version](https://badge.fury.io/js/%40nxrs%2Fcargo.svg)](https://badge.fury.io/js/%40nxrs%2Fcargo)
+
+This is a WIP plugin for `@nrwl/nx` adding support for Rust applications and libraries.
+
+## Generators
+
+```sh
+# @nxrs/cargo:bin also works
+> nx generate @nxrs/cargo:app my-rust-app
+```
+
+```sh
+> nx generate @nxrs/cargo:lib my-rust-lib
+```
+
+## Executors
+
+```sh
+# Build a library or binary
+> nx build my-rust-app
+
+# Run unit tests in a library
+> nx test my-rust-lib
+
+# Check a Rust project with `clippy`
+> nx lint my-rust-app
+# Don't fail on warnings:
+> nx lint my-rust-app --fail-on-warnings false
+```
+
+### Options
+
+The executors accept most of the same CLI args as the corresponding `cargo` commands. When in doubt, run with the `--help` flag to see all options with descriptions:
+
+```sh
+> nx build my-rust-app --help
+```

package/build.config.ts

@@ -0,0 +1,10 @@
+import { defineBuildConfig } from "unbuild";
+
+export default defineBuildConfig({
+	entries: ["src/index.ts"],
+	outDir: "dist",
+  declaration: true,
+  rollup: {
+    emitCJS: true,
+  }
+});

package/dist/index.cjs

@@ -0,0 +1,100 @@
+'use strict';
+
+const devkit = require('@nx/devkit');
+const fs = require('node:fs');
+const cp = require('node:child_process');
+const os = require('node:os');
+const path = require('node:path');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+function _interopNamespaceCompat(e) {
+	if (e && typeof e === 'object' && 'default' in e) return e;
+	const n = Object.create(null);
+	if (e) {
+		for (const k in e) {
+			n[k] = e[k];
+		}
+	}
+	n.default = e;
+	return n;
+}
+
+const fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+const cp__namespace = /*#__PURE__*/_interopNamespaceCompat(cp);
+const os__namespace = /*#__PURE__*/_interopNamespaceCompat(os);
+const path__namespace = /*#__PURE__*/_interopNamespaceCompat(path);
+
+function createDependencies(_, ctx) {
+  const allDependencies = [];
+  const processedWorkspaceRoots = /* @__PURE__ */ new Set();
+  const cargoConfigPaths = Object.values(ctx.projects).map((p) => path__namespace.join(ctx.workspaceRoot, p.root, "Cargo.toml")).filter((p) => fs__default.existsSync(p));
+  for (const configPath of cargoConfigPaths) {
+    const configDir = path__namespace.dirname(configPath);
+    const metadata = getCargoMetadata(configDir);
+    if (processedWorkspaceRoots.has(metadata.workspace_root)) {
+      continue;
+    }
+    processedWorkspaceRoots.add(metadata.workspace_root);
+    const workspaceDeps = processWorkspaceMetadata(ctx, metadata);
+    allDependencies.push(...workspaceDeps);
+  }
+  return allDependencies;
+}
+function processWorkspaceMetadata(ctx, metadata) {
+  const {
+    packages,
+    workspace_members: cargoWsMembers,
+    resolve: cargoResolve
+  } = metadata;
+  const workspacePackages = /* @__PURE__ */ new Map();
+  for (const id of cargoWsMembers) {
+    const pkg = packages.find((p) => p.id === id);
+    if (pkg) workspacePackages.set(id, pkg);
+  }
+  const nxData = mapCargoProjects(ctx, workspacePackages);
+  return cargoResolve.nodes.filter(({ id }) => nxData.has(id)).flatMap(({ id: sourceId, dependencies }) => {
+    const sourceProject = nxData.get(sourceId);
+    const cargoPackage = workspacePackages.get(sourceId);
+    const sourceManifest = path__namespace.relative(ctx.workspaceRoot, cargoPackage.manifest_path).replace(/\\/g, "/");
+    return dependencies.filter((depId) => nxData.has(depId)).map((depId) => ({
+      source: sourceProject.name,
+      target: nxData.get(depId).name,
+      type: devkit.DependencyType.static,
+      sourceFile: sourceManifest
+    }));
+  });
+}
+function getCargoMetadata(cwd) {
+  const availableMemory = os__namespace.freemem();
+  const metadata = cp__namespace.execSync("cargo metadata --format-version=1", {
+    encoding: "utf8",
+    maxBuffer: availableMemory,
+    cwd
+    // Crucial: run in the workspace directory
+  });
+  return JSON.parse(metadata);
+}
+function mapCargoProjects(ctx, packages) {
+  let result = /* @__PURE__ */ new Map();
+  for (let [cargoId, cargoPackage] of packages) {
+    if (!cargoPackage.manifest_path) {
+      throw new Error("Expected cargo package's `manifest_path` to exist");
+    }
+    let manifestDir = path__namespace.dirname(cargoPackage.manifest_path);
+    let projectDir = path__namespace.relative(ctx.workspaceRoot, manifestDir).replace(/\\/g, "/");
+    let found = Object.entries(ctx.projects).find(
+      ([, config]) => config.root === projectDir
+    );
+    if (found) {
+      let [projectName, projectConfig] = found;
+      result.set(cargoId, {
+        ...projectConfig,
+        name: projectName
+      });
+    }
+  }
+  return result;
+}
+
+exports.createDependencies = createDependencies;

package/dist/index.d.cts

@@ -0,0 +1,5 @@
+import { CreateDependenciesContext, RawProjectGraphDependency } from '@nx/devkit';
+
+declare function createDependencies(_: unknown, ctx: CreateDependenciesContext): RawProjectGraphDependency[];
+
+export { createDependencies };

package/dist/index.d.mts

@@ -0,0 +1,5 @@
+import { CreateDependenciesContext, RawProjectGraphDependency } from '@nx/devkit';
+
+declare function createDependencies(_: unknown, ctx: CreateDependenciesContext): RawProjectGraphDependency[];
+
+export { createDependencies };

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import { CreateDependenciesContext, RawProjectGraphDependency } from '@nx/devkit';
+
+declare function createDependencies(_: unknown, ctx: CreateDependenciesContext): RawProjectGraphDependency[];
+
+export { createDependencies };

package/dist/index.mjs

@@ -0,0 +1,79 @@
+import { DependencyType } from '@nx/devkit';
+import fs from 'node:fs';
+import * as cp from 'node:child_process';
+import * as os from 'node:os';
+import * as path from 'node:path';
+
+function createDependencies(_, ctx) {
+  const allDependencies = [];
+  const processedWorkspaceRoots = /* @__PURE__ */ new Set();
+  const cargoConfigPaths = Object.values(ctx.projects).map((p) => path.join(ctx.workspaceRoot, p.root, "Cargo.toml")).filter((p) => fs.existsSync(p));
+  for (const configPath of cargoConfigPaths) {
+    const configDir = path.dirname(configPath);
+    const metadata = getCargoMetadata(configDir);
+    if (processedWorkspaceRoots.has(metadata.workspace_root)) {
+      continue;
+    }
+    processedWorkspaceRoots.add(metadata.workspace_root);
+    const workspaceDeps = processWorkspaceMetadata(ctx, metadata);
+    allDependencies.push(...workspaceDeps);
+  }
+  return allDependencies;
+}
+function processWorkspaceMetadata(ctx, metadata) {
+  const {
+    packages,
+    workspace_members: cargoWsMembers,
+    resolve: cargoResolve
+  } = metadata;
+  const workspacePackages = /* @__PURE__ */ new Map();
+  for (const id of cargoWsMembers) {
+    const pkg = packages.find((p) => p.id === id);
+    if (pkg) workspacePackages.set(id, pkg);
+  }
+  const nxData = mapCargoProjects(ctx, workspacePackages);
+  return cargoResolve.nodes.filter(({ id }) => nxData.has(id)).flatMap(({ id: sourceId, dependencies }) => {
+    const sourceProject = nxData.get(sourceId);
+    const cargoPackage = workspacePackages.get(sourceId);
+    const sourceManifest = path.relative(ctx.workspaceRoot, cargoPackage.manifest_path).replace(/\\/g, "/");
+    return dependencies.filter((depId) => nxData.has(depId)).map((depId) => ({
+      source: sourceProject.name,
+      target: nxData.get(depId).name,
+      type: DependencyType.static,
+      sourceFile: sourceManifest
+    }));
+  });
+}
+function getCargoMetadata(cwd) {
+  const availableMemory = os.freemem();
+  const metadata = cp.execSync("cargo metadata --format-version=1", {
+    encoding: "utf8",
+    maxBuffer: availableMemory,
+    cwd
+    // Crucial: run in the workspace directory
+  });
+  return JSON.parse(metadata);
+}
+function mapCargoProjects(ctx, packages) {
+  let result = /* @__PURE__ */ new Map();
+  for (let [cargoId, cargoPackage] of packages) {
+    if (!cargoPackage.manifest_path) {
+      throw new Error("Expected cargo package's `manifest_path` to exist");
+    }
+    let manifestDir = path.dirname(cargoPackage.manifest_path);
+    let projectDir = path.relative(ctx.workspaceRoot, manifestDir).replace(/\\/g, "/");
+    let found = Object.entries(ctx.projects).find(
+      ([, config]) => config.root === projectDir
+    );
+    if (found) {
+      let [projectName, projectConfig] = found;
+      result.set(cargoId, {
+        ...projectConfig,
+        name: projectName
+      });
+    }
+  }
+  return result;
+}
+
+export { createDependencies };

package/executors.json

@@ -0,0 +1,25 @@
+{
+	"$schema": "http://json-schema.org/schema",
+	"executors": {
+		"build": {
+			"implementation": "./src/executors/build/executor",
+			"schema": "./src/executors/build/schema.json",
+			"description": "Build a Cargo project"
+		},
+		"run": {
+			"implementation": "./src/executors/run/executor",
+			"schema": "./src/executors/run/schema.json",
+			"description": "Run a Cargo executable"
+		},
+		"test": {
+			"implementation": "./src/executors/test/executor",
+			"schema": "./src/executors/test/schema.json",
+			"description": "Run unit tests"
+		},
+		"clippy": {
+			"implementation": "./src/executors/clippy/executor",
+			"schema": "./src/executors/clippy/schema.json",
+			"description": "Linter for Rust code"
+		}
+	}
+}

package/generators.json

@@ -0,0 +1,25 @@
+{
+	"$schema": "http://json-schema.org/schema",
+	"name": "cargo",
+	"version": "0.0.1",
+	"generators": {
+		"init": {
+			"factory": "./src/generators/init/generator",
+			"schema": "./src/generators/init/schema.json",
+			"description": "Initialize the @nxrs/cargo plugin",
+			"hidden": true
+		},
+		"binary": {
+			"factory": "./src/generators/binary/generator",
+			"schema": "./src/generators/binary/schema.json",
+			"description": "Create a Rust binary",
+			"aliases": ["bin", "app", "application"]
+		},
+		"library": {
+			"factory": "./src/generators/library/generator",
+			"schema": "./src/generators/library/schema.json",
+			"description": "Create a Rust library",
+			"aliases": ["lib"]
+		}
+	}
+}

package/jest.config.ts

@@ -0,0 +1,17 @@
+/* eslint-disable */
+export default {
+	displayName: "cargo",
+	preset: "../../jest.preset.js",
+	globals: {},
+	testEnvironment: "node",
+	transform: {
+		"^.+\\.[tj]sx?$": [
+			"ts-jest",
+			{
+				tsconfig: "<rootDir>/tsconfig.spec.json",
+			},
+		],
+	},
+	moduleFileExtensions: ["ts", "tsx", "js", "jsx"],
+	coverageDirectory: "../../coverage/packages/cargo",
+};

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@joshmossas/nx-cargo",
+  "private": false,
+  "version": "0.6.2",
+  "license": "MIT",
+  "main": "dist/index.mjs",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nxrs/cargo.git"
+  },
+  "author": {
+    "name": "Danny McGee",
+    "email": "dannymcgee@gmail.com",
+    "url": "https://github.com/dannymcgee"
+  },
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "lodash": "^4.17.21",
+    "tslib": "^2.0.0"
+  },
+  "peerDependencies": {
+    "@nx/devkit": ">= 17"
+  },
+  "devDependencies": {
+    "unbuild": "^3.6.1"
+  },
+  "scripts": {
+    "build": "unbuild"
+  }
+}

package/project.json

@@ -0,0 +1,53 @@
+{
+	"$schema": "../../node_modules/nx/schemas/project-schema.json",
+	"name": "cargo",
+	"projectType": "library",
+	"sourceRoot": "packages/cargo/src",
+	"tags": [],
+	"targets": {
+		"lint": {
+			"executor": "@nx/eslint:lint",
+			"outputs": ["{options.outputFile}"]
+		},
+		"test": {
+			"executor": "@nx/jest:jest",
+			"outputs": ["{workspaceRoot}/coverage/packages/cargo"],
+			"options": {
+				"jestConfig": "packages/cargo/jest.config.ts"
+			}
+		},
+		"build": {
+			"executor": "@nx/js:tsc",
+			"outputs": ["{options.outputPath}"],
+			"options": {
+				"outputPath": "dist/packages/cargo",
+				"tsConfig": "packages/cargo/tsconfig.lib.json",
+				"packageJson": "packages/cargo/package.json",
+				"main": "packages/cargo/src/index.ts",
+				"assets": [
+					"packages/cargo/*.md",
+					{
+						"input": "./packages/cargo/src",
+						"glob": "**/!(*.ts)",
+						"output": "./src"
+					},
+					{
+						"input": "./packages/cargo/src",
+						"glob": "**/*.d.ts",
+						"output": "./src"
+					},
+					{
+						"input": "./packages/cargo",
+						"glob": "generators.json",
+						"output": "."
+					},
+					{
+						"input": "./packages/cargo",
+						"glob": "executors.json",
+						"output": "."
+					}
+				]
+			}
+		}
+	}
+}

package/src/common/index.spec.ts

@@ -0,0 +1,183 @@
+import { ExecutorContext, Tree } from "@nx/devkit";
+import { createTreeWithEmptyWorkspace } from "@nx/devkit/testing";
+
+import ClippyCliOptions from "../executors/clippy/schema";
+import {
+	CargoOptions,
+	normalizeGeneratorOptions,
+	parseCargoArgs,
+	Target,
+} from "./index";
+
+describe("common utils", () => {
+	describe("parseCargoArgs", () => {
+		it("should support --target argument", () => {
+			let ctx = mockExecutorContext("test-app:build");
+			let opts: CargoOptions = {
+				target: "86_64-pc-windows-gnu",
+			};
+			let [args] = parseCargoArgs(Target.Build, opts, ctx);
+			args.unshift("cargo");
+
+			expect(args.join(" ")).toEqual(
+				"cargo build --bin test-app --target 86_64-pc-windows-gnu"
+			);
+		});
+
+		it("should support --package argument", () => {
+			let ctx = mockExecutorContext("test-app:build");
+			let opts: CargoOptions = {
+				package: "foo",
+			};
+
+			let args = ["cargo", ...parseCargoArgs(Target.Build, opts, ctx)[0]];
+			expect(args.join(" ")).toEqual("cargo build --bin foo");
+
+			args = ["cargo", ...parseCargoArgs(Target.Test, opts, ctx)[0]];
+			expect(args.join(" ")).toEqual("cargo test -p foo");
+
+			args = ["cargo", ...parseCargoArgs(Target.Run, opts, ctx)[0]];
+			expect(args.join(" ")).toEqual("cargo run -p foo");
+
+			args = ["cargo", ...parseCargoArgs(Target.Clippy, opts, ctx)[0]];
+			expect(args.join(" ")).toEqual(
+				"cargo clippy -p foo -- -D warnings --no-deps"
+			);
+		});
+
+		it("should ignore the Nx-config-specified target name", () => {
+			let ctx = mockExecutorContext("test-app:flooptydoopty");
+			let opts: CargoOptions = {};
+			let args = ["cargo", ...parseCargoArgs(Target.Build, opts, ctx)[0]];
+
+			expect(args.join(" ")).toEqual("cargo build --bin test-app");
+		});
+
+		it("should correctly handle `release` option", () => {
+			let ctx = mockExecutorContext("test-app:build");
+
+			let args = ["cargo", ...parseCargoArgs(Target.Build, { release: false }, ctx)[0]];
+			expect(args.join(" ")).toEqual("cargo build --bin test-app");
+
+			args = ["cargo", ...parseCargoArgs(Target.Build, { release: true }, ctx)[0]];
+			expect(args.join(" ")).toEqual("cargo build --bin test-app --profile release");
+		});
+
+		it("should pass through unknown arguments to cargo", () => {
+			let ctx = mockExecutorContext("test-app:build");
+
+			let opts: CargoOptions & { [key: string]: string } = {
+				profile: "dev-custom",
+			};
+			let args = ["cargo", ...parseCargoArgs(Target.Build, opts, ctx)[0]];
+
+			expect(args.join(" ")).toEqual(
+				"cargo build --bin test-app --profile dev-custom",
+			);
+
+			opts = { unknownArg: "lorem-ipsum" };
+			args = ["cargo", ...parseCargoArgs(Target.Build, opts, ctx)[0]];
+
+			expect(args.join(" ")).toEqual(
+				"cargo build --bin test-app --unknown-arg lorem-ipsum",
+			);
+		});
+
+		it("allows specifying a custom binary target", () => {
+			let ctx = mockExecutorContext("test-app:build");
+
+			let opts: CargoOptions = {
+				bin: "custom-bin-name",
+			};
+			let args = ["cargo", ...parseCargoArgs(Target.Build, opts, ctx)[0]];
+
+			expect(args.join(" ")).toEqual(
+				"cargo build -p test-app --bin custom-bin-name",
+			);
+		});
+
+		it("correctly handles pass-through arguments for clippy", () => {
+			let ctx = mockExecutorContext("test-app:lint");
+			let opts: ClippyCliOptions = {
+				package: "test-app-pkg",
+				target: "wasm32-unknown-unknown",
+				fix: false,
+				failOnWarnings: true,
+				noDeps: true,
+			};
+			let args = ["cargo", ...parseCargoArgs(Target.Clippy, opts, ctx)[0]];
+
+			expect(args.join(" ")).toEqual(
+				"cargo clippy -p test-app-pkg --target wasm32-unknown-unknown "
+					+ "-- -D warnings --no-deps",
+			);
+		});
+
+		it("correctly handles the `env` option", () => {
+			let ctx = mockExecutorContext("test-app:run");
+			let opts: CargoOptions = {
+				package: "foo",
+				env: {
+					RUST_BACKTRACE: "FULL",
+				},
+			};
+			let [args, env] = parseCargoArgs(Target.Run, opts, ctx);
+
+			expect(["cargo", ...args].join(" ")).toEqual("cargo run -p foo");
+			expect(env).toHaveProperty("RUST_BACKTRACE", "FULL");
+		});
+	});
+
+	describe("normalizeGeneratorOptions", () => {
+		let appTree: Tree;
+
+		beforeAll(() => {
+			appTree = createTreeWithEmptyWorkspace();
+		});
+
+		it("should respect kebab-case project names", () => {
+			let opts = normalizeGeneratorOptions("application", appTree, { name: "my-app" });
+			expect(opts.projectName).toBe("my-app");
+		});
+
+		it("should respect snake_case project names", () => {
+			let opts = normalizeGeneratorOptions("application", appTree, { name: "my_app" });
+			expect(opts.projectName).toBe("my_app");
+		});
+
+		it("should respect PascalCase project names", () => {
+			let opts = normalizeGeneratorOptions("application", appTree, { name: "MyApp" });
+			expect(opts.projectName).toBe("MyApp");
+		});
+
+		it("should respect camelCase project names (you monster)", () => {
+			let opts = normalizeGeneratorOptions("application", appTree, { name: "myApp" });
+			expect(opts.projectName).toBe("myApp");
+		});
+	});
+});
+
+function mockExecutorContext(command: string): ExecutorContext {
+	let [projectName, targetName] = command.split(":");
+
+	return {
+		cwd: "C:/test",
+		root: "C:/test",
+		isVerbose: false,
+		workspace: {
+			projects: {
+				"test-app": {
+					root: "apps/test-app",
+					projectType: "application",
+				},
+				"test-lib": {
+					root: "libs/test-lib",
+					projectType: "library",
+				},
+			},
+			version: 2,
+		},
+		projectName,
+		targetName,
+	};
+}