@codependix/nx 0.0.50 → 0.0.52

package/dist/plugin-context.utilities-AMq4HSG6.js

@@ -0,0 +1,475 @@
+import "reflect-metadata";
+import { NestFactory as e } from "@nestjs/core";
+import { Injectable as t, Module as n } from "@nestjs/common";
+import { ConfigurationModule as r, ConfigurationService as i } from "@codependix/configuration";
+import a from "node:path";
+import { spawn as o } from "node:child_process";
+import { readFileSync as s } from "node:fs";
+import { createRequire as c } from "node:module";
+import { pathToFileURL as l } from "node:url";
+import { once as u } from "node:events";
+import d from "node:os";
+import { PassThrough as f } from "node:stream";
+import { text as p } from "node:stream/consumers";
+// \0rolldown/runtime.js
+var m = Object.defineProperty, __name = (e, t) => m(e, "name", {
+	value: t,
+	configurable: !0
+});
+// src/modules/batch/batch.utilities.ts
+function describeError(e) {
+	return e instanceof Error ? e.message : String(e);
+}
+function readChargedProjects(e) {
+	let t;
+	try {
+		t = JSON.parse(extractReportText(e));
+	} catch {
+		return;
+	}
+	let n = isRecord(t) ? t.boundaries : void 0;
+	if (!isRecord(n) || !isList(n.failures) || !isList(n.violations)) return;
+	let r = /* @__PURE__ */ new Set();
+	for (let e of [...n.failures, ...n.violations]) {
+		let t = isRecord(e) ? e.projects : void 0;
+		if (!isList(t)) return;
+		for (let e of t) typeof e == "string" && r.add(e);
+	}
+	return r;
+}
+function splitProjects(e, t, n) {
+	for (let r = Math.max(1, Math.min(n, e.length)); r <= e.length; r += 1) {
+		let n = Array.from({ length: r }, () => []);
+		for (let [t, i] of e.entries()) n[t % r]?.push(i);
+		if (n.every((e) => e.join(",").length <= t)) return n;
+	}
+	return e.map((e) => [e]);
+}
+function extractReportText(e) {
+	let t = e.split("\n"), n = t.indexOf("{"), r = t.indexOf("}", n);
+	return n === -1 || r === -1 ? e : t.slice(n, r + 1).join("\n");
+}
+function isList(e) {
+	return Array.isArray(e);
+}
+function isRecord(e) {
+	return typeof e == "object" && !!e && !Array.isArray(e);
+}
+// src/modules/plugin/plugin.constants.ts
+var h = "**/{project.json,codependix.config.*}", g = "project.json", _ = "{projectRoot}/codependix.config.*", v = "__codependixPluginContext", y = "@codependix/nx", b = "codependix-bound", x = "`configurationPath` option on the @codependix/nx plugin's entry in nx.json", S = "@codependix/cli", C = "workspace:", w = [
+	"file:",
+	"link:",
+	"portal:",
+	C
+], T = ["package.json", "src/**/!(*.test.*|*.spec.*)"], E = "{workspaceRoot}/tsconfig.json", D = "tsconfig.json", O = {
+	outside: "it lies outside the workspace",
+	unresolved: "it resolves to no file"
+};
+// \0@oxc-project+runtime@0.155.0/helpers/esm/decorateMetadata.js
+function __decorateMetadata(e, t) {
+	if (typeof Reflect == "object" && typeof Reflect.metadata == "function") return Reflect.metadata(e, t);
+}
+// \0@oxc-project+runtime@0.155.0/helpers/esm/decorate.js
+function __decorate(e, t, n, r) {
+	var i = arguments.length, a = i < 3 ? t : r === null ? r = Object.getOwnPropertyDescriptor(t, n) : r, o;
+	if (typeof Reflect == "object" && typeof Reflect.decorate == "function") a = Reflect.decorate(e, t, n, r);
+	else for (var s = e.length - 1; s >= 0; s--) (o = e[s]) && (a = (i < 3 ? o(a) : i > 3 ? o(t, n, a) : o(t, n)) || a);
+	return i > 3 && a && Object.defineProperty(t, n, a), a;
+}
+// src/modules/plugin/plugin.service.ts
+var k = class PluginService {
+	configurationService;
+	constructor(e) {
+		this.configurationService = e;
+	}
+	isUnknownArray(e) {
+		return Array.isArray(e);
+	}
+	readString(e) {
+		let t = e.record[e.key];
+		return typeof t == "string" && t !== "" ? t : void 0;
+	}
+	selectProjectRoots(e) {
+		return e.filter((e) => a.basename(e) === g).map((e) => a.dirname(e)).filter((e) => e !== ".");
+	}
+	toRecord(e) {
+		return typeof e == "object" && e ? { ...e } : {};
+	}
+	inferTargets(e) {
+		let t = this.resolvePluginOptions({ options: e.options }), n = { [t.gateTargetName]: {
+			cache: !0,
+			executor: `${y}:gate`,
+			inputs: [
+				"default",
+				"^default",
+				`{workspaceRoot}/${t.configurationPath}`,
+				_,
+				...e.toolInputs
+			],
+			options: {}
+		} };
+		return new Map(this.selectProjectRoots(e.projectConfigurationFiles).map((e) => [e, n]));
+	}
+	readRegisteredOptions(e) {
+		let { plugins: t } = this.toRecord(e);
+		if (!this.isUnknownArray(t)) return;
+		let { options: n } = t.map((e) => this.toRecord(e)).find(({ plugin: e }) => e === "@codependix/nx") ?? {};
+		return n;
+	}
+	resolvePluginOptions(e) {
+		let t = this.toRecord(e.options);
+		return {
+			configurationPath: this.configurationService.requireConfigurationPath(this.readString({
+				key: "configurationPath",
+				record: t
+			}), x),
+			gateTargetName: this.readString({
+				key: "gateTargetName",
+				record: t
+			}) ?? "codependix-bound"
+		};
+	}
+};
+k = __decorate([t(), __decorateMetadata("design:paramtypes", [i === void 0 ? Object : i])], k);
+// src/modules/plugin/plugin.module.ts
+var A = class PluginModule {};
+A = __decorate([n({
+	controllers: [],
+	exports: [k],
+	imports: [r],
+	providers: [k]
+})], A);
+// src/modules/gate/gate.constants.ts
+var j = "@codependix/nx/loader", M = "@codependix/cli/main", N = "nx.json", P = "`configuration` executor option", F = "The codependix gate target judges projects its cache inputs do not cover, so it must set `cache: false`.", I = class GateService {
+	configurationService;
+	pluginService;
+	constructor(e, t) {
+		this.configurationService = e, this.pluginService = t;
+	}
+	readNameList(e) {
+		return (e ?? []).flatMap((e) => e.split(",")).map((e) => e.trim()).filter((e) => e !== "");
+	}
+	readNxConfiguration(e) {
+		try {
+			return JSON.parse(s(a.join(e, N), "utf8"));
+		} catch {
+			return;
+		}
+	}
+	async spawnCommandLine(e) {
+		return await new Promise((t, n) => {
+			let r = o(process.execPath, e.argv, {
+				cwd: e.workspaceRoot,
+				stdio: [
+					"ignore",
+					"pipe",
+					"pipe"
+				]
+			});
+			r.stdout.on("data", (e) => process.stdout.write(e)), r.stderr.on("data", (e) => process.stderr.write(e)), r.on("error", n), r.on("close", (e) => {
+				t(e === 0);
+			});
+		});
+	}
+	buildBatchArguments(e) {
+		return this.buildCommandArguments({
+			cliEntryPath: c(import.meta.url).resolve(M),
+			configurationPath: e.configurationPath,
+			dependencies: e.dependencies,
+			loaderUrl: l(c(import.meta.url).resolve(j)).href,
+			projects: e.projects,
+			tags: e.tags,
+			workspaceRoot: e.workspaceRoot
+		});
+	}
+	buildCommandArguments(e) {
+		return [
+			"--import",
+			e.loaderUrl,
+			e.cliEntryPath,
+			"map",
+			"--directory",
+			e.workspaceRoot,
+			"--config",
+			e.configurationPath,
+			"--check",
+			"boundaries",
+			...e.projects.length > 0 ? ["--projects", e.projects.join(",")] : [],
+			...e.tags.length > 0 ? ["--tags", e.tags.join(",")] : [],
+			...e.dependencies ? [] : ["--no-dependencies"]
+		];
+	}
+	judgesOwnProject(e) {
+		return e.selection.tags.length === 0 && e.selection.projects.length === 1 && e.selection.projects[0] === e.projectName;
+	}
+	resolveConfigurationPath(e) {
+		return e.configuration === void 0 ? this.pluginService.resolvePluginOptions({ options: this.pluginService.readRegisteredOptions(this.readNxConfiguration(e.workspaceRoot)) }).configurationPath : this.configurationService.requireConfigurationPath(e.configuration, P);
+	}
+	resolveSelection(e) {
+		let t = this.readNameList(e.options.projects), n = this.readNameList(e.options.tags);
+		if (t.length > 0 || n.length > 0) return {
+			projects: t,
+			tags: n
+		};
+		if (e.projectName === void 0) throw Error("The codependix gate executor must be run against a project, or given `projects` or `tags`.");
+		return {
+			projects: [e.projectName],
+			tags: n
+		};
+	}
+	async run(e) {
+		let t = this.resolveSelection(e);
+		if (e.cached && !this.judgesOwnProject({
+			...e,
+			selection: t
+		})) throw Error(F);
+		let n = this.buildCommandArguments({
+			...t,
+			cliEntryPath: c(import.meta.url).resolve(M),
+			configurationPath: this.resolveConfigurationPath({
+				configuration: e.options.configuration,
+				workspaceRoot: e.workspaceRoot
+			}),
+			dependencies: e.options.dependencies !== !1,
+			loaderUrl: l(c(import.meta.url).resolve(j)).href,
+			workspaceRoot: e.workspaceRoot
+		});
+		return await this.spawnCommandLine({
+			argv: n,
+			workspaceRoot: e.workspaceRoot
+		});
+	}
+};
+I = __decorate([t(), __decorateMetadata("design:paramtypes", [i === void 0 ? Object : i, k === void 0 ? Object : k])], I);
+// src/modules/gate/gate.module.ts
+var L = class GateModule {};
+L = __decorate([n({
+	controllers: [],
+	exports: [I],
+	imports: [r, A],
+	providers: [I]
+})], L);
+// src/modules/batch/batch.service.ts
+var R = class BatchService {
+	gateService;
+	constructor(e) {
+		this.gateService = e;
+	}
+	async captureCommandLine(e) {
+		let t = o(process.execPath, e.argv, {
+			cwd: e.workspaceRoot,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		}), n = new f();
+		t.stderr.pipe(n), e.forwardErrors && t.stderr.pipe(process.stderr, { end: !1 });
+		let r = u(t, "close");
+		try {
+			let [e, i, a] = await Promise.all([
+				r,
+				p(t.stdout),
+				p(n)
+			]), [o] = e;
+			return {
+				exitCode: typeof o == "number" ? o : null,
+				standardError: a,
+				standardOutput: i
+			};
+		} catch (e) {
+			return {
+				error: e instanceof Error ? e.message : String(e),
+				exitCode: null,
+				standardError: "",
+				standardOutput: ""
+			};
+		}
+	}
+	async explainFailure(e) {
+		let t = await this.captureCommandLine({
+			argv: e.judged.singleArguments,
+			forwardErrors: !1,
+			workspaceRoot: e.workspaceRoot
+		}), n = (t.error ?? `${t.standardOutput}${t.standardError}`).trim();
+		return {
+			success: !1,
+			terminalOutput: t.exitCode === 0 && t.error === void 0 ? `${e.judged.task.id}: findings were charged to this project in a batch that a run of its own did not reproduce.\n${n}`.trim() : n
+		};
+	}
+	failAll(e, t) {
+		return Object.fromEntries(e.map(({ task: e }) => [e.id, {
+			success: !1,
+			terminalOutput: t
+		}]));
+	}
+	async groupOrSettle(e) {
+		let { task: t } = e;
+		try {
+			let n = this.gateService.resolveSelection({
+				options: t.options,
+				projectName: t.project
+			});
+			if (!this.gateService.judgesOwnProject({
+				projectName: t.project,
+				selection: n
+			})) return t.cached ? {
+				success: !1,
+				terminalOutput: F
+			} : await this.runAlone({
+				selection: n,
+				task: t,
+				workspaceRoot: e.workspaceRoot
+			});
+			let r = t.options.dependencies !== !1, i = `${t.configurationPath}\u0000${String(r)}`, a = e.groups.get(i) ?? {
+				configuration: t.configurationPath,
+				dependencies: r,
+				tasks: []
+			};
+			a.tasks.push(t), e.groups.set(i, a);
+			return;
+		} catch (e) {
+			return {
+				success: !1,
+				terminalOutput: describeError(e)
+			};
+		}
+	}
+	async judgeRun(e) {
+		let t = await this.captureCommandLine({
+			argv: [
+				...e.argv,
+				"--format",
+				"json"
+			],
+			forwardErrors: !0,
+			workspaceRoot: e.workspaceRoot
+		});
+		if (t.error !== void 0) return this.failAll(e.judged, t.error);
+		let n = readChargedProjects(t.standardOutput);
+		if (n === void 0) return this.failAll(e.judged, `The codependix command line did not print a boundary report.\n${t.standardOutput}${t.standardError}`.trim());
+		if (t.exitCode !== 0 && !e.judged.some(({ task: e }) => n.has(e.project))) return this.failAll(e.judged, `The codependix command line exited ${String(t.exitCode)} but charged no finding to a project judged here.\n${t.standardError}`.trim());
+		let r = {};
+		for (let t of e.judged) r[t.task.id] = n.has(t.task.project) ? await this.explainFailure({
+			judged: t,
+			workspaceRoot: e.workspaceRoot
+		}) : {
+			success: !0,
+			terminalOutput: ""
+		};
+		return r;
+	}
+	planShares(e) {
+		let { group: t, workspaceRoot: n } = e, r = [];
+		for (let i of splitProjects(t.tasks.map((e) => e.project), 900, e.concurrency)) {
+			let e = [];
+			for (let r of t.tasks) i.includes(r.project) && e.push({
+				singleArguments: this.gateService.buildBatchArguments({
+					configurationPath: t.configuration,
+					dependencies: t.dependencies,
+					projects: [r.project],
+					tags: [],
+					workspaceRoot: n
+				}),
+				task: r
+			});
+			r.push({
+				argv: this.gateService.buildBatchArguments({
+					configurationPath: t.configuration,
+					dependencies: t.dependencies,
+					projects: i,
+					tags: [],
+					workspaceRoot: n
+				}),
+				judged: e
+			});
+		}
+		return r;
+	}
+	async runAlone(e) {
+		let t = await this.captureCommandLine({
+			argv: this.gateService.buildBatchArguments({
+				configurationPath: e.task.configurationPath,
+				dependencies: e.task.options.dependencies !== !1,
+				projects: e.selection.projects,
+				tags: e.selection.tags,
+				workspaceRoot: e.workspaceRoot
+			}),
+			forwardErrors: !1,
+			workspaceRoot: e.workspaceRoot
+		});
+		return {
+			success: t.exitCode === 0 && t.error === void 0,
+			terminalOutput: (t.error ?? `${t.standardOutput}${t.standardError}`).trim()
+		};
+	}
+	async runGroup(e) {
+		let t = [], n = {};
+		for (let n of this.planShares(e)) t.push(this.judgeRun({
+			...n,
+			workspaceRoot: e.workspaceRoot
+		}));
+		for (let e of await Promise.all(t)) Object.assign(n, e);
+		return n;
+	}
+	async runBatch(e) {
+		let t = {}, n = /* @__PURE__ */ new Map(), r = e.concurrency ?? Math.min(4, d.availableParallelism());
+		for (let r of e.tasks) {
+			let i = await this.groupOrSettle({
+				groups: n,
+				task: r,
+				workspaceRoot: e.workspaceRoot
+			});
+			i !== void 0 && (t[r.id] = i);
+		}
+		for (let i of n.values()) Object.assign(t, await this.runGroup({
+			concurrency: r,
+			group: i,
+			workspaceRoot: e.workspaceRoot
+		}));
+		return t;
+	}
+};
+R = __decorate([t(), __decorateMetadata("design:paramtypes", [I === void 0 ? Object : I])], R);
+// src/modules/batch/batch.module.ts
+var z = class BatchModule {};
+z = __decorate([n({
+	controllers: [],
+	exports: [R],
+	imports: [L],
+	providers: [R]
+})], z);
+// src/codependix-nx.module.ts
+var B = class MainModule {};
+B = __decorate([n({
+	controllers: [],
+	exports: [
+		z,
+		L,
+		A
+	],
+	imports: [
+		z,
+		L,
+		A
+	],
+	providers: []
+})], B);
+// src/modules/plugin/plugin-context.utilities.ts
+async function resolveBatchService() {
+	return (await resolvePluginContext()).get(R);
+}
+async function resolveGateService() {
+	return (await resolvePluginContext()).get(I);
+}
+async function resolvePluginService() {
+	return (await resolvePluginContext()).get(k);
+}
+async function resolvePluginContext() {
+	let t = globalThis;
+	return t[v] ??= e.createApplicationContext(B, {
+		abortOnError: !1,
+		logger: !1
+	}), await t[v];
+}
+export { C as _, L as a, __name as b, k as c, b as d, w as f, T as g, O as h, B as i, S as l, h as m, resolveGateService as n, I as o, D as p, resolvePluginService as r, A as s, resolveBatchService as t, y as u, E as v, describeError as y };

