0
# @nx/eslint-plugin
1

2
The @nx/eslint-plugin is a comprehensive ESLint plugin designed specifically for Nx monorepo development. It provides essential rules for enforcing module boundaries, managing dependencies, and validating plugin configurations, along with pre-configured ESLint settings for TypeScript, JavaScript, React, and Angular projects.
3

4
## Package Information
5

6
- **Package Name**: @nx/eslint-plugin
7
- **Package Type**: npm
8
- **Language**: TypeScript
9
- **Installation**: `npm install @nx/eslint-plugin`
10

11
## Core Imports
12

13
```typescript
14
import plugin from "@nx/eslint-plugin";
15
// Access configs: plugin.configs
16
// Access rules: plugin.rules
17
```
18

19
For specialized imports:
20

21
```typescript
22
// Import specific framework configs
23
import angularPlugin from "@nx/eslint-plugin/angular";
24
import reactPlugin from "@nx/eslint-plugin/react";
25
import typescriptPlugin from "@nx/eslint-plugin/typescript";
26

27
// Import rules only
28
import nxPlugin from "@nx/eslint-plugin/nx";
29
```
30

31
CommonJS:
32

33
```javascript
34
const plugin = require("@nx/eslint-plugin");
35
const { configs, rules } = plugin;
36
```
37

38
## Basic Usage
39

40
```typescript
41
// ESLint flat config setup
42
import nxPlugin from "@nx/eslint-plugin";
43

44
export default [
45
  ...nxPlugin.configs["flat/typescript"],
46
  {
47
    rules: {
48
      "@nx/enforce-module-boundaries": [
49
        "error",
50
        {
51
          depConstraints: [
52
            {
53
              sourceTag: "scope:shared",
54
              onlyDependOnLibsWithTags: ["scope:shared"]
55
            }
56
          ]
57
        }
58
      ]
59
    }
60
  }
61
];
62
```
63

64
## Architecture
65

66
The plugin is organized around several key components:
67

68
- **Core Rules**: Three main ESLint rules that enforce Nx workspace integrity
69
- **Configuration Presets**: Pre-built ESLint configurations for different frameworks and formats
70
- **Workspace Integration**: Dynamic loading of custom rules from workspace tools
71
- **Utility System**: Graph analysis, AST parsing, and project resolution utilities
72
- **Format Support**: Both legacy ESLintRC and modern flat config formats
73

74
## Capabilities
75

76
### Module Boundary Enforcement
77

78
Core rule that ensures proper module boundaries and dependency graph integrity within Nx workspaces. Prevents circular dependencies, enforces tagging constraints, and validates import patterns.
79

80
```typescript { .api }
81
interface EnforceModuleBoundariesOptions {
82
  allow: string[];
83
  buildTargets: string[];
84
  depConstraints: DepConstraint[];
85
  enforceBuildableLibDependency: boolean;
86
  allowCircularSelfDependency: boolean;
87
  ignoredCircularDependencies: Array<[string, string]>;
88
  checkDynamicDependenciesExceptions: string[];
89
  banTransitiveDependencies: boolean;
90
  checkNestedExternalImports: boolean;
91
}
92

93
interface DepConstraint {
94
  sourceTag: string;
95
  onlyDependOnLibsWithTags?: string[];
96
  notDependOnLibsWithTags?: string[];
97
  bannedExternalImports?: string[];
98
}
99
```
100

101
[Module Boundaries](./module-boundaries.md)
102

103
### Dependency Management
104

105
Validates package.json dependencies against actual usage, detecting missing dependencies, obsolete packages, and version mismatches across the workspace.
106

107
```typescript { .api }
108
interface DependencyChecksOptions {
109
  buildTargets?: string[];
110
  checkMissingDependencies?: boolean;
111
  checkObsoleteDependencies?: boolean;
112
  checkVersionMismatches?: boolean;
113
  ignoredDependencies?: string[];
114
  ignoredFiles?: string[];
115
  includeTransitiveDependencies?: boolean;
116
  useLocalPathsForWorkspaceDependencies?: boolean;
117
  runtimeHelpers?: string[];
118
}
119
```
120

