@azure-net/cli 1.4.1 → 2.0.0

package/src/utils/contextUtils.js

@@ -0,0 +1,53 @@
+import fs from 'fs/promises';
+import path from 'path';
+import prompts from 'prompts';
+import { loadUserConfig } from './loadConfig.js';
+
+const CONTEXTS_PATH = path.join(process.cwd(), 'src/app/contexts');
+const CORE_PATH = path.join(process.cwd(), 'src/app/core');
+
+export async function selectContext(message = 'Select context:') {
+    const config = await loadUserConfig();
+    const contexts = config.contexts || ['app'];
+
+    const { context } = await prompts({
+        type: 'select',
+        name: 'context',
+        message,
+        choices: [
+            ...contexts.map(c => ({ title: c, value: c })),
+            { title: 'core (shared)', value: 'core' }
+        ]
+    });
+
+    return context;
+}
+
+export function getContextPath(context) {
+    return context === 'core'
+        ? CORE_PATH
+        : path.join(CONTEXTS_PATH, context);
+}
+
+export async function getAvailableFiles(dir, pattern = '.ts') {
+    try {
+        const files = await fs.readdir(dir);
+        return files
+            .filter(f => f.endsWith(pattern) && f !== 'index.ts')
+            .map(f => f.replace(pattern, ''));
+    } catch {
+        return [];
+    }
+}
+
+export function toPascalCase(str) {
+    return str
+        .split(/[-_\s]+/)
+        .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+        .join('');
+}
+
+export function toCamelCase(str) {
+    const pascal = toPascalCase(str);
+    return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}

package/src/utils/fileUtils.js

@@ -0,0 +1,60 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+export async function writeIfNotExists(filepath, content) {
+    try {
+        await fs.access(filepath);
+        console.log(`⚠️  Skip existing: ${filepath}`);
+        return false;
+    } catch {
+        await fs.mkdir(path.dirname(filepath), { recursive: true });
+        await fs.writeFile(filepath, content, 'utf-8');
+        console.log(`✅ Created: ${filepath}`);
+        return true;
+    }
+}
+
+export async function updateIndexTs(dir, filePattern = '.ts', ignore = ['index.ts']) {
+    try {
+        const files = (await fs.readdir(dir)).filter(f =>
+            f.endsWith(filePattern) && !ignore.includes(f)
+        );
+        const content = files
+            .map(f => `export * from './${f.replace('.ts', '')}.js';`)
+            .join('\n') + '\n';
+        await fs.writeFile(path.join(dir, 'index.ts'), content, 'utf-8');
+    } catch (error) {
+        // Directory doesn't exist yet
+    }
+}
+
+export async function injectIntoFile(filepath, searchPattern, newContent, position = 'after') {
+    try {
+        let content = await fs.readFile(filepath, 'utf-8');
+        const index = content.indexOf(searchPattern);
+
+        if (index === -1) {
+            console.warn(`Pattern not found in ${filepath}`);
+            return false;
+        }
+
+        if (content.includes(newContent.trim())) {
+            console.log(`Content already exists in ${filepath}`);
+            return false;
+        }
+
+        if (position === 'after') {
+            const insertIndex = index + searchPattern.length;
+            content = content.slice(0, insertIndex) + '\n' + newContent + content.slice(insertIndex);
+        } else {
+            content = content.slice(0, index) + newContent + '\n' + content.slice(index);
+        }
+
+        await fs.writeFile(filepath, content, 'utf-8');
+        console.log(`✅ Updated: ${filepath}`);
+        return true;
+    } catch (error) {
+        console.error(`Failed to update ${filepath}:`, error.message);
+        return false;
+    }
+}

package/src/utils/loadConfig.js

@@ -8,8 +8,8 @@ export async function loadUserConfig() {
         return userConfig.default || {};
     } catch {
         return {
-            modules: ['admin', 'auth'],
-            datasourceAlias: ''
+            contexts: ['app'],
+            defaultContext: 'app'
         };
     }
 }

package/src/utils/providerUtils.js

