@boundaries/eslint-plugin 5.4.0 → 6.0.0-beta.2

package/dist/index.js

@@ -17,28 +17,28 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const fs_1 = require("fs");
-const path_1 = require("path");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
 const Recommended_1 = __importDefault(require("./Config/Recommended"));
 const Strict_1 = __importDefault(require("./Config/Strict"));
-const ElementTypes_1 = __importDefault(require("./Rules/ElementTypes"));
+const Dependencies_1 = __importDefault(require("./Rules/Dependencies"));
 const EntryPoint_1 = __importDefault(require("./Rules/EntryPoint"));
 const External_1 = __importDefault(require("./Rules/External"));
 const NoIgnored_1 = __importDefault(require("./Rules/NoIgnored"));
 const NoPrivate_1 = __importDefault(require("./Rules/NoPrivate"));
 const NoUnknown_1 = __importDefault(require("./Rules/NoUnknown"));
 const NoUnknownFiles_1 = __importDefault(require("./Rules/NoUnknownFiles"));
-const Settings_1 = require("./Settings");
-// import { warn } from "./Support";
+const Shared_1 = require("./Shared");
+// import { warn } from "./Shared";
 __exportStar(require("./Public"), exports);
 /**
  * The path to the plugin package.json file
  */
-const packageJsonPath = (0, path_1.join)(__dirname, "..", "package.json");
+const packageJsonPath = (0, node_path_1.join)(__dirname, "..", "package.json");
 /**
  * The content of the package.json file
  */
