@azure-net/cli 2.3.63 → 4.0.0-1

package/src/checks/checkDomain.ts

@@ -0,0 +1,213 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { loadUserConfig } from '../utils/loadConfig.js';
+import { normalizeContexts } from '../init/initAliases.js';
+
+type DomainIssue = {
+	file: string;
+	line: number;
+	message: string;
+};
+
+type Declaration = {
+	kind: 'interface' | 'type';
+	name: string;
+	line: number;
+};
+
+const DOMAIN_FILE_EXTENSIONS = new Set(['.ts']);
+const IGNORED_DIRS = new Set(['node_modules', 'dist', '.svelte-kit', '.git']);
+
+const INTERFACE_DECLARATION_PATTERN = /(?:^|\n)\s*(?:export\s+)?interface\s+([A-Za-z_$][A-Za-z0-9_$]*)\b/g;
+const TYPE_DECLARATION_PATTERN = /(?:^|\n)\s*(?:export\s+)?type\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*=/g;
+
+const EXPORT_STAR_PATTERN = /export\s+\*\s+from\s*['"][^'"]+['"]\s*;?/g;
+const EXPORT_FROM_PATTERN = /export\s+(?:type\s+)?\{[\s\S]*?\}\s+from\s*['"][^'"]+['"]\s*;?/g;
+const EXPORT_LOCAL_PATTERN = /export\s+(?:type\s+)?\{[\s\S]*?\}\s*;?/g;
+
+const toPosixPath = (value: string): string => value.split(path.sep).join('/');
+
+const stripComments = (content: string): string => content.replace(/\/\*[\s\S]*?\*\//g, '').replace(/(^|[^\\])\/\/.*$/gm, '$1');
+
+const stripExportStatements = (content: string): string =>
+	content.replace(EXPORT_STAR_PATTERN, '').replace(EXPORT_FROM_PATTERN, '').replace(EXPORT_LOCAL_PATTERN, '');
+
+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 getRelativeFilePath = (filePath: string): string => toPosixPath(path.relative(process.cwd(), filePath));
+
+const isEnumsPath = (filePath: string): boolean => {
+	const normalized = toPosixPath(filePath);
+	return normalized.includes('/enums/');
+};
+
+const isIndexFile = (filePath: string): boolean => path.basename(filePath) === 'index.ts';
+
+const isExportOnlyIndex = (content: string): boolean => {
+	const withoutComments = stripComments(content);
+	const withoutExports = stripExportStatements(withoutComments);
+	return withoutExports.trim().length === 0;
+};
+
+const validateName = (declaration: Declaration): string | null => {
+	if (declaration.kind === 'interface') {
+		return /^I[A-Z]/.test(declaration.name) ? null : `Interface "${declaration.name}" must start with "I" and have uppercase second letter`;
+	}
+
+	return /^[IT][A-Z]/.test(declaration.name)
+		? null
+		: `Type "${declaration.name}" must start with "I" or "T" and have uppercase second letter`;
+};
+
+const extractDeclarations = (content: string): Declaration[] => {
+	const cleaned = stripComments(content);
+	const declarations: Declaration[] = [];
+
+	const interfaceRegex = new RegExp(INTERFACE_DECLARATION_PATTERN.source, 'g');
+	let interfaceMatch: RegExpExecArray | null;
+	while ((interfaceMatch = interfaceRegex.exec(cleaned)) !== null) {
+		const name = interfaceMatch[1];
+		if (!name) continue;
+		declarations.push({
+			kind: 'interface',
+			name,
+			line: findLineByIndex(cleaned, interfaceMatch.index)
+		});
+	}
+
+	const typeRegex = new RegExp(TYPE_DECLARATION_PATTERN.source, 'g');
+	let typeMatch: RegExpExecArray | null;
+	while ((typeMatch = typeRegex.exec(cleaned)) !== null) {
+		const name = typeMatch[1];
+		if (!name) continue;
+		declarations.push({
+			kind: 'type',
+			name,
+			line: findLineByIndex(cleaned, typeMatch.index)
+		});
+	}
+
+	return declarations.sort((a, b) => a.line - b.line);
+};
+
+const listDomainFiles = async (domainRoot: string): Promise<string[]> => {
+	const files: string[] = [];
+	const stack: string[] = [domainRoot];
+
+	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 (!DOMAIN_FILE_EXTENSIONS.has(path.extname(filePath))) continue;
+			files.push(filePath);
+		}
+	}
+
+	return files;
+};
+
+const collectIssuesForFile = (filePath: string, content: string): DomainIssue[] => {
+	const issues: DomainIssue[] = [];
+
+	if (isIndexFile(filePath) && !isExportOnlyIndex(content)) {
+		issues.push({
+			file: filePath,
+			line: 1,
+			message: 'index.ts must contain only exports. Move declarations to separate files'
+		});
+	}
+
+	if (isEnumsPath(filePath)) {
+		return issues;
+	}
+
+	const declarations = extractDeclarations(content);
+	if (declarations.length > 5) {
+		issues.push({
+			file: filePath,
+			line: declarations[5]?.line ?? 1,
+			message: `Too many declarations in one file (${declarations.length}). Maximum is 5`
+		});
+	}
+
+	for (const declaration of declarations) {
+		const validationError = validateName(declaration);
+		if (!validationError) continue;
+		issues.push({
+			file: filePath,
+			line: declaration.line,
+			message: validationError
+		});
+	}
+
+	return issues;
+};
+
+export default async function checkDomain(): Promise<void> {
+	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: DomainIssue[] = [];
+
+	for (const context of contexts) {
+		const domainRoot = path.join(process.cwd(), 'src', 'app', context.name, 'layers', 'domain');
+
+		try {
+			await fs.access(domainRoot);
+		} catch {
+			issues.push({
+				file: domainRoot,
+				line: 1,
+				message: `Domain folder not found for context "${context.name}"`
+			});
+			continue;
+		}
+
+		const files = await listDomainFiles(domainRoot);
+		for (const filePath of files) {
+			const content = await fs.readFile(filePath, 'utf-8');
+			issues.push(...collectIssuesForFile(filePath, content));
+		}
+	}
+
+	if (!issues.length) {
+		console.log('✅ Domain check passed: naming, per-file limits and index exports are valid.');
+		return;
+	}
+
+	console.error('❌ Domain check failed:');
+	for (const issue of issues) {
+		console.error(`• ${getRelativeFilePath(issue.file)}:${issue.line} — ${issue.message}`);
+	}
+
+	process.exitCode = 1;
+}