@@ -0,0 +1,78 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { toPascalCase, toCamelCase } from './contextUtils.js';
+import { writeIfNotExists, updateIndexTs } from './fileUtils.js';
+
+export async function ensureProvider(context, layer, dependencies = {}) {
+    const providerName = `${toPascalCase(context)}${layer}Provider`;
+    const contextPath = path.join(process.cwd(), 'src/app/contexts', context);
+    const providerPath = path.join(contextPath, layer, 'Providers', `${layer}Provider.ts`);
+
+    try {
+        await fs.access(providerPath);
+        return { exists: true, name: providerName, path: providerPath };
+    } catch {
+        // Provider doesn't exist, create it
+        const content = generateProviderContent(context, layer, dependencies);
+        await writeIfNotExists(providerPath, content);
+        await updateIndexTs(path.dirname(providerPath));
+        await updateIndexTs(path.join(contextPath, layer));
+        return { exists: false, name: providerName, path: providerPath };
+    }
+}
+
+function generateProviderContent(context, layer, dependencies) {
+    const providerName = `${toPascalCase(context)}${layer}BoundaryProvider`;
+    const varName = `${layer}Provider`;
+
+    let imports = [`import { createBoundaryProvider } from '@azure-net/kit';`];
+    let deps = [];
+    let factories = [];
+
+    if (dependencies.datasource && layer === 'Infrastructure') {
+        imports.push(`import { ${dependencies.datasource} } from '../Datasources/index.js';`);
+        factories.push(`\t${dependencies.datasource}: () => new ${dependencies.datasource}()`);
+    }
+
+    if (dependencies.infrastructure && layer === 'Application') {
+        imports.push(`import { InfrastructureProvider } from '../../Infrastructure/index.js';`);
+        deps.push('InfrastructureProvider');
+    }
+
+    const dependsOnStr = deps.length > 0
+        ? `,\n\t{ dependsOn: { ${deps.join(', ')} } }`
+        : '';
+
+    return `${imports.join('\n')}
+
+export const ${varName} = createBoundaryProvider(
+\t'${providerName}',
+\t(${deps.length > 0 ? `{ ${deps.join(', ')} }` : ''}) => ({
+${factories.join(',\n')}
+\t})${dependsOnStr}
+);`;
+}
+
+export async function addToProvider(providerPath, serviceName, importPath) {
+    let content = await fs.readFile(providerPath, 'utf-8');
+
+    // Add import if not exists
+    const importStatement = `import { ${serviceName} } from '${importPath}';`;
+    if (!content.includes(importStatement)) {
+        const lastImportIndex = content.lastIndexOf('import ');
+        const endOfImportLine = content.indexOf('\n', lastImportIndex);
+        content = content.slice(0, endOfImportLine + 1) + importStatement + '\n' + content.slice(endOfImportLine + 1);
+    }
+
+    // Add factory method
+    const factoryLine = `\t\t${serviceName}: () => new ${serviceName}()`;
+    const returnIndex = content.indexOf('=> ({');
+    const endOfReturn = content.indexOf('\t})', returnIndex);
+
+    if (!content.includes(factoryLine)) {
+        const beforeEnd = content.lastIndexOf('\n', endOfReturn);
+        content = content.slice(0, beforeEnd) + ',\n' + factoryLine + content.slice(beforeEnd);
+    }
+
+    await fs.writeFile(providerPath, content, 'utf-8');
+}

package/.idea/azure-net-ecosystem-cli.iml

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="WEB_MODULE" version="4">
-  <component name="Go" enabled="true" />
-  <component name="NewModuleRootManager">
-    <content url="file://$MODULE_DIR$" />
-    <orderEntry type="inheritedJdk" />
-    <orderEntry type="sourceFolder" forTests="false" />
-  </component>
-</module>

package/.idea/modules.xml

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectModuleManager">
-    <modules>
-      <module fileurl="file://$PROJECT_DIR$/.idea/azure-net-ecosystem-cli.iml" filepath="$PROJECT_DIR$/.idea/azure-net-ecosystem-cli.iml" />
-    </modules>
-  </component>
-</project>

