How to set up eslint-plugin-boundaries for a monorepo?

Define element patterns that match your monorepo structure, such as per-package directories, and configure dependency rules to control cross-package imports. The flexible configuration supports glob patterns for this.

eslint-plugin-boundaries vs dependency-cruiser: which should I use?

eslint-plugin-boundaries integrates into ESLint for real-time feedback during development, while dependency-cruiser is a standalone tool for comprehensive dependency analysis. Use boundaries for enforcements in your workflow and cruiser for audits or deeper insights.

Does it work with dynamic imports in JavaScript?

No, the plugin only analyzes static import statements, so dynamic imports won't be caught by the boundary checks. You'll need manual reviews or other tools for runtime dependency validation.

How to define custom architectural layers with this plugin?

In your ESLint configuration, specify elements with types and patterns (e.g., 'service' for 'services/*'), then create rules to define allowed dependencies between these types, as detailed in the setup guide.

What's the performance impact on linting speed?

It adds minimal overhead during ESLint runs, but complex rules or large codebases with many elements might slow down linting slightly. Optimize by using efficient element selectors.

Can I use it to prevent circular dependencies?

Yes, by configuring dependency rules that disallow bidirectional imports between elements, you can enforce acyclic dependencies, though it requires careful rule definition to match your architecture.

Open-Awesome

boundaries

MITTypeScriptv6.0.2

ESLint plugin that enforces architectural boundaries between code elements in JavaScript and TypeScript projects.

Visit Website GitHub

911 stars19 forks0 contributors

What is boundaries?

ESLint Plugin Boundaries is an ESLint plugin that enforces architectural boundaries in JavaScript and TypeScript projects. It helps developers define architectural layers and dependency rules, then automatically checks imports to ensure they comply with the defined architecture, preventing violations that lead to messy codebases.

Target Audience

JavaScript and TypeScript developers working on medium to large projects who need to maintain clean architecture, especially in monorepos, modular applications, or projects following layered patterns like MVC.

Value Proposition

Developers choose this plugin because it provides automated, real-time enforcement of architectural rules directly within ESLint, eliminating manual reviews and preventing architectural decay as projects scale.

Overview

Eslint plugin checking architecture boundaries between elements

Use Cases

Best For

Enforcing layered architectures like MVC in JavaScript applications
Maintaining clean boundaries in monorepo setups
Preventing circular dependencies between modules
Ensuring teams follow defined architectural patterns
Adding architectural guardrails to TypeScript projects
Automating code organization reviews in CI/CD pipelines

Not Ideal For

Projects with undefined or rapidly evolving architectures where rules would need constant updating
Teams relying heavily on dynamic imports or runtime module loading that static analysis can't catch
Small-scale applications or prototypes where architectural enforcement adds unnecessary configuration overhead
Environments where ESLint isn't already integrated, as setup adds complexity to the build pipeline

Pros & Cons

Pros

Architectural Rule Enforcement

Allows defining custom elements and dependency rules to match project architecture, as shown in the README example where controllers can only import models and views.

Flexible Configuration

Adapts to various structures like monorepos and layered patterns with configurable element patterns, supporting any organizational scheme.

Real-time Feedback

Provides immediate ESLint errors during development when imports violate boundaries, preventing architectural drift early in the workflow.

TypeScript Support

Fully compatible with TypeScript projects, ensuring boundary enforcement works seamlessly in typed codebases without extra setup.

Cons

Configuration Complexity

Requires detailed upfront setup of elements and rules, which can be time-consuming and error-prone for complex or large codebases.

Static Analysis Limitations

Only checks static import statements, missing dynamic imports or runtime dependencies that could violate architectural boundaries.

External Documentation Dependency

Full documentation is hosted on a separate website (JS Boundaries), which may be less accessible or could become outdated if not maintained alongside the code.

Frequently Asked Questions

Related Projects

import

ESLint plugin with rules that help validate proper imports.

Stars5,923

Forks1,545

Last commit8 days ago

Promise

Enforce best practices for JavaScript promises

Stars1,000

Forks101

Last commit4 days ago

functional

ESLint rules to disable mutation and promote fp in JavaScript and TypeScript.

Stars987

Forks35