package/src/checks/checkFoldersStructure.js

@@ -0,0 +1,70 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { loadUserConfig } from '../utils/loadConfig.js';
+import { normalizeContexts } from '../init/initAliases.js';
+
+const ALLOWED_LAYERS_FOLDERS = new Set(['domain', 'presentation', 'infrastructure', 'application']);
+const ALLOWED_UI_FOLDERS = new Set(['components', 'widgets', 'design', 'style']);
+const ALLOWED_COMPONENTS_FOLDERS = new Set(['page', 'layout', 'shared']);
+
+const toPosixPath = (value) => value.split(path.sep).join('/');
+
+const getRelativePath = (filePath) => toPosixPath(path.relative(process.cwd(), filePath));
+
+const getDirectories = async (dirPath) => {
+	try {
+		const entries = await fs.readdir(dirPath, { withFileTypes: true });
+		return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+	} catch {
+		return null;
+	}
+};
+
+const checkOnlyAllowedFolders = async (basePath, allowed, scopeLabel, issues) => {
+	const directories = await getDirectories(basePath);
+	if (!directories) return;
+
+	for (const dir of directories) {
+		if (allowed.has(dir)) continue;
+		issues.push({
+			file: basePath,
+			message: `${scopeLabel} can contain only: ${Array.from(allowed).join(', ')}. Found: ${dir}`
+		});
+	}
+};
+
+export default async function checkFoldersStructure() {
+	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);
+		const layersPath = path.join(contextRoot, 'layers');
+		const uiPath = path.join(contextRoot, 'ui');
+		const componentsPath = path.join(uiPath, 'components');
+
+		await checkOnlyAllowedFolders(layersPath, ALLOWED_LAYERS_FOLDERS, `layers (${context.name})`, issues);
+		await checkOnlyAllowedFolders(uiPath, ALLOWED_UI_FOLDERS, `ui (${context.name})`, issues);
+		await checkOnlyAllowedFolders(componentsPath, ALLOWED_COMPONENTS_FOLDERS, `ui/components (${context.name})`, issues);
+	}
+
+	if (!issues.length) {
+		console.log('✅ Folders structure check passed.');
+		return;
+	}
+
+	console.error('❌ Folders structure check failed:');
+	for (const issue of issues) {
+		console.error(`• ${getRelativePath(issue.file)} — ${issue.message}`);
+	}
+
+	process.exitCode = 1;
+}