package/dist/src/executors/gate/batch-executor.d.ts

@@ -0,0 +1,57 @@
+import { ExecutorContext } from '@nx/devkit';
+import { TaskGraph } from '@nx/devkit';
+
+/**
+ * Judges every gate task Nx batched for this executor from as few command line
+ * runs as it can.
+ *
+ * Each task still passes, fails and is cached by itself — Nx hashes and
+ * replays batched tasks one by one — but the command line is started once per
+ * share of the batch instead of once per project, which is most of what a gate
+ * costs.
+ */
+declare function gateBatchExecutor(...[taskGraph, options, overrides, context]: GateBatchExecutorArguments): Promise<Record<string, GateBatchTaskResult>>;
+export default gateBatchExecutor;
+
+/**
+ * The four arguments Nx calls a batch executor with, in the order it passes them.
+ *
+ * A tuple rather than four parameters because Nx fixes that signature and the
+ * workspace holds a function to three: the task graph, each task's resolved
+ * options by task id, the overrides of the whole run, and the context.
+ */
+declare type GateBatchExecutorArguments = [
+taskGraph: TaskGraph,
+options: Record<string, GateExecutorOptions>,
+overrides: GateExecutorOptions,
+context: ExecutorContext
+];
+
+/**
+ * What one task of a gate batch settled on.
+ *
+ * Nx's own type for a batch executor's result is not exported through
+ * `@nx/devkit`, so this states the shape Nx reads back: whether the task
+ * passed, and the output to show and to store with it in the cache.
+ */
+declare interface GateBatchTaskResult {
+    readonly success: boolean;
+    readonly terminalOutput: string;
+}
+
+/** Options the gate executor accepts — see `schema.json` beside this. */
+declare type GateExecutorOptions = GateOptions;
+
+/** Options the gate executor accepts. */
+declare interface GateOptions {
+    /** Workspace-relative configuration path; the registration's when omitted. */
+    readonly configuration?: string | undefined;
+    /** Build over the named projects' dependency closure. Defaults to true. */
+    readonly dependencies?: boolean | undefined;
+    /** Nx project names to judge, replacing the target's own project. */
+    readonly projects?: string[] | undefined;
+    /** Nx project tags to judge, selecting a project carrying any of them. */
+    readonly tags?: string[] | undefined;
+}
+
+export { }

