@azure-net/cli 5.0.0-1 → 5.0.0

package/src/generate/module/generatePresenter.js

@@ -5,63 +5,61 @@ import { toKebabCase, toPascalCase } from '../../utils/contextUtils.js';
 import { writeIfNotExists, updateIndexTs } from '../../utils/fileUtils.js';
 import { getConfigState, resolveContextAlias, selectContext } from './repositoryModuleShared.js';
 import { loadUserConfig } from '../../utils/loadConfig.js';
-
+import { getFoundationConstructImportPath, getFoundationConstructPath, getSharedState } from '../../utils/sharedFoundation.js';
 const PRIMITIVE_TYPES = new Set(['string', 'number', 'boolean', 'unknown', 'void', 'null', 'undefined', 'bigint', 'symbol', 'never']);
-
 const parseProviderInfo = (content) => {
 	const providerNameMatch = content.match(/export\s+const\s+(\w+)\s*=\s*createBoundaryProvider/);
 	const providerName = providerNameMatch?.[1] ?? 'ApplicationProvider';
-
 	const registerMatch = content.match(/register\s*:\s*\([^)]*\)\s*=>\s*\(\{([\s\S]*?)\}\)/m);
 	const registerBody = registerMatch?.[1] ?? '';
 	const keys = [];
 	const keyRegex = /([A-Za-z_]\w*)\s*:/g;
 	let keyMatch;
 	while ((keyMatch = keyRegex.exec(registerBody)) !== null) {
-		keys.push(keyMatch[1]);
+		const key = keyMatch[1];
+		if (key) keys.push(key);
 	}
-
 	return { providerName, registeredKeys: keys };
 };
