@joshmossas/nx-cargo 0.6.2

package/src/generators/library/generator.spec.ts

@@ -0,0 +1,96 @@
+import { Tree } from "@nx/devkit";
+import { createTreeWithEmptyWorkspace } from "@nx/devkit/testing";
+import runGenerator from "./generator";
+
+describe("library generator", () => {
+	let appTree: Tree;
+
+	beforeAll(() => {
+		appTree = createTreeWithEmptyWorkspace({ layout: "apps-libs" });
+	});
+
+	describe("with kebab-case project name", () => {
+		beforeAll(async () => {
+			await runGenerator(appTree, { name: "my-library" });
+		});
+
+		it("should create the correct file structure", () => {
+			let changes = appTree.listChanges();
+			let cargoToml = changes.find(c => c.path === "libs/my-library/Cargo.toml");
+			let libRs = changes.find(c => c.path === "libs/my-library/src/lib.rs");
+
+			expect(cargoToml).toBeTruthy();
+			expect(libRs).toBeTruthy();
+		});
+
+		it("should populate project files with the correct content", () => {
+			let changes = appTree.listChanges();
+			let cargoContent = changes
+				.find(c => c.path === "libs/my-library/Cargo.toml")!
+				.content!.toString();
+
+			expect(cargoContent).toContain(`name = "my-library"`);
+			expect(cargoContent).toContain(`edition = "2021"`);
+
+			let libRsContent = changes
+				.find(c => c.path === "libs/my-library/src/lib.rs")!
+				.content!.toString();
+
+			expect(libRsContent).toContain(`pub fn my_library() -> String {`);
+			expect(libRsContent).toContain(`"my-library".into()`);
+			expect(libRsContent).toContain(
+				`assert_eq!(my_library(), "my-library".to_string())`
+			);
+		});
+
+		it("should add project to workspace members", () => {
+			let changes = appTree.listChanges();
+			let members = changes.find(c => c.path === "Cargo.toml")!.content!.toString();
+
+			expect(members).toContain(`"libs/my-library"`);
+		});
+	});
+
+	describe("with snake_case project name", () => {
+		beforeAll(async () => {
+			appTree = createTreeWithEmptyWorkspace({ layout: "apps-libs" });
+			await runGenerator(appTree, { name: "my_library" });
+		});
+
+		it("should create the correct file structure", () => {
+			let changes = appTree.listChanges();
+			let cargoToml = changes.find(c => c.path === "libs/my_library/Cargo.toml");
+			let libRs = changes.find(c => c.path === "libs/my_library/src/lib.rs");
+
+			expect(cargoToml).toBeTruthy();
+			expect(libRs).toBeTruthy();
+		});
+
+		it("should populate project files with the correct content", () => {
+			let changes = appTree.listChanges();
+			let cargoContent = changes
+				.find(c => c.path === "libs/my_library/Cargo.toml")!
+				.content!.toString();
+
+			expect(cargoContent).toContain(`name = "my_library"`);
+			expect(cargoContent).toContain(`edition = "2021"`);
+
+			let libRsContent = changes
+				.find(c => c.path === "libs/my_library/src/lib.rs")!
+				.content!.toString();
+
+			expect(libRsContent).toContain(`pub fn my_library() -> String {`);
+			expect(libRsContent).toContain(`"my_library".into()`);
+			expect(libRsContent).toContain(
+				`assert_eq!(my_library(), "my_library".to_string())`
+			);
+		});
+
+		it("should add project to workspace members", () => {
+			let changes = appTree.listChanges();
+			let members = changes.find(c => c.path === "Cargo.toml")!.content!.toString();
+
+			expect(members).toContain(`"libs/my_library"`);
+		});
+	});
+});

package/src/generators/library/generator.ts

