@azure-net/cli 1.2.10 → 1.3.1

package/bin/azure-net.js

@@ -4,6 +4,8 @@ import { Command } from 'commander';
 import generateRepository from '../src/commands/generateCrudRepo.js';
 import generateCrud from '../src/commands/generateCrud.js';
 import initLint from '../src/commands/initLint.js';
+import initStructure from '../src/commands/generateStructure.js';
+import initAliases from '../src/commands/initAliases.js';
 
 const program = new Command();
 
@@ -26,4 +28,14 @@ program
     .description('Setup linting and commit tools')
     .action(initLint)
 
+program
+    .command('init:structure')
+    .description('Generate base folder structure based on config')
+    .action(initStructure);
+
+program
+    .command('init:aliases')
+    .description('Generate alias mappings for modules or default architecture')
+    .action(initAliases);
+
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azure-net/cli",
-  "version": "1.2.10",
+  "version": "1.3.1",
   "type": "module",
   "bin": {
     "azure-net": "bin/azure-net.js"

package/src/commands/generateCrud.js

@@ -17,98 +17,83 @@ async function writeIfNotExists(filepath, content) {
     }
 }
 
+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');
+}
+
 export default async function generateCrud() {
     const config = await loadUserConfig();
 
     const answers = await prompts([
+        config.modules?.length
+            ? {
+                type: 'select',
+                name: 'module',
+                message: 'Select target module:',
+                choices: config.modules.map(m => ({ title: m, value: m }))
+            }
+            : null,
         { type: 'text', name: 'className', message: 'Class name (PascalCase):' },
         { type: 'text', name: 'endpoint', message: 'API endpoint:' },
         { type: 'text', name: 'datasource', message: 'Datasource name:', initial: 'BaseDatasource' }
-    ]);
+    ].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;
 
-    // === Domain lowercase folder ===
-    const domainPath = path.join(process.cwd(), config.output.domain, lower);
-    const repoPath = path.join(process.cwd(), config.output.repo);
+    const baseArch = path.join(process.cwd(), 'src/app/context');
+    const basePath = selectedModule ? path.join(baseArch, selectedModule) : baseArch;
 
-    // 1) Abstracts
+    const domainPath = path.join(basePath, 'domain', lower);
+    const serviceDir = path.join(basePath, 'application', 'services');
+    const repoPath = path.join(basePath, 'infra', 'repo');
+
+    // === 1) Abstracts
     const abstractsDir = path.join(domainPath, 'abstracts');
     for (const file of ['Class', 'ClassCreateRequest', 'ClassUpdateRequest']) {
         const tpl = await fs.readFile(path.join(__dirname, `../templates/domain/abstracts/${file}.ejs`), 'utf-8');
         const result = ejs.render(tpl, { className: capital });
         await writeIfNotExists(path.join(abstractsDir, `${capital}${file.replace('Class', '')}.ts`), result);
     }
-    await writeIfNotExists(
-        path.join(abstractsDir, `index.ts`),
-        [
-            `export * from './${capital}';`,
-            `export * from './${capital}CreateRequest';`,
-            `export * from './${capital}UpdateRequest';`
-        ].join('\n')
-    );
+    await updateIndexTs(abstractsDir);
 
-    // 2) Request
+    // === 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, { className: capital });
         await writeIfNotExists(path.join(requestDir, `${capital}${file.replace('Class', '')}.ts`), result);
     }
-    await writeIfNotExists(
-        path.join(requestDir, `index.ts`),
-        [
-            `export * from './${capital}CreateRequest';`,
-            `export * from './${capital}UpdateRequest';`
-        ].join('\n')
-    );
+    await updateIndexTs(requestDir);
 
-    // === 3) Services ===
-    const serviceDir = path.join(domainPath, 'services');
+    // === 3) Services
     const serviceTpl = await fs.readFile(path.join(__dirname, '../templates/domain/services/ClassService.ejs'), 'utf-8');
-    const serviceResult = ejs.render(serviceTpl, {
-        className: capital,
-        domainName: lower
-    });
+    const serviceResult = ejs.render(serviceTpl, { className: capital, domainName: lower });
     await writeIfNotExists(path.join(serviceDir, `${capital}Service.ts`), serviceResult);
+    await updateIndexTs(serviceDir);
 
-    // ✅ Services index.ts
-    await writeIfNotExists(
-        path.join(serviceDir, 'index.ts'),
-        `export * from './${capital}Service';\n`
-    );
-
-    // === 4) Domain Index ===
+    // === 4) Domain Index
     await writeIfNotExists(
         path.join(domainPath, 'index.ts'),
-        [
-            `export * from './abstracts';`,
-            `export * from './request';`,
-            `export * from './services';`
-        ].join('\n')
+        [`export * from './abstracts';`, `export * from './request';`].join('\n') + '\n'
     );
 
-    // === 5) Generate Repo ===
+    // === 5) Repo
     const repoTpl = await fs.readFile(path.join(__dirname, '../templates/data/repo/ClassRepo.ejs'), 'utf-8');
     const repoResult = ejs.render(repoTpl, {
         className: capital,
         endpoint,
         domainName: lower,
-        datasource // <-- 👈 Передаём!
+        datasource
     });
     await writeIfNotExists(path.join(repoPath, `${capital}Repo.ts`), repoResult);