package/src/commands/generateCrud.js

@@ -1,135 +0,0 @@
-import prompts from 'prompts';
-import fs from 'fs/promises';
-import path from 'path';
-import ejs from 'ejs';
-import { loadUserConfig } from '../utils/loadConfig.js';
-
-const __dirname = path.dirname(new URL(import.meta.url).pathname);
-const CORE_DATASOURCES_PATH = path.join(process.cwd(), 'src/app/core/datasources');
-
-async function writeIfNotExists(filepath, content) {
-    try {
-        await fs.access(filepath);
-        console.log(`⚠️  Skip existing: ${filepath}`);
-    } catch {
-        await fs.mkdir(path.dirname(filepath), { recursive: true });
-        await fs.writeFile(filepath, content, 'utf-8');
-        console.log(`✅ Created: ${filepath}`);
-    }
-}
-
-async function updateIndexTs(dir, filePattern = '.ts', ignore = ['index.ts']) {
-    const files = (await fs.readdir(dir)).filter(f => f.endsWith(filePattern) && !ignore.includes(f));
-    const content = files.map(f => `export * from './${f.replace('.ts', '')}';`).join('\n') + '\n';
-    await fs.writeFile(path.join(dir, 'index.ts'), content, 'utf-8');
-}
-
-async function getAvailableDatasources() {
-    try {
-        const files = await fs.readdir(CORE_DATASOURCES_PATH);
-        return files
-            .filter(f => f.endsWith('.ts') && !f.startsWith('_'))
-            .map(f => f.replace('.ts', ''));
-    } catch {
-        return [];
-    }
-}
-
-export default async function generateCrud() {
-    const config = await loadUserConfig();
-    const datasources = await getAvailableDatasources();
-
-    const answers = await prompts([
-        config.modules?.length
-            ? {
-                type: 'select',
-                name: 'module',
-                message: 'Select target module:',
-                choices: [...config.modules, 'shared-context'].map(m => ({
-                    title: m === 'shared-context' ? 'shared-context (shared)' : m,
-                    value: m
-                }))
-            }
-            : null,
-        { type: 'text', name: 'className', message: 'Class name (PascalCase):' },
-        { type: 'text', name: 'endpoint', message: 'API endpoint:' },
-        {
-            type: 'select',
-            name: 'datasource',
-            message: 'Select datasource:',
-            choices: datasources.map(d => ({ title: d, value: d }))
-        }
-    ].filter(Boolean));
-
-    const rawName = answers.className.trim();
-    const capital = rawName[0].toUpperCase() + rawName.slice(1);
-    const lower = rawName[0].toLowerCase() + rawName.slice(1);
-    const endpoint = answers.endpoint.trim();
-    const datasource = answers.datasource.trim();
-    const selectedModule = answers.module;
-
-    const baseArch = path.join(process.cwd(), 'src/app/contexts');
-    const basePath = selectedModule ? path.join(baseArch, selectedModule) : path.join(baseArch, 'app-context');
-
-    const domainPath = path.join(basePath, 'Domain', capital);
-    const serviceDir = path.join(basePath, 'Application', 'Services');
-    const repoPath = path.join(basePath, 'Infra', 'Repo');
-
-    const aliasCurrent = selectedModule === 'shared-context'
-        ? '$shared-context'
-        : selectedModule
-            ? `$${selectedModule}`
-            : '$app-context';
-    const aliasShared = '$shared-context';
-
-    const templateData = {
-        camelCaseName: lower,
-        pascalCaseName: capital,
-        endpoint,
-        datasource,
-        aliasDomain: `${aliasCurrent}/Domain`,
-        aliasShared,
-        aliasApplication: `${aliasCurrent}/Application`,
-        aliasInfra: `${aliasCurrent}/Infra`,
-        aliasRepo: `${aliasCurrent}/Infra/Repo`
-    };
-
-    // === 1) Abstracts
-    const abstractsDir = path.join(domainPath, 'Abstracts');
-    for (const file of ['Class', 'ClassCreateRequest', 'ClassUpdateRequest', 'ClassCollectionQuery']) {
-        const tpl = await fs.readFile(path.join(__dirname, `../templates/domain/abstracts/${file}.ejs`), 'utf-8');
-        const result = ejs.render(tpl, templateData);
-        await writeIfNotExists(path.join(abstractsDir, `${capital}${file.replace('Class', '')}.ts`), result);
-    }
-    await updateIndexTs(abstractsDir);
-
-    // === 2) Request
-    const requestDir = path.join(domainPath, 'Request');
-    for (const file of ['ClassCreateRequest', 'ClassUpdateRequest']) {
-        const tpl = await fs.readFile(path.join(__dirname, `../templates/domain/request/${file}.ejs`), 'utf-8');
-        const result = ejs.render(tpl, templateData);
-        await writeIfNotExists(path.join(requestDir, `${capital}${file.replace('Class', '')}.ts`), result);
-    }
-    await updateIndexTs(requestDir);
-
-    // === 3) Services
-    const serviceTpl = await fs.readFile(path.join(__dirname, '../templates/domain/services/ClassService.ejs'), 'utf-8');
-    const serviceResult = ejs.render(serviceTpl, templateData);
-    await writeIfNotExists(path.join(serviceDir, `${capital}Service.ts`), serviceResult);
-    await updateIndexTs(serviceDir);
-
-    // === 4) Domain Index
-    await writeIfNotExists(
-        path.join(domainPath, 'index.ts'),
-        [`export * from './Abstracts';`, `export * from './Request';`].join('\n')
-    );
-    //await updateIndexTs(domainPath);
-
-    // === 5) Repo
-    const repoTpl = await fs.readFile(path.join(__dirname, '../templates/data/repo/ClassRepo.ejs'), 'utf-8');
-    const repoResult = ejs.render(repoTpl, templateData);
-    await writeIfNotExists(path.join(repoPath, `${capital}Repo.ts`), repoResult);
-    await updateIndexTs(repoPath);
-
-    console.log(`✅ CRUD for ${capital} generated in ${selectedModule || 'app-context'} structure`);
-}