@@ -0,0 +1,78 @@
+import {
+	Tree,
+	addProjectConfiguration,
+	formatFiles,
+	generateFiles,
+} from "@nx/devkit";
+import * as path from "path";
+
+import {
+	GeneratorOptions,
+	normalizeGeneratorOptions,
+	updateWorkspaceMembers,
+} from "../../common";
+import cargoInit from "../init/generator";
+import CLIOptions from "./schema";
+
+// prettier-ignore
+type Options = CLIOptions & GeneratorOptions;
+
+export default async function (host: Tree, opts: CLIOptions) {
+	let options = normalizeGeneratorOptions("library", host, opts);
+
+	addProjectConfiguration(host, options.projectName, {
+		root: options.projectRoot,
+		projectType: "library",
+		sourceRoot: `${options.projectRoot}/src`,
+		targets: {
+			build: {
+				executor: "@nxrs/cargo:build",
+				options: {
+					profile: "dev",
+				},
+				configurations: {
+					production: {
+						profile: "release",
+					},
+				},
+			},
+			test: {
+				executor: "@nxrs/cargo:test",
+				options: {},
+			},
+			lint: {
+				executor: "@nxrs/cargo:clippy",
+				options: {
+					fix: false,
+					failOnWarnings: true,
+					noDeps: true,
+				},
+			},
+		},
+		tags: options.parsedTags,
+	});
+
+	await addFiles(host, options);
+	updateWorkspaceMembers(host, options);
+	await formatFiles(host);
+}
+
+async function addFiles(host: Tree, opts: Options) {
+	if (!host.exists("Cargo.toml")) {
+		await cargoInit(host, {});
+	}
+
+	let substitutions = {
+		projectName: opts.projectName,
+		moduleName: opts.moduleName,
+		edition: opts.edition,
+		template: "",
+	};
+
+	generateFiles(
+		host,
+		path.join(__dirname, "files"),
+		opts.projectRoot,
+		substitutions
+	);
+}

package/src/generators/library/schema.d.ts

@@ -0,0 +1,6 @@
+export default interface Options {
+	name: string;
+	edition?: number;
+	directory?: string;
+	tags?: string;
+}

package/src/generators/library/schema.json

@@ -0,0 +1,35 @@
+{
+	"$schema": "http://json-schema.org/schema",
+	"id": "Library",
+	"title": "",
+	"type": "object",
+	"properties": {
+		"name": {
+			"type": "string",
+			"description": "",
+			"$default": {
+				"$source": "argv",
+				"index": 0
+			},
+			"x-prompt": "What name would you like to use?"
+		},
+		"edition": {
+			"type": "number",
+			"description": "What Rust edition to use",
+			"default": 2021
+		},
+		"tags": {
+			"type": "string",
+			"description": "Add tags to the project (used for linting)",
+			"alias": "t"
+		},
+		"directory": {
+			"type": "string",
+			"description": "A directory where the project is placed",
+			"alias": "d"
+		}
+	},
+	"required": [
+		"name"
+	]
+}

package/src/graph/index.ts

