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

package/src/generate/module/generateRepository.js

@@ -1,127 +1,108 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import prompts from 'prompts';
-import {
-	buildRepositoryContent,
-	createUseCasesForRepository,
-	ensureRepositoryName,
-	getConfigState,
-	getDomainTypes,
-	getRepositoryMeta,
-	promptMethodsBatch,
-	resolveContextAlias,
-	resolveRepositoriesPath,
-	selectContext,
-	selectDatasource,
-	selectDomain,
-	writeRepositoryInterface
-} from './repositoryModuleShared.js';
+import { buildRepositoryContent, createUseCasesForRepository, ensureRepositoryName, getConfigState, getDomainTypes, getRepositoryMeta, promptMethodsBatch, resolveContextAlias, resolveRepositoriesPath, selectContext, selectDatasource, 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) {
-		contextName = await selectContext('Select context for repository:');
-	}
-	if (!contextName) {
-		process.exitCode = 1;
-		return null;
-	}
-	let domainName = options.domainName ? String(options.domainName) : null;
-	if (!domainName) {
-		domainName = await selectDomain(contextName);
-	}
-	if (!domainName) {
-		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',
-		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 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,
-		domainName,
-		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({
-			contextName,
-			contextAlias,
-			domainName,
-			repositoryName: meta.className
-		});
-		useCasesCreated = true;
-	}
-	if (!shouldCreateUseCases && options.forceCreateUseCases) {
-		await createUseCasesForRepository({
-			contextName,
-			contextAlias,
-			domainName,
-			repositoryName: meta.className
-		});
-		useCasesCreated = true;
-	}
-	console.log(`✅ Repository generated: ${repositoryPath}`);
-	return {
-		contextName,
-		domainName,
-		repositoryName: meta.className,
-		useCasesName: meta.useCasesClassName,
-		useCasesCreated
-	};
+    let contextName = options.contextName ? String(options.contextName) : null;
+    if (!contextName) {
+        contextName = await selectContext('Select context for repository:');
+    }
+    if (!contextName) {
+        process.exitCode = 1;
+        return null;
+    }
+    const domainName = contextName;
+    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',
+        name: 'methodsCountRaw',
+        message: 'How many methods to create?',
+        initial: 1,
+        min: 0
+    });
+    const methodsCount = Number(methodsCountRaw ?? 0);
+    if (!Number.isInteger(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`);
+    const interfaceCreated = await writeRepositoryInterface({
+        contextName,
+        domainName,
+        meta,
+        methods
+    });
+    if (!interfaceCreated)
+        throw new Error('Repository interface already exists; no repository was generated.');
+    const repositoryContent = buildRepositoryContent({
+        meta,
+        contextAlias,
+        domainName,
+        datasource,
+        domainTypes,
+        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) {
+        useCasesCreated = await createUseCasesForRepository({
+            contextName,
+            contextAlias,
+            domainName,
+            repositoryName: meta.className
+        });
+    }
+    if (!shouldCreateUseCases && options.forceCreateUseCases) {
+        useCasesCreated = await createUseCasesForRepository({
+            contextName,
+            contextAlias,
+            domainName,
+            repositoryName: meta.className
+        });
+    }
+    console.log(`✅ Repository generated: ${repositoryPath}`);
+    return {
+        contextName,
+        domainName,
+        repositoryName: meta.className,
+        useCasesName: meta.useCasesClassName,
+        useCasesCreated,
+        datasourceName: datasource.name
+    };
 }

package/src/generate/module/generateRepositoryMethod.js

@@ -0,0 +1,117 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import ts from 'typescript';
+import prompts from 'prompts';
+import { getDomainTypes, getRepositoryMeta, getAvailableTsNames, selectContext, resolveRepositoriesPath, resolveDomainRootPath, resolveUseCasesPath, promptMethodDefinition, buildRepositoryContent, buildRepositoryMethodCode } from './repositoryModuleShared.js';
+const parse = (content) => ts.createSourceFile('Source.ts', content, ts.ScriptTarget.Latest, true);
+export function addTypeImports(content, generated) {
+    const existing = new Set();
+    for (const node of parse(content).statements)
+        if (ts.isInterfaceDeclaration(node) || ts.isClassDeclaration(node) || ts.isTypeAliasDeclaration(node)) {
+            if (node.name)
+                existing.add(node.name.text);
+        }
+    for (const statement of parse(content).statements)
+        if (ts.isImportDeclaration(statement)) {
+            const bindings = statement.importClause?.namedBindings;
+            if (bindings && ts.isNamedImports(bindings))
+                for (const item of bindings.elements)
+                    existing.add(item.name.text);
+        }
+    const additions = [];
+    for (const statement of parse(generated).statements)
+        if (ts.isImportDeclaration(statement) && statement.importClause?.isTypeOnly) {
+            const bindings = statement.importClause.namedBindings;
+            if (!bindings || !ts.isNamedImports(bindings))
+                continue;
+            const names = bindings.elements.filter((item) => !existing.has(item.name.text)).map((item) => item.name.text);
+            if (names.length)
+                additions.push(`import type { ${names.join(', ')} } from ${statement.moduleSpecifier.getText()};`);
+        }
+    if (!additions.length)
+        return content;
+    const imports = parse(content).statements.filter(ts.isImportDeclaration);
+    const end = imports.at(-1)?.end ?? 0;
+    return content.slice(0, end) + '\n' + additions.join('\n') + '\n' + content.slice(end);
+}
+export default async function generateRepositoryMethod() {
+    const context = await selectContext();
+    if (!context)
+        return;
+    const names = await getAvailableTsNames(resolveRepositoriesPath(context));
+    if (!names.length)
+        throw new Error('No repositories found in this context.');
+    const answer = await prompts({
+        type: 'select',
+        name: 'repository',
+        message: 'Repository:',
+        choices: names.map((name) => ({ title: name, value: name }))
+    });
+    if (!answer.repository)
+        return;
+    const meta = getRepositoryMeta(answer.repository);
+    const repositoryFile = path.join(resolveRepositoriesPath(context), meta.className + '.ts');
+    const types = await getDomainTypes(context);
+    const contract = types.find((type) => type.name === meta.repositoryInterfaceName && type.layer === 'Ports');
+    if (!contract)
+        throw new Error(`Interface ${meta.repositoryInterfaceName} was not found in Domain/Ports.`);
+    const interfaceFile = path.join(resolveDomainRootPath(context), 'Ports', contract.fileName + '.ts');
+    const method = await promptMethodDefinition(types);
+    if (!method)
+        return;
+    const repositoryContent = await fs.readFile(repositoryFile, 'utf8');
+    const interfaceContent = await fs.readFile(interfaceFile, 'utf8');
+    const repositoryNode = parse(repositoryContent).statements.find((node) => ts.isClassDeclaration(node) && node.name?.text === meta.className);
+    const interfaceNode = parse(interfaceContent).statements.find((node) => ts.isInterfaceDeclaration(node) && node.name.text === meta.repositoryInterfaceName);
+    if (!repositoryNode || !interfaceNode)
+        throw new Error('Unable to locate the repository class and its interface. Files were not changed.');
+    if ([...repositoryNode.members, ...interfaceNode.members].some((member) => member.name?.getText() === method.name))
+        throw new Error(`Method ${method.name} already exists.`);
+    const generated = buildRepositoryContent({
+        meta,
+        contextAlias: `#contexts/${context}`,
+        domainName: context,
+        domainTypes: types,
+        datasource: { name: 'Datasource', importPath: 'unused' },
+        methods: [method]
+    });
+    const params = [
+        method.pathParamType ? `pathParam: ${method.pathParamType}` : '',
+        method.queryType ? `request: ${method.queryType.name}` : '',
+        method.bodyType ? `request: ${method.bodyType.name}` : ''
+    ]
+        .filter(Boolean)
+        .join(', ');
+    const signature = `\n\t${method.name}(${params}): Promise<${method.response.type}>;\n`;
+    const repositoryNext = addTypeImports(repositoryContent.slice(0, repositoryNode.end - 1) +
+        '\n' +
+        buildRepositoryMethodCode(method) +
+        '\n' +
+        repositoryContent.slice(repositoryNode.end - 1), generated);
+    const interfaceNext = addTypeImports(interfaceContent.slice(0, interfaceNode.end - 1) + signature + interfaceContent.slice(interfaceNode.end - 1), generated);
+    const useCasesFile = path.join(resolveUseCasesPath(context), meta.useCasesClassName + '.ts');
+    let useCasesContent;
+    try {
+        useCasesContent = await fs.readFile(useCasesFile, 'utf8');
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+    let useCasesNext;
+    if (useCasesContent !== undefined) {
+        const node = parse(useCasesContent).statements.find((item) => ts.isClassDeclaration(item) && item.name?.text === meta.useCasesClassName);
+        if (!node)
+            throw new Error('Unable to update existing UseCases safely. Files were not changed.');
+        if (!node.members.some((member) => member.name?.getText() === method.name))
+            useCasesNext =
+                useCasesContent.slice(0, node.end - 1) +
+                    `\n\tdeclare ${method.name}: ${meta.repositoryInterfaceName}['${method.name}'];\n` +
+                    useCasesContent.slice(node.end - 1);
+    }
+    await fs.writeFile(repositoryFile, repositoryNext);
+    await fs.writeFile(interfaceFile, interfaceNext);
+    if (useCasesNext !== undefined)
+        await fs.writeFile(useCasesFile, useCasesNext);
+    console.log(`Added ${method.name} to ${meta.className}, its contract and existing UseCases.`);
+}