package/src/checks/checkFoldersStructure.ts

@@ -0,0 +1,85 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { loadUserConfig } from '../utils/loadConfig.js';
+import { normalizeContexts } from '../init/initAliases.js';
+
+type StructureIssue = {
+	file: string;
+	message: string;
+};
+
+type ContextConfig = {
+	name: string;
+	alias: string;
+};
+
+const ALLOWED_LAYERS_FOLDERS = new Set(['domain', 'presentation', 'infrastructure', 'application']);
+const ALLOWED_UI_FOLDERS = new Set(['components', 'widgets', 'design', 'style']);
+const ALLOWED_COMPONENTS_FOLDERS = new Set(['page', 'layout', 'shared']);
+
+const toPosixPath = (value: string): string => value.split(path.sep).join('/');
+
+const getRelativePath = (filePath: string): string => toPosixPath(path.relative(process.cwd(), filePath));
+
+const getDirectories = async (dirPath: string): Promise<string[] | null> => {
+	try {
+		const entries = await fs.readdir(dirPath, { withFileTypes: true });
+		return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+	} catch {
+		return null;
+	}
+};
+
+const checkOnlyAllowedFolders = async (
+	basePath: string,
+	allowed: Set<string>,
+	scopeLabel: string,
+	issues: StructureIssue[]
+): Promise<void> => {
+	const directories = await getDirectories(basePath);
+	if (!directories) return;
+
+	for (const dir of directories) {
+		if (allowed.has(dir)) continue;
+		issues.push({
+			file: basePath,
+			message: `${scopeLabel} can contain only: ${Array.from(allowed).join(', ')}. Found: ${dir}`
+		});
+	}
+};
+
+export default async function checkFoldersStructure(): 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: StructureIssue[] = [];
+
+	for (const context of contexts) {
+		const contextRoot = path.join(process.cwd(), 'src', 'app', context.name);
+		const layersPath = path.join(contextRoot, 'layers');
+		const uiPath = path.join(contextRoot, 'ui');
+		const componentsPath = path.join(uiPath, 'components');
+
+		await checkOnlyAllowedFolders(layersPath, ALLOWED_LAYERS_FOLDERS, `layers (${context.name})`, issues);
+		await checkOnlyAllowedFolders(uiPath, ALLOWED_UI_FOLDERS, `ui (${context.name})`, issues);
+		await checkOnlyAllowedFolders(componentsPath, ALLOWED_COMPONENTS_FOLDERS, `ui/components (${context.name})`, issues);
+	}
+
+	if (!issues.length) {
+		console.log('✅ Folders structure check passed.');
+		return;
+	}
+
+	console.error('❌ Folders structure check failed:');
+	for (const issue of issues) {
+		console.error(`• ${getRelativePath(issue.file)} — ${issue.message}`);
+	}
+
+	process.exitCode = 1;
+}

package/src/checks/checkInternal.js

@@ -0,0 +1,35 @@
+import checkPresenterNames from './checkPresenterNames.js';
+import checkProviderNames from './checkProviderNames.js';
+import checkDomain from './checkDomain.js';
+import checkLayerBoundaries from './checkLayerBoundaries.js';
+import checkFoldersStructure from './checkFoldersStructure.js';
+
+const tasks = [
+	{ name: 'presenter-names', run: checkPresenterNames },
+	{ name: 'provider-names', run: checkProviderNames },
+	{ name: 'domain', run: checkDomain },
+	{ name: 'layer-boundaries', run: checkLayerBoundaries },
+	{ name: 'folders-structure', run: checkFoldersStructure }
+];
+
+const runTask = async (task) => {
+	console.log(`\n▶ Running check ${task.name}...`);
+	process.exitCode = 0;
+	await task.run();
+
+	if ((process.exitCode ?? 0) !== 0) {
+		throw new Error(`Check "${task.name}" failed`);
+	}
+};
+
+export default async function checkInternal() {
+	try {
+		for (const task of tasks) {
+			await runTask(task);
+		}
+		console.log('\n✅ Internal checks passed.');
+	} catch (error) {
+		console.error(`\n❌ Internal checks failed: ${error instanceof Error ? error.message : String(error)}`);
+		process.exitCode = 1;
+	}
+}