package/dist/src/executors/gate/batch-executor.js

@@ -0,0 +1,43 @@
+import { n as e, t, y as n } from "../../../plugin-context.utilities-AMq4HSG6.js";
+// src/executors/gate/batch-executor.ts
+async function gateBatchExecutor(...[n, r, i, a]) {
+	let o = await t(), s = await e(), c = {}, l = [];
+	for (let [e, t] of Object.entries(n.tasks)) {
+		let n = resolveTask({
+			cached: a.projectGraph.nodes[t.target.project]?.data.targets?.[t.target.target]?.cache === !0,
+			gateService: s,
+			id: e,
+			options: r[e] ?? i,
+			project: t.target.project,
+			workspaceRoot: a.root
+		});
+		"failure" in n ? c[e] = n.failure : l.push(n.task);
+	}
+	return Object.assign(c, await o.runBatch({
+		tasks: l,
+		workspaceRoot: a.root
+	})), printFailures(c), c;
+}
+function printFailures(e) {
+	for (let [t, n] of Object.entries(e)) n.success || process.stdout.write(`\n> ${t}\n${n.terminalOutput}\n`);
+}
+function resolveTask(e) {
+	try {
+		return { task: {
+			cached: e.cached,
+			configurationPath: e.gateService.resolveConfigurationPath({
+				configuration: e.options.configuration,
+				workspaceRoot: e.workspaceRoot
+			}),
+			id: e.id,
+			options: e.options,
+			project: e.project
+		} };
+	} catch (e) {
+		return { failure: {
+			success: !1,
+			terminalOutput: n(e)
+		} };
+	}
+}
+export { gateBatchExecutor as default };