@@ -0,0 +1,189 @@
+import {
+	ProjectConfiguration,
+	CreateDependenciesContext as Context,
+	RawProjectGraphDependency as GraphDependency,
+	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";
+
+type VersionNumber = `${number}.${number}.${number}`;
+type PackageVersion = `${string}@${VersionNumber}` | VersionNumber;
+type CargoId = `${"registry" | "path"}+${
+	| "http"
+	| "https"
+	| "file"}://${string}#${PackageVersion}`;
+
+interface CargoPackage {
+	name: string;
+	version: string;
+	id: CargoId;
+	license: string;
+	license_file: string | null;
+	description: string;
+	source: string | null;
+	dependencies: CargoDependency[];
+	targets: unknown; // TODO
+	features: Record<string, string[]>;
+	manifest_path: string;
+	metadata: unknown | null; // TODO
+	publish: unknown | null; // TODO
+	authors: string[];
+	categories: string[];
+	keywords: string[];
+	readme: string | null;
+	repository: string | null;
+	homepage: string | null;
+	documentation: string | null;
+	edition: string;
+	links: unknown | null; // TODO
+	default_run: unknown | null; // TODO
+	rust_version: string;
+}
+
+interface CargoDependency {
+	name: string;
+	source: string | null;
+	req: string;
+	kind: "build" | "dev" | null;
+	rename: string | null;
+	optional: boolean;
+	uses_default_features: boolean;
+	features: string[];
+	target: string | null;
+	registry: string | null;
+	path?: string;
+}
+
+interface CargoMetadata {
+	packages: CargoPackage[];
+	workspace_members: CargoId[];
+	workspace_default_members: CargoId[];
+	resolve: {
+		nodes: ResolveNode[];
+		root: unknown;
+	};
+	target_directory: string;
+	version: number;
+	workspace_root: string;
+	metadata: unknown | null;
+}
+
+interface ResolveNode {
+	id: CargoId;
+	dependencies: CargoId[];
+}
+export function createDependencies(_: unknown, ctx: Context): GraphDependency[] {
+	const allDependencies: GraphDependency[] = [];
+	const processedWorkspaceRoots = new Set<string>();
+
+	// 1. Identify all potential Cargo workspaces/projects in the Nx graph
+	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);
+
+		// 2. Get metadata for this specific workspace
+		const metadata = getCargoMetadata(configDir);
+
+		// 3. Skip if we've already processed this workspace (via another member)
+		if (processedWorkspaceRoots.has(metadata.workspace_root)) {
+			continue;
+		}
+		processedWorkspaceRoots.add(metadata.workspace_root);
+
+		// 4. Process this workspace's internal dependencies
+		const workspaceDeps = processWorkspaceMetadata(ctx, metadata);
+		allDependencies.push(...workspaceDeps);
+	}
+
+	return allDependencies;
+}
+
+function processWorkspaceMetadata(
+	ctx: Context,
+	metadata: CargoMetadata
+): GraphDependency[] {
+	const {
+		packages,
+		workspace_members: cargoWsMembers,
+		resolve: cargoResolve,
+	} = metadata;
+
+	const workspacePackages = new Map<CargoId, CargoPackage>();
+	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: string): CargoMetadata {
+	const availableMemory = os.freemem();
+	// Run cargo metadata from the specific directory of the Cargo.toml
+	const metadata = cp.execSync("cargo metadata --format-version=1", {
+		encoding: "utf8",
+		maxBuffer: availableMemory,
+		cwd: cwd, // Crucial: run in the workspace directory
+	});
+
+	return JSON.parse(metadata);
+}
+
+type WithReq<T, K extends keyof T> = Omit<T, K> & {
+	[Key in K]-?: Exclude<T[Key], null | undefined>;
+};
+
+function mapCargoProjects(ctx: Context, packages: Map<CargoId, CargoPackage>) {
+	let result = new Map<CargoId, WithReq<ProjectConfiguration, "name">>();
+
+	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;
+}

package/src/index.ts

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

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+	"extends": "../../tsconfig.base.json",
+	"files": [],
+	"include": [],
+	"references": [
+		{
+			"path": "./tsconfig.lib.json"
+		},
+		{
+			"path": "./tsconfig.spec.json"
+		}
+	]
+}

package/tsconfig.lib.json

@@ -0,0 +1,12 @@
+{
+	"extends": "./tsconfig.json",
+	"compilerOptions": {
+		"module": "es2022",
+		"outDir": "../../dist/out-tsc",
+		"declaration": true,
+		"types": ["node"],
+		"noPropertyAccessFromIndexSignature": true
+	},
+	"exclude": ["**/*.spec.ts", "**/*.test.ts", "jest.config.ts"],
+	"include": ["**/*.ts"]
+}

package/tsconfig.spec.json

@@ -0,0 +1,20 @@
+{
+	"extends": "./tsconfig.json",
+	"compilerOptions": {
+		"outDir": "../../dist/out-tsc",
+		"module": "es2022",
+		"types": ["jest", "node"]
+	},
+	"include": [
+		"**/*.spec.ts",
+		"**/*.test.ts",
+		"**/*.spec.tsx",
+		"**/*.test.tsx",
+		"**/*.spec.js",
+		"**/*.test.js",
+		"**/*.spec.jsx",
+		"**/*.test.jsx",
+		"**/*.d.ts",
+		"jest.config.ts"
+	]
+}