@azure-net/cli 2.3.62 → 4.0.0-0

package/src/generate/module/generateDomain.ts

@@ -0,0 +1,147 @@
+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: unknown): string[] =>
+	String(rawValue ?? '')
+		.split(',')
+		.map((item) => item.trim())
+		.filter(Boolean)
+		.map((item) => toPascalCase(item))
+		.filter(Boolean);
+
+const toFileNameFromInterface = (interfaceName: string): string => interfaceName.replace(/^I/, '') || 'Type';
+
+const validateInterfaceNames = (rawValue: unknown): true | string => {
+	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 createInterfaceContent = (name: string): string => `export interface ${name} {
+\t[key: string]: unknown;
+}
+`;
+
+const writeRootIndex = async (domainPath: string): Promise<void> => {
+	const content = `export * from './model';
+export * from './ports';
+`;
+
+	await fs.writeFile(path.join(domainPath, 'index.ts'), content, 'utf-8');
+};
+
+const selectContext = async (): Promise<string | null> => {
+	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;
+};
+
+const createInterfacesInLayer = async (layerPath: string, names: string[]): Promise<void> => {
+	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: { contextName?: string; entityName?: string } = {}
+): Promise<{ contextName: string; domainName: string; domainPath: string } | null> {
+	const { entityRaw } = await prompts({
+		type: 'text',
+		name: 'entityRaw',
+		message: 'Entity name:',
+		initial: options.entityName ?? '',
+		validate: (value: string) => (String(value ?? '').trim().length > 0 ? true : 'Entity name is required')
+	});
+
+	let context: string | null = 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 };
+}

package/src/generate/module/generateModule.js

@@ -0,0 +1,84 @@
+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;
+	}
+};
+
+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
+	});
+}

package/src/generate/module/generateModule.ts

@@ -0,0 +1,84 @@
+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: string, layerName: string, preferredFileName: string): Promise<string> => {
+	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: string, fallbackName: string): Promise<string> => {
+	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;
+	}
+};
+
+export default async function generateModule(): Promise<void> {
+	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
+	});
+}