package/src/commands/generateDatasource.js

@@ -1,44 +0,0 @@
-import prompts from 'prompts';
-import fs from 'fs/promises';
-import path from 'path';
-
-const CORE_DATASOURCES_PATH = path.join(process.cwd(), 'src/app/core/datasources');
-
-async function writeIfNotExists(filepath, content) {
-    try {
-        await fs.access(filepath);
-        console.log(`⚠️  Skip existing: ${filepath}`);
-    } catch {
-        await fs.mkdir(path.dirname(filepath), { recursive: true });
-        await fs.writeFile(filepath, content, 'utf-8');
-        console.log(`✅ Created: ${filepath}`);
-    }
-}
-
-async function updateIndexTs(dir) {
-    const files = (await fs.readdir(dir)).filter(f => f.endsWith('.ts') && f !== 'index.ts');
-    const content = files.map(f => `export * from './${f.replace('.ts', '')}';`).join('\n') + '\n';
-    await fs.writeFile(path.join(dir, 'index.ts'), content, 'utf-8');
-}
-
-export default async function generateDatasource() {
-    const { name } = await prompts({
-        type: 'text',
-        name: 'name',
-        message: 'Datasource class name (PascalCase, e.g., BackendApi):'
-    });
-
-    const capital = name.trim();
-    const filePath = path.join(CORE_DATASOURCES_PATH, `${capital}Datasource.ts`);
-
-    const content = `import { BaseHttpDatasource, HttpService } from '@azure-net/kit';
-
-export class ${capital}Datasource extends BaseHttpDatasource {
-	constructor() {
-		super({ http: new HttpService({ baseUrl: '' }) }); // TODO: fill generated class
-	}
-}`;
-
-    await writeIfNotExists(filePath, content);
-    await updateIndexTs(CORE_DATASOURCES_PATH);
-}

package/src/commands/generateRepo.js