package/src/checks/checkInternal.ts

@@ -0,0 +1,40 @@
+import checkPresenterNames from './checkPresenterNames.js';
+import checkProviderNames from './checkProviderNames.js';
+import checkDomain from './checkDomain.js';
+import checkLayerBoundaries from './checkLayerBoundaries.js';
+import checkFoldersStructure from './checkFoldersStructure.js';
+
+type CheckTask = {
+	name: string;
+	run: () => Promise<void>;
+};
+
+const tasks: CheckTask[] = [
+	{ name: 'presenter-names', run: checkPresenterNames },
+	{ name: 'provider-names', run: checkProviderNames },
+	{ name: 'domain', run: checkDomain },
+	{ name: 'layer-boundaries', run: checkLayerBoundaries },
+	{ name: 'folders-structure', run: checkFoldersStructure }
+];
+
+const runTask = async (task: CheckTask): Promise<void> => {
+	console.log(`\n▶ Running check ${task.name}...`);
+	process.exitCode = 0;
+	await task.run();
+
+	if ((process.exitCode ?? 0) !== 0) {
+		throw new Error(`Check "${task.name}" failed`);
+	}
+};
+
+export default async function checkInternal(): Promise<void> {
+	try {
+		for (const task of tasks) {
+			await runTask(task);
+		}
+		console.log('\n✅ Internal checks passed.');
+	} catch (error) {
+		console.error(`\n❌ Internal checks failed: ${error instanceof Error ? error.message : String(error)}`);
+		process.exitCode = 1;
+	}
+}

package/src/checks/checkLayerBoundaries.js

@@ -0,0 +1,178 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { loadUserConfig } from '../utils/loadConfig.js';
+import { normalizeContexts } from '../init/initAliases.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;
+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 normalizeAlias = (value, fallback = '') => {
+	const raw = String(value ?? '').trim();
+	if (!raw.length) return fallback;
+	return raw.startsWith('$') ? raw : `$${raw}`;
+};
+
+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 resolveAliasFromImport = (importPath, aliases) => {
+	const sorted = [...aliases].sort((a, b) => b.length - a.length);
+	for (const alias of sorted) {
+		if (importPath === alias || importPath.startsWith(`${alias}/`)) {
+			return alias;
+		}
+	}
+	return null;
+};
+
+const isSharedLikeContext = (contextName, alias) => {
+	const normalizedName = contextName.toLowerCase();
+	const normalizedAlias = alias.toLowerCase();
+	return normalizedName.includes('shared') || normalizedAlias.includes('shared');
+};
+
+export default async function checkLayerBoundaries() {
+	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 coreAlias = normalizeAlias(config.coreAlias, '$core');
+	const sharedAliasRaw = normalizeAlias(config.sharedAlias, '');
+	const sharedAlias = sharedAliasRaw.length ? sharedAliasRaw : null;
+
+	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 issues = [];
+
+	for (const context of contexts) {
+		const layersRoot = path.join(process.cwd(), 'src', 'app', context.name, 'layers');
+
+		try {
+			await fs.access(layersRoot);
+		} catch {
+			continue;
+		}
+
+		const files = await listFiles(layersRoot);
+		const allowedAliases = new Set([context.alias, coreAlias]);
+		if (sharedAlias) {
+			allowedAliases.add(sharedAlias);
+		}
+
+		for (const filePath of files) {
+			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) continue;
+				if (targetAlias === coreAlias) 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
+				});
+			}
+		}
+	}
+
+	if (!issues.length) {
+		console.log('✅ Layer boundaries check passed.');
+		return;
+	}
+
+	console.error('❌ Layer boundaries check failed:');
+	for (const issue of issues) {
+		console.error(`• ${getRelativePath(issue.file)}:${issue.line} — ${issue.message}`);
+	}
+
+	process.exitCode = 1;
+}