@azure-net/cli 5.1.0 → 6.0.0-next.2

package/src/generate/module/generateSchemaFromType.ts

@@ -1,368 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import prompts from 'prompts';
-import { getConfigState, resolveContextAlias, selectContext } from './repositoryModuleShared.js';
-
-const listDirectories = async (targetPath: string): Promise<string[]> => {
-	try {
-		const items = await fs.readdir(targetPath, { withFileTypes: true });
-		return items.filter((item) => item.isDirectory()).map((item) => item.name);
-	} catch {
-		return [];
-	}
-};
-
-const listSchemaFiles = async (targetPath: string): Promise<string[]> => {
-	try {
-		const files = await fs.readdir(targetPath);
-		return files.filter((item) => item.endsWith('.ts') && item !== 'index.ts');
-	} catch {
-		return [];
-	}
-};
-
-const resolveAliasMap = async (): Promise<Map<string, string>> => {
-	const { contexts } = await getConfigState();
-	const map = new Map<string, string>();
-
-	for (const context of contexts) {
-		const alias = resolveContextAlias(contexts, context.name);
-		map.set(alias, path.join(process.cwd(), 'src', 'app', context.name));
-	}
-
-	return map;
-};
-
-const resolveImportToFile = async (fromFile: string, importPath: string, aliasMap: Map<string, string>): Promise<string | null> => {
-	const rawImport = String(importPath ?? '').trim();
-	if (!rawImport.length) return null;
-
-	let absolute = '';
-	if (rawImport.startsWith('.')) {
-		absolute = path.resolve(path.dirname(fromFile), rawImport);
-	} else {
-		const alias = Array.from(aliasMap.keys()).find((key) => rawImport === key || rawImport.startsWith(`${key}/`));
-		if (!alias) return null;
-		const suffix = rawImport === alias ? '' : rawImport.slice(alias.length + 1);
-		absolute = path.join(aliasMap.get(alias) as string, suffix);
-	}
-
-	const tsCandidate = absolute.endsWith('.ts') ? absolute : `${absolute}.ts`;
-	try {
-		await fs.access(tsCandidate);
-		return tsCandidate;
-	} catch {
-		const indexCandidate = path.join(absolute, 'index.ts');
-		try {
-			await fs.access(indexCandidate);
-			return indexCandidate;
-		} catch {
-			return null;
-		}
-	}
-};
-
-const extractSchemaTypeName = (content: string): string | null => {
-	const typeMatch = content.match(/=\s*[A-Za-z0-9_]+<\s*([^>]+?)\s*>\s*\(\)/m);
-	if (!typeMatch) return null;
-	return String(typeMatch[1]).trim();
-};
-
-const findTypeImportPath = (content: string, typeName: string): string | null => {
-	const importRegex = /import\s+type\s+\{([^}]+)\}\s+from\s+['"]([^'"]+)['"]/g;
-	let match: RegExpExecArray | null;
-	while ((match = importRegex.exec(content)) !== null) {
-		const importedList = match[1];
-		const sourcePath = match[2];
-		if (!importedList || !sourcePath) continue;
-		const imported = importedList
-			.split(',')
-			.map((item) => item.trim())
-			.filter(Boolean);
-		if (imported.includes(typeName)) {
-			return sourcePath;
-		}
-	}
-	return null;
-};
-
-const extractInterfaceBody = (content: string, interfaceName: string): string | null => {
-	const declarationRegex = new RegExp(`export\\s+interface\\s+${interfaceName}\\s*\\{`);
-	const declarationMatch = content.match(declarationRegex);
-	if (!declarationMatch || declarationMatch.index === undefined) return null;
-
-	const openBraceIndex = content.indexOf('{', declarationMatch.index);
-	if (openBraceIndex === -1) return null;
-
-	let depth = 0;
-	let closeBraceIndex = -1;
-	for (let index = openBraceIndex; index < content.length; index += 1) {
-		const char = content[index];
-		if (char === '{') depth += 1;
-		if (char === '}') {
-			depth -= 1;
-			if (depth === 0) {
-				closeBraceIndex = index;
-				break;
-			}
-		}
-	}
-
-	if (closeBraceIndex === -1) return null;
-	return content.slice(openBraceIndex + 1, closeBraceIndex);
-};
-
-const resolveRelativeExportPath = async (fromFile: string, exportPath: string): Promise<string | null> => {
-	const absolute = path.resolve(path.dirname(fromFile), exportPath);
-	const tsCandidate = absolute.endsWith('.ts') ? absolute : `${absolute}.ts`;
-	try {
-		await fs.access(tsCandidate);
-		return tsCandidate;
-	} catch {
-		const indexCandidate = path.join(absolute, 'index.ts');
-		try {
-			await fs.access(indexCandidate);
-			return indexCandidate;
-		} catch {
-			return null;
-		}
-	}
-};
-
-const findInterfaceBodyByExportGraph = async (
-	entryFilePath: string,
-	interfaceName: string,
-	visited: Set<string> = new Set()
-): Promise<string | null> => {
-	const resolvedPath = path.resolve(entryFilePath);
-	if (visited.has(resolvedPath)) return null;
-	visited.add(resolvedPath);
-
-	let content = '';
-	try {
-		content = await fs.readFile(resolvedPath, 'utf-8');
-	} catch {
-		return null;
-	}
-
-	const direct = extractInterfaceBody(content, interfaceName);
-	if (direct) return direct;
-
-	const exportRegex = /export\s+(?:\*|\{[^}]+\})\s+from\s+['"]([^'"]+)['"]/g;
-	let match: RegExpExecArray | null;
-	while ((match = exportRegex.exec(content)) !== null) {
-		const exportPath = match[1];
-		if (!exportPath || !exportPath.startsWith('.')) continue;
-		const nextPath = await resolveRelativeExportPath(resolvedPath, exportPath);
-		if (!nextPath) continue;
-		const nested = await findInterfaceBodyByExportGraph(nextPath, interfaceName, visited);
-		if (nested) return nested;
-	}
-
-	return null;
-};
-
-const findInterfaceBodyByScan = async (rootDir: string, interfaceName: string): Promise<string | null> => {
-	const queue: string[] = [rootDir];
-	while (queue.length) {
-		const current = queue.shift();
-		if (!current) continue;
-		let entries: import('node:fs').Dirent[] = [];
-		try {
-			entries = await fs.readdir(current, { withFileTypes: true });
-		} catch {
-			continue;
-		}
-
-		for (const entry of entries) {
-			const absolute = path.join(current, entry.name);
-			if (entry.isDirectory()) {
-				queue.push(absolute);
-				continue;
-			}
-			if (!entry.isFile() || !entry.name.endsWith('.ts')) continue;
-			const content = await fs.readFile(absolute, 'utf-8');
-			const body = extractInterfaceBody(content, interfaceName);
-			if (body) return body;
-		}
-	}
-	return null;
-};
-
-type InterfaceField = {
-	name: string;
-	optional: boolean;
-	type: string;
-};
-
-const extractRuleKeys = (body: string): string[] => {
-	const keys: string[] = [];
-	const keyRegex = /^\s*([A-Za-z_$][A-Za-z0-9_$]*)\s*:/gm;
-	let match: RegExpExecArray | null;
-	while ((match = keyRegex.exec(body)) !== null) {
-		const key = match[1];
-		if (key) keys.push(key);
-	}
-	return Array.from(new Set(keys));
-};
-
-const extractInterfaceFields = (body: string): InterfaceField[] => {
-	const fields: InterfaceField[] = [];
-	const fieldRegex = /^\s*(?:readonly\s+)?([A-Za-z_$][A-Za-z0-9_$]*)(\?)?\s*:\s*([^;]+);/gm;
-	let match: RegExpExecArray | null;
-	while ((match = fieldRegex.exec(body)) !== null) {
-		const name = match[1];
-		const optionalMark = match[2];
-		const type = String(match[3] ?? '').trim();
-		if (!name || !type) continue;
-		fields.push({
-			name,
-			optional: optionalMark === '?',
-			type
-		});
-	}
-
-	const unique = new Map<string, InterfaceField>();
-	for (const field of fields) {
-		if (!unique.has(field.name)) unique.set(field.name, field);
-	}
-	return Array.from(unique.values());
-};
-
-const buildRulesArray = (field: InterfaceField): string => {
-	const ruleCalls: string[] = [];
-	if (!field.optional) {
-		ruleCalls.push('rules.required()');
-	}
-
-	if (field.type === 'string') {
-		ruleCalls.push('rules.string()');
-	} else if (field.type === 'number') {
-		ruleCalls.push('rules.number()');
-	}
-
-	return `[${ruleCalls.join(', ')}]`;
-};
-
-const updateRulesObject = (schemaContent: string, fields: InterfaceField[]): string | null => {
-	const rulesRegex = /\.rules\(\(rules\)\s*=>\s*\(\{([\s\S]*?)\}\)\)/m;
-	const match = schemaContent.match(rulesRegex);
-	if (!match) return null;
-
-	const currentBody = match[1] ?? '';
-	const existingKeys = new Set(extractRuleKeys(currentBody));
-	const newLines = fields.filter((field) => !existingKeys.has(field.name)).map((field) => `\t\t${field.name}: ${buildRulesArray(field)},`);
-
-	if (!newLines.length) return schemaContent;
-
-	const trimmedBody = currentBody.trimEnd();
-	const nextBody = trimmedBody.length ? `${trimmedBody}\n${newLines.join('\n')}\n\t` : `\n${newLines.join('\n')}\n\t`;
-
-	return schemaContent.replace(rulesRegex, `.rules((rules) => ({${nextBody}}))`);
-};
-
-export default async function generateSchemaFromType(): Promise<void> {
-	const contextName = await selectContext('Select context for schema update:');
-	if (!contextName) {
-		process.exitCode = 1;
-		return;
-	}
-
-	const presentationPath = path.join(process.cwd(), 'src', 'app', contextName, 'layers', 'presentation');
-	const presenterFolders = await listDirectories(presentationPath);
-	if (!presenterFolders.length) {
-		console.error(`❌ No presenter folders found in ${presentationPath}`);
-		process.exitCode = 1;
-		return;
-	}
-
-	const { presenterFolder } = await prompts({
-		type: 'select',
-		name: 'presenterFolder',
-		message: 'Select presenter folder:',
-		choices: presenterFolders.map((item) => ({ title: item, value: item })),
-		initial: 0
-	});
-
-	if (!presenterFolder) {
-		process.exitCode = 1;
-		return;
-	}
-
-	const schemaFolderPath = path.join(presentationPath, String(presenterFolder), 'schema');
-	const schemas = await listSchemaFiles(schemaFolderPath);
-	if (!schemas.length) {
-		console.error(`❌ No schemas found in ${schemaFolderPath}`);
-		process.exitCode = 1;
-		return;
-	}
-
-	const { schemaFile } = await prompts({
-		type: 'select',
-		name: 'schemaFile',
-		message: 'Select schema file:',
-		choices: schemas.map((item) => ({ title: item, value: item })),
-		initial: 0
-	});
-
-	if (!schemaFile) {
-		process.exitCode = 1;
-		return;
-	}
-
-	const schemaPath = path.join(schemaFolderPath, String(schemaFile));
-	const schemaContent = await fs.readFile(schemaPath, 'utf-8');
-
-	const typeName = extractSchemaTypeName(schemaContent);
-	if (!typeName) {
-		console.error('❌ Unable to resolve schema generic type.');
-		process.exitCode = 1;
-		return;
-	}
-
-	const importPath = findTypeImportPath(schemaContent, typeName);
-	if (!importPath) {
-		console.error(`❌ Unable to find import for type "${typeName}".`);
-		process.exitCode = 1;
-		return;
-	}
-
-	const aliasMap = await resolveAliasMap();
-	const typeFilePath = await resolveImportToFile(schemaPath, importPath, aliasMap);
-	if (!typeFilePath) {
-		console.error(`❌ Unable to resolve type file path from import "${importPath}".`);
-		process.exitCode = 1;
-		return;
-	}
-
-	let interfaceBody = await findInterfaceBodyByExportGraph(typeFilePath, typeName);
-	if (!interfaceBody) {
-		interfaceBody = await findInterfaceBodyByScan(path.dirname(typeFilePath), typeName);
-	}
-	if (!interfaceBody) {
-		console.error(`❌ Interface "${typeName}" not found in ${typeFilePath}`);
-		process.exitCode = 1;
-		return;
-	}
-
-	const interfaceFields = extractInterfaceFields(interfaceBody);
-	if (!interfaceFields.length) {
-		console.log('ℹ️ Interface has no explicit keys to transfer into rules.');
-		return;
-	}
-
-	const updatedSchemaContent = updateRulesObject(schemaContent, interfaceFields);
-	if (!updatedSchemaContent) {
-		console.error('❌ Could not locate `.rules((rules) => ({}))` block in schema file.');
-		process.exitCode = 1;
-		return;
-	}
-
-	if (updatedSchemaContent === schemaContent) {
-		console.log('ℹ️ Rules already include all keys from type.');
-		return;
-	}
-
-	await fs.writeFile(schemaPath, updatedSchemaContent, 'utf-8');
-	console.log(`✅ Schema updated from type: ${schemaPath}`);
-}

