@alveolus/arch 0.1.0-alpha.0 → 0.1.0

package/dist/cli-CW1zAnrP.mjs

@@ -1,1229 +0,0 @@
-import { Command, CommanderError } from "commander";
-import { basename, dirname, isAbsolute, join, matchesGlob, relative, resolve, sep } from "node:path";
-import { Project, Scope, SyntaxKind } from "ts-morph";
-import { existsSync } from "node:fs";
-import { readFile, writeFile } from "node:fs/promises";
-import { createJiti } from "jiti";
-import { z } from "zod";
-import picocolors from "picocolors";
-//#region src/analysis/code-analyzer.ts
-var CodeAnalyzer = class {};
-//#endregion
-//#region src/codebase/code-class.ts
-var CodeClass = class {
-	name;
-	line;
-	isAbstract;
-	constructorParameters;
-	fields;
-	publicMethods;
-	kinds;
-	markers;
-	constructor(props) {
-		this.name = props.name;
-		this.line = props.line;
-		this.isAbstract = props.isAbstract;
-		this.kinds = props.kinds;
-		this.markers = props.markers;
-		this.constructorParameters = props.constructorParameters;
-		this.fields = props.fields;
-		this.publicMethods = props.publicMethods;
-	}
-	is(kind) {
-		return this.kinds.includes(kind);
-	}
-	implements(marker) {
-		return this.markers.includes(marker);
-	}
-	get extendsBuildingBlock() {
-		return this.kinds.length > 0;
-	}
-	get hasMarker() {
-		return this.markers.length > 0;
-	}
-};
-//#endregion
-//#region src/codebase/code-file.ts
-var CodeFile = class {
-	path;
-	location;
-	imports;
-	classes;
-	declarations;
-	domainErrorThrows;
-	constructor(props) {
-		this.path = props.path;
-		this.location = props.location;
-		this.imports = props.imports;
-		this.classes = props.classes;
-		this.declarations = props.declarations;
-		this.domainErrorThrows = props.domainErrorThrows;
-	}
-	declaresOpenHostService(name) {
-		return this.classes.some((codeClass) => codeClass.name === name && codeClass.implements("OpenHostService"));
-	}
-	get declaresAntiCorruptionLayer() {
-		return this.classes.some((codeClass) => codeClass.implements("AntiCorruptionLayer"));
-	}
-};
-//#endregion
-//#region src/codebase/codebase.ts
-var Codebase = class {
-	files;
-	config;
-	filesByPath;
-	constructor(files, config) {
-		this.files = files;
-		this.config = config;
-		this.filesByPath = new Map(files.map((file) => [file.path, file]));
-	}
-	file(path) {
-		return this.filesByPath.get(path);
-	}
-	relativePath(path) {
-		return relative(this.config.projectDir, path).split(sep).join("/");
-	}
-};
-//#endregion
-//#region src/codebase/core-api.ts
-var CoreApi = class CoreApi {
-	static packageName = "@alveolus/core";
-	static domainSymbols = /* @__PURE__ */ new Set([
-		"AggregateRoot",
-		"AnyAggregateRoot",
-		"AnyDomainError",
-		"AnyDomainEvent",
-		"AnyEntity",
-		"AnyIdentifier",
-		"AnySnapshot",
-		"AnyValueObject",
-		"Clock",
-		"CommandRepository",
-		"DomainError",
-		"DomainEvent",
-		"DomainEventProps",
-		"DomainService",
-		"Entity",
-		"Err",
-		"IdGenerator",
-		"Identifier",
-		"IdentifierValue",
-		"Ok",
-		"Port",
-		"QueryRepository",
-		"Result",
-		"SnapshotValue",
-		"ValueObject",
-		"View",
-		"andThen",
-		"combine",
-		"err",
-		"map",
-		"mapErr",
-		"ok"
-	]);
-	static publishedLanguageSymbols = /* @__PURE__ */ new Set([
-		"AnyIntegrationEvent",
-		"IntegrationEvent",
-		"JsonValue",
-		"PublishedLanguage"
-	]);
-	static markers = /* @__PURE__ */ new Set(["OpenHostService", "AntiCorruptionLayer"]);
-	static kinds = /* @__PURE__ */ new Set([
-		"AggregateRoot",
-		"Entity",
-		"ValueObject",
-		"Identifier",
-		"DomainEvent",
-		"DomainError",
-		"DomainService",
-		"Port",
-		"CommandRepository",
-		"QueryRepository",
-		"CommandHandler",
-		"QueryHandler",
-		"EventTranslator",
-		"EventPublisher",
-		"Outbox",
-		"UnitOfWork"
-	]);
-	static isDomainSymbol(name) {
-		return CoreApi.domainSymbols.has(name);
-	}
-	static isPublishedLanguageSymbol(name) {
-		return CoreApi.publishedLanguageSymbols.has(name);
-	}
-	static isKind(name) {
-		return CoreApi.kinds.has(name);
-	}
-	static isMarker(name) {
-		return CoreApi.markers.has(name);
-	}
-};
-//#endregion
-//#region src/codebase/declaration.ts
-var Declaration = class {
-	kind;
-	name;
-	line;
-	constructor(kind, name, line) {
-		this.kind = kind;
-		this.name = name;
-		this.line = line;
-	}
-};
-//#endregion
-//#region src/codebase/import.ts
-var Import = class {
-	line;
-	specifier;
-	names;
-	target;
-	constructor(line, specifier, names, target) {
-		this.line = line;
-		this.specifier = specifier;
-		this.names = names;
-		this.target = target;
-	}
-	get label() {
-		return this.names.length === 0 ? this.specifier : this.names.join(", ");
-	}
-	isFromPackage(name) {
-		return this.target.kind === "package" && this.target.name === name;
-	}
-};
-//#endregion
-//#region src/codebase/location.ts
-var Location = class {
-	area;
-	context;
-	layer;
-	folder;
-	fileName;
-	isCompositionRoot;
-	constructor(props) {
-		this.area = props.area;
-		this.context = props.context;
-		this.layer = props.layer;
-		this.folder = props.folder;
-		this.fileName = props.fileName;
-		this.isCompositionRoot = props.isCompositionRoot ?? false;
-	}
-	get isInBoundedContext() {
-		return this.area === "context";
-	}
-	get isInSharedKernel() {
-		return this.area === "shared-kernel";
-	}
-	get isAtRoot() {
-		return this.area === "root";
-	}
-	get isOutside() {
-		return this.area === "outside";
-	}
-	get isInLayer() {
-		return this.layer !== void 0;
-	}
-	isSameContextAs(other) {
-		return this.context !== void 0 && this.context === other.context;
-	}
-	isOtherBoundedContextThan(other) {
-		return this.isInBoundedContext && !this.isSameContextAs(other);
-	}
-	describe() {
-		if (this.isOutside) return "outside the declared bounded contexts and shared kernel";
-		if (this.isAtRoot) return "at the root";
-		const role = this.isCompositionRoot ? "composition root" : this.layer ?? "outside the layers";
-		return `${this.context} ${role}`;
-	}
-};
-//#endregion
-//#region src/codebase/layout.ts
-const layers = /* @__PURE__ */ new Set([
-	"domain",
-	"application",
-	"published-language",
-	"driven",
-	"driving"
-]);
-var Layout = class {
-	config;
-	constructor(config) {
-		this.config = config;
-	}
-	locate(path) {
-		const fileName = basename(path);
-		const folder = this.contextFolderOf(path);
-		if (folder === void 0) return new Location({
-			area: dirname(path) === this.config.rootDir ? "root" : "outside",
-			fileName
-		});
-		const area = folder.isSharedKernel ? "shared-kernel" : "context";
-		const context = folder.name;
-		const directories = this.directoriesBetween(folder.dir, path);
-		if (directories.length === 0) return new Location({
-			area,
-			context,
-			fileName,
-			isCompositionRoot: this.isCompositionRoot(fileName)
-		});
-		const layerIndex = directories.findIndex((directory) => layers.has(directory));
-		if (layerIndex === -1) return new Location({
-			area,
-			context,
-			fileName,
-			isCompositionRoot: folder.isSharedKernel && directories.length === 1 && this.isCompositionRoot(fileName)
-		});
-		const layer = directories[layerIndex];
-		const subfolder = directories.length - 1 > layerIndex ? directories.at(-1) : void 0;
-		return new Location({
-			area,
-			context,
-			fileName,
-			layer,
-			...subfolder === void 0 ? {} : { folder: subfolder }
-		});
-	}
-	isCompositionRoot(fileName) {
-		return matchesGlob(fileName, this.config.compositionRoot);
-	}
-	contextFolderOf(path) {
-		return this.config.contextFolders.filter((folder) => this.isInside(folder.dir, path)).sort((left, right) => right.dir.length - left.dir.length)[0];
-	}
-	directoriesBetween(dir, path) {
-		const between = relative(dir, dirname(path));
-		return between === "" ? [] : between.split(sep);
-	}
-	isInside(dir, path) {
-		const offset = relative(dir, path);
-		return offset !== "" && !offset.startsWith("..") && !isAbsolute(offset);
-	}
-};
-//#endregion
-//#region src/codebase/method.ts
-var Method = class {
-	name;
-	line;
-	returnsResult;
-	constructor(name, line, returnsResult) {
-		this.name = name;
-		this.line = line;
-		this.returnsResult = returnsResult;
-	}
-};
-//#endregion
-//#region src/codebase/type-usage.ts
-var TypeUsage = class {
-	member;
-	line;
-	typeName;
-	kinds;
-	constructor(member, line, typeName, kinds) {
-		this.member = member;
-		this.line = line;
-		this.typeName = typeName;
-		this.kinds = kinds;
-	}
-	is(kind) {
-		return this.kinds.includes(kind);
-	}
-};
-//#endregion
-//#region src/analysis/class-reader.ts
-var ClassReader = class {
-	types;
-	constructor(types) {
-		this.types = types;
-	}
-	read(declaration) {
-		const parameters = declaration.getConstructors()[0]?.getParameters() ?? [];
-		const parameterProperties = parameters.filter((parameter) => parameter.isParameterProperty());
-		return new CodeClass({
-			constructorParameters: parameters.flatMap((parameter) => this.usagesOf(parameter)),
-			fields: [...declaration.getProperties(), ...parameterProperties].flatMap((member) => this.usagesOf(member)),
-			isAbstract: declaration.isAbstract(),
-			kinds: this.types.kindsOf(declaration.getType()),
-			line: declaration.getStartLineNumber(),
-			markers: this.markersOf(declaration),
-			name: declaration.getName() ?? "default",
-			publicMethods: this.publicMethodsOf(declaration)
-		});
-	}
-	markersOf(declaration) {
-		const markers = [];
-		for (const clause of declaration.getImplements()) {
-			const marker = this.types.markerOf(clause.getType());
-			if (marker !== void 0) markers.push(marker);
-		}
-		return markers;
-	}
-	publicMethodsOf(declaration) {
-		return declaration.getMethods().filter((method) => !method.isStatic() && method.getScope() === Scope.Public).map((method) => new Method(method.getName(), method.getStartLineNumber(), this.types.isResult(method.getReturnType())));
-	}
-	usagesOf(member) {
-		return this.types.classTypesIn(member.getType()).map((type) => new TypeUsage(member.getName(), member.getStartLineNumber(), type.getSymbol()?.getName() ?? type.getText(), this.types.kindsOf(type)));
-	}
-};
-//#endregion
-//#region src/analysis/package-names.ts
-var PackageNames = class {
-	fileSystem;
-	cache = /* @__PURE__ */ new Map();
-	constructor(fileSystem) {
-		this.fileSystem = fileSystem;
-	}
-	ofFile(path) {
-		return this.ofDirectory(dirname(path));
-	}
-	ofDirectory(directory) {
-		if (this.cache.has(directory)) return this.cache.get(directory);
-		const name = this.readManifest(directory) ?? this.ofParent(directory);
-		this.cache.set(directory, name);
-		return name;
-	}
-	ofParent(directory) {
-		const parent = dirname(directory);
-		return parent === directory ? void 0 : this.ofDirectory(parent);
-	}
-	readManifest(directory) {
-		const manifest = join(directory, "package.json");
-		if (!this.fileSystem.fileExistsSync(manifest)) return;
-		const content = JSON.parse(this.fileSystem.readFileSync(manifest));
-		return typeof content.name === "string" ? content.name : void 0;
-	}
-};
-//#endregion
-//#region src/analysis/type-inspector.ts
-const containers = /* @__PURE__ */ new Set([
-	"Array",
-	"ReadonlyArray",
-	"Map",
-	"ReadonlyMap",
-	"Set",
-	"ReadonlySet",
-	"Readonly",
-	"Promise"
-]);
-var TypeInspector = class {
-	packageNames;
-	constructor(packageNames) {
-		this.packageNames = packageNames;
-	}
-	kindsOf(type) {
-		const classType = type.getTargetType() ?? type;
-		const symbol = classType.getSymbol();
-		if (symbol === void 0 || !classType.isClass()) return [];
-		const kinds = [];
-		const name = symbol.getName();
-		if (CoreApi.isKind(name) && this.isCore(symbol)) kinds.push(name);
-		for (const base of classType.getBaseTypes()) kinds.push(...this.kindsOf(base));
-		return kinds;
-	}
-	markerOf(type) {
-		const symbol = type.getSymbol();
-		if (symbol === void 0) return;
-		const name = symbol.getName();
-		return CoreApi.isMarker(name) && this.isCore(symbol) ? name : void 0;
-	}
-	isResult(type) {
-		const alias = type.getAliasSymbol();
-		if (alias !== void 0 && alias.getName() === "Result" && this.isCore(alias)) return true;
-		return (type.isUnion() ? type.getUnionTypes() : [type]).every((member) => this.isOkOrErr(member));
-	}
-	classTypesIn(type) {
-		if (type.isUnion()) return type.getUnionTypes().flatMap((member) => this.classTypesIn(member));
-		if (type.isIntersection()) return type.getIntersectionTypes().flatMap((member) => this.classTypesIn(member));
-		const element = type.getArrayElementType();
-		if (element !== void 0) return this.classTypesIn(element);
-		if (this.isContainer(type)) return [...type.getTypeArguments(), ...type.getAliasTypeArguments()].flatMap((argument) => this.classTypesIn(argument));
-		return type.isClass() ? [type] : [];
-	}
-	isContainer(type) {
-		const name = type.getSymbol()?.getName() ?? type.getAliasSymbol()?.getName();
-		return name !== void 0 && containers.has(name);
-	}
-	isOkOrErr(type) {
-		const symbol = type.getSymbol();
-		if (symbol === void 0) return false;
-		const name = symbol.getName();
-		return (name === "Ok" || name === "Err") && this.isCore(symbol);
-	}
-	isCore(symbol) {
-		const declaration = symbol.getDeclarations()[0];
-		if (declaration === void 0) return false;
-		return this.packageNames.ofFile(declaration.getSourceFile().getFilePath()) === CoreApi.packageName;
-	}
-};
-//#endregion
-//#region src/analysis/ts-morph-analyzer.ts
-var TsMorphAnalyzer = class TsMorphAnalyzer extends CodeAnalyzer {
-	project;
-	types;
-	classes;
-	constructor(project) {
-		super();
-		this.project = project;
-		this.types = new TypeInspector(new PackageNames(project.getFileSystem()));
-		this.classes = new ClassReader(this.types);
-	}
-	static fromTsConfig(projectDir) {
-		return new TsMorphAnalyzer(new Project({ tsConfigFilePath: join(projectDir, "tsconfig.json") }));
-	}
-	analyze(config) {
-		const layout = new Layout(config);
-		return new Codebase(this.project.getSourceFiles().filter((file) => this.isInside(config.rootDir, file.getFilePath()) && !config.isIgnored(file.getFilePath())).map((file) => this.read(file, config, layout)), config);
-	}
-	read(file, config, layout) {
-		const path = file.getFilePath();
-		const imports = this.moduleDeclarationsOf(file).map((declaration) => this.readImport(declaration, config, layout));
-		return new CodeFile({
-			classes: file.getClasses().map((declaration) => this.classes.read(declaration)),
-			declarations: this.declarationsOf(file),
-			domainErrorThrows: this.domainErrorThrowsOf(file),
-			imports,
-			location: layout.locate(path),
-			path
-		});
-	}
-	declarationsOf(file) {
-		const functions = file.getFunctions().map((declaration) => new Declaration("function", declaration.getName() ?? "default", declaration.getStartLineNumber()));
-		const functionConstants = file.getVariableDeclarations().filter((declaration) => declaration.getInitializerIfKind(SyntaxKind.ArrowFunction) !== void 0 || declaration.getInitializerIfKind(SyntaxKind.FunctionExpression) !== void 0).map((declaration) => new Declaration("function", declaration.getName(), declaration.getStartLineNumber()));
-		const enums = file.getEnums().map((declaration) => new Declaration("enum", declaration.getName(), declaration.getStartLineNumber()));
-		return [
-			...functions,
-			...functionConstants,
-			...enums
-		];
-	}
-	moduleDeclarationsOf(file) {
-		const reexports = file.getExportDeclarations().filter((declaration) => declaration.hasModuleSpecifier());
-		return [...file.getImportDeclarations(), ...reexports];
-	}
-	readImport(declaration, config, layout) {
-		const specifier = declaration.getModuleSpecifierValue() ?? "";
-		return new Import(declaration.getStartLineNumber(), specifier, this.importedNames(declaration), this.targetOf(declaration, specifier, config, layout));
-	}
-	importedNames(declaration) {
-		if (declaration.isKind(SyntaxKind.ExportDeclaration)) return declaration.isNamespaceExport() ? ["*"] : declaration.getNamedExports().map((named) => named.getName());
-		const names = declaration.getNamedImports().map((named) => named.getName());
-		if (declaration.getDefaultImport() !== void 0) names.unshift("default");
-		if (declaration.getNamespaceImport() !== void 0) names.unshift("*");
-		return names;
-	}
-	targetOf(declaration, specifier, config, layout) {
-		const resolved = declaration.getModuleSpecifierSourceFile()?.getFilePath();
-		if (resolved !== void 0 && this.isInside(config.projectDir, resolved)) return {
-			kind: "file",
-			location: layout.locate(resolved),
-			path: resolved
-		};
-		if (specifier.startsWith(".")) {
-			const path = join(declaration.getSourceFile().getDirectoryPath(), specifier);
-			return {
-				kind: "file",
-				location: layout.locate(path),
-				path
-			};
-		}
-		return {
-			kind: "package",
-			name: this.packageNameOf(specifier)
-		};
-	}
-	packageNameOf(specifier) {
-		const segments = specifier.split("/");
-		const length = specifier.startsWith("@") ? 2 : 1;
-		return segments.slice(0, length).join("/");
-	}
-	domainErrorThrowsOf(file) {
-		return file.getDescendantsOfKind(SyntaxKind.ThrowStatement).filter((statement) => this.types.kindsOf(statement.getExpression().getType()).includes("DomainError")).map((statement) => statement.getStartLineNumber());
-	}
-	isInside(directory, path) {
-		const offset = relative(directory, path);
-		return offset !== "" && !offset.startsWith("..") && !isAbsolute(offset) && !offset.split(/[\\/]/).includes("node_modules");
-	}
-};
-//#endregion
-//#region src/baseline/baseline.ts
-var Baseline = class Baseline {
-	entries;
-	static fileName = "alveolus.baseline.json";
-	constructor(entries) {
-		this.entries = entries;
-	}
-	static of(violations) {
-		return new Baseline(violations.map(({ file, rule, symbol }) => ({
-			file,
-			rule,
-			symbol
-		})));
-	}
-	static async load(path) {
-		if (!existsSync(path)) return new Baseline([]);
-		const content = JSON.parse(await readFile(path, "utf8"));
-		return new Baseline(content.violations ?? []);
-	}
-	newViolations(violations) {
-		const remaining = /* @__PURE__ */ new Map();
-		for (const entry of this.entries) remaining.set(this.keyOf(entry), (remaining.get(this.keyOf(entry)) ?? 0) + 1);
-		const fresh = [];
-		for (const violation of violations) {
-			const key = this.keyOf(violation);
-			const count = remaining.get(key) ?? 0;
-			if (count > 0) remaining.set(key, count - 1);
-			else fresh.push(violation);
-		}
-		return fresh;
-	}
-	async save(path) {
-		const violations = [...this.entries].sort((left, right) => this.keyOf(left).localeCompare(this.keyOf(right)));
-		await writeFile(path, `${JSON.stringify({ violations }, null, "	")}\n`);
-	}
-	keyOf(entry) {
-		return [
-			entry.rule,
-			entry.file,
-			entry.symbol
-		].join("\n");
-	}
-};
-//#endregion
-//#region src/checker/arch-checker.ts
-var ArchChecker = class {
-	analyzer;
-	rules;
-	constructor(analyzer, rules) {
-		this.analyzer = analyzer;
-		this.rules = rules;
-	}
-	check(config) {
-		const codebase = this.analyzer.analyze(config);
-		return this.rules.filter((rule) => config.isEnabled(rule.id)).flatMap((rule) => rule.check(codebase)).sort((left, right) => this.compare(left, right));
-	}
-	compare(left, right) {
-		return left.file.localeCompare(right.file) || left.line - right.line || left.rule.localeCompare(right.rule);
-	}
-};
-//#endregion
-//#region src/config/config.ts
-const testFiles = [
-	"**/*.spec.ts",
-	"**/*.test.ts",
-	"**/__tests__/**"
-];
-var Config = class {
-	projectDir;
-	rootDir;
-	compositionRoot;
-	domainDependencies;
-	contextFolders;
-	ignored;
-	rules;
-	constructor(config, projectDir) {
-		this.projectDir = resolve(projectDir);
-		this.rootDir = resolve(projectDir, config.root);
-		this.compositionRoot = config.compositionRoot ?? "*.module.ts";
-		this.domainDependencies = config.domainDependencies ?? [];
-		this.ignored = [...testFiles, ...config.ignore ?? []];
-		this.rules = config.rules;
-		const sharedKernel = config.sharedKernel ?? "shared-kernel";
-		this.contextFolders = [...Object.entries(config.boundedContexts).map(([name, folder]) => ({
-			dir: resolve(this.rootDir, folder),
-			isSharedKernel: false,
-			name
-		})), {
-			dir: resolve(this.rootDir, sharedKernel),
-			isSharedKernel: true,
-			name: "shared kernel"
-		}];
-	}
-	isIgnored(path) {
-		const projectPath = relative(this.projectDir, path).split(sep).join("/");
-		return this.ignored.some((glob) => matchesGlob(projectPath, glob));
-	}
-	isEnabled(rule) {
-		return this.rules?.[rule] !== "off";
-	}
-};
-//#endregion
-//#region src/config/config-loader.ts
-const ruleSetting = z.enum(["error", "off"]);
-const schema = z.strictObject({
-	boundedContexts: z.record(z.string(), z.string()),
-	compositionRoot: z.string().exactOptional(),
-	domainDependencies: z.array(z.string()).exactOptional(),
-	ignore: z.array(z.string()).exactOptional(),
-	root: z.string(),
-	rules: z.strictObject({
-		"bc-isolation": ruleSetting.exactOptional(),
-		"building-blocks-only": ruleSetting.exactOptional(),
-		"command-query-separation": ruleSetting.exactOptional(),
-		"domain-purity": ruleSetting.exactOptional(),
-		"driven-adapters-extend-port": ruleSetting.exactOptional(),
-		"errors-as-values": ruleSetting.exactOptional(),
-		"layer-direction": ruleSetting.exactOptional(),
-		placement: ruleSetting.exactOptional(),
-		"reference-by-identity": ruleSetting.exactOptional()
-	}).exactOptional(),
-	sharedKernel: z.string().exactOptional()
-});
-var ConfigLoader = class ConfigLoader {
-	static fileName = "alveolus.config.ts";
-	async load(projectDir, configFile = ConfigLoader.fileName) {
-		const path = resolve(projectDir, configFile);
-		if (!existsSync(path)) throw new Error(`No configuration found at ${path}.`);
-		const exported = await createJiti(import.meta.url).import(path, { default: true });
-		return new Config(this.validate(exported, path), projectDir);
-	}
-	validate(exported, path) {
-		const parsed = schema.safeParse(exported);
-		if (!parsed.success) throw new Error(`Invalid configuration in ${path}:\n${z.prettifyError(parsed.error)}`);
-		return parsed.data;
-	}
-};
-//#endregion
-//#region src/report/report.ts
-var Report = class {
-	violations;
-	baselined;
-	colors;
-	constructor(violations, baselined, colored = false) {
-		this.violations = violations;
-		this.baselined = baselined;
-		this.colors = picocolors.createColors(colored);
-	}
-	text() {
-		return `${[...this.violations.map((violation) => this.block(violation)), this.summary()].join("\n\n")}\n`;
-	}
-	json() {
-		return `${JSON.stringify({
-			baselined: this.baselined,
-			violations: this.violations
-		}, null, "	")}\n`;
-	}
-	block(violation) {
-		const { bold, red } = this.colors;
-		return `${bold(`${violation.file}:${violation.line}`)}\n  ${red(violation.rule)}: ${violation.message}`;
-	}
-	summary() {
-		const { dim, green, red } = this.colors;
-		const count = this.violations.length;
-		const baselined = this.baselined > 0 ? dim(` (${this.baselined} in the baseline)`) : "";
-		if (count === 0) return `${green("No violation")}${baselined}`;
-		return `${red(`${count} violation${count === 1 ? "" : "s"}`)}${baselined}`;
-	}
-};
-//#endregion
-//#region src/rules/rule.ts
-var Rule = class {
-	violation(codebase, file, problem) {
-		return {
-			file: codebase.relativePath(file.path),
-			line: problem.line,
-			message: problem.message,
-			rule: this.id,
-			symbol: problem.symbol
-		};
-	}
-};
-//#endregion
-//#region src/rules/import-rule.ts
-var ImportRule = class extends Rule {
-	check(codebase) {
-		const violations = [];
-		for (const file of codebase.files) {
-			if (!this.appliesTo(file)) continue;
-			for (const imported of file.imports) {
-				const message = this.problemWith(imported, file, codebase);
-				if (message !== void 0) violations.push(this.violation(codebase, file, {
-					line: imported.line,
-					message,
-					symbol: imported.label
-				}));
-			}
-		}
-		return violations;
-	}
-	describeTarget(imported, codebase) {
-		if (imported.target.kind === "package") return imported.target.name;
-		return `${codebase.relativePath(imported.target.path)} (${imported.target.location.describe()})`;
-	}
-};
-//#endregion
-//#region src/rules/bc-isolation.rule.ts
-var BcIsolationRule = class extends ImportRule {
-	id = "bc-isolation";
-	appliesTo(file) {
-		return file.location.isInBoundedContext || file.location.isInSharedKernel;
-	}
-	problemWith(imported, file, codebase) {
-		if (imported.target.kind !== "file") return;
-		const from = file.location;
-		const to = imported.target.location;
-		if (!to.isOtherBoundedContextThan(from)) return;
-		if (from.isInSharedKernel) return `The shared kernel imports no bounded context, but imports ${this.describeTarget(imported, codebase)}.`;
-		if (from.isCompositionRoot && to.isCompositionRoot) return;
-		if (to.layer === "published-language") return `Imports the published language of ${to.context}: redeclare the fields you read in your own published-language/.`;
-		if (!this.importsOnlyOpenHostServices(imported, codebase)) return `Imports ${this.describeTarget(imported, codebase)}: only an OpenHostService of another bounded context may be imported.`;
-		if (!from.isCompositionRoot && !file.declaresAntiCorruptionLayer) return `Uses the open host service of ${to.context} outside an AntiCorruptionLayer: translate it in an anti-corruption layer.`;
-	}
-	importsOnlyOpenHostServices(imported, codebase) {
-		if (imported.target.kind !== "file" || imported.names.length === 0) return false;
-		const target = codebase.file(imported.target.path);
-		return target !== void 0 && imported.names.every((name) => target.declaresOpenHostService(name));
-	}
-};
-//#endregion
-//#region src/rules/building-blocks-only.rule.ts
-const guarded = /* @__PURE__ */ new Set(["domain", "application"]);
-const blocksOf = {
-	application: "CommandHandler, QueryHandler or EventTranslator",
-	domain: "AggregateRoot, Entity, ValueObject, Identifier, DomainEvent, DomainError, DomainService or a Port"
-};
-var BuildingBlocksOnlyRule = class extends Rule {
-	id = "building-blocks-only";
-	check(codebase) {
-		const violations = [];
-		for (const file of codebase.files) {
-			if (!guarded.has(file.location.layer)) continue;
-			for (const problem of [...this.plainClasses(file), ...this.freeDeclarations(file)]) violations.push(this.violation(codebase, file, problem));
-		}
-		return violations;
-	}
-	plainClasses(file) {
-		const blocks = blocksOf[file.location.layer ?? ""];
-		return file.classes.filter((codeClass) => !codeClass.extendsBuildingBlock).map((codeClass) => ({
-			line: codeClass.line,
-			message: `${codeClass.name} extends no building block: extend ${blocks}.`,
-			symbol: codeClass.name
-		}));
-	}
-	freeDeclarations(file) {
-		return file.declarations.map((declaration) => {
-			if (declaration.kind === "enum") return {
-				line: declaration.line,
-				message: `The enum ${declaration.name} has no place here: use a union of literal types, or a ValueObject when it has behaviour.`,
-				symbol: declaration.name
-			};
-			return {
-				line: declaration.line,
-				message: `The function ${declaration.name} floats outside any class: make it a method of a value object or of a DomainService.`,
-				symbol: declaration.name
-			};
-		});
-	}
-};
-//#endregion
-//#region src/rules/class-rule.ts
-var ClassRule = class extends Rule {
-	check(codebase) {
-		const violations = [];
-		for (const file of codebase.files) for (const codeClass of file.classes) for (const problem of this.problemsWith(codeClass, file)) violations.push(this.violation(codebase, file, problem));
-		return violations;
-	}
-};
-//#endregion
-//#region src/rules/command-query-separation.rule.ts
-const separations = [{
-	forbidden: ["QueryRepository"],
-	handler: "CommandHandler"
-}, {
-	forbidden: [
-		"CommandRepository",
-		"Outbox",
-		"UnitOfWork",
-		"EventPublisher"
-	],
-	handler: "QueryHandler"
-}];
-var CommandQuerySeparationRule = class extends ClassRule {
-	id = "command-query-separation";
-	problemsWith(codeClass) {
-		const problems = [];
-		for (const { handler, forbidden } of separations) {
-			if (!codeClass.is(handler)) continue;
-			for (const parameter of codeClass.constructorParameters) {
-				const kind = forbidden.find((candidate) => parameter.is(candidate));
-				if (kind !== void 0) problems.push({
-					line: parameter.line,
-					message: `The ${handler} ${codeClass.name} receives ${parameter.typeName}, a ${kind}: keep commands and queries apart.`,
-					symbol: `${codeClass.name}.${parameter.member}`
-				});
-			}
-		}
-		return problems;
-	}
-};
-//#endregion
-//#region src/rules/domain-purity.rule.ts
-var DomainPurityRule = class extends ImportRule {
-	id = "domain-purity";
-	appliesTo(file) {
-		return file.location.layer === "domain";
-	}
-	problemWith(imported, file, codebase) {
-		const target = imported.target;
-		if (target.kind === "file") {
-			if (this.isDomainReachableFrom(target.location, file.location)) return;
-			return `The domain imports ${this.describeTarget(imported, codebase)}: it may only import the domain.`;
-		}
-		if (target.name === CoreApi.packageName) {
-			const forbidden = imported.names.filter((name) => !CoreApi.isDomainSymbol(name));
-			if (forbidden.length === 0) return;
-			return `The domain imports ${forbidden.join(", ")} from ${CoreApi.packageName}: only domain building blocks and Result are allowed.`;
-		}
-		if (codebase.config.domainDependencies.includes(target.name)) return;
-		return `The domain imports ${target.name}: add it to domainDependencies if the domain really needs it.`;
-	}
-	isDomainReachableFrom(to, from) {
-		return to.layer === "domain" && (to.isSameContextAs(from) || to.isInSharedKernel);
-	}
-};
-//#endregion
-//#region src/rules/driven-adapters-extend-port.rule.ts
-var DrivenAdaptersExtendPortRule = class extends ClassRule {
-	id = "driven-adapters-extend-port";
-	problemsWith(codeClass, file) {
-		const location = file.location;
-		if (this.isAdaptersFolder(location) && !codeClass.is("Port")) return [{
-			line: codeClass.line,
-			message: `${codeClass.name} is a driven adapter but extends no Port: extend the port it implements.`,
-			symbol: codeClass.name
-		}];
-		if (codeClass.is("Port") && codeClass.isAbstract && !this.isPortsFolder(location) && !this.isAdaptersFolder(location)) return [{
-			line: codeClass.line,
-			message: `The port ${codeClass.name} is declared outside the domain: move it to domain/ports/ or domain/repositories/.`,
-			symbol: codeClass.name
-		}];
-		return [];
-	}
-	isAdaptersFolder(location) {
-		return location.layer === "driven" && location.folder === "adapters";
-	}
-	isPortsFolder(location) {
-		return location.layer === "domain" && (location.folder === "ports" || location.folder === "repositories");
-	}
-};
-//#endregion
-//#region src/rules/errors-as-values.rule.ts
-const exempt = /* @__PURE__ */ new Set(["equals", "toSnapshot"]);
-var ErrorsAsValuesRule = class extends Rule {
-	id = "errors-as-values";
-	check(codebase) {
-		const violations = [];
-		for (const file of codebase.files) for (const problem of [...this.methodsWithoutResult(file), ...this.thrownErrors(file)]) violations.push(this.violation(codebase, file, problem));
-		return violations;
-	}
-	methodsWithoutResult(file) {
-		const problems = [];
-		for (const codeClass of file.classes.filter((candidate) => candidate.is("Entity"))) for (const method of codeClass.publicMethods) if (!exempt.has(method.name) && !method.returnsResult) problems.push({
-			line: method.line,
-			message: `${codeClass.name}.${method.name} must return a Result: expose reads as getters and return business failures as values.`,
-			symbol: `${codeClass.name}.${method.name}`
-		});
-		return problems;
-	}
-	thrownErrors(file) {
-		return file.domainErrorThrows.map((line) => ({
-			line,
-			message: "A DomainError is thrown: return it in a Result instead.",
-			symbol: "throw"
-		}));
-	}
-};
-//#endregion
-//#region src/rules/layer-direction.rule.ts
-const allowedLayers = {
-	application: [
-		"domain",
-		"application",
-		"published-language"
-	],
-	driven: [
-		"domain",
-		"application",
-		"published-language",
-		"driven"
-	],
-	driving: [
-		"domain",
-		"application",
-		"published-language",
-		"driving"
-	],
-	"published-language": ["published-language"]
-};
-var LayerDirectionRule = class extends ImportRule {
-	id = "layer-direction";
-	check(codebase) {
-		return [...this.filesOutsideLayers(codebase), ...super.check(codebase)];
-	}
-	appliesTo(file) {
-		const location = file.location;
-		return location.isAtRoot || location.isCompositionRoot || location.isInLayer && location.layer !== "domain";
-	}
-	problemWith(imported, file, codebase) {
-		if (imported.target.kind === "file") return this.fileProblem(file.location, imported.target.location, this.describeTarget(imported, codebase));
-		return this.packageProblem(file.location, imported, codebase.config);
-	}
-	filesOutsideLayers(codebase) {
-		const violations = [];
-		for (const file of codebase.files) {
-			const location = file.location;
-			if (location.isOutside) violations.push(this.violation(codebase, file, {
-				line: 1,
-				message: "The file is outside the bounded contexts and the shared kernel declared in alveolus.config.ts: move it, or add it to ignore.",
-				symbol: location.fileName
-			}));
-			else if (!location.isAtRoot && !location.isInLayer && !location.isCompositionRoot) violations.push(this.violation(codebase, file, {
-				line: 1,
-				message: "The file is outside the layers: move it to domain/, application/, published-language/, driven/ or driving/.",
-				symbol: location.fileName
-			}));
-		}
-		return violations;
-	}
-	fileProblem(from, to, target) {
-		if (from.isAtRoot) return to.isInBoundedContext && !to.isCompositionRoot ? `Files at the root import composition roots only, not ${target}.` : void 0;
-		if (from.isCompositionRoot || to.isOtherBoundedContextThan(from)) return;
-		if (to.isCompositionRoot) return `Imports ${target}: only the composition root wires the layers.`;
-		const layer = from.layer;
-		if (layer === void 0 || layer === "domain") return;
-		const allowed = allowedLayers[layer];
-		if (to.layer !== void 0 && allowed.includes(to.layer)) return;
-		return `The ${layer} layer imports ${target}: it may only import ${allowed.join(", ")}.`;
-	}
-	packageProblem(from, imported, config) {
-		if (from.layer === "application") return this.applicationPackageProblem(imported, config);
-		if (from.layer === "published-language" && imported.isFromPackage(CoreApi.packageName)) {
-			const forbidden = imported.names.filter((name) => !CoreApi.isPublishedLanguageSymbol(name));
-			return forbidden.length === 0 ? void 0 : `The published language imports ${forbidden.join(", ")} from ${CoreApi.packageName}: only published-language types are allowed.`;
-		}
-	}
-	applicationPackageProblem(imported, config) {
-		if (imported.target.kind !== "package" || imported.isFromPackage(CoreApi.packageName)) return;
-		if (imported.isFromPackage("@nestjs/common")) {
-			const forbidden = imported.names.filter((name) => name !== "Injectable");
-			return forbidden.length === 0 ? void 0 : `The application imports ${forbidden.join(", ")} from @nestjs/common: only Injectable is allowed.`;
-		}
-		if (config.domainDependencies.includes(imported.target.name)) return;
-		return `The application imports ${imported.target.name}: only ${CoreApi.packageName}, Injectable from @nestjs/common and domainDependencies are allowed.`;
-	}
-};
-//#endregion
-//#region src/rules/place.ts
-var Place = class {
-	layer;
-	folder;
-	suffix;
-	constructor(layer, folder, suffix) {
-		this.layer = layer;
-		this.folder = folder;
-		this.suffix = suffix;
-	}
-	fits(location) {
-		if (!location.isInBoundedContext && !location.isInSharedKernel) return false;
-		if (location.layer !== this.layer) return false;
-		if (this.folder !== void 0 && location.folder !== this.folder) return false;
-		return this.suffix === void 0 || location.fileName.endsWith(this.suffix);
-	}
-	describe() {
-		return this.folder === void 0 ? `${this.layer}/` : `${this.layer}/${this.folder}/*${this.suffix ?? ".ts"}`;
-	}
-};
-//#endregion
-//#region src/rules/placement.rule.ts
-const repositories = new Place("domain", "repositories", ".repository.ts");
-const kindPlaces = [
-	{
-		kind: "AggregateRoot",
-		place: new Place("domain", "aggregates", ".aggregate.ts")
-	},
-	{
-		kind: "Entity",
-		place: new Place("domain", "entities", ".entity.ts")
-	},
-	{
-		kind: "Identifier",
-		place: new Place("domain", "value-objects", ".identifier.ts")
-	},
-	{
-		kind: "ValueObject",
-		place: new Place("domain", "value-objects", ".value-object.ts")
-	},
-	{
-		kind: "DomainEvent",
-		place: new Place("domain", "events", ".event.ts")
-	},
-	{
-		kind: "DomainError",
-		place: new Place("domain", "errors", ".error.ts")
-	},
-	{
-		kind: "DomainService",
-		place: new Place("domain", "services", ".service.ts")
-	},
-	{
-		kind: "CommandHandler",
-		place: new Place("application", "commands", ".command.ts")
-	},
-	{
-		kind: "QueryHandler",
-		place: new Place("application", "queries", ".query.ts")
-	},
-	{
-		kind: "EventTranslator",
-		place: new Place("application", "translators", ".translator.ts")
-	},
-	{
-		concreteOnly: true,
-		kind: "Port",
-		place: new Place("driven", "adapters", ".adapter.ts")
-	},
-	{
-		kind: "CommandRepository",
-		place: repositories
-	},
-	{
-		kind: "QueryRepository",
-		place: repositories
-	},
-	{
-		kind: "Port",
-		place: new Place("domain", "ports", ".port.ts")
-	}
-];
-const markedPlace = new Place("driving");
-var PlacementRule = class extends Rule {
-	id = "placement";
-	check(codebase) {
-		const violations = [];
-		for (const file of codebase.files) for (const problem of [...this.extraClasses(file), ...this.misplacedClasses(file)]) violations.push(this.violation(codebase, file, problem));
-		return violations;
-	}
-	extraClasses(file) {
-		const [first, ...others] = file.classes;
-		return others.map((codeClass) => ({
-			line: codeClass.line,
-			message: `${codeClass.name} shares its file with ${first?.name}: one class per file.`,
-			symbol: codeClass.name
-		}));
-	}
-	misplacedClasses(file) {
-		const problems = [];
-		for (const codeClass of file.classes) {
-			const place = this.placeOf(codeClass);
-			if (place !== void 0 && !place.fits(file.location)) problems.push({
-				line: codeClass.line,
-				message: `${codeClass.name} belongs in ${place.describe()}.`,
-				symbol: codeClass.name
-			});
-		}
-		return problems;
-	}
-	placeOf(codeClass) {
-		const match = kindPlaces.find((entry) => codeClass.is(entry.kind) && !(entry.concreteOnly === true && codeClass.isAbstract));
-		if (match !== void 0) return match.place;
-		return codeClass.hasMarker ? markedPlace : void 0;
-	}
-};
-//#endregion
-//#region src/rules/reference-by-identity.rule.ts
-var ReferenceByIdentityRule = class extends ClassRule {
-	id = "reference-by-identity";
-	problemsWith(codeClass) {
-		if (!codeClass.is("Entity")) return [];
-		return this.membersOf(codeClass).filter((member) => member.is("AggregateRoot")).map((member) => ({
-			line: member.line,
-			message: `${codeClass.name}.${member.member} holds the aggregate ${member.typeName}: reference it by its identifier instead.`,
-			symbol: `${codeClass.name}.${member.member}`
-		}));
-	}
-	membersOf(codeClass) {
-		const byName = /* @__PURE__ */ new Map();
-		for (const member of [...codeClass.fields, ...codeClass.constructorParameters]) byName.set(`${member.member}:${member.typeName}`, member);
-		return [...byName.values()];
-	}
-};
-//#endregion
-//#region src/rules/rules.ts
-var Rules = class {
-	static all() {
-		return [
-			new BcIsolationRule(),
-			new DomainPurityRule(),
-			new LayerDirectionRule(),
-			new DrivenAdaptersExtendPortRule(),
-			new ReferenceByIdentityRule(),
-			new CommandQuerySeparationRule(),
-			new ErrorsAsValuesRule(),
-			new PlacementRule(),
-			new BuildingBlocksOnlyRule()
-		];
-	}
-};
-//#endregion
-//#region src/cli/cli.ts
-var Cli = class {
-	stdout;
-	stderr;
-	cwd;
-	colored;
-	exitCode = 0;
-	constructor(stdout, stderr, cwd, colored = false) {
-		this.stdout = stdout;
-		this.stderr = stderr;
-		this.cwd = cwd;
-		this.colored = colored;
-	}
-	async run(args) {
-		try {
-			await this.program().parseAsync([...args], { from: "user" });
-		} catch (error) {
-			return this.fail(error);
-		}
-		return this.exitCode;
-	}
-	program() {
-		const program = new Command("alveolus").exitOverride().configureOutput({
-			writeErr: (text) => this.stderr.write(text),
-			writeOut: (text) => this.stdout.write(text)
-		});
-		const arch = program.command("arch").description("Check the architecture of a Domain-Driven Design project");
-		this.withOptions(arch.command("check").description("Report the violations that are not in the baseline")).action((options) => this.check(options));
-		this.withOptions(arch.command("baseline").description(`Write the current violations to ${Baseline.fileName}`)).action((options) => this.baseline(options));
-		return program;
-	}
-	withOptions(command) {
-		return command.option("--project <dir>", "project directory", ".").option("--config <file>", "configuration file", ConfigLoader.fileName).option("--format <format>", "text or json", "text");
-	}
-	async check(options) {
-		const { config, violations } = await this.analyze(options);
-		const fresh = (await Baseline.load(join(config.projectDir, Baseline.fileName))).newViolations(violations);
-		const report = new Report(fresh, violations.length - fresh.length, this.colored);
-		this.stdout.write(options.format === "json" ? report.json() : report.text());
-		this.exitCode = fresh.length === 0 ? 0 : 1;
-	}
-	async baseline(options) {
-		const { config, violations } = await this.analyze(options);
-		await Baseline.of(violations).save(join(config.projectDir, Baseline.fileName));
-		this.stdout.write(`${violations.length} violations written to ${Baseline.fileName}\n`);
-	}
-	async analyze(options) {
-		const projectDir = resolve(this.cwd, options.project);
-		const config = await new ConfigLoader().load(projectDir, options.config);
-		return {
-			config,
-			violations: new ArchChecker(TsMorphAnalyzer.fromTsConfig(config.projectDir), Rules.all()).check(config)
-		};
-	}
-	fail(error) {
-		if (error instanceof CommanderError) return error.exitCode === 0 ? 0 : 2;
-		this.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
-		return 2;
-	}
-};
-//#endregion
-export { ConfigLoader as a, Baseline as c, Report as i, TsMorphAnalyzer as l, Rules as n, Config as o, Rule as r, ArchChecker as s, Cli as t, CodeAnalyzer as u };
-
-//# sourceMappingURL=cli-CW1zAnrP.mjs.map