-const packageJson = JSON.parse((0, fs_1.readFileSync)(packageJsonPath, "utf-8"));
+const packageJson = JSON.parse((0, node_fs_1.readFileSync)(packageJsonPath, "utf-8"));
 // TODO: Enable this warning in the next major release
 /* if (packageJson.name !== "@boundaries/eslint-plugin") {
   warn(
@@ -46,13 +46,15 @@ const packageJson = JSON.parse((0, fs_1.readFileSync)(packageJsonPath, "utf-8"))
   );
 } */
 const RULES = {
-    [Settings_1.RULE_SHORT_NAMES_MAP.ENTRY_POINT]: EntryPoint_1.default,
-    [Settings_1.RULE_SHORT_NAMES_MAP.ELEMENT_TYPES]: ElementTypes_1.default,
-    [Settings_1.RULE_SHORT_NAMES_MAP.EXTERNAL]: External_1.default,
-    [Settings_1.RULE_SHORT_NAMES_MAP.NO_IGNORED]: NoIgnored_1.default,
-    [Settings_1.RULE_SHORT_NAMES_MAP.NO_PRIVATE]: NoPrivate_1.default,
-    [Settings_1.RULE_SHORT_NAMES_MAP.NO_UNKNOWN]: NoUnknown_1.default,
-    [Settings_1.RULE_SHORT_NAMES_MAP.NO_UNKNOWN_FILES]: NoUnknownFiles_1.default,
+    [Shared_1.RULE_SHORT_NAMES_MAP.ENTRY_POINT]: EntryPoint_1.default,
+    /** @deprecated Use dependencies rule instead */
+    [Shared_1.RULE_SHORT_NAMES_MAP.ELEMENT_TYPES]: (0, Dependencies_1.default)(Shared_1.SETTINGS.RULE_ELEMENT_TYPES),
+    [Shared_1.RULE_SHORT_NAMES_MAP.DEPENDENCIES]: (0, Dependencies_1.default)(),
+    [Shared_1.RULE_SHORT_NAMES_MAP.EXTERNAL]: External_1.default,
+    [Shared_1.RULE_SHORT_NAMES_MAP.NO_IGNORED]: NoIgnored_1.default,
+    [Shared_1.RULE_SHORT_NAMES_MAP.NO_PRIVATE]: NoPrivate_1.default,
+    [Shared_1.RULE_SHORT_NAMES_MAP.NO_UNKNOWN]: NoUnknown_1.default,
+    [Shared_1.RULE_SHORT_NAMES_MAP.NO_UNKNOWN_FILES]: NoUnknownFiles_1.default,
 };
 /**
  * Eslint plugin ensuring that architecture boundaries are respected by the elements in a project

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@boundaries/eslint-plugin",
-  "version": "5.4.0",
+  "version": "6.0.0-beta.2",
   "description": "Eslint plugin checking architecture boundaries between elements",
   "keywords": [
     "eslint",
@@ -52,32 +52,33 @@
     "chalk": "4.1.2",
     "eslint-import-resolver-node": "0.3.9",
     "eslint-module-utils": "2.12.1",
+    "handlebars": "4.7.8",
     "micromatch": "4.0.8",
-    "@boundaries/elements": "1.2.0"
+    "@boundaries/elements": "2.0.0-beta.2"
   },
   "engines": {
     "node": ">=18.18"
   },
   "devDependencies": {
     "@types/estree": "1.0.8",
-    "@types/micromatch": "4.0.9",
-    "eslint-plugin-eslint-plugin": "7.2.0",
+    "@types/micromatch": "4.0.10",
+    "eslint-plugin-eslint-plugin": "7.3.2",
     "eslint-plugin-local-rules": "3.0.2"
   },
   "scripts": {
     "eslint": "eslint",
     "build": "pnpm build:tsc && pnpm copy:readme",
-    "build:tsc": "tsc",
+    "build:tsc": "tsc --project ./tsconfig.code.json",
     "copy:readme": "cross-env node ./scripts/copy-readme.js",
     "check:all": "echo 'All checks passed'",
     "check:spell": "cspell --quiet .",
     "check:types": "pnpm check:types:code && pnpm check:types:test",
-    "check:types:code": "tsc --noEmit",
-    "check:types:test": "tsc --noEmit --project ./test/tsconfig.json",
+    "check:types:code": "tsc --noEmit --project ./tsconfig.code.json",
+    "check:types:test": "tsc --noEmit --project ./tsconfig.test.json",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
     "serve:unit:report": "serve --config ./serve.test-unit-report.json",
     "test": "jest",
-    "test:unit": "cross-env ESLINT_PLUGIN_BOUNDARIES_DEBUG=false pnpm test"
+    "test:unit": "pnpm test"
   }
 }

package/dist/Rules/ElementTypes.d.ts

@@ -1,25 +0,0 @@
-import type { DependencyDescription, Matcher } from "@boundaries/elements";
-import type { ElementTypesRuleOptions, RuleResult, SettingsNormalized } from "../Settings";
-type PolicyMatch = {
-    isMatch: boolean;
-    specifiers?: string | string[];
-    internalPath?: string;
-};
-export declare function getRulesResults(ruleOptions: ElementTypesRuleOptions, dependencyDescription: DependencyDescription, matcher: Matcher, settings: SettingsNormalized): {
-    index: number;
-    originalRuleIndex: any;
-    selectorsMatching: {
-        selectors: {
-            [x: string]: string | import("@boundaries/elements").BaseElementSelectorData | import("@boundaries/elements").BaseElementSelectorWithOptions | import("@boundaries/elements").BaseElementSelector[] | null;
-        };
-        selectorsData: {
-            isMatch: boolean;
-        } | null;
-    };
-    ruleHasImportKind: boolean;
-    allowPolicyMatches: PolicyMatch;
-    denyPolicyMatches: PolicyMatch;
-}[];
-export declare function elementRulesAllowDependency(dependency: DependencyDescription, settings: SettingsNormalized, ruleOptions?: ElementTypesRuleOptions): RuleResult;
-declare const _default: import("eslint").Rule.RuleModule;
-export default _default;

package/dist/Rules/ElementTypes.js

@@ -1,279 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRulesResults = getRulesResults;
-exports.elementRulesAllowDependency = elementRulesAllowDependency;
-const elements_1 = require("@boundaries/elements");
-const micromatch_1 = __importDefault(require("micromatch"));
-const Elements_1 = require("../Elements");
-const Messages_1 = require("../Messages");
-const Settings_1 = require("../Settings");
-const Support_1 = require("../Support");
-const Support_2 = require("./Support");
-const { RULE_ELEMENT_TYPES } = Settings_1.SETTINGS;
-/**
- * Safely matches a dependency selector, catching and logging any errors
- */
-function createSafeMatcherFunction(dependencyDescription, matcher) {
-    return (dependencySelector, extraTemplateData, dependencySelectorsGlobals) => {
-        // Just in case selectors are invalid, we catch errors here to avoid breaking the whole rule evaluation
-        try {
-            return matcher.getSelectorMatchingDescription(dependencyDescription, dependencySelector, {
-                extraTemplateData,
-                dependencySelectorsGlobals,
-            });
-        }
-        catch (error) {
-            (0, Support_1.warnOnce)(`Error occurred while matching dependency with selector ${JSON.stringify(dependencySelector)}: ${String(error)}`);
-            return { isMatch: false, from: null, to: null };
-        }
-    };
-}
-/**
- * Determines the rule matching context (directions, template data, etc.)
- */
-function createRuleMatchContext(rule, dependencyDescription) {
-    const targetElementDirection = rule.from ? "from" : "to";
-    const policyElementDirection = rule.from ? "to" : "from";
-    const denyKeyToUse = rule.deny ? "deny" : "disallow";
-    const capturedValuesTemplateData = targetElementDirection === "from"
-        ? {
-            ...dependencyDescription.from.captured,
-            from: dependencyDescription.from.captured,
-            to: dependencyDescription.to.captured,
-        }
-        : {
-            ...dependencyDescription.to.captured,
-            from: dependencyDescription.from.captured,
-            to: dependencyDescription.to.captured,
-        };
-    const dependencySelectorsGlobals = rule.importKind ? { kind: rule.importKind } : {};
-    const targetElementSelector = rule[targetElementDirection];
-    return {
-        targetElementDirection,
-        policyElementDirection,
-        denyKeyToUse,
-        capturedValuesTemplateData,
-        dependencySelectorsGlobals,
-        targetElementSelector,
-    };
-}
-/**
- * Evaluates both deny and allow policy matches for a rule
- */
-function evaluatePolicyMatches(rule, context, isMatch, settings) {
-    const { targetElementDirection, policyElementDirection, denyKeyToUse, capturedValuesTemplateData, dependencySelectorsGlobals, targetElementSelector, } = context;
-    const templateData = settings.legacyTemplates
-        ? capturedValuesTemplateData
-        : {};
-    const disallowPolicyMatches = rule[denyKeyToUse]
-        ? isMatch({
-            [targetElementDirection]: targetElementSelector,
-            [policyElementDirection]: rule[denyKeyToUse],
-        }, templateData, dependencySelectorsGlobals)
-        : { isMatch: false };
-    const allowPolicyMatches = !disallowPolicyMatches.isMatch && rule.allow
-        ? isMatch({
-            [targetElementDirection]: targetElementSelector,
-            [policyElementDirection]: rule.allow,
-        }, templateData, dependencySelectorsGlobals)
-        : { isMatch: false };
-    return { disallowPolicyMatches, allowPolicyMatches };
-}
-/**
- * Creates rule selectors data based on policy matches
- */
-function createRuleSelectorsData(rule, context, disallowPolicyMatches, allowPolicyMatches) {
-    const { targetElementDirection, policyElementDirection, denyKeyToUse } = context;
-    const allowPolicyMatchesIsMatch = allowPolicyMatches.isMatch;
-    const disallowPolicyMatchesIsMatch = disallowPolicyMatches.isMatch;
-    const targetSelector = disallowPolicyMatchesIsMatch || allowPolicyMatchesIsMatch
-        ? context.targetElementSelector
-        : null;
-    let policySelector = null;
-    if (disallowPolicyMatchesIsMatch) {
-        policySelector = rule[denyKeyToUse];
-    }
-    else if (allowPolicyMatchesIsMatch) {
-        policySelector = rule.allow;
-    }
-    let selectorsData = null;
-    if (disallowPolicyMatchesIsMatch) {
-        selectorsData = disallowPolicyMatches;
-    }
-    else if (allowPolicyMatchesIsMatch) {
-        selectorsData = allowPolicyMatches;
-    }
-    return {
-        selectors: {
-            [targetElementDirection]: targetSelector,
-            [policyElementDirection]: policySelector,
-        },
-        selectorsData,
-    };
-}
-function getRulesResults(ruleOptions, dependencyDescription, matcher, settings) {
-    if (!ruleOptions.rules) {
-        return [];
-    }
-    const isMatch = createSafeMatcherFunction(dependencyDescription, matcher);
-    return ruleOptions.rules.map((rule, index) => {
-        const context = createRuleMatchContext(rule, dependencyDescription);
-        const { disallowPolicyMatches, allowPolicyMatches } = evaluatePolicyMatches(rule, context, isMatch, settings);
-        const selectorsMatching = createRuleSelectorsData(rule, context, disallowPolicyMatches, allowPolicyMatches);
-        return {
-            index,
-            // @ts-expect-error Workaround to support both allow and disallow in the same entry point rule
-            originalRuleIndex: rule.originalRuleIndex,
-            selectorsMatching,
-            ruleHasImportKind: !!rule.importKind,
-            allowPolicyMatches,
-            denyPolicyMatches: disallowPolicyMatches,
-        };
-    });
-}
-/**
- * Determines the rule result based on policy matches
- */
-function determineRuleResult(rulesResults) {
-    let isAllowed = false;
-    let ruleIndexMatching = null;
-    for (const ruleResult of rulesResults) {
-        if (ruleResult.denyPolicyMatches.isMatch) {
-            isAllowed = false;
-            ruleIndexMatching = ruleResult.index;
-        }
-        else if (ruleResult.allowPolicyMatches.isMatch) {
-            isAllowed = true;
-            ruleIndexMatching = ruleResult.index;
-        }
-    }
-    return { isAllowed, ruleIndexMatching };
-}
-/**
- * Gets the message for the rule, prioritizing rule-specific messages
- */
-function getRuleMessage(ruleIndexMatching, ruleOptions) {
-    return ((ruleIndexMatching === null
-        ? ruleOptions.message
-        : ruleOptions.rules?.[ruleIndexMatching]?.message) || ruleOptions.message);
-}
-/**
- * Gets specifiers that match the rule for error reporting
- */
-function getMatchingSpecifiers(ruleIndexMatching, rulesResults, dependency) {
-    if (ruleIndexMatching === null)
-        return null;
-    const selectorDataSpecifiers = 
-    // @ts-expect-error TODO: Align types. At this point, selectorsData.to must always be defined, because otherwise isMatch would be false
-    rulesResults[ruleIndexMatching].selectorsMatching?.selectorsData?.to
-        ?.specifiers;
-    if (!selectorDataSpecifiers) {
-        return null;
-    }
-    if ((0, Support_1.isString)(selectorDataSpecifiers)) {
-        const hasMatchingSpecifier = dependency.dependency.specifiers?.some((specifier) => micromatch_1.default.isMatch(specifier, selectorDataSpecifiers));
-        return hasMatchingSpecifier ? [selectorDataSpecifiers] : null;
-    }
-    return selectorDataSpecifiers.filter((pattern) => {
-        return dependency.dependency.specifiers?.some((specifier) => micromatch_1.default.isMatch(specifier, pattern));
-    });
-}
-/**
- * Creates the rule report object
- */
-function createRuleReport(ruleIndexMatching, message, dependency, rulesResults) {
-    if (ruleIndexMatching === null) {
-        return {
-            message,
-            isDefault: true,
-            importKind: undefined,
-            disallow: dependency.to,
-            element: dependency.from,
-            index: -1,
-        };
-    }
-    return {
-        message,
-        isDefault: false,
-        importKind: rulesResults[ruleIndexMatching].ruleHasImportKind
-            ? dependency.dependency.kind
-            : undefined,
-        disallow: rulesResults[ruleIndexMatching].selectorsMatching?.selectors.to,
-        element: rulesResults[ruleIndexMatching].selectorsMatching?.selectors.from,
-        index: rulesResults[ruleIndexMatching].originalRuleIndex ?? ruleIndexMatching,
-    };
-}
-/**
- * Determines the report path for error reporting
- */
-function getReportPath(ruleIndexMatching, rulesResults, dependency) {
-    return ruleIndexMatching === null ||
-        // @ts-expect-error TODO: Align types. At this point, selectorsData should always be defined
-        !rulesResults[ruleIndexMatching].selectorsMatching?.selectorsData?.to
-            ?.internalPath
-        ? null
-        : dependency.to.internalPath;
-}
-function elementRulesAllowDependency(dependency, settings, ruleOptions = {}) {
-    const defaultIsAllowed = ruleOptions.default === "allow";
-    const matcher = (0, Elements_1.getElementsMatcher)(settings);
-    const rulesResults = getRulesResults(ruleOptions, dependency, matcher, settings);
-    const { isAllowed, ruleIndexMatching } = determineRuleResult(rulesResults);
-    const finalIsAllowed = ruleIndexMatching === null ? defaultIsAllowed : isAllowed;
-    if (finalIsAllowed) {
-        return {
-            result: finalIsAllowed,
-            ruleReport: null,
-            report: null,
-        };
-    }
-    const message = getRuleMessage(ruleIndexMatching, ruleOptions);
-    const ruleReport = createRuleReport(ruleIndexMatching, message, dependency, rulesResults);
-    const reportPath = getReportPath(ruleIndexMatching, rulesResults, dependency);
-    const result = {
-        result: finalIsAllowed,
-        // @ts-expect-error Temporary workaround for RuleResult type until types are aligned
-        ruleReport,
-        report: {
-            specifiers: getMatchingSpecifiers(ruleIndexMatching, rulesResults, dependency) ||
-                undefined,
-            path: reportPath,
-        },
-    };
-    return result;
-}
-function errorMessage(ruleData, dependency) {
-    const ruleReport = ruleData.ruleReport;
-    if (!ruleReport) {
-        return `No detailed rule report available. This is likely a bug in ${Settings_1.PLUGIN_NAME}. Please report it at ${Settings_1.PLUGIN_ISSUES_URL}`;
-    }
-    if (ruleReport.message) {
-        return (0, Messages_1.customErrorMessage)(ruleReport.message, dependency);
-    }
-    if (ruleReport.isDefault) {
-        return `No rule allowing this dependency was found. File is ${(0, Messages_1.elementMessage)(dependency.from)}. Dependency is ${(0, Messages_1.elementMessage)(dependency.to)}`;
-    }
-    return `Importing ${(0, Messages_1.dependencyImportKindMessage)(ruleReport.importKind, dependency)}${(0, Messages_1.ruleElementMessage)(ruleReport.disallow, dependency.from.captured)} is not allowed in ${(0, Messages_1.ruleElementMessage)(ruleReport.element, dependency.from.captured)}. Disallowed in rule ${ruleReport.index + 1}`;
-}
-exports.default = (0, Support_2.dependencyRule)({
-    ruleName: RULE_ELEMENT_TYPES,
-    description: `Check allowed dependencies between element types`,
-    schema: (0, Settings_1.rulesOptionsSchema)(),
-}, function ({ dependency, node, context, settings, options }) {
-    // TODO: Remove these checks when allowing to use more selectors in ESLint rules
-    if ((0, elements_1.isLocalElement)(dependency.to) &&
-        !(0, elements_1.isIgnoredElement)(dependency.to) &&
-        !(0, elements_1.isUnknownLocalElement)(dependency.to) &&
-        !(0, elements_1.isInternalDependency)(dependency)) {
-        const ruleData = elementRulesAllowDependency(dependency, settings, options);
-        if (!ruleData.result) {
-            context.report({
-                message: errorMessage(ruleData, dependency),
-                node,
-            });
-        }
-    }
-});

