build-firewall-plugin 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aliaksei Malinouski
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/build/index.d.ts

@@ -0,0 +1,37 @@
+import { Compiler, RspackPluginInstance } from "@rspack/core";
+type Options = {
+    /**
+     * Path to your JSON file with project rules
+     */
+    path: string;
+    /**
+     * Generate a template JSON files with project rules
+     */
+    generateFile?: boolean;
+    /**
+     * Name of your JSON file with project rules
+     */
+    name?: string;
+    /**
+     * Generate a JSON file with latest report of checking your project
+     * will be added to .gitignore if this file is in your project
+     */
+    report?: boolean;
+    /**
+     * What kind of logs you will get
+     */
+    mode?: 'error' | 'warn';
+    /**
+     * exceptions that will not be checked, plugin already has a default value:
+     *
+     * node_modules, assets, images, types, intefaces, styles file and directories
+     */
+    exceptions?: string[];
+};
+export declare class BuildFirewallPlugin implements RspackPluginInstance {
+    private readonly config;
+    private shouldRunAgain;
+    constructor(options?: Options);
+    apply(compiler: Compiler): void;
+}
+export {};

package/build/index.js

@@ -0,0 +1,192 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuildFirewallPlugin = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/**
+ * empty settings of modules rules map
+ */
+const settings = {
+    allow: [],
+    deny: [],
+};
+/**
+ * empty template of project rules map
+ */
+const template = {
+    layers: {
+        ui: settings,
+        lib: settings,
+        hooks: settings,
+        pages: settings,
+        models: settings,
+        widgets: settings,
+        services: settings,
+        components: settings,
+        declarations: settings,
+    },
+    mode: 'warn',
+};
+/**
+ * dependecies exceptions
+ */
+const exceptions = ['node_modules', 'assets', '.css', '.scss', 'styles', 'style', 'images', 'types', 'type', 'inteface', 'intefaces'];
+/**
+ * @function guard validates received file by path
+ */
+const isValidSchema = (value) => {
+    var _a, _b;
+    return (!!value &&
+        typeof value === 'object' &&
+        'mode' in value &&
+        'layers' in value &&
+        typeof value.layers === 'object' &&
+        Object.keys((_a = value.layers) !== null && _a !== void 0 ? _a : {}).length > 0 &&
+        (value.mode === 'warn' || value.mode === 'error') &&
+        Object.entries((_b = value.layers) !== null && _b !== void 0 ? _b : {}).every(([_, layer]) => typeof layer === 'object' && 'allow' in layer && 'deny' in layer
+            && Array.isArray(layer.allow) && Array.isArray(layer.deny)));
+};
+/**
+ * @function resolveLayer normilize module resource
+ */
+function resolveLayer(resource, layers) {
+    const normalized = resource.replace(/\\/g, '/');
+    for (const layer of Object.keys(layers)) {
+        if (normalized.includes(`/src/${layer}/`)) {
+            return layer;
+        }
+    }
+    return null;
+}
+class BuildFirewallPlugin {
+    constructor(options) {
+        this.config = {
+            path: '',
+            exceptions,
+            report: false,
+            generateFile: false,
+            mode: template.mode,
+            layers: template.layers,
+            name: 'build-firewall-plugin.rules.json',
+        };
+        this.shouldRunAgain = false;
+        this.config = { ...this.config, ...(Boolean(options) && { ...options }) };
+    }
+    ;
+    apply(compiler) {
+        this.shouldRunAgain = false;
+        compiler.hooks.thisCompilation.tap('BuildFirewallPluginThisCompilation', (compilation) => {
+            compilation.hooks.finishModules.tap('BuildFirewallPluginThisCompilationFinishModules', (modules) => {
+                /**
+                 * Creating or Validating a rules file
+                 */
+                if (!this.config.path) {
+                    try {
+                        const pathToFile = path_1.default.resolve(__dirname, this.config.name);
+                        fs_1.default.writeFileSync(pathToFile, JSON.stringify(template));
+                        this.shouldRunAgain = true;
+                        this.config.path = pathToFile;
+                        console.log(`Created a template of ${this.config.name} file successfully`);
+                        console.log(`Check and edit a ${this.config.name} file if it is not passing for your project`);
+                    }
+                    catch (e) {
+                        console.error(`Could not create a rules file: \n ${e}`);
+                        return;
+                    }
+                    ;
+                }
+                else {
+                    try {
+                        const pathToFile = path_1.default.resolve(__dirname, this.config.name);
+                        const rawFile = fs_1.default.readFileSync(pathToFile).toString();
+                        const extention = path_1.default.extname(pathToFile);
+                        const isJSON = extention.endsWith('.json');
+                        if (!isJSON) {
+                            console.error(`Your ${this.config.name} file is not a JSON`);
+                            return;
+                        }
+                        ;
+                        if (rawFile.length < 0) {
+                            console.error(`Your ${this.config.name} file is empty`);
+                            return;
+                        }
+                        ;
+                        const parsedFile = JSON.parse(rawFile);
+                        const isObject = typeof parsedFile === 'object';
+                        if (!isObject) {
+                            console.error(`Your ${this.config.name} file value is not an object`);
+                            return;
+                        }
+                        ;
+                        const hasValidSchema = isValidSchema(parsedFile);
+                        if (!hasValidSchema) {
+                            console.error(`Your ${this.config.name} file value is not valid schema, it has to be like this: \n 
+                                { 
+                                    layers: { 
+                                        [name]: { allow: [], deny: [] },
+                                        mode: 'warn'
+                                    } 
+                                }
+                            `);
+                            return;
+                        }
+                        ;
+                        this.config.layers = parsedFile.layers;
+                        this.config.mode = parsedFile.mode || 'warn';
+                        console.log(`Your ${this.config.name} file is valid!`);
+                    }
+                    catch (e) {
+                        console.error(`Error while validating your ${this.config.name} file \n ${e}`);
+                        return;
+                    }
+                    ;
+                }
+                ;
+                if (this.shouldRunAgain)
+                    return;
+                /**
+                 * plugin logic
+                 */
+                const graph = compilation.moduleGraph;
+                for (const module of modules) {
+                    const fromResource = module.nameForCondition();
+                    if (!fromResource)
+                        continue;
+                    const fromLayer = resolveLayer(fromResource, this.config.layers);
+                    if (!fromLayer)
+                        continue;
+                    for (const dependency of module.dependencies) {
+                        const toModule = compilation.moduleGraph.getModule(dependency);
+                        const toModuleResource = toModule === null || toModule === void 0 ? void 0 : toModule.nameForCondition();
+                        if (!toModuleResource)
+                            continue;
+                        const isException = this.config.exceptions.some(e => toModuleResource.includes(e));
+                        if (isException) {
+                            continue;
+                        }
+                        const toLayer = resolveLayer(toModuleResource, this.config.layers);
+                        if (!toLayer)
+                            continue;
+                        if (fromLayer === toLayer && fromResource === toModuleResource) {
+                            continue;
+                        }
+                        const rules = this.config.layers[fromLayer];
+                        if (!rules)
+                            continue;
+                        const isDenided = rules.deny.includes(toLayer);
+                        const isAllowed = rules.allow.includes(toLayer);
+                        if (isDenided || !isAllowed) {
+                            /** report */
+                        }
+                    }
+                }
+            });
+        });
+    }
+    ;
+}
+exports.BuildFirewallPlugin = BuildFirewallPlugin;
+;

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "build-firewall-plugin",
+  "version": "0.0.1",
+  "type": "commonjs",
+  "license": "MIT",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "author": "Aliaksei Malinouski",
+  "description": "",
+  "keywords": [
+    "rspack",
+    "rspack-plugin",
+    "build-tracing",
+    "dependency-analysis",
+    "React",
+    "TypeScript",
+    "build-optimization",
+    "module-tracking"
+  ],
+  "files": [
+    "build",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "vitest",
+    "build": "tsc -p tsconfig.build.json"
+  },
+  "peerDependencies": {
+    "@rspack/core": ">=0.5.0"
+  },
+  "devDependencies": {
+    "@rspack/cli": "1.6.5",
+    "@rspack/core": "1.6.5",
+    "@types/node": "24.10.1",
+    "typescript": "5.9.3",
+    "vitest": "4.0.15"
+  }
+}