@@ -1,69 +0,0 @@
-import prompts from 'prompts';
-import fs from 'fs/promises';
-import path from 'path';
-import { loadUserConfig } from '../utils/loadConfig.js';
-
-const CORE_DATASOURCES_PATH = path.join(process.cwd(), 'src/app/core/datasources');
-const CONTEXTS_PATH = path.join(process.cwd(), 'src/app/contexts');
-
-async function getAvailableDatasources() {
-    try {
-        const files = await fs.readdir(CORE_DATASOURCES_PATH);
-        return files.filter(f => f.endsWith('.ts') && !f.startsWith('_')).map(f => f.replace('.ts', ''));
-    } catch {
-        return [];
-    }
-}
-
-async function updateIndexTs(dir) {
-    const files = (await fs.readdir(dir)).filter(f => f.endsWith('.ts') && f !== 'index.ts');
-    const content = files.map(f => `export * from './${f.replace('.ts', '')}';`).join('\n') + '\n';
-    await fs.writeFile(path.join(dir, 'index.ts'), content, 'utf-8');
-}
-
-export default async function generateRepo() {
-    const config = await loadUserConfig();
-    const datasources = await getAvailableDatasources();
-
-    const answers = await prompts([
-        config.modules?.length ? {
-            type: 'select',
-            name: 'module',
-            message: 'Select target module:',
-            choices: [...config.modules, 'shared-context'].map(m => ({ title: m, value: m }))
-        } : null,
-        { type: 'text', name: 'name', message: 'Repository class name (PascalCase):' },
-        {
-            type: 'select',
-            name: 'datasource',
-            message: 'Select datasource:',
-            choices: datasources.map(d => ({ title: d, value: d }))
-        }
-    ].filter(Boolean));
-
-    const { name, module, datasource } = answers;
-    const capital = name.trim();
-
-    const basePath = path.join(CONTEXTS_PATH, module || 'app-context');
-    const repoDir = path.join(basePath, 'Infra', 'Repo');
-    const filePath = path.join(repoDir, `${capital}Repo.ts`);
-
-    const aliasRepo = module === 'shared-context'
-        ? '$shared-context/Infra/Repo'
-        : `$${module}/Infra/Repo`;
-
-    const content = `import { ${datasource} } from '$core/datasources';
-
-export class ${capital}Repo {
-	private source = new ${datasource}();
-
-	constructor() {
-		// TODO: fill generated class
-	}
-}`;
-
-    await fs.mkdir(repoDir, { recursive: true });
-    await fs.writeFile(filePath, content);
-    await updateIndexTs(repoDir);
-    console.log(`✅ Repo created at ${filePath}`);
-}

package/src/commands/generateService.js