package/dist/Support/Debug.d.ts

@@ -1,5 +0,0 @@
-import type { DependencyDescription, ElementDescription } from "@boundaries/elements";
-export declare function warn(message: string): void;
-export declare function success(message: string): void;
-export declare function warnOnce(message: string): void;
-export declare function debugDescription(elementDescription: ElementDescription | DependencyDescription): void;

package/dist/Support/Debug.js

@@ -1,54 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.warn = warn;
-exports.success = success;
-exports.warnOnce = warnOnce;
-exports.debugDescription = debugDescription;
-const elements_1 = require("@boundaries/elements");
-const chalk_1 = __importDefault(require("chalk"));
-const Settings_1 = require("../Settings");
-const warns = [];
-const debuggedFiles = [];
-const COLORS_MAP = {
-    gray: "gray",
-    green: "green",
-    yellow: "yellow",
-};
-function trace(message, color) {
-    // eslint-disable-next-line no-console
-    console.log(chalk_1.default[COLORS_MAP[color]](`[${Settings_1.PLUGIN_NAME}]: ${message}`));
-}
-function warn(message) {
-    trace(message, COLORS_MAP.yellow);
-}
-function success(message) {
-    trace(message, COLORS_MAP.green);
-}
-function warnOnce(message) {
-    if (!warns.includes(message)) {
-        warns.push(message);
-        warn(message);
-    }
-}
-function debugDescription(elementDescription) {
-    const isDependency = (0, elements_1.isDependencyDescription)(elementDescription);
-    const key = isDependency
-        ? elementDescription.to.source
-        : elementDescription.path || "";
-    const type = isDependency
-        ? elementDescription.to.type
-        : elementDescription.type;
-    if ((0, Settings_1.isDebugModeEnabled)() && !debuggedFiles.includes(key)) {
-        debuggedFiles.push(key);
-        if (type) {
-            success(`'${key}' is of type '${type}'`);
-        }
-        else {
-            warn(`'${key}' is of unknown type`);
-        }
-        trace(`\n${JSON.stringify(elementDescription, null, 2)}`, COLORS_MAP.gray);
-    }
-}

package/dist/Support/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./Common";
-export * from "./Debug";