@azure-net/cli 1.3.11 → 1.4.0

package/bin/azure-net.js

@@ -1,7 +1,9 @@
 #!/usr/bin/env node
 
 import { Command } from 'commander';
-import generateRepository from '../src/commands/generateCrudRepo.js';
+import generateDatasource from '../src/commands/generateDatasource.js';
+import generateRepo from '../src/commands/generateRepo.js';
+import generateService from '../src/commands/generateService.js';
 import generateCrud from '../src/commands/generateCrud.js';
 import initLint from '../src/commands/initLint.js';
 import initStructure from '../src/commands/generateStructure.js';
@@ -14,9 +16,20 @@ program
     .description('Universal code generator')
     .version('1.0.0');
 
-program.command('generate:crud-repo')
-    .description('Generate a CRUD repository')
-    .action(generateRepository);
+program
+    .command('make:datasource')
+    .description('Generate datasource')
+    .action(generateDatasource);
+
+program
+    .command('make:repo')
+    .description('Generate repo')
+    .action(generateRepo);
+
+program
+    .command('make:service')
+    .description('Generate service')
+    .action(generateService);
 
 program
     .command('make:crud')

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@azure-net/cli",
-  "version": "1.3.11",
+  "version": "1.4.0",
   "type": "module",
   "bin": {
     "azure-net": "bin/azure-net.js"
   },
   "dependencies": {
-    "@azure-net/kit": "^0.1.3",
+    "@azure-net/kit": "^0.3.3",
     "commander": "^11",
     "ejs": "^3",
     "prompts": "^2"

package/src/commands/generateCrud.js

@@ -96,7 +96,7 @@ export default async function generateCrud() {
 
     // === 1) Abstracts
     const abstractsDir = path.join(domainPath, 'Abstracts');
-    for (const file of ['Class', 'ClassCreateRequest', 'ClassUpdateRequest']) {
+    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);

package/src/commands/generateDatasource.js

@@ -0,0 +1,38 @@
+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}`);
+    }
+}
+
+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 {
+    // TODO: fill generated class
+	constructor() {
+		super({ http: new HttpService({ baseUrl: '' }) });
+	}
+}`;
+
+    await writeIfNotExists(filePath, content);
+}

package/src/commands/generateRepo.js

@@ -0,0 +1,63 @@
+// === generateRepo.js ===
+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 [];
+    }
+}
+
+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);
+    console.log(`✅ Repo created at ${filePath}`);
+}

package/src/commands/generateService.js

@@ -0,0 +1,70 @@
+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'];
+    }
+}
+
+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);
+    console.log(`✅ Service created at ${filePath}`);
+}

package/src/templates/data/datasource/ClassDatasource.ejs

@@ -0,0 +1,7 @@
+import { BaseHttpDatasource, HttpService } from '@azure-net/kit';
+
+export class <%= name %>Datasource extends BaseHttpDatasource {
+	constructor() {
+		super({ http: new HttpService({ baseUrl: '' }) });
+	}
+}

package/src/templates/data/repo/ClassRepo.ejs

@@ -3,15 +3,16 @@ import type {
     I<%= pascalCaseName %>Collection,
     I<%= pascalCaseName %>Resource,
     I<%= pascalCaseName %>CreateRequest,
-    I<%= pascalCaseName %>UpdateRequest
+    I<%= pascalCaseName %>UpdateRequest,
+    I<%= pascalCaseName %>CollectionQuery,
 } from '<%= aliasDomain %>/<%= pascalCaseName %>';
 
 export class <%= pascalCaseName %>Repo {
     private endpoint = '<%= endpoint %>';
     constructor(private source = new <%= datasource %>()) {}
 
-    public async collection() {
-        return await this.source.createRequest<I<%= pascalCaseName %>Collection>(({ http }) => http.get(this.endpoint));
+    public async collection(queryParams?: I<%= pascalCaseName %>CollectionQuery) {
+        return await this.source.createRequest<I<%= pascalCaseName %>Collection>(({ http, query }) => http.get(`${this.endpoint}${query.build(queryParams)}`));
     }
 
     public async resource(id: number) {

package/src/templates/domain/abstracts/ClassCollectionQuery.ejs

@@ -0,0 +1,3 @@
+export interface I<%= pascalCaseName %>CollectionQuery {
+    [key: string]: unknown;
+}

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

@@ -1,14 +1,14 @@
 import { BaseService } from '@azure-net/kit';
 import { <%= pascalCaseName %>Repo } from '<%= aliasRepo %>';
-import type { <%= pascalCaseName %>CreateRequest, <%= pascalCaseName %>UpdateRequest } from '<%= aliasDomain %>/<%= pascalCaseName %>';
+import type { <%= pascalCaseName %>CreateRequest, <%= pascalCaseName %>UpdateRequest, I<%= pascalCaseName %>CollectionQuery } from '<%= aliasDomain %>/<%= pascalCaseName %>';
 
 export class <%= pascalCaseName %>Service extends BaseService {
     constructor(private <%= camelCaseName %>Repo = new <%= pascalCaseName %>Repo()) {
         super();
     }
 
-    async collection() {
-        return await this.transformResponse(this.<%= camelCaseName %>Repo.collection());
+    async collection(queryParams?: I<%= pascalCaseName %>CollectionQuery) {
+        return await this.transformResponse(this.<%= camelCaseName %>Repo.collection(queryParams));
     }
 
     async resource(id: number) {

package/src/commands/generateCrudRepo.js

@@ -1,27 +0,0 @@
-import prompts from 'prompts';
-import ejs from 'ejs';
-import fs from 'fs/promises';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { loadUserConfig } from "../utils/loadConfig.js";
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-export default async function generateCrudRepository() {
-    const config = await loadUserConfig();
-    const answers = await prompts([
-        { type: 'text', name: 'className', message: 'Class name:' },
-        { type: 'text', name: 'endpoint', message: 'API endpoint:' },
-    ]);
-
-    const templatePath = path.join(__dirname, '../templates/generateCrudRepo.ejs');
-    const template = await fs.readFile(templatePath, 'utf-8');
-    const result = ejs.render(template, answers);
-
-    const outputDir = config.output.repository;
-    const outFile = path.join(process.cwd(), outputDir, `${answers.className}Repo.ts`);
-    await fs.mkdir(path.dirname(outFile), { recursive: true });
-    await fs.writeFile(outFile, result, 'utf-8');
-
-    console.log(`✅ Created: ${outFile}`);
-}

package/src/templates/generateCrudRepo.ejs

@@ -1,26 +0,0 @@
-import { BaseDatasource } from '@azure-net/kit';
-
-export class <%= className %>Repo {
-  private endpoint = '<%= endpoint %>';
-  constructor(private source: BaseDatasource) {}
-
-  public async collection() {
-    return await this.source.createRequest<unknown[]>(({ http }) => http.get(this.endpoint));
-  }
-
-  public async resource(id: number) {
-    return await this.source.createRequest<unknown>(({ http }) => http.get(`${this.endpoint}/${id}`));
-  }
-
-  public async create(data: unknown) {
-    return await this.source.createRequest<unknown>(({ http }) => http.post(this.endpoint, { json: data }));
-  }
-
-  public async update(id: number, data: unknown) {
-    return await this.source.createRequest<unknown>(({ http }) => http.put(`${this.endpoint}/${id}`, { json: data }));
-  }
-
-  public async delete(id: number) {
-    return await this.source.createRequest<unknown>(({ http }) => http.delete(`${this.endpoint}/${id}`));
-  }
-}