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

package/src/generate/layers/generateRepository.js

@@ -1,109 +1 @@
-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() {
-	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 = [];
-	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}`);
-}
+export { default } from '../module/generateRepository.js';

package/src/generate/layers/generateRepositoryMethod.js

@@ -1,90 +1 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import prompts from 'prompts';
-import {
-	appendRepositoryMethod,
-	ensureDomainType,
-	ensureRepositoryInterfaceFile,
-	getAvailableTsNames,
-	getConfigState,
-	getRepositoryMeta,
-	parseRepositoryMethods,
-	resolveContextAlias,
-	resolveRepositoriesPath,
-	selectContext,
-	promptMethodDefinition
-} from './repositoryShared.js';
-export default async function generateRepositoryMethod() {
-	const contextName = await selectContext('Select context for repository method:');
-	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((name) => ({ title: name, value: name })),
-		initial: 0
-	});
-	if (!repositoryName) {
-		process.exitCode = 1;
-		return;
-	}
-	const meta = getRepositoryMeta(String(repositoryName));
-	const repositoryPath = path.join(repositoriesPath, `${meta.className}.ts`);
-	const method = await promptMethodDefinition();
-	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;
-	}
-	let repositoryContent = '';
-	try {
-		repositoryContent = await fs.readFile(repositoryPath, 'utf-8');
-	} catch {
-		console.error(`❌ Repository file not found: ${repositoryPath}`);
-		process.exitCode = 1;
-		return;
-	}
-	const existingMethods = parseRepositoryMethods(repositoryContent);
-	if (existingMethods.some((item) => item.name === method.name)) {
-		console.warn(`⚠️ Method "${method.name}" already exists in ${meta.className}.`);
-		process.exitCode = 1;
-		return;
-	}
-	const { contexts } = await getConfigState();
-	const contextAlias = resolveContextAlias(contexts, contextName);
-	await appendRepositoryMethod({
-		repositoryPath,
-		method,
-		contextAlias,
-		domainName: meta.domainName
-	});
-	await ensureRepositoryInterfaceFile({
-		contextName,
-		meta,
-		methods: [...existingMethods, method]
-	});
-	console.log(`✅ Method "${method.name}" added to ${meta.className}`);
-}
+export { default } from '../module/generateRepositoryMethod.js';

package/src/generate/layers/generateUseCases.js

@@ -1,44 +1 @@
-import prompts from 'prompts';
-import {
-	ensureUseCasesFile,
-	getAvailableTsNames,
-	getConfigState,
-	getRepositoryMeta,
-	resolveContextAlias,
-	resolveRepositoriesPath,
-	selectContext
-} from './repositoryShared.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) {
-		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((name) => ({ title: name, value: name })),
-		initial: 0
-	});
-	if (!repositoryName) {
-		process.exitCode = 1;
-		return;
-	}
-	const { contexts } = await getConfigState();
-	const contextAlias = resolveContextAlias(contexts, contextName);
-	const meta = getRepositoryMeta(String(repositoryName));
-	const created = await ensureUseCasesFile({ contextName, contextAlias, meta });
-	if (!created) {
-		process.exitCode = 1;
-		return;
-	}
-	console.log(`✅ UseCases generated: ${meta.useCasesClassName}`);
-}
+export { default } from '../module/generateUseCases.js';

package/src/generate/module/generateDomain.js

@@ -1,121 +1,97 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import prompts from 'prompts';
-import { normalizeContexts } from '../../init/initAliases.js';
-import { loadUserConfig } from '../../utils/loadConfig.js';
-import { toKebabCase, toPascalCase } from '../../utils/contextUtils.js';
-import { updateIndexTs, writeIfNotExists } from '../../utils/fileUtils.js';
-const parseInterfaceNames = (rawValue) =>
-	String(rawValue ?? '')
-		.split(',')
-		.map((item) => item.trim())
-		.filter(Boolean)
-		.map((item) => toPascalCase(item))
-		.filter(Boolean);
+import { selectContext, toPascalCase } from '../../utils/contextUtils.js';
+import { appendBarrelExports, updateIndexTs, writeIfNotExists } from '../../utils/fileUtils.js';
+const parseInterfaceNames = (rawValue) => String(rawValue ?? '')
+    .split(',')
+    .map((item) => item.trim())
+    .filter(Boolean)
+    .map((item) => toPascalCase(item))
+    .filter(Boolean);
 const toFileNameFromInterface = (interfaceName) => interfaceName.replace(/^I/, '') || 'Type';
 const validateInterfaceNames = (rawValue) => {
-	const names = parseInterfaceNames(rawValue);
-	if (!names.length) return 'Provide at least one interface name';
-	for (const name of names) {
-		if (!name.startsWith('I')) {
-			return `Interface "${name}" must start with "I"`;
-		}
-	}
-	return true;
+    const names = parseInterfaceNames(rawValue);
+    if (!names.length)
+        return 'Provide at least one interface name';
+    for (const name of names) {
+        if (!/^I[A-Z][A-Za-z0-9]*$/.test(name)) {
+            return `Interface "${name}" must start with "I"`;
+        }
+    }
+    return true;
 };
 const createInterfaceContent = (name) => `export interface ${name} {
 \t[key: string]: unknown;
 }
 `;
 const writeRootIndex = async (domainPath) => {
-	const content = `export * from './model';
-export * from './ports';
-`;
-	await fs.writeFile(path.join(domainPath, 'index.ts'), content, 'utf-8');
-};
-const selectContext = async () => {
-	const config = await loadUserConfig();
-	const contexts = normalizeContexts(config.contexts);
-	if (!contexts.length) {
-		console.error('❌ Cannot generate domain: `contexts` is missing or empty in azure-net.config.ts/js');
-		return null;
-	}
-	const { context } = await prompts({
-		type: 'select',
-		name: 'context',
-		message: 'Select context:',
-		choices: contexts.map((item) => ({ title: item.name, value: item.name })),
-		initial: 0
-	});
-	return context ? String(context) : null;
+    await appendBarrelExports(path.join(domainPath, 'index.ts'), ['./Entities', './Ports', './Enums']);
 };
 const createInterfacesInLayer = async (layerPath, names) => {
-	for (const interfaceName of names) {
-		const fileName = toFileNameFromInterface(interfaceName);
-		const filePath = path.join(layerPath, `${fileName}.ts`);
-		await writeIfNotExists(filePath, createInterfaceContent(interfaceName));
-	}
-	await updateIndexTs(layerPath);
+    for (const interfaceName of names) {
+        const fileName = toFileNameFromInterface(interfaceName);
+        const filePath = path.join(layerPath, `${fileName}.ts`);
+        await writeIfNotExists(filePath, createInterfaceContent(interfaceName));
+    }
+    await updateIndexTs(layerPath);
 };
 export default async function generateDomain(options = {}) {
-	const { entityRaw } = await prompts({
-		type: 'text',
-		name: 'entityRaw',
-		message: 'Entity name:',
-		initial: options.entityName ?? '',
-		validate: (value) => (String(value ?? '').trim().length > 0 ? true : 'Entity name is required')
-	});
-	let context = options.contextName ? String(options.contextName) : null;
-	if (!context) {
-		context = await selectContext();
-	}
-	if (!context) {
-		process.exitCode = 1;
-		return null;
-	}
-	const entityName = toKebabCase(String(entityRaw ?? '').trim()) || 'entity';
-	const domainPath = path.join(process.cwd(), 'src', 'app', context, 'layers', 'domain', entityName);
-	const modelPath = path.join(domainPath, 'model');
-	const portsPath = path.join(domainPath, 'ports');
-	await fs.mkdir(modelPath, { recursive: true });
-	await fs.mkdir(portsPath, { recursive: true });
-	const { shouldCreateModels } = await prompts({
-		type: 'confirm',
-		name: 'shouldCreateModels',
-		message: 'Create model interfaces?',
-		initial: true
-	});
-	if (shouldCreateModels) {
-		const { modelNamesRaw } = await prompts({
-			type: 'text',
-			name: 'modelNamesRaw',
-			message: 'Model interface names (comma separated, start with I):',
-			validate: validateInterfaceNames
-		});
-		const modelNames = parseInterfaceNames(modelNamesRaw);
-		await createInterfacesInLayer(modelPath, modelNames);
-	} else {
-		await updateIndexTs(modelPath);
-	}
-	const { shouldCreatePorts } = await prompts({
-		type: 'confirm',
-		name: 'shouldCreatePorts',
-		message: 'Create port interfaces?',
-		initial: true
-	});
-	if (shouldCreatePorts) {
-		const { portNamesRaw } = await prompts({
-			type: 'text',
-			name: 'portNamesRaw',
-			message: 'Port interface names (comma separated, start with I):',
-			validate: validateInterfaceNames
-		});
-		const portNames = parseInterfaceNames(portNamesRaw);
-		await createInterfacesInLayer(portsPath, portNames);
-	} else {
-		await updateIndexTs(portsPath);
-	}
-	await writeRootIndex(domainPath);
-	console.log(`✅ Domain generated: ${domainPath}`);
-	return { contextName: context, domainName: entityName, domainPath };
+    let context = options.contextName ? String(options.contextName) : null;
+    if (!context) {
+        context = await selectContext();
+    }
+    if (!context) {
+        process.exitCode = 1;
+        return null;
+    }
+    context = toPascalCase(context);
+    const domainPath = path.join(process.cwd(), 'src/app/Contexts', context, 'Domain');
+    const modelPath = path.join(domainPath, 'Entities');
+    const portsPath = path.join(domainPath, 'Ports');
+    await fs.mkdir(modelPath, { recursive: true });
+    await fs.mkdir(portsPath, { recursive: true });
+    const { shouldCreateModels } = await prompts({
+        type: 'confirm',
+        name: 'shouldCreateModels',
+        message: 'Create entity interfaces?',
+        initial: true
+    });
+    if (shouldCreateModels) {
+        const { modelNamesRaw } = await prompts({
+            type: 'text',
+            name: 'modelNamesRaw',
+            message: 'Entity interface names (comma separated, start with I):',
+            validate: validateInterfaceNames
+        });
+        const modelNames = parseInterfaceNames(modelNamesRaw);
+        await createInterfacesInLayer(modelPath, modelNames);
+    }
+    else {
+        await updateIndexTs(modelPath);
+    }
+    const { shouldCreatePorts } = await prompts({
+        type: 'confirm',
+        name: 'shouldCreatePorts',
+        message: 'Create port interfaces?',
+        initial: true
+    });
+    if (shouldCreatePorts) {
+        const { portNamesRaw } = await prompts({
+            type: 'text',
+            name: 'portNamesRaw',
+            message: 'Port interface names (comma separated, start with I):',
+            validate: validateInterfaceNames
+        });
+        const portNames = parseInterfaceNames(portNamesRaw);
+        await createInterfacesInLayer(portsPath, portNames);
+    }
+    else {
+        await updateIndexTs(portsPath);
+    }
+    await fs.mkdir(path.join(domainPath, 'Enums'), { recursive: true });
+    await updateIndexTs(path.join(domainPath, 'Enums'));
+    await writeRootIndex(domainPath);
+    console.log(`✅ Domain generated: ${domainPath}`);
+    return { contextName: context, domainName: context, domainPath };
 }

package/src/generate/module/generateModule.js

@@ -1,74 +1,40 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
 import prompts from 'prompts';
 import generateDomain from './generateDomain.js';
 import generateRepository from './generateRepository.js';
 import generatePresenter from './generatePresenter.js';
-const findProviderFile = async (contextName, layerName, preferredFileName) => {
-	const providersPath = path.join(process.cwd(), 'src', 'app', contextName, 'layers', layerName, 'providers');
-	const preferredPath = path.join(providersPath, preferredFileName);
-	try {
-		await fs.access(preferredPath);
-		return preferredPath;
-	} catch {
-		try {
-			const files = await fs.readdir(providersPath);
-			const firstTs = files.find((item) => item.endsWith('.ts') && item !== 'index.ts');
-			return firstTs ? path.join(providersPath, firstTs) : preferredPath;
-		} catch {
-			return preferredPath;
-		}
-	}
-};
-const parseProviderConstName = async (providerPath, fallbackName) => {
-	try {
-		const content = await fs.readFile(providerPath, 'utf-8');
-		const match = content.match(/export\s+const\s+([A-Za-z_][A-Za-z0-9_]*)\s*=\s*createBoundaryProvider/);
-		return match?.[1] ?? fallbackName;
-	} catch {
-		return fallbackName;
-	}
-};
+import { printApplicationProviderWiring } from './repositoryModuleShared.js';
 export default async function generateModule() {
-	const domainResult = await generateDomain();
-	if (!domainResult) {
-		process.exitCode = 1;
-		return;
-	}
-	const repositoryResult = await generateRepository({
-		contextName: domainResult.contextName,
-		domainName: domainResult.domainName,
-		forceCreateUseCases: true
-	});
-	if (!repositoryResult) {
-		process.exitCode = 1;
-		return;
-	}
-	const infrastructureProviderPath = await findProviderFile(repositoryResult.contextName, 'infrastructure', 'InfrastructureProvider.ts');
-	const applicationProviderPath = await findProviderFile(repositoryResult.contextName, 'application', 'ApplicationProvider.ts');
-	const infrastructureProviderName = await parseProviderConstName(infrastructureProviderPath, 'InfrastructureProvider');
-	console.log('\n⚠️ Manual provider registration is required before presenter generation.');
-	console.log(`Infrastructure provider file: ${infrastructureProviderPath}`);
-	console.log(`Application provider file: ${applicationProviderPath}`);
-	console.log('\nSuggested register snippets:');
-	console.log(
-		`- Infrastructure register: ${repositoryResult.repositoryName}: () => new ${repositoryResult.repositoryName}(/* datasource */),`
-	);
-	console.log(
-		`- Application register: ${repositoryResult.useCasesName}: () => new ${repositoryResult.useCasesName}(${infrastructureProviderName}().${repositoryResult.repositoryName}),`
-	);
-	const { isReadyForPresenter } = await prompts({
-		type: 'confirm',
-		name: 'isReadyForPresenter',
-		message: 'Did you register repository/use-cases in providers and want to continue?',
-		initial: false
-	});
-	if (!isReadyForPresenter) {
-		console.log('ℹ️ Module flow paused. Complete provider wiring and rerun `azure-net generate presenter`.');
-		return;
-	}
-	await generatePresenter({
-		contextName: repositoryResult.contextName,
-		useCasesName: repositoryResult.useCasesName
-	});
+    const domainResult = await generateDomain();
+    if (!domainResult) {
+        process.exitCode = 1;
+        return;
+    }
+    const repositoryResult = await generateRepository({
+        contextName: domainResult.contextName,
+        domainName: domainResult.domainName,
+        forceCreateUseCases: true
+    });
+    if (!repositoryResult) {
+        process.exitCode = 1;
+        return;
+    }
+    if (!repositoryResult.useCasesCreated) {
+        process.exitCode = 1;
+        return;
+    }
+    printApplicationProviderWiring(repositoryResult.contextName, repositoryResult.repositoryName, repositoryResult.datasourceName);
+    const { isReadyForPresenter } = await prompts({
+        type: 'confirm',
+        name: 'isReadyForPresenter',
+        message: 'Did you register repository/use-cases in the central ApplicationProvider and want to continue?',
+        initial: false
+    });
+    if (!isReadyForPresenter) {
+        console.log('ℹ️ Module flow paused. Complete provider wiring and rerun `azure-net generate presenter`.');
+        return;
+    }
+    await generatePresenter({
+        contextName: repositoryResult.contextName,
+        useCasesName: repositoryResult.useCasesName
+    });
 }