+    await updateIndexTs(repoPath);
 
-    // === 6) Repo Index ===
-    const files = await fs.readdir(repoPath);
-    const exports = files
-        .filter(f => f.endsWith('Repo.ts') && f !== 'index.ts')
-        .map(f => `export * from './${f.replace('.ts', '')}';`)
-        .join('\n');
-    await fs.writeFile(path.join(repoPath, 'index.ts'), exports, 'utf-8');
-
-    console.log(`✅ CRUD for ${capital} generated successfully!`);
+    console.log(`✅ CRUD for ${capital} generated in ${selectedModule || 'monolith'} structure`);
 }

package/src/commands/generateStructure.js

@@ -0,0 +1,56 @@
+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 ARCHITECTURE_PATH = path.join(APP_ROOT, 'architecture');
+
+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;
+
+    if (!modules || modules.length === 0) {
+        // Без модулей
+        console.log('📦 Generating monolithic architecture...');
+        await createBaseStructure(ARCHITECTURE_PATH);
+    } else {
+        // С модулями
+        console.log('📦 Generating modular architecture...');
+        for (const mod of modules) {
+            const modRoot = path.join(ARCHITECTURE_PATH, mod);
+            await createBaseStructure(modRoot);
+        }
+    }
+
+    // shared и ui вне modules
+    await createDirIfNotExists(path.join(APP_ROOT, 'shared'));
+    await createDirIfNotExists(path.join(APP_ROOT, 'ui'));
+
+    console.log('✅ Structure initialization complete!');
+}

package/src/commands/initAliases.js

@@ -0,0 +1,72 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { loadUserConfig } from '../utils/loadConfig.js';
+
+/** Файл конфигурации */
+const svelteConfigPath = path.resolve('svelte.config.js');
+
+function generateAliases(config) {
+    const hasModules = Array.isArray(config.modules) && config.modules.length > 0;
+
+    if (hasModules) {
+        return Object.fromEntries(
+            config.modules.map(m => [`$${m}`, `./src/app/context/${m}`])
+        );
+    }
+
+    return {
+        '$domain': './src/app/context/domain',
+        '$infra': './src/app/context/infra',
+        '$application': './src/app/context/application',
+        '$presentation': './src/app/context/presentation',
+        '$services': './src/app/context/application/services'
+    };
+}
+
+function parseObjectLiteral(text) {
+    const obj = {};
+    const entries = text.split(/,(?![^{]*})/).filter(Boolean);
+    for (const entry of entries) {
+        const [key, value] = entry.split(':').map(s => s.trim());
+        if (key && value) {
+            obj[key.replace(/^['"]|['"]$/g, '')] = value.replace(/^['"]|['"]$/g, '');
+        }
+    }
+    return obj;
+}
+
+function serializeObjectLiteral(obj) {
+    return Object.entries(obj)
+        .map(([key, value]) => `\t\t\t'${key}': '${value}'`)
+        .join(',\n');
+}
+
+async function updateAliases() {
+    const config = await loadUserConfig();
+    const newAliases = generateAliases(config);
+
+    let content = await fs.readFile(svelteConfigPath, 'utf-8');
+
+    const aliasRegex = /alias:\s*{([\s\S]*?)}/m;
+    const match = content.match(aliasRegex);
+
+    if (!match) {
+        console.error('❌ No `alias` field found in svelte.config.js');
+        process.exit(1);
+    }
+
+    // существующие алиасы
+    const existingAliases = parseObjectLiteral(match[1]);
+
+    // объединение
+    const updatedAliases = { ...existingAliases, ...newAliases };
+
+    // замена в контенте
+    const newAliasBlock = `alias: {\n${serializeObjectLiteral(updatedAliases)}\n\t\t}`;
+    content = content.replace(aliasRegex, newAliasBlock);
+
+    await fs.writeFile(svelteConfigPath, content, 'utf-8');
+    console.log('✅ Aliases updated in svelte.config.js');
+}
+
+export default updateAliases;

package/src/templates/domain/services/ClassService.ejs

@@ -1,6 +1,6 @@
 import { BaseService } from '@azure-net/kit';
 import { <%= className %>Repo } from '$data/repo';
-import type { <%= className %>CreateRequest, <%= className %>UpdateRequest } from '$domain/<%= domainName %>/request';
+import type { <%= className %>CreateRequest, <%= className %>UpdateRequest } from '$domain/<%= domainName %>';
 
 export class <%= className %>Service extends BaseService {
     constructor(private <%= domainName %>Repo = new <%= className %>Repo()) {

package/src/utils/loadConfig.js

@@ -8,10 +8,7 @@ export async function loadUserConfig() {
         return userConfig.default || {};
     } catch {
         return {
-            output: {
-                domain: 'src/app/layers/domain',
-                repo: 'src/app/layers/data/repo'
-            }
+            modules: ['admin', 'auth']
         };
     }
 }