@callidescope/nx 0.0.63 → 0.0.65

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

@@ -0,0 +1,64 @@
+import { c as e, n as t, r as n } from "../../../plugin-context.utilities-BstelNQl.js";
+import { t as r } from "../../../plugin.utilities-C8eEw5MU.js";
+// src/executors/gate/batch-executor.ts
+async function gateBatchExecutor(...[e, t, r, i]) {
+	let a = await Promise.all(Object.entries(e.tasks).map(async ([e, n]) => await resolveTask({
+		context: i,
+		options: t[e] ?? r,
+		projectName: n.target.project,
+		taskId: e
+	}))), o = {}, s = /* @__PURE__ */ new Map();
+	for (let e of a) "failure" in e ? o[e.taskId] = e.failure : s.set(e.configurationPath, [...s.get(e.configurationPath) ?? [], e.task]);
+	let c = await n();
+	for (let [e, t] of s) {
+		let n = await c.runGateBatch({
+			configurationPath: e,
+			tasks: t,
+			workspaceRoot: i.root
+		});
+		for (let [e, t] of Object.entries(n)) o[e] = {
+			success: t.ok,
+			terminalOutput: t.report
+		};
+	}
+	return printFailures(o), o;
+}
+function printFailures(e) {
+	for (let [t, n] of Object.entries(e)) n.success || process.stdout.write(`\n> ${t}\n${n.terminalOutput}\n`);
+}
+async function resolveTask(n) {
+	try {
+		let i = await t(), a = await r({
+			context: {
+				...n.context,
+				projectName: n.projectName
+			},
+			label: "gate",
+			options: n.options
+		});
+		return a.directories.length === 0 ? {
+			failure: {
+				success: !1,
+				terminalOutput: e
+			},
+			taskId: n.taskId
+		} : {
+			configurationPath: i.readConfiguration(n.options.configuration),
+			task: {
+				directories: a.directories,
+				id: n.taskId,
+				judgedProjectNames: a.selectedDirectories
+			},
+			taskId: n.taskId
+		};
+	} catch (e) {
+		return {
+			failure: {
+				success: !1,
+				terminalOutput: e instanceof Error ? e.message : String(e)
+			},
+			taskId: n.taskId
+		};
+	}
+}
+export { gateBatchExecutor as default };

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

