@azure-net/cli 5.0.0-3 → 5.0.0

package/src/generate/module/generateSchemaFromType.js

@@ -2,7 +2,6 @@ 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) => {
 	try {
 		const items = await fs.readdir(targetPath, { withFileTypes: true });
@@ -11,7 +10,6 @@ const listDirectories = async (targetPath) => {
 		return [];
 	}
 };
-
 const listSchemaFiles = async (targetPath) => {
 	try {
 		const files = await fs.readdir(targetPath);
@@ -20,24 +18,18 @@ const listSchemaFiles = async (targetPath) => {
 		return [];
 	}
 };
-
 const resolveAliasMap = async () => {
-	const { contexts, coreAlias } = await getConfigState();
+	const { contexts } = await getConfigState();
 	const map = new Map();
-	map.set(coreAlias, path.join(process.cwd(), 'src', 'core'));
-
 	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, importPath, aliasMap) => {
 	const rawImport = String(importPath ?? '').trim();
 	if (!rawImport.length) return null;
-
 	let absolute = '';
 	if (rawImport.startsWith('.')) {
 		absolute = path.resolve(path.dirname(fromFile), rawImport);
@@ -47,7 +39,6 @@ const resolveImportToFile = async (fromFile, importPath, aliasMap) => {
 		const suffix = rawImport === alias ? '' : rawImport.slice(alias.length + 1);
 		absolute = path.join(aliasMap.get(alias), suffix);
 	}
-
 	const tsCandidate = absolute.endsWith('.ts') ? absolute : `${absolute}.ts`;
 	try {
 		await fs.access(tsCandidate);
@@ -62,36 +53,34 @@ const resolveImportToFile = async (fromFile, importPath, aliasMap) => {
 		}
 	}
 };
-
 const extractSchemaTypeName = (content) => {
 	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, typeName) => {
 	const importRegex = /import\s+type\s+\{([^}]+)\}\s+from\s+['"]([^'"]+)['"]/g;
 	let match;
 	while ((match = importRegex.exec(content)) !== null) {
-		const imported = match[1]
+		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 match[2];
+			return sourcePath;
 		}
 	}
 	return null;
 };
-
 const extractInterfaceBody = (content, interfaceName) => {
 	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) {
@@ -105,11 +94,9 @@ const extractInterfaceBody = (content, interfaceName) => {
 			}
 		}
 	}
-
 	if (closeBraceIndex === -1) return null;
 	return content.slice(openBraceIndex + 1, closeBraceIndex);
 };
-
 const resolveRelativeExportPath = async (fromFile, exportPath) => {
 	const absolute = path.resolve(path.dirname(fromFile), exportPath);
 	const tsCandidate = absolute.endsWith('.ts') ? absolute : `${absolute}.ts`;
@@ -126,38 +113,30 @@ const resolveRelativeExportPath = async (fromFile, exportPath) => {
 		}
 	}
 };
-
 const findInterfaceBodyByExportGraph = async (entryFilePath, interfaceName, visited = new Set()) => {
 	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;
+	const exportRegex = /export\s+(?:\*|\{[^}]+\})\s+from\s+['"]([^'"]+)['"]/g;
 	let match;
 	while ((match = exportRegex.exec(content)) !== null) {
 		const exportPath = match[1];
 		if (!exportPath || !exportPath.startsWith('.')) continue;
-		// eslint-disable-next-line no-await-in-loop
 		const nextPath = await resolveRelativeExportPath(resolvedPath, exportPath);
 		if (!nextPath) continue;
-		// eslint-disable-next-line no-await-in-loop
 		const nested = await findInterfaceBodyByExportGraph(nextPath, interfaceName, visited);
 		if (nested) return nested;
 	}
-
 	return null;
 };
