@azure-net/cli 1.3.0 → 1.3.2

package/bin/azure-net.js

@@ -5,6 +5,7 @@ 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();
 
@@ -32,4 +33,9 @@ program
     .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.3.0",
+  "version": "1.3.2",
   "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/initAliases.js

@@ -0,0 +1,98 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { loadUserConfig } from '../utils/loadConfig.js';
+import { execSync } from 'child_process';
+
+/** Файл конфигурации */
+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');
+}
+
+function insertAliasBlock(content, aliasBlock) {
+    const kitRegex = /kit:\s*{([\s\S]*?)}/m;
+    const match = content.match(kitRegex);
+
+    if (!match) {
+        throw new Error('❌ Cannot find `kit: {}` block in svelte.config.js');
+    }
+
+    const existingKit = match[0];
+    const newKit = existingKit.includes('alias:')
+        ? existingKit.replace(/alias:\s*{([\s\S]*?)}/m, aliasBlock)
+        : existingKit.replace(/{/, `{\n\t\t${aliasBlock},`);
+
+    return content.replace(kitRegex, newKit);
+}
+
+async function updateAliases() {
+    const config = await loadUserConfig();
+    const newAliases = generateAliases(config);
+
+    let content = await fs.readFile(svelteConfigPath, 'utf-8');
+
+    // если alias уже есть
+    const aliasRegex = /alias:\s*{([\s\S]*?)}/m;
+    const aliasMatch = content.match(aliasRegex);
+
+    let updatedAliases = {};
+
+    if (aliasMatch) {
+        const existingAliases = parseObjectLiteral(aliasMatch[1]);
+        updatedAliases = { ...existingAliases, ...newAliases };
+    } else {
+        updatedAliases = { ...newAliases };
+    }
+
+    const newAliasBlock = `alias: {\n${serializeObjectLiteral(updatedAliases)}\n\t\t}`;
+
+    content = aliasMatch
+        ? content.replace(aliasRegex, newAliasBlock)
+        : insertAliasBlock(content, newAliasBlock);
+
+    await fs.writeFile(svelteConfigPath, content, 'utf-8');
+    console.log('✅ Aliases updated in svelte.config.js');
+
+    // Run formatter
+    try {
+        execSync('npm run format', { stdio: 'inherit' });
+        console.log('✅ Ran npm run format');
+    } catch {
+        console.warn('⚠️ Failed to run format. Make sure you have a format script in package.json');
+    }
+}
+
+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,6 @@ export async function loadUserConfig() {
         return userConfig.default || {};
     } catch {
         return {
-            output: {
-                domain: 'src/app/architecture/domain',
-                repo: 'src/app/architecture/infra/repo'
-            },
             modules: ['admin', 'auth']
         };
     }