@@ -1,5 +1,5 @@
-import { c as e, n as t, r as n } from "../../../plugin-context.utilities-Bl7Iny6b.js";
-import { t as r } from "../../../plugin.utilities-BYLiorWH.js";
+import { c as e, n as t, r as n } from "../../../plugin-context.utilities-BstelNQl.js";
+import { t as r } from "../../../plugin.utilities-C8eEw5MU.js";
 // src/executors/gate/executor.ts
 async function gateExecutor(i, a) {
 	let o = await r({

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

@@ -1,5 +1,5 @@
-import { n as e, r as t } from "../../../plugin-context.utilities-Bl7Iny6b.js";
-import { t as n } from "../../../plugin.utilities-BYLiorWH.js";
+import { n as e, r as t } from "../../../plugin-context.utilities-BstelNQl.js";
+import { t as n } from "../../../plugin.utilities-C8eEw5MU.js";
 // src/executors/trace/executor.ts
 async function traceExecutor(r, i) {
 	let a = await n({

package/dist/src/index.d.ts

@@ -2,13 +2,16 @@ import { AddressDepthService } from '@callidescope/graph';
 import { AddressLookupService } from '@callidescope/cli';
 import { AddressReportService } from '@callidescope/output';
 import { BreadthService } from '@callidescope/graph';
+import { CallGraphResult } from '@callidescope/core';
 import { CallidescopeOutputFormat } from '@callidescope/configuration';
 import { CallidescopeService } from '@callidescope/cli';
 import { ConfigurationService } from '@callidescope/configuration';
 import { CreateNodes } from '@nx/devkit';
 import { FileFilterService } from '@callidescope/graph';
 import { MarkdownReportService } from '@callidescope/output';
+import { OwnedFindings } from '@callidescope/output';
 import { ProjectGraph } from '@nx/devkit';
+import { ProjectLimitsLookup } from '@callidescope/configuration';
 import { ProjectReportsService } from '@callidescope/output';
 import { ResolvedCallidescopeConfiguration } from '@callidescope/configuration';
 
@@ -277,10 +280,10 @@ export declare class PluginService {
     private readonly fileFilterService;
     private readonly markdownReportService;
     private readonly optionsService;
-    private readonly projectReportsService;
     private readonly projectsService;
     private readonly runConfigurationService;
-    constructor(callidescopeService: CallidescopeService, configurationService: ConfigurationService, fileFilterService: FileFilterService, markdownReportService: MarkdownReportService, optionsService: OptionsService, projectReportsService: ProjectReportsService, projectsService: ProjectsService, runConfigurationService: RunConfigurationService);
+    private readonly verdictService;
+    constructor(callidescopeService: CallidescopeService, configurationService: ConfigurationService, fileFilterService: FileFilterService, markdownReportService: MarkdownReportService, optionsService: OptionsService, projectsService: ProjectsService, runConfigurationService: RunConfigurationService, verdictService: VerdictService);
     /**
      * Builds the predicate deciding which projects the workspace configuration
      * keeps out of every trace.
@@ -312,15 +315,6 @@ export declare class PluginService {
      * failing on that would hand it a permanently red target.
      */
     private buildInferredTargets;
-    /**
-     * The block a verdict owes the reader when its findings cannot explain it.
-     *
-     * Both targets print this and only one fails on it — see `judge` — because
-     * an unread project is a fact about the run either way. The unread projects
-     * come first when both apply: they name what went missing, where the
-     * whole-run reason can only say that something did.
-     */
-    private explainVerdict;
     /** Whether a project's directory holds a TypeScript program to trace. */
     private holdsProgram;
     /**
@@ -337,45 +331,14 @@ export declare class PluginService {
      */
     private isExcludedProject;
     /**
-     * Decides whether a traced result passes, for every target that reads one.
-     *
-     * One predicate rather than the same expression beside each caller, so a
-     * rule added here cannot reach one verdict and miss the other.
-     *
-     * **Only the projects the run was scoped to are judged.** A trace reaches
-     * into the dependencies of what it was pointed at, so judging the whole
-     * run's findings would fail `alpha`'s task for a breach in `beta`. The same
-     * line the publishing side already draws, one step further along:
-     * measurement reaches into dependencies, publishing does not, and judging
-     * does not either. A dependency's breach is its own gate's business, and
-     * `nx affected` selects it too when it changes, so nothing escapes a verdict.
-     *
-     * **A judged project none of whose own files were read is named back**, the
-     * case `callidescope`'s own `reportEmptyTrace` fails for the same reason: a
-     * gate that passes because it never looked reports the project as clean.
-     * Asked of each judged project rather than of the whole run, because
-     * narrowing made those two different questions — a project with dependencies
-     * has a non-empty run whatever became of its own sources, so its own
-     * `exclude` over-matching would otherwise leave it owning no finding and
-     * passing green. The whole run is asked too, for a run judging no project at
-     * all.
+     * Turns one traced outcome into the gate's result for the projects it judges.
      *
-     * It is the one rule whose **consequence** is the caller's rather than this
-     * predicate's, and so the one thing `unreadProjectNames` is returned beside
-     * `ok` for: a `gate` fails on it and a `trace` prints it and passes. Every
-     * project the workspace configuration excludes reads nothing of its own and
-     * is denied a gate while keeping its trace, so failing the trace too would
-     * make that project's target permanently red for being configured exactly as
-     * it was asked to be. Finding the projects stays here either way, so the
-     * rule cannot be applied to one verdict and forgotten by the other.
-     *
-     * **Depth is judged always, breadth wherever a limit exists** — not two
-     * modes to be selected between. `maximumDepth` has a default and
-     * `maximumBreadth` has none at any level, so a project declaring no breadth
-     * limit can produce no breadth finding to fail on. Reading the findings
-     * rather than naming a check is what keeps that true without a decision.
+     * What to print comes from the verdict: the findings it judged, or, for a
+     * run that read nothing and so has none to show, the reason it failed. The
+     * one thing added to that verdict is the exit code for an unread judged
+     * project, which is the gate's alone — see `VerdictService.judge`.
      */
-    private judge;
+    private renderGateVerdict;
     /**
      * States what a selection asked for that the workspace does not have.
      *
@@ -422,6 +385,17 @@ export declare class PluginService {
      * judged project, which is the gate's alone — see `judge`.
      */
     runGate(args: RunGateArguments): Promise<RunTraceResult>;
+    /**
+     * Gates every task of a batch from one trace of their combined scope.
+     *
+     * Each gate used to trace the whole workspace on its own, so a run of ~60
+     * projects traced it ~60 times. The trace reads the union of the tasks'
+     * directories once, then every task is judged by `judge` on the projects it
+     * alone answers for, exactly as `runGate` judges one — a breach the shared
+     * trace found fails only the task whose project owns it, which is what keeps
+     * a batch's verdicts the same as the separate runs' would have been.
+     */
+    runGateBatch(args: RunGateBatchArguments): Promise<Record<string, RunTraceResult>>;
     /**
      * Traces the resolved directories and renders the report.
      *
@@ -667,6 +641,24 @@ declare class RunConfigurationService {
  */
 declare type RunGateArguments = Omit<RunTraceArguments, "format">;
 
+/** Arguments for gating several tasks from one trace. */
+declare interface RunGateBatchArguments {
+    /** The workspace configuration file, as this plugin's registration names it. */
+    readonly configurationPath: string;
+    readonly tasks: readonly RunGateBatchTask[];
+    readonly workspaceRoot: string;
+}
+
+/** One task of a gate batch: the projects it reads and the ones it answers for. */
+declare interface RunGateBatchTask {
+    /** Workspace-relative directories the task's trace reads. */
+    readonly directories: readonly string[];
+    /** Nx's id for the task, which the result is keyed by. */
+    readonly id: string;
+    /** What the task judges, a subset of its `directories`. */
+    readonly judgedProjectNames: readonly string[];
+}
+
 /** Arguments for tracing one resolved selection. */
 declare interface RunTraceArguments {
     /** The workspace configuration file, as this plugin's registration names it. */
@@ -696,4 +688,100 @@ export declare interface RunTraceResult {
     readonly report: string;
 }
 
+/**
+ * What one predicate decided about a traced result.
+ *
+ * The findings come back with the verdict so the rendering shows what was
+ * judged rather than what was measured — the two differ for every scoped run.
+ *
+ * `reason` carries the rendering a verdict owes the reader when the findings
+ * cannot explain it themselves — a run that read nothing has no finding to
+ * show, and a bare red task there is the guessing game this rule exists to
+ * end.
+ */
+declare interface RunVerdict {
+    readonly findings: OwnedFindings;
+    /** Whether every rule both targets share was cleared. */
+    readonly ok: boolean;
+    readonly reason: string | undefined;
+    /**
+     * Judged projects none of whose own files were read.
+     *
+     * Reported beside `ok` rather than folded into it, because this is the one
+     * rule the two targets act on differently: a `gate` fails on it, a `trace`
+     * prints it and passes. Every project the workspace configuration excludes
+     * reads nothing of its own and keeps its trace while losing its gate, so a
+     * trace failing here would be permanently red for being configured as asked.
+     * The rule itself still lives in one place — `PluginService.judge` — and only
+     * the consequence is the caller's.
+     */
+    readonly unreadProjectNames: readonly string[];
+}
+
+/**
+ * Decides whether a traced result passes, for every target that reads one.
+ *
+ * Its own service so one trace can be judged once per project: a batch of
+ * gates traces the workspace a single time and asks this the same question of
+ * each project, which is why a verdict takes the result and the projects to
+ * judge rather than a trace to run.
+ */
+declare class VerdictService {
+    private readonly projectReportsService;
+    constructor(projectReportsService: ProjectReportsService);
+    /**
+     * The block a verdict owes the reader when its findings cannot explain it.
+     *
+     * Both targets print this and only one fails on it — see `judge` — because
+     * an unread project is a fact about the run either way. The unread projects
+     * come first when both apply: they name what went missing, where the
+     * whole-run reason can only say that something did.
+     */
+    explain(verdict: RunVerdict): string | undefined;
+    /**
+     * Decides whether a traced result passes, for every target that reads one.
+     *
+     * One predicate rather than the same expression beside each caller, so a
+     * rule added here cannot reach one verdict and miss the other.
+     *
+     * **Only the projects the run was scoped to are judged.** A trace reaches
+     * into the dependencies of what it was pointed at, so judging the whole
+     * run's findings would fail `alpha`'s task for a breach in `beta`. The same
+     * line the publishing side already draws, one step further along:
+     * measurement reaches into dependencies, publishing does not, and judging
+     * does not either. A dependency's breach is its own gate's business, and
+     * `nx affected` selects it too when it changes, so nothing escapes a verdict.
+     *
+     * **A judged project none of whose own files were read is named back**, the
+     * case `callidescope`'s own `reportEmptyTrace` fails for the same reason: a
+     * gate that passes because it never looked reports the project as clean.
+     * Asked of each judged project rather than of the whole run, because
+     * narrowing made those two different questions — a project with dependencies
+     * has a non-empty run whatever became of its own sources, so its own
+     * `exclude` over-matching would otherwise leave it owning no finding and
+     * passing green. The whole run is asked too, for a run judging no project at
+     * all.
+     *
+     * It is the one rule whose **consequence** is the caller's rather than this
+     * predicate's, and so the one thing `unreadProjectNames` is returned beside
+     * `ok` for: a `gate` fails on it and a `trace` prints it and passes. Every
+     * project the workspace configuration excludes reads nothing of its own and
+     * is denied a gate while keeping its trace, so failing the trace too would
+     * make that project's target permanently red for being configured exactly as
+     * it was asked to be. Finding the projects stays here either way, so the
+     * rule cannot be applied to one verdict and forgotten by the other.
+     *
+     * **Depth is judged always, breadth wherever a limit exists** — not two
+     * modes to be selected between. `maximumDepth` has a default and
+     * `maximumBreadth` has none at any level, so a project declaring no breadth
+     * limit can produce no breadth finding to fail on. Reading the findings
+     * rather than naming a check is what keeps that true without a decision.
+     */
+    judge(args: {
+        judgedProjectNames: readonly string[];
+        projectLimits: ProjectLimitsLookup;
+        result: CallGraphResult;
+    }): RunVerdict;
+}
+
 export { }

package/dist/src/index.js

@@ -1,4 +1,4 @@
-import { _ as e, a as t, b as n, d as r, f as i, g as a, h as o, i as s, l as c, m as l, n as u, o as d, p as f, r as p, s as m, t as h, u as g, v as _, y as v } from "../plugin-context.utilities-Bl7Iny6b.js";
+import { _ as e, a as t, b as n, d as r, f as i, g as a, h as o, i as s, l as c, m as l, n as u, o as d, p as f, r as p, s as m, t as h, u as g, v as _, y as v } from "../plugin-context.utilities-BstelNQl.js";
 import y from "node:path";
 // src/index.ts
 var b = {

package/executors.json

@@ -12,8 +12,10 @@
       "schema": "./src/executors/depth/schema.json"
     },
     "gate": {
+      "batchImplementation": "@callidescope/nx/src/executors/gate/batch-executor",
       "description": "Fail a project whose call stacks broke the depth or breadth limits it is held to, resolved against the project and its Nx dependencies.",
       "implementation": "@callidescope/nx/src/executors/gate/executor",
+      "preferBatch": true,
       "schema": "./src/executors/gate/schema.json"
     },
     "trace": {

package/package.json

@@ -4,11 +4,11 @@
     "url": "https://github.com/organizzolini/codebase/issues"
   },
   "dependencies": {
-    "@callidescope/cli": "0.0.63",
-    "@callidescope/configuration": "0.0.63",
-    "@callidescope/core": "0.0.62",
-    "@callidescope/graph": "0.0.62",
-    "@callidescope/output": "0.0.62",
+    "@callidescope/cli": "0.0.64",
+    "@callidescope/configuration": "0.0.64",
+    "@callidescope/core": "0.0.63",
+    "@callidescope/graph": "0.0.63",
+    "@callidescope/output": "0.0.63",
     "@nestjs/common": "^11.1.21 || ^12.0.1",
     "@nestjs/core": "^11.1.21 || ^12.0.1",
     "@nx/devkit": "^24.0.0",
@@ -79,5 +79,5 @@
     "strict": true
   },
   "types": "./dist/src/index.d.ts",
-  "version": "0.0.63"
+  "version": "0.0.65"
 }