package/dist/src/executors/gate/executor.js

@@ -1,4 +1,4 @@
-import { t as e } from "../../../plugin-context.utilities-Bc3NR0GZ.js";
+import { n as e } from "../../../plugin-context.utilities-AMq4HSG6.js";
 // src/executors/gate/executor.ts
 async function gateExecutor(t, n) {
 	let r = await e(), i = n.projectName === void 0 || n.targetName === void 0 ? void 0 : n.projectGraph.nodes[n.projectName]?.data.targets?.[n.targetName];

package/dist/src/index.d.ts

@@ -1,6 +1,15 @@
 import { ConfigurationService } from '@codependix/configuration';
 import { CreateNodes } from '@nx/devkit';
 
+/** Arguments for building the command line of a run whose configuration is resolved. */
+declare interface BuildBatchArguments {
+    readonly configurationPath: string;
+    readonly dependencies: boolean;
+    readonly projects: string[];
+    readonly tags: string[];
+    readonly workspaceRoot: string;
+}
+
 /** Arguments for building the command line one gate runs. */
 declare interface BuildCommandArguments extends GateSelection {
     /** Filesystem path of the codependix command line's entry. */
@@ -74,8 +83,6 @@ export declare class GateService {
     private readonly configurationService;
     private readonly pluginService;
     constructor(configurationService: ConfigurationService, pluginService: PluginService);
-    /** Whether a selection names exactly the project the target belongs to. */
-    private judgesOwnProject;
     /**
      * Reads a list of names out of an executor's options.
      *
@@ -101,6 +108,16 @@ export declare class GateService {
      * verdict was reached, so none may be recorded as a pass.
      */
     private spawnCommandLine;
+    /**
+     * Builds the `node` arguments for a run that is handed its configuration
+     * already resolved, as a batch is.
+     *
+     * Kept shallow on purpose: a batch builds one of these for every run it
+     * starts and for every project it may have to explain, so the long chain that
+     * resolves a configuration path is walked once, by the executor, and never
+     * from here.
+     */
+    buildBatchArguments(args: BuildBatchArguments): string[];
     /**
      * Builds the `node` arguments one gate runs.
      *
@@ -110,6 +127,11 @@ export declare class GateService {
      * dependency's own gate rather than every gate downstream of it.
      */
     buildCommandArguments(args: BuildCommandArguments): string[];
+    /** Whether a selection names exactly the project the target belongs to. */
+    judgesOwnProject(args: {
+        projectName: string | undefined;
+        selection: GateSelection;
+    }): boolean;
     /**
      * Resolves the configuration path one gate runs with.
      *