@azure-net/cli 5.0.0-1 → 5.0.0

package/src/checks/checkLayerBoundaries.js

@@ -2,6 +2,7 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { loadUserConfig } from '../utils/loadConfig.js';
 import { normalizeContexts } from '../init/initAliases.js';
+import { SHARED_ESSENTIALS_DIR_NAME } from '../utils/sharedFoundation.js';
 const TARGET_EXTENSIONS = new Set(['.ts', '.js', '.svelte']);
 const IGNORED_DIRS = new Set(['node_modules', 'dist', '.svelte-kit', '.git']);
 const IMPORT_FROM_PATTERN = /\bimport\s+(?:type\s+)?[\s\S]*?\sfrom\s*['"]([^'"]+)['"]/g;
@@ -83,10 +84,10 @@ const resolveContextFromRelativeImport = (filePath, importPath, contexts) => {
 	}
 	return null;
 };
-const isSharedLikeContext = (contextName, alias) => {
-	const normalizedName = contextName.toLowerCase();
-	const normalizedAlias = alias.toLowerCase();
-	return normalizedName.includes('shared') || normalizedAlias.includes('shared');
+const isInside = (targetPath, rootPath) => targetPath === rootPath || targetPath.startsWith(`${rootPath}${path.sep}`);
+const resolveAbsoluteRelativeImport = (filePath, importPath) => {
+	if (!importPath.startsWith('.')) return null;
+	return path.resolve(path.dirname(filePath), importPath);
 };
 export default async function checkLayerBoundaries() {
 	const config = await loadUserConfig();
@@ -96,96 +97,92 @@ export default async function checkLayerBoundaries() {
 		process.exitCode = 1;
 		return;
 	}
-	const coreAlias = normalizeAlias(config.coreAlias, '$core');
 	const sharedAliasRaw = normalizeAlias(config.sharedAlias, '');
 	const sharedAlias = sharedAliasRaw.length ? sharedAliasRaw : null;
+	if (!sharedAlias) {
+		console.error('❌ sharedAlias is missing in azure-net.config.ts/js. Set it explicitly to the shared context alias.');
+		process.exitCode = 1;
+		return;
+	}
 	const aliasToContext = new Map();
 	for (const context of contexts) {
 		aliasToContext.set(context.alias, context);
 	}
-	const knownAliases = [coreAlias, ...contexts.map((context) => context.alias)];
-	if (sharedAlias && !knownAliases.includes(sharedAlias)) {
-		knownAliases.push(sharedAlias);
+	const knownAliases = [...contexts.map((context) => context.alias)];
+	const sharedContext = aliasToContext.get(sharedAlias);
+	if (!sharedContext) {
+		console.error(`❌ sharedAlias "${sharedAlias}" does not point to any configured context.`);
+		process.exitCode = 1;
+		return;
 	}
 	const issues = [];
-	const coreRoot = path.join(process.cwd(), 'src', 'core');
-	try {
-		await fs.access(coreRoot);
-		const coreFiles = await listFiles(coreRoot);
-		for (const filePath of coreFiles) {
-			const content = await fs.readFile(filePath, 'utf-8');
-			const imports = extractImports(content);
-			for (const entry of imports) {
-				const targetAlias = resolveAliasFromImport(entry.value, knownAliases);
-				if (targetAlias && targetAlias !== coreAlias) {
-					const targetContext = aliasToContext.get(targetAlias);
-					issues.push({
-						file: filePath,
-						line: entry.line,
-						message: targetContext
-							? `Layer boundary violation: core cannot import from context "${targetContext.name}" (${targetAlias})`
-							: `Layer boundary violation: core cannot import from "${targetAlias}"`
-					});
-					continue;
-				}
-				const relativeTargetContext = resolveContextFromRelativeImport(filePath, entry.value, contexts);
-				if (!relativeTargetContext) continue;
-				issues.push({
-					file: filePath,
-					line: entry.line,
-					message: `Layer boundary violation: core cannot import from context "${relativeTargetContext.name}" via relative path`
-				});
-			}
-		}
-	} catch {
-		// Core folder is optional for the check.
-	}
 	for (const context of contexts) {
 		const contextRoot = path.join(process.cwd(), 'src', 'app', context.name);
+		const isSharedContext = context.alias === sharedAlias;
+		const sharedEssentialsRoot = isSharedContext ? path.join(contextRoot, SHARED_ESSENTIALS_DIR_NAME) : null;
 		try {
 			await fs.access(contextRoot);
 		} catch {
 			continue;
 		}
 		const files = await listFiles(contextRoot);
-		const allowedAliases = new Set([context.alias, coreAlias]);
-		if (sharedAlias && context.alias !== sharedAlias) {
+		const allowedAliases = new Set([context.alias]);
+		if (context.alias !== sharedAlias) {
 			allowedAliases.add(sharedAlias);
 		}
 		for (const filePath of files) {
 			const content = await fs.readFile(filePath, 'utf-8');
 			const imports = extractImports(content);
+			const isSharedEssentialsFile = Boolean(sharedEssentialsRoot && isInside(filePath, sharedEssentialsRoot));
 			for (const entry of imports) {
 				const targetAlias = resolveAliasFromImport(entry.value, knownAliases);
 				if (!targetAlias) continue;
-				if (targetAlias === coreAlias) continue;
+				if (isSharedEssentialsFile && targetAlias === sharedAlias) {
+					const importRest = entry.value.slice(sharedAlias.length).replace(/^\/+/, '');
+					if (importRest.length && !importRest.startsWith(`${SHARED_ESSENTIALS_DIR_NAME}/`)) {
+						issues.push({
+							file: filePath,
+							line: entry.line,
+							message: `Layer boundary violation: shared essentials cannot import from shared "${importRest}". Essentials may depend only on shared essentials code.`
+						});
+						continue;
+					}
+				}
 				if (allowedAliases.has(targetAlias)) continue;
 				const targetContext = aliasToContext.get(targetAlias);
 				const baseMessage = targetContext
 					? `Layer boundary violation: context "${context.name}" cannot import from context "${targetContext.name}" (${targetAlias})`
 					: `Layer boundary violation: context "${context.name}" cannot import from "${targetAlias}"`;
-				const withSharedHint =
-					!sharedAlias && targetContext && isSharedLikeContext(targetContext.name, targetAlias)
-						? `${baseMessage}. sharedAlias is not configured in azure-net.config.ts/js; if this context is shared, set sharedAlias explicitly`
-						: baseMessage;
 				issues.push({
 					file: filePath,
 					line: entry.line,
-					message: withSharedHint
+					message: baseMessage
 				});
 			}
 			for (const entry of imports) {
+				const absoluteRelativeImport = resolveAbsoluteRelativeImport(filePath, entry.value);
+				if (
+					isSharedEssentialsFile &&
+					absoluteRelativeImport &&
+					sharedEssentialsRoot &&
+					isInside(absoluteRelativeImport, contextRoot) &&
+					!isInside(absoluteRelativeImport, sharedEssentialsRoot)
+				) {
+					issues.push({
+						file: filePath,
+						line: entry.line,
+						message: 'Layer boundary violation: shared essentials cannot import from shared layers/ui via relative path.'
+					});
+					continue;
+				}
 				const relativeTargetContext = resolveContextFromRelativeImport(filePath, entry.value, contexts);
 				if (!relativeTargetContext || relativeTargetContext.name === context.name) continue;
+				if (context.alias !== sharedAlias && relativeTargetContext.alias === sharedAlias) continue;
 				const baseMessage = `Layer boundary violation: context "${context.name}" cannot import from context "${relativeTargetContext.name}" via relative path`;
-				const withSharedHint =
-					!sharedAlias && isSharedLikeContext(relativeTargetContext.name, relativeTargetContext.alias)
-						? `${baseMessage}. sharedAlias is not configured in azure-net.config.ts/js; if this context is shared, set sharedAlias explicitly`
-						: baseMessage;
 				issues.push({
 					file: filePath,
 					line: entry.line,
-					message: withSharedHint
+					message: baseMessage
 				});
 			}
 		}
@@ -200,4 +197,3 @@ export default async function checkLayerBoundaries() {
 	}
 	process.exitCode = 1;
 }
-//# sourceMappingURL=checkLayerBoundaries.js.map

package/src/checks/checkLayerBoundaries.ts

@@ -2,6 +2,7 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { loadUserConfig } from '../utils/loadConfig.js';
 import { normalizeContexts } from '../init/initAliases.js';
+import { SHARED_ESSENTIALS_DIR_NAME } from '../utils/sharedFoundation.js';
 
 type BoundaryIssue = {
 	file: string;
@@ -115,10 +116,12 @@ const resolveContextFromRelativeImport = (filePath: string, importPath: string,
 	return null;
 };
 
-const isSharedLikeContext = (contextName: string, alias: string): boolean => {
-	const normalizedName = contextName.toLowerCase();
-	const normalizedAlias = alias.toLowerCase();
-	return normalizedName.includes('shared') || normalizedAlias.includes('shared');
+const isInside = (targetPath: string, rootPath: string): boolean =>
+	targetPath === rootPath || targetPath.startsWith(`${rootPath}${path.sep}`);
+
+const resolveAbsoluteRelativeImport = (filePath: string, importPath: string): string | null => {
+	if (!importPath.startsWith('.')) return null;
+	return path.resolve(path.dirname(filePath), importPath);
 };
 
 export default async function checkLayerBoundaries(): Promise<void> {
@@ -131,60 +134,33 @@ export default async function checkLayerBoundaries(): Promise<void> {
 		return;
 	}
 
-	const coreAlias = normalizeAlias(config.coreAlias, '$core');
 	const sharedAliasRaw = normalizeAlias(config.sharedAlias, '');
 	const sharedAlias = sharedAliasRaw.length ? sharedAliasRaw : null;
+	if (!sharedAlias) {
+		console.error('❌ sharedAlias is missing in azure-net.config.ts/js. Set it explicitly to the shared context alias.');
+		process.exitCode = 1;
+		return;
+	}
 
 	const aliasToContext = new Map<string, ContextConfig>();
 	for (const context of contexts) {
 		aliasToContext.set(context.alias, context);
 	}
 
-	const knownAliases = [coreAlias, ...contexts.map((context) => context.alias)];
-	if (sharedAlias && !knownAliases.includes(sharedAlias)) {
-		knownAliases.push(sharedAlias);
+	const knownAliases = [...contexts.map((context) => context.alias)];
+	const sharedContext = aliasToContext.get(sharedAlias);
+	if (!sharedContext) {
+		console.error(`❌ sharedAlias "${sharedAlias}" does not point to any configured context.`);
+		process.exitCode = 1;
+		return;
 	}
 
 	const issues: BoundaryIssue[] = [];
 
-	const coreRoot = path.join(process.cwd(), 'src', 'core');
-	try {
-		await fs.access(coreRoot);
-		const coreFiles = await listFiles(coreRoot);
-		for (const filePath of coreFiles) {
-			const content = await fs.readFile(filePath, 'utf-8');
-			const imports = extractImports(content);
-
-			for (const entry of imports) {
-				const targetAlias = resolveAliasFromImport(entry.value, knownAliases);
-				if (targetAlias && targetAlias !== coreAlias) {
-					const targetContext = aliasToContext.get(targetAlias);
-					issues.push({
-						file: filePath,
-						line: entry.line,
-						message: targetContext
-							? `Layer boundary violation: core cannot import from context "${targetContext.name}" (${targetAlias})`
-							: `Layer boundary violation: core cannot import from "${targetAlias}"`
-					});
-					continue;
-				}
-
-				const relativeTargetContext = resolveContextFromRelativeImport(filePath, entry.value, contexts);
-				if (!relativeTargetContext) continue;
-
-				issues.push({
-					file: filePath,
-					line: entry.line,
-					message: `Layer boundary violation: core cannot import from context "${relativeTargetContext.name}" via relative path`
-				});
-			}
-		}
-	} catch {
-		// Core folder is optional for the check.
-	}
-
 	for (const context of contexts) {
 		const contextRoot = path.join(process.cwd(), 'src', 'app', context.name);
+		const isSharedContext = context.alias === sharedAlias;
+		const sharedEssentialsRoot = isSharedContext ? path.join(contextRoot, SHARED_ESSENTIALS_DIR_NAME) : null;
 
 		try {
 			await fs.access(contextRoot);
@@ -193,19 +169,32 @@ export default async function checkLayerBoundaries(): Promise<void> {
 		}
 
 		const files = await listFiles(contextRoot);
-		const allowedAliases = new Set<string>([context.alias, coreAlias]);
-		if (sharedAlias && context.alias !== sharedAlias) {
+		const allowedAliases = new Set<string>([context.alias]);
+		if (context.alias !== sharedAlias) {
 			allowedAliases.add(sharedAlias);
 		}
 
 		for (const filePath of files) {
 			const content = await fs.readFile(filePath, 'utf-8');
 			const imports = extractImports(content);
+			const isSharedEssentialsFile = Boolean(sharedEssentialsRoot && isInside(filePath, sharedEssentialsRoot));
 
 			for (const entry of imports) {
 				const targetAlias = resolveAliasFromImport(entry.value, knownAliases);
 				if (!targetAlias) continue;
-				if (targetAlias === coreAlias) continue;
+
+				if (isSharedEssentialsFile && targetAlias === sharedAlias) {
+					const importRest = entry.value.slice(sharedAlias.length).replace(/^\/+/, '');
+					if (importRest.length && !importRest.startsWith(`${SHARED_ESSENTIALS_DIR_NAME}/`)) {
+						issues.push({
+							file: filePath,
+							line: entry.line,
+							message: `Layer boundary violation: shared essentials cannot import from shared "${importRest}". Essentials may depend only on shared essentials code.`
+						});
+						continue;
+					}
+				}
+
 				if (allowedAliases.has(targetAlias)) continue;
 
 				const targetContext = aliasToContext.get(targetAlias);
@@ -213,32 +202,40 @@ export default async function checkLayerBoundaries(): Promise<void> {
 					? `Layer boundary violation: context "${context.name}" cannot import from context "${targetContext.name}" (${targetAlias})`
 					: `Layer boundary violation: context "${context.name}" cannot import from "${targetAlias}"`;
 
-				const withSharedHint =
-					!sharedAlias && targetContext && isSharedLikeContext(targetContext.name, targetAlias)
-						? `${baseMessage}. sharedAlias is not configured in azure-net.config.ts/js; if this context is shared, set sharedAlias explicitly`
-						: baseMessage;
-
 				issues.push({
 					file: filePath,
 					line: entry.line,
-					message: withSharedHint
+					message: baseMessage
 				});
 			}
 
 			for (const entry of imports) {
+				const absoluteRelativeImport = resolveAbsoluteRelativeImport(filePath, entry.value);
+				if (
+					isSharedEssentialsFile &&
+					absoluteRelativeImport &&
+					sharedEssentialsRoot &&
+					isInside(absoluteRelativeImport, contextRoot) &&
+					!isInside(absoluteRelativeImport, sharedEssentialsRoot)
+				) {
+					issues.push({
+						file: filePath,
+						line: entry.line,
+						message: 'Layer boundary violation: shared essentials cannot import from shared layers/ui via relative path.'
+					});
+					continue;
+				}
+
 				const relativeTargetContext = resolveContextFromRelativeImport(filePath, entry.value, contexts);
 				if (!relativeTargetContext || relativeTargetContext.name === context.name) continue;
+				if (context.alias !== sharedAlias && relativeTargetContext.alias === sharedAlias) continue;
 
 				const baseMessage = `Layer boundary violation: context "${context.name}" cannot import from context "${relativeTargetContext.name}" via relative path`;
-				const withSharedHint =
-					!sharedAlias && isSharedLikeContext(relativeTargetContext.name, relativeTargetContext.alias)
-						? `${baseMessage}. sharedAlias is not configured in azure-net.config.ts/js; if this context is shared, set sharedAlias explicitly`
-						: baseMessage;
 
 				issues.push({
 					file: filePath,
 					line: entry.line,
-					message: withSharedHint
+					message: baseMessage
 				});
 			}
 		}

package/src/checks/checkLayerImports.js

@@ -0,0 +1,136 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { normalizeContexts } from '../init/initAliases.js';
+import { loadUserConfig } from '../utils/loadConfig.js';
+const TARGET_EXTENSIONS = new Set(['.ts', '.js', '.svelte']);
+const IGNORED_DIRS = new Set(['node_modules', 'dist', '.svelte-kit', '.git']);
+const LAYERS = ['domain', 'application', 'infrastructure', 'presentation'];
+const FORBIDDEN_LAYER_IMPORTS = {
+	infrastructure: ['application', 'presentation'],
+	application: ['presentation'],
+	domain: ['application', 'infrastructure', 'presentation'],
+	presentation: []
+};
+const IMPORT_FROM_PATTERN = /\bimport\s+(?:type\s+)?[\s\S]*?\sfrom\s*['"]([^'"]+)['"]/g;
+const EXPORT_FROM_PATTERN = /\bexport\s+(?:type\s+)?\{[\s\S]*?\}\sfrom\s*['"]([^'"]+)['"]/g;
+const DYNAMIC_IMPORT_PATTERN = /\bimport\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+const toPosixPath = (value) => value.split(path.sep).join('/');
+const findLineByIndex = (content, index) => {
+	let line = 1;
+	for (let i = 0; i < index; i += 1) {
+		if (content[i] === '\n') line += 1;
+	}
+	return line;
+};
+const getRelativePath = (filePath) => toPosixPath(path.relative(process.cwd(), filePath));
+const listFiles = async (rootDir) => {
+	const files = [];
+	const stack = [rootDir];
+	while (stack.length) {
+		const current = stack.pop();
+		if (!current) continue;
+		let entries = [];
+		try {
+			entries = await fs.readdir(current, { withFileTypes: true });
+		} catch {
+			continue;
+		}
+		for (const entry of entries) {
+			if (entry.isDirectory()) {
+				if (!IGNORED_DIRS.has(entry.name)) {
+					stack.push(path.join(current, entry.name));
+				}
+				continue;
+			}
+			if (!entry.isFile()) continue;
+			const filePath = path.join(current, entry.name);
+			if (!TARGET_EXTENSIONS.has(path.extname(filePath))) continue;
+			files.push(filePath);
+		}
+	}
+	return files;
+};
+const extractImports = (content) => {
+	const matches = [];
+	const patterns = [IMPORT_FROM_PATTERN, EXPORT_FROM_PATTERN, DYNAMIC_IMPORT_PATTERN];
+	for (const pattern of patterns) {
+		const regex = new RegExp(pattern.source, 'g');
+		let match;
+		while ((match = regex.exec(content)) !== null) {
+			const value = match[1];
+			if (!value) continue;
+			matches.push({ value, line: findLineByIndex(content, match.index) });
+		}
+	}
+	return matches;
+};
+const getLayerFromPath = (filePath, contextRoot) => {
+	for (const layer of LAYERS) {
+		const layerRoot = path.join(contextRoot, 'layers', layer);
+		if (filePath === layerRoot || filePath.startsWith(`${layerRoot}${path.sep}`)) {
+			return layer;
+		}
+	}
+	return null;
+};
+const getLayerFromAliasImport = (importPath, context) => {
+	if (importPath !== context.alias && !importPath.startsWith(`${context.alias}/`)) return null;
+	const withoutAlias = importPath.slice(context.alias.length).replace(/^\/+/, '');
+	for (const layer of LAYERS) {
+		if (withoutAlias === `layers/${layer}` || withoutAlias.startsWith(`layers/${layer}/`)) return layer;
+		if (withoutAlias === layer || withoutAlias.startsWith(`${layer}/`)) return layer;
+	}
+	return null;
+};
+const getLayerFromRelativeImport = (filePath, importPath, contextRoot) => {
+	if (!importPath.startsWith('.')) return null;
+	const absoluteImportPath = path.resolve(path.dirname(filePath), importPath);
+	return getLayerFromPath(absoluteImportPath, contextRoot);
+};
+const createMessage = (sourceLayer, targetLayer, context) =>
+	`Layer import violation: "${context.name}" ${sourceLayer} layer cannot import from ${targetLayer} layer`;
+export default async function checkLayerImports() {
+	const config = await loadUserConfig();
+	const contexts = normalizeContexts(config.contexts);
+	if (!contexts.length) {
+		console.error('❌ No contexts found in azure-net.config.ts/js. Fill `contexts` first.');
+		process.exitCode = 1;
+		return;
+	}
+	const issues = [];
+	for (const context of contexts) {
+		const contextRoot = path.join(process.cwd(), 'src', 'app', context.name);
+		try {
+			await fs.access(contextRoot);
+		} catch {
+			continue;
+		}
+		const files = await listFiles(path.join(contextRoot, 'layers'));
+		for (const filePath of files) {
+			const sourceLayer = getLayerFromPath(filePath, contextRoot);
+			if (!sourceLayer) continue;
+			const forbiddenLayers = FORBIDDEN_LAYER_IMPORTS[sourceLayer];
+			if (!forbiddenLayers.length) continue;
+			const content = await fs.readFile(filePath, 'utf-8');
+			const imports = extractImports(content);
+			for (const entry of imports) {
+				const targetLayer = getLayerFromAliasImport(entry.value, context) ?? getLayerFromRelativeImport(filePath, entry.value, contextRoot);
+				if (!targetLayer || !forbiddenLayers.includes(targetLayer)) continue;
+				issues.push({
+					file: filePath,
+					line: entry.line,
+					message: createMessage(sourceLayer, targetLayer, context)
+				});
+			}
+		}
+	}
+	if (!issues.length) {
+		console.log('✅ Layer imports check passed.');
+		return;
+	}
+	console.error('❌ Layer imports check failed:');
+	for (const issue of issues) {
+		console.error(`• ${getRelativePath(issue.file)}:${issue.line} — ${issue.message}`);
+	}
+	process.exitCode = 1;
+}

package/src/checks/checkLayerImports.ts

@@ -0,0 +1,185 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { normalizeContexts } from '../init/initAliases.js';
+import { loadUserConfig } from '../utils/loadConfig.js';
+
+type LayerName = 'domain' | 'application' | 'infrastructure' | 'presentation';
+
+type ContextConfig = {
+	name: string;
+	alias: string;
+};
+
+type LayerImportIssue = {
+	file: string;
+	line: number;
+	message: string;
+};
+
+const TARGET_EXTENSIONS = new Set(['.ts', '.js', '.svelte']);
+const IGNORED_DIRS = new Set(['node_modules', 'dist', '.svelte-kit', '.git']);
+const LAYERS: LayerName[] = ['domain', 'application', 'infrastructure', 'presentation'];
+const FORBIDDEN_LAYER_IMPORTS: Record<LayerName, LayerName[]> = {
+	infrastructure: ['application', 'presentation'],
+	application: ['presentation'],
+	domain: ['application', 'infrastructure', 'presentation'],
+	presentation: []
+};
+
+const IMPORT_FROM_PATTERN = /\bimport\s+(?:type\s+)?[\s\S]*?\sfrom\s*['"]([^'"]+)['"]/g;
+const EXPORT_FROM_PATTERN = /\bexport\s+(?:type\s+)?\{[\s\S]*?\}\sfrom\s*['"]([^'"]+)['"]/g;
+const DYNAMIC_IMPORT_PATTERN = /\bimport\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+
+const toPosixPath = (value: string): string => value.split(path.sep).join('/');
+
+const findLineByIndex = (content: string, index: number): number => {
+	let line = 1;
+	for (let i = 0; i < index; i += 1) {
+		if (content[i] === '\n') line += 1;
+	}
+	return line;
+};
+
+const getRelativePath = (filePath: string): string => toPosixPath(path.relative(process.cwd(), filePath));
+
+const listFiles = async (rootDir: string): Promise<string[]> => {
+	const files: string[] = [];
+	const stack: string[] = [rootDir];
+
+	while (stack.length) {
+		const current = stack.pop();
+		if (!current) continue;
+
+		let entries: import('node:fs').Dirent[] = [];
+		try {
+			entries = await fs.readdir(current, { withFileTypes: true });
+		} catch {
+			continue;
+		}
+
+		for (const entry of entries) {
+			if (entry.isDirectory()) {
+				if (!IGNORED_DIRS.has(entry.name)) {
+					stack.push(path.join(current, entry.name));
+				}
+				continue;
+			}
+
+			if (!entry.isFile()) continue;
+			const filePath = path.join(current, entry.name);
+			if (!TARGET_EXTENSIONS.has(path.extname(filePath))) continue;
+			files.push(filePath);
+		}
+	}
+
+	return files;
+};
+
+const extractImports = (content: string): Array<{ value: string; line: number }> => {
+	const matches: Array<{ value: string; line: number }> = [];
+	const patterns = [IMPORT_FROM_PATTERN, EXPORT_FROM_PATTERN, DYNAMIC_IMPORT_PATTERN];
+
+	for (const pattern of patterns) {
+		const regex = new RegExp(pattern.source, 'g');
+		let match: RegExpExecArray | null;
+		while ((match = regex.exec(content)) !== null) {
+			const value = match[1];
+			if (!value) continue;
+			matches.push({ value, line: findLineByIndex(content, match.index) });
+		}
+	}
+
+	return matches;
+};
+
+const getLayerFromPath = (filePath: string, contextRoot: string): LayerName | null => {
+	for (const layer of LAYERS) {
+		const layerRoot = path.join(contextRoot, 'layers', layer);
+		if (filePath === layerRoot || filePath.startsWith(`${layerRoot}${path.sep}`)) {
+			return layer;
+		}
+	}
+
+	return null;
+};
+
+const getLayerFromAliasImport = (importPath: string, context: ContextConfig): LayerName | null => {
+	if (importPath !== context.alias && !importPath.startsWith(`${context.alias}/`)) return null;
+
+	const withoutAlias = importPath.slice(context.alias.length).replace(/^\/+/, '');
+	for (const layer of LAYERS) {
+		if (withoutAlias === `layers/${layer}` || withoutAlias.startsWith(`layers/${layer}/`)) return layer;
+		if (withoutAlias === layer || withoutAlias.startsWith(`${layer}/`)) return layer;
+	}
+
+	return null;
+};
+
+const getLayerFromRelativeImport = (filePath: string, importPath: string, contextRoot: string): LayerName | null => {
+	if (!importPath.startsWith('.')) return null;
+
+	const absoluteImportPath = path.resolve(path.dirname(filePath), importPath);
+	return getLayerFromPath(absoluteImportPath, contextRoot);
+};
+
+const createMessage = (sourceLayer: LayerName, targetLayer: LayerName, context: ContextConfig): string =>
+	`Layer import violation: "${context.name}" ${sourceLayer} layer cannot import from ${targetLayer} layer`;
+
+export default async function checkLayerImports(): Promise<void> {
+	const config = await loadUserConfig();
+	const contexts = normalizeContexts(config.contexts) as ContextConfig[];
+
+	if (!contexts.length) {
+		console.error('❌ No contexts found in azure-net.config.ts/js. Fill `contexts` first.');
+		process.exitCode = 1;
+		return;
+	}
+
+	const issues: LayerImportIssue[] = [];
+
+	for (const context of contexts) {
+		const contextRoot = path.join(process.cwd(), 'src', 'app', context.name);
+
+		try {
+			await fs.access(contextRoot);
+		} catch {
+			continue;
+		}
+
+		const files = await listFiles(path.join(contextRoot, 'layers'));
+
+		for (const filePath of files) {
+			const sourceLayer = getLayerFromPath(filePath, contextRoot);
+			if (!sourceLayer) continue;
+
+			const forbiddenLayers = FORBIDDEN_LAYER_IMPORTS[sourceLayer];
+			if (!forbiddenLayers.length) continue;
+
+			const content = await fs.readFile(filePath, 'utf-8');
+			const imports = extractImports(content);
+
+			for (const entry of imports) {
+				const targetLayer = getLayerFromAliasImport(entry.value, context) ?? getLayerFromRelativeImport(filePath, entry.value, contextRoot);
+				if (!targetLayer || !forbiddenLayers.includes(targetLayer)) continue;
+
+				issues.push({
+					file: filePath,
+					line: entry.line,
+					message: createMessage(sourceLayer, targetLayer, context)
+				});
+			}
+		}
+	}
+
+	if (!issues.length) {
+		console.log('✅ Layer imports check passed.');
+		return;
+	}
+
+	console.error('❌ Layer imports check failed:');
+	for (const issue of issues) {
+		console.error(`• ${getRelativePath(issue.file)}:${issue.line} — ${issue.message}`);
+	}
+
+	process.exitCode = 1;
+}