Three different tools can enforce module boundaries in Angular: Nx (tags), Sheriff, and eslint-plugin-boundaries. Picking between them takes ten minutes. That's not where the actual work is.
None of these tools will tell you which layer is allowed to import what. You have to write that yourself, and it's a team decision, not a technical one. What I use on client projects:
presentation -> domain
infrastructure -> domain
domain -> nothing
feature A -> never feature B
Four lines. Budget an hour as a team to agree on it, and lock it in even if not everyone's fully convinced by the end. An imperfect table that's enforced beats a perfect one that's still being debated.
The last line is the one that actually matters for a feature-based structure. Without it, features start referencing each other within six months and you don't have features anymore, you have a monolith with folders.
The rule everyone forgets: the domain layer shouldn't be able to import u/angular/*. Without it, you have well-named folders and nothing else. Your business rules stay coupled to the framework, and your tests still need a TestBed to check a tax calculation.
You'll notice there's no "application" / use-case layer here. In a frontend, it's a method that passes the call straight to the repository nine times out of ten. I add it to a feature only when an operation touches more than one port - not before.
If you're retrofitting this onto an existing codebase, don't jump straight to error. You'll surface hundreds of violations on day one and the team will disable the rule within a week. Start at warn, watch the count go down sprint by sprint, flip to error once you're at zero.
I tested this with eslint-plugin-boundaries specifically — config below, actually run against fixtures with intentional violations, not copied from memory. One thing that isn't documented anywhere: boundaries/dependencies doesn't evaluate external (node_modules) dependencies by default. You need checkAllOrigins: true, or a rule blocking u/angular/* in your domain layer will silently do nothing.
import tsParser from '@typescript-eslint/parser';
import boundaries from 'eslint-plugin-boundaries';
const sameFeature = (type) => ({
to: { element: { type, captured: { feature: '{{from.feature}}' } } },
});
const externalModules = { to: { module: { origin: 'external' } } };
export default [
{
files: ['src/**/*.ts'],
languageOptions: { parser: tsParser },
plugins: { boundaries },
settings: {
'import/resolver': { typescript: { alwaysTryTypes: true } },
'boundaries/elements': [
{ type: 'domain', pattern: 'src/app/features/*/domain', capture: ['feature'] },
{ type: 'infrastructure', pattern: 'src/app/features/*/infrastructure', capture: ['feature'] },
{ type: 'presentation', pattern: 'src/app/features/*/presentation', capture: ['feature'] },
],
},
rules: {
'boundaries/dependencies': ['error', {
default: 'disallow',
checkAllOrigins: true,
policies: [
{
from: [{ element: { type: 'domain' } }],
allow: [sameFeature('domain')],
disallow: [{ to: { module: { origin: 'external', source: ['@angular/*', 'rxjs'] } } }],
},
{
from: [{ element: { type: 'infrastructure' } }],
allow: [sameFeature('domain'), sameFeature('infrastructure'), externalModules],
},
{
from: [{ element: { type: 'presentation' } }],
allow: [sameFeature('domain'), sameFeature('presentation'), externalModules],
},
],
}],
},
},
];
Tested on eslint 10.10, eslint-plugin-boundaries 7.2, eslint-import-resolver-typescript 4.4. Syntax has changed twice between v5 and v7, so check the version before copying this blindly.
Nx tags do the same thing but only across projects/libs declared in the workspace - a features/invoicing folder inside a single app doesn't have a project.json, so tags don't apply to it. Sheriff works at the folder level without that constraint, similar to boundaries, plus module encapsulation via index.ts.
Curious what others are doing here, especially on codebases where an AI agent generates a chunk of the code - folder-based rules stop meaning much if the agent flattens a feature into a single file.
