@azure-net/cli 4.0.0-0 → 4.1.0

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;
+}

package/src/checks/checkLayerBoundaries.ts

@@ -0,0 +1,216 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { loadUserConfig } from '../utils/loadConfig.js';
+import { normalizeContexts } from '../init/initAliases.js';
+
+type BoundaryIssue = {
+	file: string;
+	line: number;
+	message: string;
+};
+
+type ContextConfig = {
+	name: string;
+	alias: string;
+};
+
+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: string): string => value.split(path.sep).join('/');
+
+const normalizeAlias = (value: unknown, fallback = ''): string => {
+	const raw = String(value ?? '').trim();
+	if (!raw.length) return fallback;
+	return raw.startsWith('$') ? raw : `$${raw}`;
+};
+
+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 resolveAliasFromImport = (importPath: string, aliases: string[]): string | null => {
+	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: string, alias: string): boolean => {
+	const normalizedName = contextName.toLowerCase();
+	const normalizedAlias = alias.toLowerCase();
+	return normalizedName.includes('shared') || normalizedAlias.includes('shared');
+};
+
+export default async function checkLayerBoundaries(): 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 coreAlias = normalizeAlias(config.coreAlias, '$core');
+	const sharedAliasRaw = normalizeAlias(config.sharedAlias, '');
+	const sharedAlias = sharedAliasRaw.length ? sharedAliasRaw : null;
+
+	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 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) continue;
+				if (!aliasToContext.has(targetAlias)) continue;
+
+				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}"`
+				});
+			}
+		}
+	} catch {
+		// Core folder is optional for the check.
+	}
+
+	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(contextRoot);
+		const allowedAliases = new Set<string>([context.alias, coreAlias]);
+		if (sharedAlias && context.alias !== 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;
+}

package/src/checks/checkPresenterNames.js