@@ -1,77 +0,0 @@
-import prompts from 'prompts';
-import fs from 'fs/promises';
-import path from 'path';
-import { loadUserConfig } from '../utils/loadConfig.js';
-
-const CONTEXTS_PATH = path.join(process.cwd(), 'src/app/contexts');
-
-async function getAvailableRepos(module) {
-    const repoPath = path.join(CONTEXTS_PATH, module, 'Infra', 'Repo');
-    try {
-        const files = await fs.readdir(repoPath);
-        return ['Without repo', ...files.filter(f => f.endsWith('.ts') && f !== 'index.ts').map(f => f.replace('.ts', ''))];
-    } catch {
-        return ['Without repo'];
-    }
-}
-
-async function updateIndexTs(dir) {
-    const files = (await fs.readdir(dir)).filter(f => f.endsWith('.ts') && f !== 'index.ts');
-    const content = files.map(f => `export * from './${f.replace('.ts', '')}';`).join('\n') + '\n';
-    await fs.writeFile(path.join(dir, 'index.ts'), content, 'utf-8');
-}
-
-export default async function generateService() {
-    const config = await loadUserConfig();
-
-    const { module } = await prompts({
-        type: 'select',
-        name: 'module',
-        message: 'Select target module:',
-        choices: [...config.modules, 'shared-context'].map(m => ({ title: m, value: m }))
-    });
-
-    const { name } = await prompts({
-        type: 'text',
-        name: 'name',
-        message: 'Service class name (PascalCase):'
-    });
-
-    const repos = await getAvailableRepos(module);
-    const { repo } = await prompts({
-        type: 'select',
-        name: 'repo',
-        message: 'Select repository:',
-        choices: repos.map(r => ({ title: r, value: r }))
-    });
-
-    const capital = name.trim();
-    const basePath = path.join(CONTEXTS_PATH, module || 'app-context');
-    const serviceDir = path.join(basePath, 'Application', 'Services');
-    const filePath = path.join(serviceDir, `${capital}Service.ts`);
-
-    const aliasRepo = module === 'shared-context'
-        ? '$shared-context/Infra/Repo'
-        : `$${module}/Infra/Repo`;
-
-    const content = repo === 'Without repo'
-        ? `export class ${capital}Service {
-	constructor() {
-		// TODO: fill generated class
-	}
-}`
-        : `import { ${repo} } from '${aliasRepo}';
-
-export class ${capital}Service {
-	private repo = new ${repo}();
-
-	constructor() {
-		// TODO: fill generated class
-	}
-}`;
-
-    await fs.mkdir(serviceDir, { recursive: true });
-    await fs.writeFile(filePath, content);
-    await updateIndexTs(serviceDir);
-    console.log(`✅ Service created at ${filePath}`);
-}

package/src/commands/generateStructure.js

@@ -1,65 +0,0 @@
-import fs from 'fs/promises';
-import path from 'path';
-import { loadUserConfig } from '../utils/loadConfig.js';
-
-const BASE_STRUCTURE = ['Domain', 'Infra', 'Application', 'Presentation'];
-const APP_ROOT = path.join(process.cwd(), 'src', 'app');
-const CONTEXTS_PATH = path.join(APP_ROOT, 'contexts');
-const CORE_PATH = path.join(APP_ROOT, 'core');
-
-async function createDirIfNotExists(dirPath) {
-    try {
-        await fs.mkdir(dirPath, { recursive: true });
-        console.log(`📁 Created: ${dirPath}`);
-    } catch (e) {
-        console.error(`❌ Failed to create ${dirPath}:`, e.message);
-    }
-}
-
-async function createBaseStructure(root) {
-    for (const section of BASE_STRUCTURE) {
-        const sectionPath = path.join(root, section);
-        await createDirIfNotExists(sectionPath);
-
-        if (section === 'Infra') {
-            await createDirIfNotExists(path.join(sectionPath, 'Repo'));
-        }
-        if (section === 'Application') {
-            await createDirIfNotExists(path.join(sectionPath, 'Services'));
-            await createDirIfNotExists(path.join(sectionPath, 'Orchestrators'));
-        }
-    }
-}
-
-export default async function initStructure() {
-    const config = await loadUserConfig();
-    const modules = config.modules;
-    const hasModules = Array.isArray(modules) && modules.length > 0;
-
-    console.log('📦 Generating architecture in: /contexts');
-
-    // всегда shared-context
-    const sharedKernelPath = path.join(CONTEXTS_PATH, 'shared-context');
-    await createBaseStructure(sharedKernelPath);
-
-    if (hasModules) {
-        // по модулям
-        console.log('🔧 Creating module contexts...');
-        for (const mod of modules) {
-            const modPath = path.join(CONTEXTS_PATH, mod);
-            await createBaseStructure(modPath);
-        }
-    } else {
-        // fallback-контекст
-        console.log('🧱 No modules found — using default "app-context"...');
-        const fallbackPath = path.join(CONTEXTS_PATH, 'app-context');
-        await createBaseStructure(fallbackPath);
-    }
-
-    // Доп. слои вне contexts
-    await createDirIfNotExists(CORE_PATH);
-    await createDirIfNotExists(path.join(CORE_PATH, 'datasources'));
-    await createDirIfNotExists(path.join(APP_ROOT, 'ui'));
-
-    console.log('✅ Structure initialization complete!');
-}