@azure-net/cli 1.4.0 → 1.4.2

package/bin/azure-net.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 
 import { Command } from 'commander';
+import generateRequest from '../src/commands/generateRequest.js';
 import generateDatasource from '../src/commands/generateDatasource.js';
 import generateRepo from '../src/commands/generateRepo.js';
 import generateService from '../src/commands/generateService.js';
@@ -26,6 +27,11 @@ program
     .description('Generate repo')
     .action(generateRepo);
 
+program
+    .command('make:request')
+    .description('Generate request')
+    .action(generateRequest);
+
 program
     .command('make:service')
     .description('Generate service')

package/package.json

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

package/src/commands/generateDatasource.js

@@ -15,6 +15,12 @@ async function writeIfNotExists(filepath, content) {
     }
 }
 
+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',
@@ -28,11 +34,11 @@ export default async function generateDatasource() {
     const content = `import { BaseHttpDatasource, HttpService } from '@azure-net/kit';
 
 export class ${capital}Datasource extends BaseHttpDatasource {
-    // TODO: fill generated class
 	constructor() {
-		super({ http: new HttpService({ baseUrl: '' }) });
+		super({ http: new HttpService({ baseUrl: '' }) }); // TODO: fill generated class
 	}
 }`;
 
     await writeIfNotExists(filePath, content);
+    await updateIndexTs(CORE_DATASOURCES_PATH);
 }

package/src/commands/generateRepo.js

@@ -1,4 +1,3 @@
-// === generateRepo.js ===
 import prompts from 'prompts';
 import fs from 'fs/promises';
 import path from 'path';
@@ -16,6 +15,12 @@ async function getAvailableDatasources() {
     }
 }
 
+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();
@@ -59,5 +64,6 @@ export class ${capital}Repo {
 
     await fs.mkdir(repoDir, { recursive: true });
     await fs.writeFile(filePath, content);
+    await updateIndexTs(repoDir);
     console.log(`✅ Repo created at ${filePath}`);
-}
+}

package/src/commands/generateRequest.js

@@ -0,0 +1,95 @@
+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 CONTEXTS_PATH = path.join(process.cwd(), 'src/app/contexts');
+
+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');
+}
+
+async function getAvailableSubfolders(baseDomainPath) {
+    try {
+        const entries = await fs.readdir(baseDomainPath, { withFileTypes: true });
+        return entries.filter(e => e.isDirectory()).map(e => e.name);
+    } catch {
+        return [];
+    }
+}
+
+export default async function generateRequest() {
+    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 { className } = await prompts({
+        type: 'text',
+        name: 'className',
+        message: 'Request class name (PascalCase, without `Request` suffix):'
+    });
+
+    const pascalCaseName = className.trim();
+    const aliasModule = module === 'shared-context' ? '$shared-context' : `$${module}`;
+
+    const domainPath = path.join(CONTEXTS_PATH, module, 'Domain');
+    const availableSub = await getAvailableSubfolders(domainPath);
+
+    const { submodule } = await prompts({
+        type: 'autocomplete',
+        name: 'submodule',
+        message: 'Select or enter submodule:',
+        choices: [...availableSub.map(s => ({ title: s, value: s })), { title: '[Create new submodule]', value: '__custom' }]
+    });
+
+    let actualSub = submodule;
+    if (submodule === '__custom') {
+        const { newSub } = await prompts({
+            type: 'text',
+            name: 'newSub',
+            message: 'Enter new submodule name:'
+        });
+        actualSub = newSub.trim();
+    }
+
+    const basePath = path.join(domainPath, actualSub);
+    const abstractsDir = path.join(basePath, 'Abstracts');
+    const requestDir = path.join(basePath, 'Request');
+
+    const templateData = { pascalCaseName };
+
+    const abstractTpl = `export interface I${pascalCaseName}Request {
+    // TODO: define fields
+    [key: string]: unknown;
+    }`;
+    await writeIfNotExists(path.join(abstractsDir, `I${pascalCaseName}Request.ts`), abstractTpl);
+    await updateIndexTs(abstractsDir);
+
+    const requestTplPath = path.join(__dirname, '../templates/domain/request/ClassRequest.ejs');
+    const tpl = await fs.readFile(requestTplPath, 'utf-8');
+    const result = ejs.render(tpl, templateData);
+    await writeIfNotExists(path.join(requestDir, `${pascalCaseName}Request.ts`), result);
+    await updateIndexTs(requestDir);
+
+    console.log(`✅ Request generated in ${path.join(module, actualSub)}`);
+}

package/src/commands/generateService.js

@@ -15,6 +15,12 @@ async function getAvailableRepos(module) {
     }
 }
 
+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();
 
@@ -66,5 +72,6 @@ export class ${capital}Service {
 
     await fs.mkdir(serviceDir, { recursive: true });
     await fs.writeFile(filePath, content);
+    await updateIndexTs(serviceDir);
     console.log(`✅ Service created at ${filePath}`);
 }

package/src/templates/domain/request/ClassRequest.ejs

@@ -0,0 +1,8 @@
+import { BaseRequest } from '@azure-net/kit';
+import type { I<%= pascalCaseName %>Request } from '../Abstracts';
+
+export class <%= pascalCaseName %>Request extends BaseRequest<I<%= pascalCaseName %>Request> {
+    override rules() {
+        return {};
+    }
+}