@codependix/boundaries 0.0.3

package/dist/src/index.js

@@ -0,0 +1,509 @@
+import { Injectable as e, Module as t } from "@nestjs/common";
+import n from "node:path";
+import { PythonModule as r, PythonService as i, TypescriptModule as a, TypescriptService as o } from "@codependix/file-imports";
+import { ModuleGraphModule as s, ModuleGraphService as c, NestjsProjectModule as l, NestjsProjectService as u } from "@codependix/nestjs-modules";
+import { NeighborhoodModule as d, NeighborhoodService as f, WorkspaceGraphModule as p, WorkspaceGraphService as m } from "@codependix/nx-projects";
+import { CODEPENDIX_GRAPH_TYPES as h, ConfigurationModule as g, ConfigurationService as _ } from "@codependix/configuration";
+//#region packages/ic-suite/codependix/codependix-boundaries/src/modules/boundaries/boundaries.constants.ts
+var v = " → ", y = (e) => `${e.rule}: ${e.cycle.join(v)} is a cycle.`, b = (e) => `${e.rule}: ${e.source} may not depend on ${e.target}, which the rule's allowed targets do not cover.`, x = (e) => `${e.rule}: ${e.source} must not depend on ${e.target}.`;
+//#endregion
+//#region \0@oxc-project+runtime@0.151.0/helpers/esm/decorateMetadata.js
+function S(e, t) {
+	if (typeof Reflect == "object" && typeof Reflect.metadata == "function") return Reflect.metadata(e, t);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.151.0/helpers/esm/decorate.js
+function C(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;
+}
+//#endregion
+//#region packages/ic-suite/codependix/codependix-boundaries/src/modules/boundaries/boundary-cycles.service.ts
+var w = class {
+	constructor() {}
+	buildAdjacency(e) {
+		let t = /* @__PURE__ */ new Map();
+		for (let n of e.edges) {
+			if (!e.nodeIds.has(n.source) || !e.nodeIds.has(n.target)) continue;
+			let r = t.get(n.source) ?? [];
+			r.push(n.target), t.set(n.source, r);
+		}
+		for (let [e, n] of t) t.set(e, n.toSorted());
+		return t;
+	}
+	buildCycleKey(e) {
+		return [...new Set(e)].toSorted().join(">");
+	}
+	recordCycle(e) {
+		let { source: t, state: n, target: r } = e, i = [...n.stack.slice(n.stack.indexOf(r)), r], a = this.buildCycleKey(i);
+		n.keys.has(a) || (n.keys.add(a), n.cycles.push({
+			path: i,
+			source: t,
+			target: r
+		}));
+	}
+	walk(e) {
+		let { adjacency: t, node: n, state: r } = e;
+		r.onStack.add(n), r.stack.push(n);
+		for (let e of t.get(n) ?? []) {
+			if (r.onStack.has(e)) {
+				this.recordCycle({
+					source: n,
+					state: r,
+					target: e
+				});
+				continue;
+			}
+			r.visited.has(e) || this.walk({
+				adjacency: t,
+				node: e,
+				state: r
+			});
+		}
+		r.stack.pop(), r.onStack.delete(n), r.visited.add(n);
+	}
+	findCycles(e) {
+		let t = this.buildAdjacency(e), n = {
+			cycles: [],
+			keys: /* @__PURE__ */ new Set(),
+			onStack: /* @__PURE__ */ new Set(),
+			stack: [],
+			visited: /* @__PURE__ */ new Set()
+		};
+		for (let r of [...e.nodeIds].toSorted()) n.visited.has(r) || this.walk({
+			adjacency: t,
+			node: r,
+			state: n
+		});
+		return n.cycles;
+	}
+};
+w = C([e(), S("design:paramtypes", [])], w);
+//#endregion
+//#region packages/ic-suite/codependix/codependix-boundaries/src/modules/boundaries/boundary-selector.service.ts
+var T = class {
+	constructor() {}
+	matchesGlobs(e, t) {
+		return t === void 0 || e !== void 0 && t.some((t) => n.matchesGlob(e, t));
+	}
+	matchesTags(e, t) {
+		return t === void 0 || e !== void 0 && t.some((t) => e.some((e) => n.matchesGlob(e, t)));
+	}
+	matches(e, t) {
+		return this.matchesGlobs(e.id, t.id) && this.matchesGlobs(e.path, t.path) && this.matchesGlobs(e.project, t.project) && this.matchesTags(e.tags, t.tags);
+	}
+	selectIds(e, t) {
+		return t === void 0 ? new Set(e.map((e) => e.id)) : new Set(e.filter((e) => this.matches(e, t)).map((e) => e.id));
+	}
+};
+T = C([e(), S("design:paramtypes", [])], T);
+//#endregion
+//#region packages/ic-suite/codependix/codependix-boundaries/src/modules/boundaries/boundaries.service.ts
+var E = class {
+	cyclesService;
+	selectorService;
+	constructor(e, t) {
+		this.cyclesService = e, this.selectorService = t;
+	}
+	buildAccessViolation(e) {
+		let { edge: t, graph: n, rule: r } = e, i = r.kind === "forbid" ? x : b;
+		return {
+			cycle: void 0,
+			level: n.level,
+			message: this.buildMessage({
+				generated: i({
+					rule: r.name,
+					source: t.source,
+					target: t.target
+				}),
+				message: r.message
+			}),
+			rule: r.name,
+			scope: n.scope,
+			source: t.source,
+			target: t.target
+		};
+	}
+	buildMessage(e) {
+		return e.message === void 0 ? e.generated : `${e.generated} ${e.message}`;
+	}
+	evaluateAccessRule(e) {
+		let { graph: t, rule: n } = e, r = this.indexNodes(t), i = [];
+		for (let e of t.edges) {
+			if (!this.judgesEdge({
+				edge: e,
+				rule: n
+			})) continue;
+			let a = this.resolveNode(r, e.source);
+			if (!this.selectorService.matches(a, n.from)) continue;
+			let o = this.resolveNode(r, e.target);
+			this.selectorService.matches(o, n.to) === (n.kind === "forbid") && i.push(this.buildAccessViolation({
+				edge: e,
+				graph: t,
+				rule: n
+			}));
+		}
+		return i;
+	}
+	evaluateAcyclicRule(e) {
+		let { graph: t, rule: n } = e, r = this.selectorService.selectIds(t.nodes, n.nodes);
+		return this.cyclesService.findCycles({
+			edges: t.edges,
+			nodeIds: r
+		}).map((e) => ({
+			cycle: e.path,
+			level: t.level,
+			message: this.buildMessage({
+				generated: y({
+					cycle: e.path,
+					rule: n.name
+				}),
+				message: n.message
+			}),
+			rule: n.name,
+			scope: t.scope,
+			source: e.source,
+			target: e.target
+		}));
+	}
+	indexNodes(e) {
+		return new Map(e.nodes.map((e) => [e.id, e]));
+	}
+	judgesEdge(e) {
+		let t = e.rule.edges?.implicit;
+		return t === void 0 || (e.edge.implicit ?? !1) === t;
+	}
+	resolveNode(e, t) {
+		return e.get(t) ?? { id: t };
+	}
+	evaluate(e) {
+		return e.rules.flatMap((t) => t.kind === "acyclic" ? this.evaluateAcyclicRule({
+			graph: e.graph,
+			rule: t
+		}) : this.evaluateAccessRule({
+			graph: e.graph,
+			rule: t
+		}));
+	}
+};
+E = C([e(), S("design:paramtypes", [w === void 0 ? Object : w, T === void 0 ? Object : T])], E);
+//#endregion
+//#region packages/ic-suite/codependix/codependix-boundaries/src/modules/boundaries/boundary-report.service.ts
+var D = class {
+	constructor() {}
+	renderSummary(e) {
+		if (e.length === 0) return "No boundary violations.";
+		let t = new Set(e.map((e) => e.rule)), n = e.length === 1 ? "violation" : "violations", r = t.size === 1 ? "rule" : "rules";
+		return `${e.length} boundary ${n} across ${t.size} ${r}.`;
+	}
+	renderViolations(e) {
+		return e.map((e) => `${e.level} ${e.scope}: ${e.message}`);
+	}
+};
+D = C([e(), S("design:paramtypes", [])], D);
+//#endregion
+//#region packages/ic-suite/codependix/codependix-boundaries/src/modules/boundaries/boundaries.module.ts
+var O = class {};
+O = C([t({
+	controllers: [],
+	exports: [
+		E,
+		w,
+		D,
+		T
+	],
+	imports: [],
+	providers: [
+		E,
+		w,
+		D,
+		T
+	]
+})], O);
+//#endregion
+//#region packages/ic-suite/codependix/codependix-boundaries/src/modules/boundary-check/boundary-check.constants.ts
+var k = "workspace", A = [
+	"nxProjects",
+	"nestjsModules",
+	"typescript",
+	"python"
+], j = class {
+	constructor() {}
+	buildFileNodes(e) {
+		return e.fileNames.map((t) => ({
+			id: t,
+			path: t,
+			project: e.projectName
+		}));
+	}
+	resolveProjectRoot(e, t) {
+		return e === void 0 ? void 0 : n.relative(t, e);
+	}
+	buildNestjsGraph(e) {
+		return {
+			edges: e.edges,
+			level: "nestjsModules",
+			nodes: e.nodes.map((t) => ({
+				id: t.name,
+				path: t.declaringFile,
+				project: e.projectName
+			})),
+			scope: e.projectName
+		};
+	}
+	buildNxGraph(e) {
+		let t = new Map(e.projects.map((e) => [e.name, e]));
+		return {
+			edges: e.workspaceGraph.edges,
+			level: "nxProjects",
+			nodes: e.workspaceGraph.projectNames.map((n) => ({
+				id: n,
+				path: this.resolveProjectRoot(t.get(n)?.absoluteRoot, e.workingDirectory),
+				project: n,
+				tags: t.get(n)?.tags
+			})),
+			scope: e.scope
+		};
+	}
+	buildPythonImportGraph(e) {
+		return {
+			edges: e.edges,
+			level: "python",
+			nodes: this.buildFileNodes({
+				fileNames: e.fileNames,
+				projectName: e.projectName
+			}),
+			scope: e.projectName
+		};
+	}
+	buildTypescriptImportGraph(e) {
+		return {
+			edges: e.edges,
+			level: "typescript",
+			nodes: this.buildFileNodes({
+				fileNames: e.fileNames,
+				projectName: e.projectName
+			}),
+			scope: e.projectName
+		};
+	}
+};
+j = C([e(), S("design:paramtypes", [])], j);
+//#endregion
+//#region packages/ic-suite/codependix/codependix-boundaries/src/modules/boundary-check/boundary-check.service.ts
+var M = class {
+	boundariesService;
+	boundaryGraphService;
+	moduleGraphService;
+	nestjsProjectService;
+	pythonService;
+	typescriptService;
+	workspaceGraphService;
+	constructor(e, t, n, r, i, a, o) {
+		this.boundariesService = e, this.boundaryGraphService = t, this.moduleGraphService = n, this.nestjsProjectService = r, this.pythonService = i, this.typescriptService = a, this.workspaceGraphService = o;
+	}
+	collectProjectFailure(e, t) {
+		return {
+			error: t instanceof Error ? t.message : String(t),
+			projectName: e
+		};
+	}
+	graphTypeForLevel(e) {
+		return {
+			nestjsModules: "nestjsModules",
+			nxProjects: "nxProjects",
+			python: "fileImports",
+			typescript: "fileImports"
+		}[e];
+	}
+	rulesForLevel(e, t) {
+		return {
+			nestjsModules: e.nestjsModules,
+			nxProjects: e.nxProjects,
+			python: e.fileImports.python,
+			typescript: e.fileImports.typescript
+		}[t];
+	}
+	async runLevel(e) {
+		return {
+			nestjsModules: async (e) => this.runNestjsLevel(e),
+			nxProjects: (e) => this.runNxLevel(e),
+			python: async (e) => this.runPythonImportsLevel(e),
+			typescript: async (e) => this.runTypescriptImportsLevel(e)
+		}[e.level](e);
+	}
+	async runNestjsLevel(e) {
+		return this.runProjectLevel({
+			buildGraph: async (e) => this.boundaryGraphService.buildNestjsGraph(this.moduleGraphService.buildGraph(await this.nestjsProjectService.exploreProject(e), e.name)),
+			projects: this.nestjsProjectService.discoverProjects(e.context.selectedProjects),
+			rules: e.rules
+		});
+	}
+	runNxLevel(e) {
+		let { context: t, rules: n } = e;
+		try {
+			let e = this.boundaryGraphService.buildNxGraph({
+				projects: t.selectedProjects,
+				scope: k,
+				workingDirectory: t.workingDirectory,
+				workspaceGraph: this.workspaceGraphService.buildWorkspaceGraph(t.graph, t.selectedProjects)
+			});
+			return {
+				failures: [],
+				violations: this.boundariesService.evaluate({
+					graph: e,
+					rules: n
+				})
+			};
+		} catch (e) {
+			return {
+				failures: [this.collectProjectFailure(k, e)],
+				violations: []
+			};
+		}
+	}
+	async runProjectLevel(e) {
+		let t = [], n = [];
+		for (let r of e.projects) try {
+			let t = await e.buildGraph(r);
+			n.push(...this.boundariesService.evaluate({
+				graph: t,
+				rules: e.rules
+			}));
+		} catch (e) {
+			t.push(this.collectProjectFailure(r.name, e));
+		}
+		return {
+			failures: t,
+			violations: n
+		};
+	}
+	async runPythonImportsLevel(e) {
+		return this.runProjectLevel({
+			buildGraph: (e) => this.boundaryGraphService.buildPythonImportGraph(this.pythonService.buildGraph(e)),
+			projects: this.pythonService.discoverProjects(e.context.selectedProjects),
+			rules: e.rules
+		});
+	}
+	async runTypescriptImportsLevel(e) {
+		return this.runProjectLevel({
+			buildGraph: (e) => this.boundaryGraphService.buildTypescriptImportGraph(this.typescriptService.buildGraph(this.typescriptService.buildProgram(e))),
+			projects: this.typescriptService.discoverProjects(e.context.selectedProjects),
+			rules: e.rules
+		});
+	}
+	async run(e) {
+		let { boundaries: t } = e.configuration, n = [];
+		for (let r of A) {
+			if (!e.enabledGraphTypes.has(this.graphTypeForLevel(r))) continue;
+			let i = this.rulesForLevel(t, r);
+			i.length > 0 && n.push(await this.runLevel({
+				context: e,
+				level: r,
+				rules: i
+			}));
+		}
+		return {
+			failures: n.flatMap((e) => e.failures),
+			violations: n.flatMap((e) => e.violations)
+		};
+	}
+};
+M = C([e(), S("design:paramtypes", [
+	E === void 0 ? Object : E,
+	j === void 0 ? Object : j,
+	c === void 0 ? Object : c,
+	u === void 0 ? Object : u,
+	i === void 0 ? Object : i,
+	o === void 0 ? Object : o,
+	m === void 0 ? Object : m
+])], M);
+//#endregion
+//#region packages/ic-suite/codependix/codependix-boundaries/src/modules/boundary-check/boundary-check.module.ts
+var N = class {};
+N = C([t({
+	controllers: [],
+	exports: [
+		O,
+		M,
+		j
+	],
+	imports: [
+		O,
+		s,
+		l,
+		r,
+		a,
+		p
+	],
+	providers: [M, j]
+})], N);
+//#endregion
+//#region packages/ic-suite/codependix/codependix-boundaries/src/modules/run-context/run-context.service.ts
+var P = class {
+	configurationService;
+	neighborhoodService;
+	constructor(e, t) {
+		this.configurationService = e, this.neighborhoodService = t;
+	}
+	async loadProjectConfigurations(e) {
+		let t = await Promise.all(e.map(async (e) => [e.name, await this.configurationService.loadProjectConfiguration({ projectRoot: e.absoluteRoot })]));
+		return new Map(t);
+	}
+	resolveEnabledGraphTypes(e) {
+		return new Set(h.filter((t) => e[t] !== !1));
+	}
+	resolveProjectGraphPath(e, t) {
+		return e === void 0 ? void 0 : n.resolve(t, e);
+	}
+	selectProjects(e) {
+		return e.projects.filter((t) => this.configurationService.isProjectSelected({
+			configuration: e.configuration,
+			projectName: t.name,
+			projectRoot: n.relative(e.workingDirectory, t.absoluteRoot),
+			projectTags: t.tags
+		}));
+	}
+	async build(e) {
+		let { mode: t, options: n, workingDirectory: r } = e, i = await this.configurationService.loadConfiguration({
+			configurationPath: n.config,
+			overrides: {
+				exclude: n.exclude,
+				include: n.include
+			},
+			searchDirectory: r,
+			selection: {
+				projects: n.projects,
+				tags: n.tags
+			}
+		}), a = await this.neighborhoodService.readProjectGraph(this.resolveProjectGraphPath(i.projectGraph, r)), o = this.neighborhoodService.readProjects(a, r), s = await this.loadProjectConfigurations(o);
+		return {
+			configuration: i,
+			enabledGraphTypes: this.resolveEnabledGraphTypes(n),
+			graph: a,
+			mode: t,
+			projectConfigurations: s,
+			projects: o,
+			selectedProjects: this.selectProjects({
+				configuration: i,
+				projects: o,
+				workingDirectory: r
+			}),
+			workingDirectory: r
+		};
+	}
+};
+P = C([e(), S("design:paramtypes", [_ === void 0 ? Object : _, f === void 0 ? Object : f])], P);
+//#endregion
+//#region packages/ic-suite/codependix/codependix-boundaries/src/modules/run-context/run-context.module.ts
+var F = class {};
+F = C([t({
+	controllers: [],
+	exports: [P],
+	imports: [g, d],
+	providers: [P]
+})], F);
+//#endregion
+export { A as BOUNDARY_LEVEL_ORDER, O as BoundariesModule, E as BoundariesService, N as BoundaryCheckModule, M as BoundaryCheckService, w as BoundaryCyclesService, j as BoundaryGraphService, D as BoundaryReportService, T as BoundarySelectorService, v as CYCLE_SEPARATOR, F as RunContextModule, P as RunContextService, k as WORKSPACE_SCOPE, y as describeCycle, b as describeDisallowedEdge, x as describeForbiddenEdge };

package/package.json

@@ -0,0 +1,65 @@
+{
+  "author": "Jimmy Paolini",
+  "bugs": {
+    "url": "https://github.com/organizzolini/codebase/issues"
+  },
+  "dependencies": {
+    "@codependix/configuration": "0.0.3",
+    "@codependix/core": "0.0.3",
+    "@codependix/file-imports": "0.0.3",
+    "@codependix/nestjs-modules": "0.0.3",
+    "@codependix/nx-projects": "0.0.3",
+    "@nestjs/common": "^11.1.21 || ^12.0.1",
+    "reflect-metadata": "^0.2.2"
+  },
+  "description": "Boundary rule validation, forbid/allow rule enforcement, and cycle detection for Codependix graphs",
+  "devDependencies": {
+    "@golevelup/ts-vitest": "^4.0.0",
+    "@nestjs/testing": "^12.0.1",
+    "@nx/eslint-plugin": "^23.0.0",
+    "@swc/helpers": "^0.5.21",
+    "@types/node": "^26.5.1",
+    "@vitest/coverage-v8": "^5.0.0",
+    "typescript": "^6.0.3",
+    "vitest": "^5.0.0"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "default": "./dist/src/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "homepage": "https://github.com/organizzolini/codebase/tree/main/packages/ic-suite/codependix/codependix-boundaries#readme",
+  "keywords": [
+    "boundaries",
+    "codependix",
+    "cycle-detection",
+    "linting",
+    "rule-enforcement"
+  ],
+  "license": "MIT",
+  "main": "./dist/src/index.js",
+  "name": "@codependix/boundaries",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "repository": {
+    "directory": "packages/ic-suite/codependix/codependix-boundaries",
+    "type": "git",
+    "url": "git+https://github.com/organizzolini/codebase.git"
+  },
+  "type": "module",
+  "typeCoverage": {
+    "atLeast": 100,
+    "strict": true
+  },
+  "types": "./dist/src/index.d.ts",
+  "version": "0.0.3"
+}