-
 const findInterfaceBodyByScan = async (rootDir, interfaceName) => {
 	const queue = [rootDir];
 	while (queue.length) {
@@ -169,7 +148,6 @@ const findInterfaceBodyByScan = async (rootDir, interfaceName) => {
 		} catch {
 			continue;
 		}
-
 		for (const entry of entries) {
 			const absolute = path.join(current, entry.name);
 			if (entry.isDirectory()) {
@@ -177,7 +155,6 @@ const findInterfaceBodyByScan = async (rootDir, interfaceName) => {
 				continue;
 			}
 			if (!entry.isFile() || !entry.name.endsWith('.ts')) continue;
-			// eslint-disable-next-line no-await-in-loop
 			const content = await fs.readFile(absolute, 'utf-8');
 			const body = extractInterfaceBody(content, interfaceName);
 			if (body) return body;
@@ -185,17 +162,16 @@ const findInterfaceBodyByScan = async (rootDir, interfaceName) => {
 	}
 	return null;
 };
-
 const extractRuleKeys = (body) => {
 	const keys = [];
 	const keyRegex = /^\s*([A-Za-z_$][A-Za-z0-9_$]*)\s*:/gm;
 	let match;
 	while ((match = keyRegex.exec(body)) !== null) {
-		keys.push(match[1]);
+		const key = match[1];
+		if (key) keys.push(key);
 	}
 	return Array.from(new Set(keys));
 };
-
 const extractInterfaceFields = (body) => {
 	const fields = [];
 	const fieldRegex = /^\s*(?:readonly\s+)?([A-Za-z_$][A-Za-z0-9_$]*)(\?)?\s*:\s*([^;]+);/gm;
@@ -211,53 +187,42 @@ const extractInterfaceFields = (body) => {
 			type
 		});
 	}
-
 	const unique = new Map();
 	for (const field of fields) {
 		if (!unique.has(field.name)) unique.set(field.name, field);
 	}
 	return Array.from(unique.values());
 };
-
 const buildRulesArray = (field) => {
 	const ruleCalls = [];
 	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, fields) => {
 	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() {
 	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) {
@@ -265,7 +230,6 @@ export default async function generateSchemaFromType() {
 		process.exitCode = 1;
 		return;
 	}
-
 	const { presenterFolder } = await prompts({
 		type: 'select',
 		name: 'presenterFolder',
@@ -273,12 +237,10 @@ export default async function generateSchemaFromType() {
 		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) {
@@ -286,7 +248,6 @@ export default async function generateSchemaFromType() {
 		process.exitCode = 1;
 		return;
 	}
-
 	const { schemaFile } = await prompts({
 		type: 'select',
 		name: 'schemaFile',
@@ -294,29 +255,24 @@ export default async function generateSchemaFromType() {
 		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) {
@@ -324,7 +280,6 @@ export default async function generateSchemaFromType() {
 		process.exitCode = 1;
 		return;
 	}
-
 	let interfaceBody = await findInterfaceBodyByExportGraph(typeFilePath, typeName);
 	if (!interfaceBody) {
 		interfaceBody = await findInterfaceBodyByScan(path.dirname(typeFilePath), typeName);
@@ -334,25 +289,21 @@ export default async function generateSchemaFromType() {
 		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/generateSchemaFromType.ts

@@ -22,9 +22,8 @@ const listSchemaFiles = async (targetPath: string): Promise<string[]> => {
 };
 
 const resolveAliasMap = async (): Promise<Map<string, string>> => {
-	const { contexts, coreAlias } = await getConfigState();
+	const { contexts } = await getConfigState();
 	const map = new Map<string, string>();
-	map.set(coreAlias, path.join(process.cwd(), 'src', 'core'));
 
 	for (const context of contexts) {
 		const alias = resolveContextAlias(contexts, context.name);

package/src/generate/module/generateTypesJson.js

@@ -2,34 +2,26 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import prompts from 'prompts';
 import { selectContext } from './repositoryModuleShared.js';
-
 const isValidIdentifier = (value) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(value);
-
 const toPropertyName = (key) => (isValidIdentifier(key) ? key : `'${String(key).replace(/'/g, "\\'")}'`);
-
 const getIndent = (level) => '\t'.repeat(level);
-
 const normalizeObjectInput = (rawValue) => {
 	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) => {
 	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)) {
@@ -39,63 +31,49 @@ const parseObjectInput = (rawValue) => {
 	} catch {
 		// fallback to JS object literal
 	}
-
-	// eslint-disable-next-line no-new-func
 	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;
 };
-
 const stringifyType = (value, level = 1) => {
 	if (value === null) return 'null';
-
 	const valueType = typeof value;
 	if (valueType === 'string') return 'string';
 	if (valueType === 'number') return Number.isFinite(value) ? '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];
+			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);
 		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) => {
 	const declarationMatch = content.match(/export\s+interface\s+([A-Za-z0-9_]+)\s*\{/);
 	if (!declarationMatch || declarationMatch.index === undefined) return null;
-
-	const name = declarationMatch[1];
+	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) {
@@ -109,9 +87,7 @@ const findInterfaceDeclaration = (content) => {
 			}
 		}
 	}
-
 	if (closeBraceIndex === -1) return null;
-
 	const body = content.slice(openBraceIndex + 1, closeBraceIndex);
 	return {
 		name,
@@ -120,17 +96,16 @@ const findInterfaceDeclaration = (content) => {
 		body
 	};
 };
-
 const extractExistingRootKeys = (body) => {
 	const keys = new Set();
 	const keyRegex = /^\s*([A-Za-z_$][A-Za-z0-9_$]*)\??\s*:/gm;
 	let match;
 	while ((match = keyRegex.exec(body)) !== null) {
-		keys.add(match[1]);
+		const key = match[1];
+		if (key) keys.add(key);
 	}
 	return keys;
 };
-
 const listDomains = async (contextName) => {
 	const domainRoot = path.join(process.cwd(), 'src', 'app', contextName, 'layers', 'domain');
 	try {
@@ -140,7 +115,6 @@ const listDomains = async (contextName) => {
 		return [];
 	}
 };
-
 const listModelFiles = async (contextName, domainName) => {
 	const modelRoot = path.join(process.cwd(), 'src', 'app', contextName, 'layers', 'domain', domainName, 'model');
 	try {
@@ -155,21 +129,18 @@ const listModelFiles = async (contextName, domainName) => {
 		return [];
 	}
 };
-
 export default async function generateTypesJson() {
 	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',
@@ -177,19 +148,16 @@ export default async function generateTypesJson() {
 		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',
@@ -197,12 +165,10 @@ export default async function generateTypesJson() {
 		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',
@@ -216,12 +182,10 @@ export default async function generateTypesJson() {
 			}
 		}
 	});
-
 	if (!rawJson) {
 		process.exitCode = 1;
 		return;
 	}
-
 	const parsedJson = parseObjectInput(rawJson);
 	const content = await fs.readFile(String(modelPath), 'utf-8');
 	const interfaceDeclaration = findInterfaceDeclaration(content);
@@ -230,23 +194,18 @@ export default async function generateTypesJson() {
 		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.js

@@ -8,14 +8,12 @@ import {
 	resolveRepositoriesPath,
 	selectContext
 } from './repositoryModuleShared.js';
-
 export default async function generateUseCases() {
 	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) {
@@ -23,7 +21,6 @@ export default async function generateUseCases() {
 		process.exitCode = 1;
 		return;
 	}
-
 	const { repositoryName } = await prompts({
 		type: 'select',
 		name: 'repositoryName',
@@ -31,12 +28,10 @@ export default async function generateUseCases() {
 		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({
@@ -44,24 +39,20 @@ export default async function generateUseCases() {
 		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}`);
 }