@azure-net/cli 2.3.62 → 4.0.0-0

package/src/commands/generate/generateSchema.js

@@ -24,73 +24,77 @@ export const {{name}}Schema = Schema()
 \t.create();`;
 
 export default async function generateSchema() {
-    const context = await selectContext('Select context for schema:');
-
-    if (context === 'core') {
-        console.error('❌ Cannot create schema in core. Choose a specific context.');
-        return;
-    }
-
-    const { module } = await prompts({
-        type: 'text',
-        name: 'module',
-        message: 'Module name (folder in delivery):'
-    });
-
-    const { name } = await prompts({
-        type: 'text',
-        name: 'name',
-        message: 'Schema name (without "Schema" suffix):'
-    });
-
-    // Check for core schemas
-    const coreSchemas = await getAvailableFiles(
-        path.join(process.cwd(), 'src/core/schemas')
-    );
-
-    const choices = [
-        { title: 'Use createSchemaFactory from package', value: 'package' },
-        ...coreSchemas.map(s => ({ title: `Use ${s} from core`, value: s }))
-    ];
-
-    const { schemaType } = await prompts({
-        type: 'select',
-        name: 'schemaType',
-        message: 'Select schema factory:',
-        choices
-    });
-
-    const pascalName = toPascalCase(name);
-    const moduleName = toPascalCase(module);
-    const moduleLower = moduleName.toLowerCase();
-    const entityLower = moduleName.toLowerCase();
-    const contextPath = getContextPath(context);
-    const schemaPath = path.join(contextPath, 'delivery', moduleLower, 'schema');
-    const filePath = path.join(schemaPath, `${pascalName}Schema.ts`);
-
-    const content = schemaType === 'package'
-        ? schemaWithPackageTemplate
-            .replace(/{{name}}/g, pascalName)
-            .replace(/{{context}}/g, context)
-            .replace(/{{entityLower}}/g, entityLower)
-        : schemaWithCoreTemplate
-            .replace(/{{name}}/g, pascalName)
-            .replace(/{{context}}/g, context)
-            .replace(/{{entityLower}}/g, entityLower)
-            .replace(/{{coreSchema}}/g, schemaType);
-
-    await writeIfNotExists(filePath, content);
-    await updateIndexTs(schemaPath);
-
-    // Update module index
-    const moduleIndexPath = path.join(contextPath, 'delivery', moduleLower, 'index.ts');
-    if (await fs.access(moduleIndexPath).then(() => true).catch(() => false)) {
-        let indexContent = await fs.readFile(moduleIndexPath, 'utf-8');
-        if (!indexContent.includes(`export * from './schema'`)) {
-            indexContent += `\nexport * from './schema';`;
-            await fs.writeFile(moduleIndexPath, indexContent, 'utf-8');
-        }
-    }
-
-    console.log(`✅ Schema created at ${filePath}`);
-}
+	const context = await selectContext('Select context for schema:');
+
+	if (context === 'core') {
+		console.error('❌ Cannot create schema in core. Choose a specific context.');
+		return;
+	}
+
+	const { module } = await prompts({
+		type: 'text',
+		name: 'module',
+		message: 'Module name (folder in delivery):'
+	});
+
+	const { name } = await prompts({
+		type: 'text',
+		name: 'name',
+		message: 'Schema name (without "Schema" suffix):'
+	});
+
+	// Check for core schemas
+	const coreSchemas = await getAvailableFiles(path.join(process.cwd(), 'src/core/schemas'));
+
+	const choices = [
+		{ title: 'Use createSchemaFactory from package', value: 'package' },
+		...coreSchemas.map((s) => ({ title: `Use ${s} from core`, value: s }))
+	];
+
+	const { schemaType } = await prompts({
+		type: 'select',
+		name: 'schemaType',
+		message: 'Select schema factory:',
+		choices
+	});
+
+	const pascalName = toPascalCase(name);
+	const moduleName = toPascalCase(module);
+	const moduleLower = moduleName.toLowerCase();
+	const entityLower = moduleName.toLowerCase();
+	const contextPath = getContextPath(context);
+	const schemaPath = path.join(contextPath, 'delivery', moduleLower, 'schema');
+	const filePath = path.join(schemaPath, `${pascalName}Schema.ts`);
+
+	const content =
+		schemaType === 'package'
+			? schemaWithPackageTemplate
+					.replace(/{{name}}/g, pascalName)
+					.replace(/{{context}}/g, context)
+					.replace(/{{entityLower}}/g, entityLower)
+			: schemaWithCoreTemplate
+					.replace(/{{name}}/g, pascalName)
+					.replace(/{{context}}/g, context)
+					.replace(/{{entityLower}}/g, entityLower)
+					.replace(/{{coreSchema}}/g, schemaType);
+
+	await writeIfNotExists(filePath, content);
+	await updateIndexTs(schemaPath);
+
+	// Update module index
+	const moduleIndexPath = path.join(contextPath, 'delivery', moduleLower, 'index.ts');
+	if (
+		await fs
+			.access(moduleIndexPath)
+			.then(() => true)
+			.catch(() => false)
+	) {
+		let indexContent = await fs.readFile(moduleIndexPath, 'utf-8');
+		if (!indexContent.includes(`export * from './schema'`)) {
+			indexContent += `\nexport * from './schema';`;
+			await fs.writeFile(moduleIndexPath, indexContent, 'utf-8');
+		}
+	}
+
+	console.log(`✅ Schema created at ${filePath}`);
+}

package/src/commands/generate/generateService.js

@@ -24,48 +24,43 @@ const serviceWithoutRepoTemplate = `export class {{name}}Service {
 }`;
 
 export default async function generateService() {
-    const context = await selectContext('Select context for service:');
+	const context = await selectContext('Select context for service:');
 
-    const { name } = await prompts({
-        type: 'text',
-        name: 'name',
-        message: 'Service name (without "Service" suffix):'
-    });
+	const { name } = await prompts({
+		type: 'text',
+		name: 'name',
+		message: 'Service name (without "Service" suffix):'
+	});
 
-    // Get available repositories
-    const contextPath = getContextPath(context);
-    const repositories = await getAvailableFiles(
-        path.join(contextPath, 'infrastructure', 'http', 'repositories')
-    );
+	// Get available repositories
+	const contextPath = getContextPath(context);
+	const repositories = await getAvailableFiles(path.join(contextPath, 'infrastructure', 'http', 'repositories'));
 
-    const choices = [
-        { title: 'Without repository', value: null },
-        ...repositories.map(r => ({ title: `${r}`, value: r }))
-    ];
+	const choices = [{ title: 'Without repository', value: null }, ...repositories.map((r) => ({ title: `${r}`, value: r }))];
 
-    const { repository } = await prompts({
-        type: 'select',
-        name: 'repository',
-        message: 'Select repository:',
-        choices
-    });
+	const { repository } = await prompts({
+		type: 'select',
+		name: 'repository',
+		message: 'Select repository:',
+		choices
+	});
 
-    const pascalName = toPascalCase(name);
-    const servicePath = path.join(contextPath, 'application', 'services');
-    const filePath = path.join(servicePath, `${pascalName}Service.ts`);
+	const pascalName = toPascalCase(name);
+	const servicePath = path.join(contextPath, 'application', 'services');
+	const filePath = path.join(servicePath, `${pascalName}Service.ts`);
 
-    // Generate service
-    const content = repository
-        ? serviceTemplate
-            .replace(/{{name}}/g, pascalName)
-            .replace(/{{repository}}/g, repository)
-            .replace(/{{repositoryVar}}/g, repository.charAt(0).toLowerCase() + repository.slice(1))
-            .replace(/{{context}}/g, context)
-        : serviceWithoutRepoTemplate.replace(/{{name}}/g, pascalName);
+	// Generate service
+	const content = repository
+		? serviceTemplate
+				.replace(/{{name}}/g, pascalName)
+				.replace(/{{repository}}/g, repository)
+				.replace(/{{repositoryVar}}/g, repository.charAt(0).toLowerCase() + repository.slice(1))
+				.replace(/{{context}}/g, context)
+		: serviceWithoutRepoTemplate.replace(/{{name}}/g, pascalName);
 
-    await writeIfNotExists(filePath, content);
-    await updateIndexTs(servicePath);
+	await writeIfNotExists(filePath, content);
+	await updateIndexTs(servicePath);
 
-    console.log(`✅ Service created at ${filePath}`);
-    console.log(`\n💡 Remember to manually add this service to ApplicationProvider when needed.`);
-}
+	console.log(`✅ Service created at ${filePath}`);
+	console.log(`\n💡 Remember to manually add this service to ApplicationProvider when needed.`);
+}

package/src/commands/generate/index.js

@@ -1,5 +1,3 @@
-export { default as generateDatasource } from './generateDatasource.js';
-export { default as generateResponse } from './generateResponse.js';
 export { default as generateRepository } from './generateRepository.js';
 export { default as generateService } from './generateService.js';
 export { default as generateSchema } from './generateSchema.js';
@@ -9,6 +7,3 @@ export { default as generateCrudBase } from './generateCrudBase.js';
 export { default as generateCrudPresenter } from './generateCrudPresenter.js';
 export { default as generateModuleBase } from './generateModuleBase.js';
 export { default as generateModulePresenter } from './generateModulePresenter.js';
-export { default as generateComponent } from './generateComponent.js';
-export { default as generateWidget } from './generateWidget.js';
-export { default as generateDesignComponent } from './generateDesignComponent.js';

package/src/generate/layers/generateRepository.js

@@ -0,0 +1,124 @@
+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}`);
+		// eslint-disable-next-line no-await-in-loop
+		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) {
+		// eslint-disable-next-line no-await-in-loop
+		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) {
+			// eslint-disable-next-line no-await-in-loop
+			const ensuredRequestType = await ensureDomainType({
+				contextName,
+				domainName: meta.domainName,
+				typeName: method.requestType,
+				layer: method.requestLayer ?? 'ports'
+			});
+			method.requestType = ensuredRequestType.interfaceName;
+			method.requestLayer = ensuredRequestType.layer;
+		}
+	}
+
+	await ensureRepositoryInterfaceFile({ contextName, meta, methods });
+	const repositoryContent = buildRepositoryContent({
+		meta,
+		contextAlias,
+		datasourceImportPath: datasource.importPath,
+		datasourceName: datasource.name,
+		methods
+	});
+
+	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}`);
+}

package/src/generate/layers/generateRepositoryMethod.js

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

package/src/generate/layers/generateUseCases.js

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