package/src/generate/module/generateTypesJson.ts

@@ -1,259 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import prompts from 'prompts';
-import { selectContext } from './repositoryModuleShared.js';
-
-type InterfaceDeclaration = {
-	name: string;
-	openBraceIndex: number;
-	closeBraceIndex: number;
-	body: string;
-};
-
-const isValidIdentifier = (value: string): boolean => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(value);
-
-const toPropertyName = (key: string): string => (isValidIdentifier(key) ? key : `'${String(key).replace(/'/g, "\\'")}'`);
-
-const getIndent = (level: number): string => '\t'.repeat(level);
-
-const normalizeObjectInput = (rawValue: unknown): string => {
-	let input = String(rawValue ?? '').trim();
-	if (input.endsWith(';')) {
-		input = input.slice(0, -1).trim();
-	}
-
-	const openCurly = (input.match(/\{/g) ?? []).length;
-	const closeCurly = (input.match(/\}/g) ?? []).length;
-	if (openCurly > closeCurly) {
-		input += '}'.repeat(openCurly - closeCurly);
-	}
-
-	return input;
-};
-
-const parseObjectInput = (rawValue: unknown): Record<string, unknown> => {
-	const input = normalizeObjectInput(rawValue);
-	if (!input.length) {
-		throw new Error('Input is empty');
-	}
-
-	try {
-		const parsed = JSON.parse(input);
-		if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-			throw new Error('Input root must be an object');
-		}
-		return parsed as Record<string, unknown>;
-	} catch {
-		// fallback to JS object literal
-	}
-
-	const parsed = new Function(`"use strict"; return (${input});`)();
-	if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-		throw new Error('Input root must be an object');
-	}
-	return parsed as Record<string, unknown>;
-};
-
-const stringifyType = (value: unknown, level = 1): string => {
-	if (value === null) return 'null';
-
-	const valueType = typeof value;
-	if (valueType === 'string') return 'string';
-	if (valueType === 'number') return Number.isFinite(value as number) ? 'number' : 'unknown';
-	if (valueType === 'boolean') return 'boolean';
-	if (valueType === 'bigint') return 'bigint';
-	if (valueType === 'undefined') return 'undefined';
-
-	if (Array.isArray(value)) {
-		if (!value.length) return 'unknown[]';
-
-		const itemTypes = Array.from(new Set(value.map((item) => stringifyType(item, level + 1))));
-		if (itemTypes.length === 1) {
-			const single = itemTypes[0] ?? 'unknown';
-			if (single.includes('\n')) return `Array<${single}>`;
-			return `${single}[]`;
-		}
-
-		const union = itemTypes.join(' | ');
-		if (union.includes('\n')) return `Array<${union}>`;
-		return `(${union})[]`;
-	}
-
-	if (valueType === 'object') {
-		const entries = Object.entries(value as Record<string, unknown>);
-		if (!entries.length) return 'Record<string, unknown>';
-
-		const lines = entries.map(([entryKey, entryValue]) => {
-			const propertyType = stringifyType(entryValue, level + 1);
-			return `${getIndent(level + 1)}${toPropertyName(entryKey)}: ${propertyType};`;
-		});
-
-		return `{\n${lines.join('\n')}\n${getIndent(level)}}`;
-	}
-
-	return 'unknown';
-};
-
-const findInterfaceDeclaration = (content: string): InterfaceDeclaration | null => {
-	const declarationMatch = content.match(/export\s+interface\s+([A-Za-z0-9_]+)\s*\{/);
-	if (!declarationMatch || declarationMatch.index === undefined) return null;
-
-	const name = declarationMatch[1] ?? 'Interface';
-	const openBraceIndex = content.indexOf('{', declarationMatch.index);
-	if (openBraceIndex === -1) return null;
-
-	let depth = 0;
-	let closeBraceIndex = -1;
-	for (let index = openBraceIndex; index < content.length; index += 1) {
-		const char = content[index];
-		if (char === '{') depth += 1;
-		if (char === '}') {
-			depth -= 1;
-			if (depth === 0) {
-				closeBraceIndex = index;
-				break;
-			}
-		}
-	}
-
-	if (closeBraceIndex === -1) return null;
-
-	const body = content.slice(openBraceIndex + 1, closeBraceIndex);
-	return {
-		name,
-		openBraceIndex,
-		closeBraceIndex,
-		body
-	};
-};
-
-const extractExistingRootKeys = (body: string): Set<string> => {
-	const keys = new Set<string>();
-	const keyRegex = /^\s*([A-Za-z_$][A-Za-z0-9_$]*)\??\s*:/gm;
-	let match: RegExpExecArray | null;
-	while ((match = keyRegex.exec(body)) !== null) {
-		const key = match[1];
-		if (key) keys.add(key);
-	}
-	return keys;
-};
-
-const listDomains = async (contextName: string): Promise<string[]> => {
-	const domainRoot = path.join(process.cwd(), 'src', 'app', contextName, 'layers', 'domain');
-	try {
-		const items = await fs.readdir(domainRoot, { withFileTypes: true });
-		return items.filter((item) => item.isDirectory()).map((item) => item.name);
-	} catch {
-		return [];
-	}
-};
-
-const listModelFiles = async (contextName: string, domainName: string): Promise<Array<{ name: string; path: string }>> => {
-	const modelRoot = path.join(process.cwd(), 'src', 'app', contextName, 'layers', 'domain', domainName, 'model');
-	try {
-		const files = await fs.readdir(modelRoot);
-		return files
-			.filter((fileName) => fileName.endsWith('.ts') && fileName !== 'index.ts')
-			.map((fileName) => ({
-				name: fileName.replace(/\.ts$/, ''),
-				path: path.join(modelRoot, fileName)
-			}));
-	} catch {
-		return [];
-	}
-};
-
-export default async function generateTypesJson(): Promise<void> {
-	const contextName = await selectContext('Select context for model update:');
-	if (!contextName) {
-		process.exitCode = 1;
-		return;
-	}
-
-	const domains = await listDomains(contextName);
-	if (!domains.length) {
-		console.error(`❌ No domains found in context "${contextName}".`);
-		process.exitCode = 1;
-		return;
-	}
-
-	const { domainName } = await prompts({
-		type: 'select',
-		name: 'domainName',
-		message: 'Select domain:',
-		choices: domains.map((item) => ({ title: item, value: item })),
-		initial: 0
-	});
-
-	if (!domainName) {
-		process.exitCode = 1;
-		return;
-	}
-
-	const models = await listModelFiles(contextName, String(domainName));
-	if (!models.length) {
-		console.error(`❌ No model files found in domain "${domainName}".`);
-		process.exitCode = 1;
-		return;
-	}
-
-	const { modelPath } = await prompts({
-		type: 'select',
-		name: 'modelPath',
-		message: 'Select model:',
-		choices: models.map((item) => ({ title: item.name, value: item.path })),
-		initial: 0
-	});
-
-	if (!modelPath) {
-		process.exitCode = 1;
-		return;
-	}
-
-	const { rawJson } = await prompts({
-		type: 'text',
-		name: 'rawJson',
-		message: 'Paste JSON or JS object (single line):',
-		validate: (value: string) => {
-			try {
-				parseObjectInput(value);
-				return true;
-			} catch {
-				return 'Invalid JSON/JS object';
-			}
-		}
-	});
-
-	if (!rawJson) {
-		process.exitCode = 1;
-		return;
-	}
-
-	const parsedJson = parseObjectInput(rawJson);
-	const content = await fs.readFile(String(modelPath), 'utf-8');
-	const interfaceDeclaration = findInterfaceDeclaration(content);
-	if (!interfaceDeclaration) {
-		console.error(`❌ Unable to parse interface in ${modelPath}`);
-		process.exitCode = 1;
-		return;
-	}
-
-	const existingKeys = extractExistingRootKeys(interfaceDeclaration.body);
-	const generatedLines = Object.entries(parsedJson)
-		.filter(([key]) => !existingKeys.has(key))
-		.map(([key, value]) => `${getIndent(1)}${toPropertyName(key)}: ${stringifyType(value, 1)};`);
-
-	if (!generatedLines.length) {
-		console.log('ℹ️ No new keys to add. Model already contains all JSON keys.');
-		return;
-	}
-
-	const trimmedBody = interfaceDeclaration.body.trimEnd();
-	const bodyPrefix = trimmedBody.length ? `${trimmedBody}\n` : '';
-	const newBody = `${bodyPrefix}${generatedLines.join('\n')}\n`;
-
-	const updatedContent = `${content.slice(0, interfaceDeclaration.openBraceIndex + 1)}${newBody}${content.slice(interfaceDeclaration.closeBraceIndex)}`;
-	await fs.writeFile(String(modelPath), updatedContent, 'utf-8');
-
-	console.log(`✅ Model updated: ${modelPath}`);
-}

package/src/generate/module/generateUseCases.ts

@@ -1,67 +0,0 @@
-import prompts from 'prompts';
-import {
-	createUseCasesForRepository,
-	getAvailableTsNames,
-	getConfigState,
-	resolveContextAlias,
-	resolveDomainForRepository,
-	resolveRepositoriesPath,
-	selectContext
-} from './repositoryModuleShared.js';
-
-export default async function generateUseCases(): Promise<void> {
-	const contextName = await selectContext('Select context for UseCases:');
-	if (!contextName) {
-		process.exitCode = 1;
-		return;
-	}
-
-	const repositoriesPath = resolveRepositoriesPath(contextName);
-	const repositories = await getAvailableTsNames(repositoriesPath);
-	if (!repositories.length) {
-		console.error(`❌ No repositories found in ${repositoriesPath}`);
-		process.exitCode = 1;
-		return;
-	}
-
-	const { repositoryName } = await prompts({
-		type: 'select',
-		name: 'repositoryName',
-		message: 'Select repository:',
-		choices: repositories.map((item) => ({ title: item, value: item })),
-		initial: 0
-	});
-
-	if (!repositoryName) {
-		process.exitCode = 1;
-		return;
-	}
-
-	const { contexts } = await getConfigState();
-	const contextAlias = resolveContextAlias(contexts, contextName);
-	const domainName = await resolveDomainForRepository({
-		contextName,
-		contextAlias,
-		repositoryName: String(repositoryName)
-	});
-
-	if (!domainName) {
-		console.error('❌ Unable to resolve domain from repository imports.');
-		process.exitCode = 1;
-		return;
-	}
-
-	const created = await createUseCasesForRepository({
-		contextName,
-		contextAlias,
-		domainName,
-		repositoryName: String(repositoryName)
-	});
-
-	if (!created) {
-		process.exitCode = 1;
-		return;
-	}
-
-	console.log(`✅ UseCases generated for ${repositoryName}`);
-}