121
[Dependency Checks](./dependency-checks.md)
122

123
### Plugin Configuration Validation
124

125
Validates Nx plugin configuration files including generators.json, executors.json, migrations.json, and related TypeScript implementations.
126

127
```typescript { .api }
128
interface NxPluginChecksOptions {
129
  generatorsJson?: string;
130
  executorsJson?: string;
131
  migrationsJson?: string;
132
  packageJson?: string;
133
  allowedVersionStrings: string[];
134
  tsConfig?: string;
135
}
136
```
137

138
[Plugin Validation](./plugin-validation.md)
139

140
### ESLint Configurations
141

142
Pre-configured ESLint setups for different frameworks and formats, supporting both legacy ESLintRC and modern flat config approaches.
143

144
```typescript { .api }
145
interface PluginConfigs {
146
  // Legacy ESLintRC configs
147
  typescript: ESLintConfig;
148
  javascript: ESLintConfig;
149
  react: ESLintConfig;
150
  "react-base": ESLintConfig;
151
  "react-typescript": ESLintConfig;
152
  "react-jsx": ESLintConfig;
153
  angular: ESLintConfig;
154
  "angular-template": ESLintConfig;
155
  
156
  // Flat configs
157
  "flat/base": FlatConfig[];
158
  "flat/typescript": FlatConfig[];
159
  "flat/javascript": FlatConfig[];
160
  "flat/react": FlatConfig[];
161
  "flat/react-base": FlatConfig[];
162
  "flat/react-typescript": FlatConfig[];
163
  "flat/react-jsx": FlatConfig[];
164
  "flat/angular": FlatConfig[];
165
  "flat/angular-template": FlatConfig[];
166
}
167
```
168

169
[ESLint Configurations](./configurations.md)
170

171
### Workspace Rule Integration
172

173
Dynamically loads and integrates custom ESLint rules from the workspace's tools/eslint-rules directory, enabling project-specific linting extensions.
174

175
```typescript { .api }
176
interface WorkspaceRules {
177
  [key: `workspace-${string}`]: TSESLint.RuleModule<string, unknown[]>;
178
  [key: `workspace/${string}`]: TSESLint.RuleModule<string, unknown[]>; // backwards compatibility
179
}
180
```
181

182
[Workspace Rules](./workspace-rules.md)
183

184
## Plugin Exports
185

186
```typescript { .api }
187
interface NxESLintPlugin {
188
  configs: PluginConfigs;
189
  rules: {
190
    "enforce-module-boundaries": RuleModule;
191
    "dependency-checks": RuleModule;
192
    "nx-plugin-checks": RuleModule;
193
  } & WorkspaceRules;
194
}
195

196
// Default export
197
export default NxESLintPlugin;
198

199
// Named exports
200
export { configs, rules };
201
```
202

203
## Type Definitions
204

205
```typescript { .api }
206
interface ESLintConfig {
207
  parser?: string;
208
  parserOptions?: ParserOptions;
209
  plugins?: string[];
210
  extends?: string[];
211
  rules?: Record<string, any>;
212
}
213

214
interface FlatConfig {
215
  files?: string[];
216
  ignores?: string[];
217
  plugins?: Record<string, any>;
218
  languageOptions?: LanguageOptions;
219
  rules?: Record<string, any>;
220
}
221

222
interface ParserOptions {
223
  ecmaVersion?: number;
224
  sourceType?: "module" | "script";
225
  tsconfigRootDir?: string;
226
}
227

228
interface LanguageOptions {
229
  parser?: any;
230
  ecmaVersion?: number;
231
  sourceType?: "module" | "script";
232
  parserOptions?: ParserOptions;
233
}
234
```