@azure-net/cli 4.0.0-0 → 4.1.0

package/src/checks/checkProviderGraph.ts

@@ -0,0 +1,234 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+type ProviderNode = {
+	name: string;
+	file: string;
+	line: number;
+	dependsOn: string[];
+};
+
+type GraphIssue = {
+	file: string;
+	line: number;
+	message: string;
+};
+
+const TARGET_EXTENSIONS = new Set(['.ts', '.js']);
+const IGNORED_DIRS = new Set(['node_modules', 'dist', '.svelte-kit', '.git']);
+
+const toPosixPath = (value: string): string => value.split(path.sep).join('/');
+
+const getLineByIndex = (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 listSourceFiles = 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 findMatchingBracket = (content: string, startIndex: number, openChar: string, closeChar: string): number => {
+	let depth = 0;
+	for (let i = startIndex; i < content.length; i += 1) {
+		const ch = content[i];
+		if (ch === openChar) depth += 1;
+		if (ch === closeChar) {
+			depth -= 1;
+			if (depth === 0) return i;
+		}
+	}
+	return -1;
+};
+
+const extractDependsOn = (configBlock: string): string[] => {
+	const dependsOnMatch = configBlock.match(/dependsOn\s*:\s*\{([\s\S]*?)\}/m);
+	if (!dependsOnMatch?.[1]) return [];
+
+	const block = dependsOnMatch[1];
+	const deps = new Set<string>();
+	const keyRegex = /([A-Za-z_$][A-Za-z0-9_$]*)\s*:/g;
+	let match: RegExpExecArray | null;
+	while ((match = keyRegex.exec(block)) !== null) {
+		const key = match[1];
+		if (key) deps.add(key);
+	}
+	return [...deps];
+};
+
+const parseProviderGraphFromFile = (content: string, filePath: string): ProviderNode[] => {
+	const nodes: ProviderNode[] = [];
+	const token = 'createBoundaryProvider(';
+	let fromIndex = 0;
+
+	while (fromIndex < content.length) {
+		const start = content.indexOf(token, fromIndex);
+		if (start === -1) break;
+
+		const openParenIndex = start + token.length - 1;
+		const closeParenIndex = findMatchingBracket(content, openParenIndex, '(', ')');
+		if (closeParenIndex === -1) break;
+
+		const fullCall = content.slice(openParenIndex + 1, closeParenIndex);
+		const idMatch = fullCall.match(/^\s*(['"`])([^'"`]+)\1\s*,/m);
+		const providerName = idMatch?.[2];
+		if (providerName) {
+			const objectStartInCall = fullCall.indexOf('{');
+			if (objectStartInCall !== -1) {
+				const absoluteObjectStart = openParenIndex + 1 + objectStartInCall;
+				const absoluteObjectEnd = findMatchingBracket(content, absoluteObjectStart, '{', '}');
+				const configBlock =
+					absoluteObjectEnd !== -1 ? content.slice(absoluteObjectStart, absoluteObjectEnd + 1) : fullCall.slice(objectStartInCall);
+
+				nodes.push({
+					name: providerName,
+					file: filePath,
+					line: getLineByIndex(content, start),
+					dependsOn: extractDependsOn(configBlock)
+				});
+			} else {
+				nodes.push({
+					name: providerName,
+					file: filePath,
+					line: getLineByIndex(content, start),
+					dependsOn: []
+				});
+			}
+		}
+
+		fromIndex = closeParenIndex + 1;
+	}
+
+	return nodes;
+};
+
+const findCycles = (graph: Map<string, string[]>): string[][] => {
+	const cycles: string[][] = [];
+	const visited = new Set<string>();
+	const inStack = new Set<string>();
+	const stack: string[] = [];
+
+	const dfs = (node: string): void => {
+		visited.add(node);
+		inStack.add(node);
+		stack.push(node);
+
+		const neighbors = graph.get(node) ?? [];
+		for (const next of neighbors) {
+			if (!graph.has(next)) continue;
+			if (!visited.has(next)) {
+				dfs(next);
+				continue;
+			}
+			if (inStack.has(next)) {
+				const idx = stack.indexOf(next);
+				if (idx !== -1) cycles.push([...stack.slice(idx), next]);
+			}
+		}
+
+		stack.pop();
+		inStack.delete(node);
+	};
+
+	for (const node of graph.keys()) {
+		if (!visited.has(node)) dfs(node);
+	}
+
+	return cycles;
+};
+
+export default async function checkProviderGraph(): Promise<void> {
+	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 providers: ProviderNode[] = [];
+
+	for (const filePath of files) {
+		const content = await fs.readFile(filePath, 'utf-8');
+		providers.push(...parseProviderGraphFromFile(content, filePath));
+	}
+
+	if (!providers.length) {
+		console.log('✅ No createBoundaryProvider declarations found.');
+		return;
+	}
+
+	const graph = new Map<string, string[]>();
+	const issues: GraphIssue[] = [];
+	const byName = new Map<string, ProviderNode>();
+
+	for (const provider of providers) {
+		if (byName.has(provider.name)) {
+			const existing = byName.get(provider.name)!;
+			issues.push({
+				file: provider.file,
+				line: provider.line,
+				message: `Provider graph ambiguity: duplicate provider id "${provider.name}" (first declared at ${toPosixPath(
+					path.relative(process.cwd(), existing.file)
+				)}:${existing.line})`
+			});
+			continue;
+		}
+		byName.set(provider.name, provider);
+		graph.set(provider.name, provider.dependsOn);
+	}
+
+	const cycles = findCycles(graph);
+	for (const cycle of cycles) {
+		const firstNode = byName.get(cycle[0] ?? '');
+		issues.push({
+			file: firstNode?.file ?? srcPath,
+			line: firstNode?.line ?? 1,
+			message: `Circular provider dependency detected: ${cycle.join(' -> ')}`
+		});
+	}
+
+	if (!issues.length) {
+		console.log(`✅ Provider graph check passed (${providers.length} providers).`);
+		return;
+	}
+
+	console.error('❌ Provider graph check failed:');
+	for (const issue of issues) {
+		console.error(`• ${toPosixPath(path.relative(process.cwd(), issue.file))}:${issue.line} — ${issue.message}`);
+	}
+
+	process.exitCode = 1;
+}

package/src/checks/checkProviderNames.js

@@ -0,0 +1,158 @@
+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 IMPORT_PATTERN = 'import\\s*\\{([^}]+)\\}\\s*from\\s*[\'"]([^\'"]+)[\'"]';
+const CALL_PATTERN = '\\b([A-Za-z_$][A-Za-z0-9_$]*)\\s*\\(\\s*([\'"`])([^\'"`]*)\\2';
+
+const toPosixPath = (value) => value.split(path.sep).join('/');
+
+const parseImportAliases = (rawImports, importName) => {
+	const aliases = [];
+	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?.[1] === importName && aliasMatch[2]) {
+			aliases.push(aliasMatch[2]);
+			continue;
+		}
+
+		if (item === importName) {
+			aliases.push(importName);
+		}
+	}
+	return aliases;
+};
+
+const listSourceFiles = 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 getLineByIndex = (content, index) => {
+	let line = 1;
+	for (let i = 0; i < index; i += 1) {
+		if (content[i] === '\n') line += 1;
+	}
+	return line;
+};
+
+const extractBoundaryFactoryAliases = (content) => {
+	const importRegex = new RegExp(IMPORT_PATTERN, 'g');
+	const aliases = new Set(['createBoundaryProvider']);
+	let match;
+
+	while ((match = importRegex.exec(content)) !== null) {
+		const rawImports = match[1];
+		if (!rawImports) continue;
+		for (const alias of parseImportAliases(rawImports, 'createBoundaryProvider')) {
+			aliases.add(alias);
+		}
+	}
+
+	return aliases;
+};
+
+const collectProviderOccurrences = (content, filepath) => {
+	const aliases = extractBoundaryFactoryAliases(content);
+	const callRegex = new RegExp(CALL_PATTERN, 'g');
+	const occurrences = [];
+	let match;
+
+	while ((match = callRegex.exec(content)) !== null) {
+		const callee = match[1];
+		const quote = match[2];
+		const providerId = match[3];
+
+		if (!callee || !providerId) continue;
+		if (!aliases.has(callee)) continue;
+		if (quote === '`' && providerId.includes('${')) continue;
+
+		occurrences.push({
+			id: providerId,
+			file: filepath,
+			line: getLineByIndex(content, match.index),
+			callee
+		});
+	}
+
+	return occurrences;
+};
+
+export default async function checkProviderNames() {
+	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 occurrences = [];
+
+	for (const filepath of files) {
+		const content = await fs.readFile(filepath, 'utf-8');
+		occurrences.push(...collectProviderOccurrences(content, filepath));
+	}
+
+	if (!occurrences.length) {
+		console.log('✅ No providers 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(`✅ Provider names are unique (${occurrences.length} found).`);
+		return;
+	}
+
+	console.error('❌ Duplicate provider names found:');
+	for (const [providerId, list] of duplicated) {
+		console.error(`\n- "${providerId}"`);
+		for (const item of list) {
+			console.error(`  • ${toPosixPath(path.relative(process.cwd(), item.file))}:${item.line} (${item.callee})`);
+		}
+	}
+
+	process.exitCode = 1;
+}

package/src/checks/checkProviderNames.ts

@@ -0,0 +1,165 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+type ProviderOccurrence = {
+	id: string;
+	file: string;
+	line: number;
+	callee: string;
+};
+
+const TARGET_EXTENSIONS = new Set(['.ts', '.js', '.svelte']);
+const IGNORED_DIRS = new Set(['node_modules', 'dist', '.svelte-kit', '.git']);
+const IMPORT_PATTERN = 'import\\s*\\{([^}]+)\\}\\s*from\\s*[\'"]([^\'"]+)[\'"]';
+const CALL_PATTERN = '\\b([A-Za-z_$][A-Za-z0-9_$]*)\\s*\\(\\s*([\'"`])([^\'"`]*)\\2';
+
+const toPosixPath = (value: string): string => value.split(path.sep).join('/');
+
+const parseImportAliases = (rawImports: string, importName: string): string[] => {
+	const aliases: string[] = [];
+	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?.[1] === importName && aliasMatch[2]) {
+			aliases.push(aliasMatch[2]);
+			continue;
+		}
+
+		if (item === importName) {
+			aliases.push(importName);
+		}
+	}
+	return aliases;
+};
+
+const listSourceFiles = 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 getLineByIndex = (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 extractBoundaryFactoryAliases = (content: string): Set<string> => {
+	const importRegex = new RegExp(IMPORT_PATTERN, 'g');
+	const aliases = new Set<string>(['createBoundaryProvider']);
+	let match: RegExpExecArray | null;
+
+	while ((match = importRegex.exec(content)) !== null) {
+		const rawImports = match[1];
+		if (!rawImports) continue;
+		for (const alias of parseImportAliases(rawImports, 'createBoundaryProvider')) {
+			aliases.add(alias);
+		}
+	}
+
+	return aliases;
+};
+
+const collectProviderOccurrences = (content: string, filepath: string): ProviderOccurrence[] => {
+	const aliases = extractBoundaryFactoryAliases(content);
+	const callRegex = new RegExp(CALL_PATTERN, 'g');
+	const occurrences: ProviderOccurrence[] = [];
+	let match: RegExpExecArray | null;
+
+	while ((match = callRegex.exec(content)) !== null) {
+		const callee = match[1];
+		const quote = match[2];
+		const providerId = match[3];
+
+		if (!callee || !providerId) continue;
+		if (!aliases.has(callee)) continue;
+		if (quote === '`' && providerId.includes('${')) continue;
+
+		occurrences.push({
+			id: providerId,
+			file: filepath,
+			line: getLineByIndex(content, match.index),
+			callee
+		});
+	}
+
+	return occurrences;
+};
+
+export default async function checkProviderNames(): Promise<void> {
+	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 occurrences: ProviderOccurrence[] = [];
+
+	for (const filepath of files) {
+		const content = await fs.readFile(filepath, 'utf-8');
+		occurrences.push(...collectProviderOccurrences(content, filepath));
+	}
+
+	if (!occurrences.length) {
+		console.log('✅ No providers declarations found.');
+		return;
+	}
+
+	const grouped = new Map<string, ProviderOccurrence[]>();
+	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(`✅ Provider names are unique (${occurrences.length} found).`);
+		return;
+	}
+
+	console.error('❌ Duplicate provider names found:');
+	for (const [providerId, list] of duplicated) {
+		console.error(`\n- "${providerId}"`);
+		for (const item of list) {
+			console.error(`  • ${toPosixPath(path.relative(process.cwd(), item.file))}:${item.line} (${item.callee})`);
+		}
+	}
+
+	process.exitCode = 1;
+}

package/src/checks/index.js

@@ -0,0 +1,8 @@
+export { default as checkPresenterNames } from './checkPresenterNames.js';
+export { default as checkProviderNames } from './checkProviderNames.js';
+export { default as checkProviderGraph } from './checkProviderGraph.js';
+export { default as checkDomain } from './checkDomain.js';
+export { default as checkLayerBoundaries } from './checkLayerBoundaries.js';
+export { default as checkFoldersStructure } from './checkFoldersStructure.js';
+export { default as checkInternal } from './checkInternal.js';
+export { default as checkProject } from './checkProject.js';

package/src/checks/index.ts

@@ -0,0 +1,9 @@
+export { default as checkPresenterNames } from './checkPresenterNames.js';
+export { default as checkProviderNames } from './checkProviderNames.js';
+export { default as checkProviderGraph } from './checkProviderGraph.js';
+export { default as checkDomain } from './checkDomain.js';
+export { default as checkImports } from './checkImports.js';
+export { default as checkLayerBoundaries } from './checkLayerBoundaries.js';
+export { default as checkFoldersStructure } from './checkFoldersStructure.js';
+export { default as checkInternal } from './checkInternal.js';
+export { default as checkProject } from './checkProject.js';

package/src/generate/layers/generateRepository.ts

@@ -0,0 +1,123 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import prompts from 'prompts';
+import {
+	buildRepositoryContent,
+	ensureDomainType,
+	ensureRepositoryInterfaceFile,
+	ensureRepositoryName,
+	ensureUseCasesFile,
+	getConfigState,
+	getRepositoryMeta,
+	resolveContextAlias,
+	resolveRepositoriesPath,
+	selectContext,
+	selectDatasource,
+	promptMethodDefinition
+} from './repositoryShared.js';
+import { updateIndexTs, writeIfNotExists } from '../../utils/fileUtils.js';
+
+export default async function generateRepository(): Promise<void> {
+	const { rawName } = await prompts({
+		type: 'text',
+		name: 'rawName',
+		message: 'Repository name:',
+		validate: (value) => (String(value ?? '').trim().length > 0 ? true : 'Repository name is required')
+	});
+
+	const className = ensureRepositoryName(rawName);
+	const meta = getRepositoryMeta(className);
+	const contextName = await selectContext('Select context for repository:');
+	if (!contextName) {
+		process.exitCode = 1;
+		return;
+	}
+
+	const datasource = await selectDatasource(contextName);
+	if (!datasource) {
+		process.exitCode = 1;
+		return;
+	}
+
+	const { methodsCountRaw } = await prompts({
+		type: 'number',
+		name: 'methodsCountRaw',
+		message: 'How many methods to create?',
+		initial: 1,
+		min: 0
+	});
+
+	const methodsCount = Number(methodsCountRaw ?? 0);
+	if (!Number.isFinite(methodsCount) || methodsCount < 0) {
+		console.error('❌ Invalid methods count.');
+		process.exitCode = 1;
+		return;
+	}
+
+	const methods: Array<Awaited<ReturnType<typeof promptMethodDefinition>>> = [];
+	for (let index = 0; index < methodsCount; index += 1) {
+		console.log(`\n🧩 Method ${index + 1} of ${methodsCount}`);
+		const method = await promptMethodDefinition();
+		methods.push(method);
+	}
+
+	const { contexts } = await getConfigState();
+	const contextAlias = resolveContextAlias(contexts, contextName);
+	const repositoriesPath = resolveRepositoriesPath(contextName);
+	await fs.mkdir(repositoriesPath, { recursive: true });
+	const repositoryPath = path.join(repositoriesPath, `${meta.className}.ts`);
+
+	for (const method of methods) {
+		if (!method) continue;
+		const ensuredResponseType = await ensureDomainType({
+			contextName,
+			domainName: meta.domainName,
+			typeName: method.responseType,
+			layer: method.responseLayer
+		});
+		method.responseType = ensuredResponseType.interfaceName;
+		method.responseLayer = ensuredResponseType.layer;
+
+		if (method.requestType) {
+			const ensuredRequestType = await ensureDomainType({
+				contextName,
+				domainName: meta.domainName,
+				typeName: method.requestType,
+				layer: method.requestLayer ?? 'ports'
+			});
+			method.requestType = ensuredRequestType.interfaceName;
+			method.requestLayer = ensuredRequestType.layer;
+		}
+	}
+
+	const filteredMethods = methods.filter(Boolean);
+	await ensureRepositoryInterfaceFile({ contextName, meta, methods: filteredMethods });
+	const repositoryContent = buildRepositoryContent({
+		meta,
+		contextAlias,
+		datasourceImportPath: datasource.importPath,
+		datasourceName: datasource.name,
+		methods: filteredMethods
+	});
+
+	const created = await writeIfNotExists(repositoryPath, repositoryContent);
+	await updateIndexTs(repositoriesPath);
+	if (!created) {
+		console.warn(`⚠️ Repository "${meta.className}" already exists. File was not overwritten.`);
+		process.exitCode = 1;
+		return;
+	}
+
+	const { shouldCreateUseCases } = await prompts({
+		type: 'confirm',
+		name: 'shouldCreateUseCases',
+		message: 'Create UseCases for this repository?',
+		initial: true
+	});
+
+	if (shouldCreateUseCases) {
+		await ensureUseCasesFile({ contextName, contextAlias, meta });
+	}
+
+	console.log(`✅ Repository generated: ${repositoryPath}`);
+}