@@ -0,0 +1,202 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+const TARGET_EXTENSIONS = new Set(['.ts', '.js', '.svelte']);
+const IGNORED_DIRS = new Set(['node_modules', 'dist', '.svelte-kit', '.git']);
+
+const CREATE_FACTORY_PATTERN = '(?:export\\s+)?(?:const|let|var)\\s+([A-Za-z_$][A-Za-z0-9_$]*)\\s*=\\s*createPresenterFactory\\s*\\(';
+const IMPORT_FROM_PRESENTER_PATTERN = 'import\\s*\\{([^}]+)\\}\\s*from\\s*[\'"]([^\'"]+)[\'"]';
+const PRESENTER_CALL_PATTERN = '\\b([A-Za-z_$][A-Za-z0-9_$]*)\\s*\\(\\s*([\'"`])([^\'"`]*)\\2';
+
+const toPosixPath = (value) => value.split(path.sep).join('/');
+
+const isPresenterImportPath = (importPath) => {
+	const normalized = importPath.replace(/\\/g, '/');
+	return /(^|\/)presenter(\/|$)/.test(normalized);
+};
+
+const parseImportLocals = (rawImports) => {
+	const locals = [];
+	for (const segment of rawImports.split(',')) {
+		const item = segment.trim();
+		if (!item.length) continue;
+		const aliasMatch = item.match(/^([A-Za-z_$][A-Za-z0-9_$]*)\s+as\s+([A-Za-z_$][A-Za-z0-9_$]*)$/);
+		if (aliasMatch?.[2]) {
+			locals.push(aliasMatch[2]);
+			continue;
+		}
+
+		const directMatch = item.match(/^([A-Za-z_$][A-Za-z0-9_$]*)$/);
+		if (directMatch?.[1]) {
+			locals.push(directMatch[1]);
+		}
+	}
+	return locals;
+};
+
+const listSourceFiles = async (rootDir) => {
+	const result = [];
+	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 fullPath = path.join(current, entry.name);
+			const extension = path.extname(fullPath);
+			if (!TARGET_EXTENSIONS.has(extension)) continue;
+			result.push(fullPath);
+		}
+	}
+
+	return result;
+};
+
+const getLineByIndex = (content, index) => {
+	let line = 1;
+	for (let i = 0; i < index; i += 1) {
+		if (content[i] === '\n') line += 1;
+	}
+	return line;
+};
+
+const extractFactoryNamesFromContent = (content) => {
+	const createFactoryRegex = new RegExp(CREATE_FACTORY_PATTERN, 'g');
+	const names = [];
+	let match;
+	while ((match = createFactoryRegex.exec(content)) !== null) {
+		const name = match[1];
+		if (name) names.push(name);
+	}
+	return names;
+};
+
+const extractImportedPresenterFactories = (content) => {
+	const importFromPresenterRegex = new RegExp(IMPORT_FROM_PRESENTER_PATTERN, 'g');
+	const names = [];
+	let match;
+	while ((match = importFromPresenterRegex.exec(content)) !== null) {
+		const rawImports = match[1];
+		const importPath = match[2];
+		if (!rawImports || !importPath) continue;
+		if (!isPresenterImportPath(importPath)) continue;
+		names.push(...parseImportLocals(rawImports));
+	}
+	return names;
+};
+
+const collectPresenterOccurrences = (content, filePath, knownFactories) => {
+	const presenterCallRegex = new RegExp(PRESENTER_CALL_PATTERN, 'g');
+	const occurrences = [];
+	const availableCallees = new Set(['createPresenter']);
+
+	for (const name of extractFactoryNamesFromContent(content)) {
+		availableCallees.add(name);
+	}
+	for (const name of extractImportedPresenterFactories(content)) {
+		availableCallees.add(name);
+	}
+	for (const name of knownFactories) {
+		availableCallees.add(name);
+	}
+
+	let match;
+	while ((match = presenterCallRegex.exec(content)) !== null) {
+		const callee = match[1];
+		const quote = match[2];
+		const presenterId = match[3];
+		if (!callee || !presenterId) continue;
+		if (!availableCallees.has(callee)) continue;
+		if (quote === '`' && presenterId.includes('${')) continue;
+
+		occurrences.push({
+			id: presenterId,
+			file: filePath,
+			line: getLineByIndex(content, match.index),
+			callee
+		});
+	}
+
+	return occurrences;
+};
+
+export default async function checkPresenterNames() {
+	const srcPath = path.join(process.cwd(), 'src');
+	try {
+		await fs.access(srcPath);
+	} catch {
+		console.error('❌ src folder not found in current workspace.');
+		process.exitCode = 1;
+		return;
+	}
+
+	const files = await listSourceFiles(srcPath);
+	const fileContents = new Map();
+
+	for (const filePath of files) {
+		// eslint-disable-next-line no-await-in-loop
+		const content = await fs.readFile(filePath, 'utf-8');
+		fileContents.set(filePath, content);
+	}
+
+	const globalFactoryNames = new Set();
+	for (const [filePath, content] of fileContents.entries()) {
+		for (const name of extractFactoryNamesFromContent(content)) {
+			globalFactoryNames.add(name);
+		}
+		if (filePath.endsWith(path.join('core', 'presenter', 'index.ts')) || filePath.endsWith(path.join('core', 'presenter', 'index.js'))) {
+			for (const name of extractImportedPresenterFactories(content)) {
+				globalFactoryNames.add(name);
+			}
+		}
+	}
+
+	const occurrences = [];
+	for (const [filePath, content] of fileContents.entries()) {
+		occurrences.push(...collectPresenterOccurrences(content, filePath, globalFactoryNames));
+	}
+
+	if (!occurrences.length) {
+		console.log('✅ No presenter declarations found.');
+		return;
+	}
+
+	const grouped = new Map();
+	for (const occurrence of occurrences) {
+		const list = grouped.get(occurrence.id) ?? [];
+		list.push(occurrence);
+		grouped.set(occurrence.id, list);
+	}
+
+	const duplicated = Array.from(grouped.entries()).filter(([, list]) => list.length > 1);
+	if (!duplicated.length) {
+		console.log(`✅ Presenter names are unique (${occurrences.length} found).`);
+		return;
+	}
+
+	console.error('❌ Duplicate presenter names found:');
+	for (const [presenterId, list] of duplicated) {
+		console.error(`\n- "${presenterId}"`);
+		for (const item of list) {
+			console.error(`  • ${toPosixPath(path.relative(process.cwd(), item.file))}:${item.line} (${item.callee})`);
+		}
+	}
+
+	process.exitCode = 1;
+}