archunit
Version:
ArchUnit TypeScript is an architecture testing library, to specify and assert architecture rules in your TypeScript app
129 lines • 5.58 kB
JavaScript
"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.nxProjectSlices = exports.PositiveSliceCondition = exports.PositiveConditionBuilder = exports.NegativeSliceCondition = exports.SliceConditionBuilder = exports.projectSlices = void 0;
const uml_1 = require("../uml");
const extraction_1 = require("../../common/extraction");
const fs = __importStar(require("fs"));
const error_1 = require("../../common/error");
const assertion_1 = require("../assertion");
const projection_1 = require("../projection");
const projection_2 = require("../../common/projection");
const util_1 = require("../../common/util");
const projectSlices = (filename) => {
const graphProvider = () => (0, extraction_1.extractGraph)(filename);
return new SliceConditionBuilder(graphProvider);
};
exports.projectSlices = projectSlices;
class SliceConditionBuilder {
constructor(graphProvider) {
this.graphProvider = graphProvider;
this.mapFunction = (0, projection_1.identity)();
this.definedBy = (pattern) => {
this.mapFunction = (0, projection_1.sliceByPattern)(pattern);
return this;
};
this.should = () => {
return new PositiveConditionBuilder(this);
};
this.shouldNot = () => {
return new NegativeSliceCondition(this, []);
};
}
}
exports.SliceConditionBuilder = SliceConditionBuilder;
class NegativeSliceCondition {
constructor(sliceConditionBuilder, forbiddenEdges) {
this.sliceConditionBuilder = sliceConditionBuilder;
this.forbiddenEdges = forbiddenEdges;
this.containDependency = (from, to) => {
return new NegativeSliceCondition(this.sliceConditionBuilder, [
...this.forbiddenEdges,
{ source: from, target: to },
]);
};
this.check = async () => {
const graph = await this.sliceConditionBuilder.graphProvider();
const mapped = (0, projection_2.projectEdges)(graph, this.sliceConditionBuilder.mapFunction);
return (0, assertion_1.gatherViolations)(mapped, this.forbiddenEdges);
};
}
}
exports.NegativeSliceCondition = NegativeSliceCondition;
class PositiveConditionBuilder {
constructor(sliceConditionBuilder) {
this.sliceConditionBuilder = sliceConditionBuilder;
this.ignoreUnknownNodes = false;
this.ignoreExternals = false;
}
adhereToDiagram(diagram) {
return new PositiveSliceCondition(this, { diagram });
}
adhereToDiagramInFile(filename) {
return new PositiveSliceCondition(this, { filename });
}
ignoringUnknownNodes() {
this.ignoreUnknownNodes = true;
return this;
}
ignoringExternalDependencies() {
this.ignoreExternals = true;
return this;
}
}
exports.PositiveConditionBuilder = PositiveConditionBuilder;
class PositiveSliceCondition {
constructor(positiveConditionBuilder, diagram) {
this.positiveConditionBuilder = positiveConditionBuilder;
this.diagram = diagram;
}
async check(options) {
const graph = await this.positiveConditionBuilder.sliceConditionBuilder.graphProvider();
const filtered = this.positiveConditionBuilder.ignoreExternals
? graph.filter((edge) => !edge.external)
: graph;
let diagram = this.diagram.diagram;
const filename = this.diagram.filename;
if (diagram === undefined) {
if (filename !== undefined) {
diagram = fs.readFileSync(filename).toString();
}
else {
throw new error_1.TechnicalError('No diagram provided');
}
}
const { rules, containedNodes } = (0, uml_1.generateRule)(diagram);
const mapped = (0, projection_2.projectEdges)(filtered, this.positiveConditionBuilder.sliceConditionBuilder.mapFunction);
mapped.forEach((edge) => util_1.sharedLogger.info(options?.logging, `Found edge: From ${edge.sourceLabel} to ${edge.targetLabel}`));
return (0, assertion_1.gatherPositiveViolations)(mapped, rules, containedNodes, this.positiveConditionBuilder.ignoreUnknownNodes);
}
}
exports.PositiveSliceCondition = PositiveSliceCondition;
const nxProjectSlices = (rootFolder) => {
const graphProvider = () => Promise.resolve((0, extraction_1.extractNxGraph)(rootFolder));
return new SliceConditionBuilder(graphProvider);
};
exports.nxProjectSlices = nxProjectSlices;
//# sourceMappingURL=slices.js.map