-
 const parseUseCasesInfo = (content) => {
 	const interfaceImport = content.match(/import\s+type\s+\{\s*(\w+)\s*\}\s+from\s+['"]([^'"]+)['"]/);
 	const repositoryInterfaceName = interfaceImport?.[1] ?? null;
 	const domainImportPath = interfaceImport?.[2] ?? null;
 	const domainNameMatch = domainImportPath?.match(/\/layers\/domain\/([^'"]+)$/);
 	const domainName = domainNameMatch?.[1] ?? null;
-
 	const methods = [];
 	const declareRegex = /declare\s+(\w+)\s*:\s*\w+\['\w+'\];/g;
 	let declareMatch;
 	while ((declareMatch = declareRegex.exec(content)) !== null) {
-		methods.push(declareMatch[1]);
+		const methodName = declareMatch[1];
+		if (methodName) methods.push(methodName);
 	}
-
 	return { repositoryInterfaceName, domainName, methods };
 };
-
 const parseRepositoryInterfaceMethods = (content) => {
 	const methods = [];
 	const regex = /(\w+)\(([^)]*)\)\s*:\s*Promise<([^>]+)>;/g;
 	let match;
 	while ((match = regex.exec(content)) !== null) {
-		const paramsRaw = match[2].trim();
+		const methodName = match[1];
+		const paramsChunk = match[2];
+		const responseTypeChunk = match[3];
+		if (!methodName || paramsChunk === undefined || !responseTypeChunk) continue;
+		const paramsRaw = paramsChunk.trim();
 		const params = paramsRaw
 			? paramsRaw.split(',').map((part) => {
 					const [name, ...typeParts] = part.trim().split(':');
-					return { name: name.trim(), type: typeParts.join(':').trim() };
+					return { name: String(name ?? '').trim(), type: typeParts.join(':').trim() };
 				})
 			: [];
 		methods.push({
-			name: match[1],
+			name: methodName,
 			params,
-			responseType: match[3].trim()
+			responseType: responseTypeChunk.trim()
 		});
 	}
 	return methods;
 };
-
 const findRepositoryByInterface = async (contextName, repositoryInterfaceName) => {
 	const repositoriesPath = path.join(process.cwd(), 'src', 'app', contextName, 'layers', 'infrastructure', 'http', 'repositories');
 	try {
@@ -69,7 +67,6 @@ const findRepositoryByInterface = async (contextName, repositoryInterfaceName) =
 		for (const fileName of files) {
 			if (!fileName.endsWith('.ts') || fileName === 'index.ts') continue;
 			const absolute = path.join(repositoriesPath, fileName);
-			// eslint-disable-next-line no-await-in-loop
 			const content = await fs.readFile(absolute, 'utf-8');
 			if (content.includes(`implements ${repositoryInterfaceName}`)) {
 				return { filePath: absolute, content };
@@ -80,22 +77,22 @@ const findRepositoryByInterface = async (contextName, repositoryInterfaceName) =
 		return null;
 	}
 };
-
 const parseRepositoryHttpMethods = (content) => {
 	const methods = new Map();
 	const regex = /public\s+async\s+(\w+)\([^)]*\)\s*\{([\s\S]*?)\n\t\}/g;
 	let match;
 	while ((match = regex.exec(content)) !== null) {
 		const methodName = match[1];
+		if (!methodName) continue;
 		const body = match[2] ?? '';
 		const httpMatch = body.match(/http\.(get|post|put|delete|head|options|patch)\(/);
-		if (httpMatch) methods.set(methodName, httpMatch[1]);
+		if (httpMatch?.[1]) methods.set(methodName, httpMatch[1]);
 	}
 	return methods;
 };
-
-const getCorePresenterFactories = async () => {
-	const presenterPath = path.join(process.cwd(), 'src', 'core', 'presenter');
+const getSharedPresenterFactories = async () => {
+	const { sharedContext } = await getSharedState();
+	const presenterPath = getFoundationConstructPath(sharedContext.name, 'presenter');
 	try {
 		const files = await fs.readdir(presenterPath);
 		return files.filter((item) => item.endsWith('.ts') && item !== 'index.ts').map((item) => item.replace(/\.ts$/, ''));
@@ -103,9 +100,9 @@ const getCorePresenterFactories = async () => {
 		return [];
 	}
 };
-
-const getCoreSchemaFactories = async () => {
-	const schemaPath = path.join(process.cwd(), 'src', 'core', 'schema');
+const getSharedSchemaFactories = async () => {
+	const { sharedContext } = await getSharedState();
+	const schemaPath = getFoundationConstructPath(sharedContext.name, 'schema');
 	try {
 		const files = await fs.readdir(schemaPath);
 		return files.filter((item) => item.endsWith('.ts') && item !== 'index.ts').map((item) => item.replace(/\.ts$/, ''));
@@ -113,19 +110,15 @@ const getCoreSchemaFactories = async () => {
 		return [];
 	}
 };
-
 const normalizePresenterName = (rawName, fallbackUseCasesName) => {
 	const fallback = fallbackUseCasesName.replace(/UseCases$/, '') || 'Module';
 	const source = String(rawName ?? '').trim() || fallback;
 	const normalized = toPascalCase(source);
 	return normalized.endsWith('Presenter') ? normalized : `${normalized}Presenter`;
 };
-
 const isPrimitive = (typeName) => PRIMITIVE_TYPES.has(String(typeName ?? '').trim());
-
 const normalizeTypeImports = (types) => Array.from(new Set(types.filter((typeName) => !isPrimitive(typeName))));
 const isPathParamName = (name) => name === 'pathParam' || name === 'path';
-
 const buildMethodInvocation = (method, useCasesName, schemaByMethod) => {
 	const paramsSignature = method.params.map((item) => `${item.name}: ${item.type}`).join(', ');
 	const argNames = method.params.map((item) => item.name);
@@ -137,21 +130,17 @@ const buildMethodInvocation = (method, useCasesName, schemaByMethod) => {
 		}
 		return argName;
 	});
-
 	const httpMethod = method.httpMethod;
 	if (httpMethod === 'get' || httpMethod === 'head' || httpMethod === 'options') {
 		return `\tconst ${method.name} = (${paramsSignature}) => createAsyncResource(() => ${useCasesName}.${method.name}(${args.join(', ')}));`;
 	}
-
 	const responseType = method.responseType;
 	const requestType = requestParam?.type ?? null;
 	let generic = `<${responseType}`;
 	if (requestType) generic += `, ${requestType}`;
 	generic += '>';
-
 	return `\tconst ${method.name} = async (${paramsSignature}) =>\n\t\tawait createAsyncAction${generic}(() => ${useCasesName}.${method.name}(${args.join(', ')}));`;
 };
-
 const getApplicationProviderFile = async (contextName) => {
 	const providersPath = path.join(process.cwd(), 'src', 'app', contextName, 'layers', 'application', 'providers');
 	const targetPath = path.join(providersPath, 'ApplicationProvider.ts');
@@ -164,7 +153,6 @@ const getApplicationProviderFile = async (contextName) => {
 		return candidate ? path.join(providersPath, candidate) : null;
 	}
 };
-
 export default async function generatePresenter(options = {}) {
 	let contextName = options.contextName ? String(options.contextName) : null;
 	if (!contextName) {
@@ -174,17 +162,14 @@ export default async function generatePresenter(options = {}) {
 		process.exitCode = 1;
 		return;
 	}
-
 	const appProviderFile = await getApplicationProviderFile(contextName);
 	if (!appProviderFile) {
 		console.error('❌ ApplicationProvider file was not found.');
 		process.exitCode = 1;
 		return;
 	}
-
 	const appProviderContent = await fs.readFile(appProviderFile, 'utf-8');
 	const providerInfo = parseProviderInfo(appProviderContent);
-
 	const useCasesPath = path.join(process.cwd(), 'src', 'app', contextName, 'layers', 'application', 'use-cases');
 	let useCasesFiles = [];
 	try {
@@ -194,14 +179,12 @@ export default async function generatePresenter(options = {}) {
 	} catch {
 		// ignore
 	}
-
 	const registeredUseCases = useCasesFiles.filter((item) => providerInfo.registeredKeys.includes(item));
 	if (!registeredUseCases.length) {
 		console.error('❌ No registered UseCases were found in ApplicationProvider register().');
 		process.exitCode = 1;
 		return;
 	}
-
 	let useCasesName = options.useCasesName ? String(options.useCasesName) : '';
 	if (!useCasesName) {
 		const { selectedUseCases } = await prompts({
@@ -213,13 +196,11 @@ export default async function generatePresenter(options = {}) {
 		});
 		useCasesName = String(selectedUseCases ?? '');
 	}
-
 	if (!registeredUseCases.includes(useCasesName)) {
 		console.error(`❌ UseCases "${useCasesName}" is not registered in ApplicationProvider.`);
 		process.exitCode = 1;
 		return;
 	}
-
 	const useCasesFile = path.join(useCasesPath, `${useCasesName}.ts`);
 	const useCasesContent = await fs.readFile(useCasesFile, 'utf-8');
 	const useCasesInfo = parseUseCasesInfo(useCasesContent);
@@ -228,14 +209,12 @@ export default async function generatePresenter(options = {}) {
 		process.exitCode = 1;
 		return;
 	}
-
 	const repositoryInfo = await findRepositoryByInterface(contextName, useCasesInfo.repositoryInterfaceName);
 	if (!repositoryInfo) {
 		console.error(`❌ Repository implementing ${useCasesInfo.repositoryInterfaceName} was not found.`);
 		process.exitCode = 1;
 		return;
 	}
-
 	const repositoryHttpMethods = parseRepositoryHttpMethods(repositoryInfo.content);
 	const domainPortsInterfacePath = path.join(
 		process.cwd(),
@@ -252,25 +231,23 @@ export default async function generatePresenter(options = {}) {
 	const repositoryMethods = parseRepositoryInterfaceMethods(repositoryInterfaceContent).filter((method) =>
 		useCasesInfo.methods.includes(method.name)
 	);
-
 	const { presenterNameRaw } = await prompts({
 		type: 'text',
 		name: 'presenterNameRaw',
 		message: 'Presenter name (optional):'
 	});
-
 	const presenterName = normalizePresenterName(presenterNameRaw, useCasesName);
 	const presenterFolder = toKebabCase(presenterName.replace(/Presenter$/, ''));
 	const presentationPath = path.join(process.cwd(), 'src', 'app', contextName, 'layers', 'presentation', presenterFolder);
 	await fs.mkdir(presentationPath, { recursive: true });
-
-	const { contexts, coreAlias } = await getConfigState();
+	const { contexts, sharedAlias } = await getConfigState();
 	const contextAlias = resolveContextAlias(contexts, contextName);
-
+	const presenterImportPath = getFoundationConstructImportPath(sharedAlias, 'presenter');
+	const schemaFactoryImportPath = getFoundationConstructImportPath(sharedAlias, 'schema');
 	let presenterFactory = String((await loadUserConfig()).defaultPresenterFactory ?? '').trim();
 	let useNativePresenter = false;
 	if (!presenterFactory) {
-		const availableFactories = await getCorePresenterFactories();
+		const availableFactories = await getSharedPresenterFactories();
 		const { selectedFactory } = await prompts({
 			type: 'select',
 			name: 'selectedFactory',
@@ -281,7 +258,6 @@ export default async function generatePresenter(options = {}) {
 			],
 			initial: 0
 		});
-
 		if (selectedFactory === '__native__') {
 			useNativePresenter = true;
 			presenterFactory = 'createPresenter';
@@ -289,46 +265,38 @@ export default async function generatePresenter(options = {}) {
 			presenterFactory = String(selectedFactory ?? '');
 		}
 	}
-
 	if (!presenterFactory) {
 		useNativePresenter = true;
 		presenterFactory = 'createPresenter';
 	}
-
 	const mutationMethods = repositoryMethods.filter((method) => {
 		const httpMethod = repositoryHttpMethods.get(method.name) ?? 'get';
 		return httpMethod !== 'get' && httpMethod !== 'head' && httpMethod !== 'options';
 	});
-
 	let schemaFactory = String((await loadUserConfig()).defaultSchemaFactory ?? '').trim();
 	let schemaFactoryResolved = false;
 	const schemaByMethod = new Map();
 	const schemaImports = [];
 	let schemaIndexNeeded = false;
-
 	if (mutationMethods.length) {
 		for (const method of mutationMethods) {
 			const requestParam = method.params.find((item) => !isPathParamName(item.name));
 			if (!requestParam) continue;
-
 			const { shouldCreateSchema } = await prompts({
 				type: 'confirm',
 				name: 'shouldCreateSchema',
 				message: `Create schema for "${method.name}"?`,
 				initial: false
 			});
-
 			if (!shouldCreateSchema) continue;
-
 			if (!schemaFactoryResolved) {
 				if (!schemaFactory) {
-					const availableSchemas = await getCoreSchemaFactories();
+					const availableSchemas = await getSharedSchemaFactories();
 					if (!availableSchemas.length) {
-						console.error('❌ No schema factories found in src/core/schema.');
+						console.error('❌ No schema factories found in shared foundation constructs/schema.');
 						process.exitCode = 1;
 						return;
 					}
-
 					const { selectedSchemaFactory } = await prompts({
 						type: 'select',
 						name: 'selectedSchemaFactory',
@@ -336,37 +304,30 @@ export default async function generatePresenter(options = {}) {
 						choices: availableSchemas.map((item) => ({ title: item, value: item })),
 						initial: 0
 					});
-
 					schemaFactory = String(selectedSchemaFactory ?? '');
 				}
-
 				schemaFactoryResolved = true;
 			}
-
 			const schemaConstName = `${toPascalCase(method.name)}${presenterName}Schema`;
 			const schemaFileName = `${schemaConstName}.ts`;
 			const schemaPath = path.join(presentationPath, 'schema');
 			await fs.mkdir(schemaPath, { recursive: true });
 			schemaIndexNeeded = true;
-
-			const schemaContent = `import { ${schemaFactory} } from '${coreAlias}/schema';
+			const schemaContent = `import { ${schemaFactory} } from '${schemaFactoryImportPath}';
 import type { ${requestParam.type} } from '${contextAlias}/layers/domain/${useCasesInfo.domainName}';
 
 export const ${schemaConstName} = ${schemaFactory}<${requestParam.type}>()
 \t.rules((rules) => ({}))
 \t.create();
 `;
-
 			await writeIfNotExists(path.join(schemaPath, schemaFileName), schemaContent);
 			schemaByMethod.set(method.name, { constName: schemaConstName });
 			schemaImports.push(schemaConstName);
 		}
 	}
-
 	if (schemaIndexNeeded) {
 		await updateIndexTs(path.join(presentationPath, 'schema'));
 	}
-
 	const hasGetLike = repositoryMethods.some((method) => {
 		const httpMethod = repositoryHttpMethods.get(method.name) ?? 'get';
 		return httpMethod === 'get' || httpMethod === 'head' || httpMethod === 'options';
@@ -375,29 +336,23 @@ export const ${schemaConstName} = ${schemaFactory}<${requestParam.type}>()
 		const httpMethod = repositoryHttpMethods.get(method.name) ?? 'get';
 		return httpMethod !== 'get' && httpMethod !== 'head' && httpMethod !== 'options';
 	});
-
 	const helperParams = [hasGetLike ? 'createAsyncResource' : null, hasMutation ? 'createAsyncAction' : null].filter(Boolean).join(', ');
-
 	const typeImports = normalizeTypeImports(
 		repositoryMethods.flatMap((method) => [method.responseType, ...method.params.map((item) => item.type)])
 	);
-
 	const methodsCode = repositoryMethods
 		.map((method) => {
 			const httpMethod = repositoryHttpMethods.get(method.name) ?? 'get';
 			return buildMethodInvocation({ ...method, httpMethod }, useCasesName, schemaByMethod);
 		})
 		.join('\n\n');
-
 	const factoryImport = useNativePresenter
 		? `import { createPresenter } from '@azure-net/kit/delivery';`
-		: `import { ${presenterFactory} } from '${coreAlias}/presenter';`;
-
+		: `import { ${presenterFactory} } from '${presenterImportPath}';`;
 	const schemaImportLine = schemaImports.length ? `import { ${Array.from(new Set(schemaImports)).join(', ')} } from './schema';` : '';
 	const typeImportLine = typeImports.length
 		? `import type { ${typeImports.join(', ')} } from '${contextAlias}/layers/domain/${useCasesInfo.domainName}';`
 		: '';
-
 	const presenterId = `${toPascalCase(contextName)}${presenterName}`;
 	const presenterContent = `${factoryImport}
 import { ${providerInfo.providerName} } from '${contextAlias}/layers/application/providers';
@@ -411,9 +366,7 @@ ${methodsCode ? `${methodsCode}\n` : ''}
 \treturn { ${repositoryMethods.map((method) => method.name).join(', ')} };
 });
 `;
-
 	await writeIfNotExists(path.join(presentationPath, `${presenterName}.ts`), presenterContent);
 	await fs.writeFile(path.join(presentationPath, 'index.ts'), `export * from './${presenterName}';\n`, 'utf-8');
-
 	console.log(`✅ Presenter generated: ${path.join(presentationPath, `${presenterName}.ts`)}`);
 }

package/src/generate/module/generatePresenter.ts

@@ -5,6 +5,7 @@ import { toKebabCase, toPascalCase } from '../../utils/contextUtils.js';
 import { writeIfNotExists, updateIndexTs } from '../../utils/fileUtils.js';
 import { getConfigState, resolveContextAlias, selectContext } from './repositoryModuleShared.js';
 import { loadUserConfig } from '../../utils/loadConfig.js';
+import { getFoundationConstructImportPath, getFoundationConstructPath, getSharedState } from '../../utils/sharedFoundation.js';
 
 type MethodParam = { name: string; type: string };
 type RepositoryMethod = { name: string; params: MethodParam[]; responseType: string };
@@ -108,8 +109,9 @@ const parseRepositoryHttpMethods = (content: string): Map<string, string> => {
 	return methods;
 };
 
-const getCorePresenterFactories = async (): Promise<string[]> => {
-	const presenterPath = path.join(process.cwd(), 'src', 'core', 'presenter');
+const getSharedPresenterFactories = async (): Promise<string[]> => {
+	const { sharedContext } = await getSharedState();
+	const presenterPath = getFoundationConstructPath(sharedContext.name, 'presenter');
 	try {
 		const files = await fs.readdir(presenterPath);
 		return files.filter((item) => item.endsWith('.ts') && item !== 'index.ts').map((item) => item.replace(/\.ts$/, ''));
@@ -118,8 +120,9 @@ const getCorePresenterFactories = async (): Promise<string[]> => {
 	}
 };
 
-const getCoreSchemaFactories = async (): Promise<string[]> => {
-	const schemaPath = path.join(process.cwd(), 'src', 'core', 'schema');
+const getSharedSchemaFactories = async (): Promise<string[]> => {
+	const { sharedContext } = await getSharedState();
+	const schemaPath = getFoundationConstructPath(sharedContext.name, 'schema');
 	try {
 		const files = await fs.readdir(schemaPath);
 		return files.filter((item) => item.endsWith('.ts') && item !== 'index.ts').map((item) => item.replace(/\.ts$/, ''));
@@ -287,13 +290,15 @@ export default async function generatePresenter(options: GeneratePresenterOption
 	const presentationPath = path.join(process.cwd(), 'src', 'app', contextName, 'layers', 'presentation', presenterFolder);
 	await fs.mkdir(presentationPath, { recursive: true });
 
-	const { contexts, coreAlias } = await getConfigState();
+	const { contexts, sharedAlias } = await getConfigState();
 	const contextAlias = resolveContextAlias(contexts, contextName);
+	const presenterImportPath = getFoundationConstructImportPath(sharedAlias, 'presenter');
+	const schemaFactoryImportPath = getFoundationConstructImportPath(sharedAlias, 'schema');
 
 	let presenterFactory = String((await loadUserConfig()).defaultPresenterFactory ?? '').trim();
 	let useNativePresenter = false;
 	if (!presenterFactory) {
-		const availableFactories = await getCorePresenterFactories();
+		const availableFactories = await getSharedPresenterFactories();
 		const { selectedFactory } = await prompts({
 			type: 'select',
 			name: 'selectedFactory',
@@ -345,9 +350,9 @@ export default async function generatePresenter(options: GeneratePresenterOption
 
 			if (!schemaFactoryResolved) {
 				if (!schemaFactory) {
-					const availableSchemas = await getCoreSchemaFactories();
+					const availableSchemas = await getSharedSchemaFactories();
 					if (!availableSchemas.length) {
-						console.error('❌ No schema factories found in src/core/schema.');
+						console.error('❌ No schema factories found in shared foundation constructs/schema.');
 						process.exitCode = 1;
 						return;
 					}
@@ -372,7 +377,7 @@ export default async function generatePresenter(options: GeneratePresenterOption
 			await fs.mkdir(schemaPath, { recursive: true });
 			schemaIndexNeeded = true;
 
-			const schemaContent = `import { ${schemaFactory} } from '${coreAlias}/schema';
+			const schemaContent = `import { ${schemaFactory} } from '${schemaFactoryImportPath}';
 import type { ${requestParam.type} } from '${contextAlias}/layers/domain/${useCasesInfo.domainName}';
 
 export const ${schemaConstName} = ${schemaFactory}<${requestParam.type}>()
@@ -414,7 +419,7 @@ export const ${schemaConstName} = ${schemaFactory}<${requestParam.type}>()
 
 	const factoryImport = useNativePresenter
 		? `import { createPresenter } from '@azure-net/kit/delivery';`
-		: `import { ${presenterFactory} } from '${coreAlias}/presenter';`;
+		: `import { ${presenterFactory} } from '${presenterImportPath}';`;
 
 	const schemaImportLine = schemaImports.length ? `import { ${Array.from(new Set(schemaImports)).join(', ')} } from './schema';` : '';
 	const typeImportLine = typeImports.length

package/src/generate/module/generateRepository.js

@@ -17,7 +17,6 @@ import {
 	writeRepositoryInterface
 } from './repositoryModuleShared.js';
 import { updateIndexTs, writeIfNotExists } from '../../utils/fileUtils.js';
-
 export default async function generateRepository(options = {}) {
 	let contextName = options.contextName ? String(options.contextName) : null;
 	if (!contextName) {
@@ -27,7 +26,6 @@ export default async function generateRepository(options = {}) {
 		process.exitCode = 1;
 		return null;
 	}
-
 	let domainName = options.domainName ? String(options.domainName) : null;
 	if (!domainName) {
 		domainName = await selectDomain(contextName);
@@ -36,23 +34,19 @@ export default async function generateRepository(options = {}) {
 		process.exitCode = 1;
 		return null;
 	}
-
 	const { repositoryNameRaw } = await prompts({
 		type: 'text',
 		name: 'repositoryNameRaw',
 		message: 'Repository name:',
 		validate: (value) => (String(value ?? '').trim().length > 0 ? true : 'Repository name is required')
 	});
-
 	const className = ensureRepositoryName(repositoryNameRaw);
 	const meta = getRepositoryMeta(className);
-
 	const datasource = await selectDatasource(contextName);
 	if (!datasource) {
 		process.exitCode = 1;
 		return null;
 	}
-
 	const domainTypes = await getDomainTypes(contextName, domainName);
 	const { methodsCountRaw } = await prompts({
 		type: 'number',
@@ -61,33 +55,28 @@ export default async function generateRepository(options = {}) {
 		initial: 1,
 		min: 0
 	});
-
 	const methodsCount = Number(methodsCountRaw ?? 0);
 	if (!Number.isFinite(methodsCount) || methodsCount < 0) {
 		console.error('❌ Invalid methods count.');
 		process.exitCode = 1;
 		return null;
 	}
-
 	const methods = await promptMethodsBatch(domainTypes, methodsCount);
 	if (!methods) {
 		process.exitCode = 1;
 		return null;
 	}
-
 	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`);
-
 	await writeRepositoryInterface({
 		contextName,
 		domainName,
 		meta,
 		methods
 	});
-
 	const repositoryContent = buildRepositoryContent({
 		meta,
 		contextAlias,
@@ -95,23 +84,19 @@ export default async function generateRepository(options = {}) {
 		datasource,
 		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 null;
 	}
-
 	const { shouldCreateUseCases } = await prompts({
 		type: 'confirm',
 		name: 'shouldCreateUseCases',
 		message: 'Create UseCases for this repository?',
 		initial: true
 	});
-
 	let useCasesCreated = false;
 	if (shouldCreateUseCases) {
 		await createUseCasesForRepository({
@@ -122,7 +107,6 @@ export default async function generateRepository(options = {}) {
 		});
 		useCasesCreated = true;
 	}
-
 	if (!shouldCreateUseCases && options.forceCreateUseCases) {
 		await createUseCasesForRepository({
 			contextName,
@@ -132,7 +116,6 @@ export default async function generateRepository(options = {}) {
 		});
 		useCasesCreated = true;
 	}
-
 	console.log(`✅ Repository generated: ${repositoryPath}`);
 	return {
 		contextName,