@azure-net/cli 2.0.2 → 2.0.4

package/package.json

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

package/src/commands/generate/generateCrud.js

@@ -13,7 +13,7 @@ const entityTemplate = `export interface I{{name}} {
 \tupdated_at: string;
 }`;
 
-const portsIndexTemplate = `import type { I{{name}} } from '../../Entities/{{name}}';
+const portsIndexTemplate = `import type { I{{name}} } from '\${{context}}/Domain/Entities/{{name}}';
 
 export interface I{{name}}Collection {
 \tdata: I{{name}}[];
@@ -28,10 +28,12 @@ export interface I{{name}}CollectionQuery {
 
 export interface I{{name}}CreateRequest {
 \t// Add request fields here
+\t[key: string]: unknown;
 }
 
 export interface I{{name}}UpdateRequest {
-\t// Add request fields here  
+\t// Add request fields here
+\t[key: string]: unknown;
 }`;
 
 const repositoryTemplate = `import { {{datasource}} } from '{{datasourceImport}}';
@@ -80,7 +82,7 @@ export class {{name}}Repository {
 }`;
 
 const serviceTemplate = `import { ClassMirror } from '@azure-net/kit';
-import { {{name}}Repository } from '../../Infrastructure/Http/Repositories';
+import { {{name}}Repository } from '\${{context}}/Infrastructure/Http/Repositories';
 
 export class {{name}}Service extends ClassMirror<{{name}}Repository> {
 \tconstructor(private {{camelName}}Repository: {{name}}Repository) {
@@ -112,7 +114,8 @@ export const Update{{name}}Schema = {{schemaFactory}}<I{{name}}UpdateRequest>()
 \t}))
 \t.create();`;
 
-const presenterTemplate = `import { {{presenterFactory}} } from '{{presenterImport}}';
+// Presenter template with core factory (includes async helpers)
+const presenterWithCoreTemplate = `import { {{presenterFactory}} } from '\$core/Presenter';
 import { ApplicationProvider } from '\${{context}}/Application';
 import { Create{{name}}Schema, Update{{name}}Schema } from './Schema';
 import type { 
@@ -142,6 +145,37 @@ export const {{name}}Presenter = {{presenterFactory}}('{{name}}Presenter', ({ cr
 \treturn { collection, resource, create, update, remove };
 });`;
 
+// Presenter template without async helpers
+const presenterWithoutCoreTemplate = `import { createPresenter } from '@azure-net/kit';
+import { ApplicationProvider } from '\${{context}}/Application';
+import { Create{{name}}Schema, Update{{name}}Schema } from './Schema';
+import type { 
+\tI{{name}}CollectionQuery,
+\tI{{name}}CreateRequest,
+\tI{{name}}UpdateRequest
+} from '\${{context}}/Domain/Ports/{{name}}';
+
+export const {{name}}Presenter = createPresenter('{{name}}Presenter', () => {
+\tconst { {{name}}Service } = ApplicationProvider();
+\t
+\tconst collection = async (query?: I{{name}}CollectionQuery) => 
+\t\tawait {{name}}Service.collection(query);
+\t
+\tconst resource = async (id: number) => 
+\t\tawait {{name}}Service.resource(id);
+\t
+\tconst create = async (request: I{{name}}CreateRequest) =>
+\t\tawait {{name}}Service.create(Create{{name}}Schema.from(request).json());
+\t
+\tconst update = async (id: number, request: I{{name}}UpdateRequest) =>
+\t\tawait {{name}}Service.update(id, Update{{name}}Schema.from(request).json());
+\t
+\tconst remove = async (id: number) => 
+\t\tawait {{name}}Service.remove(id);
+\t
+\treturn { collection, resource, create, update, remove };
+});`;
+
 export default async function generateCrud() {
     const context = await selectContext('Select context for CRUD module:');
 
@@ -219,14 +253,14 @@ export default async function generateCrud() {
     console.log('\n🚀 Generating CRUD module...\n');
 
     // 1. Create Entity
-    const entityPath = path.join(contextPath, 'Domain', 'Entities', pascalName);
+    const entityPath = path.join(contextPath, 'Domain/Entities', pascalName);
     await writeIfNotExists(
         path.join(entityPath, 'index.ts'),
         entityTemplate.replace(/{{name}}/g, pascalName)
     );
 
     // 2. Create Ports
-    const portsPath = path.join(contextPath, 'Domain', 'Ports', pascalName);
+    const portsPath = path.join(contextPath, 'Domain/Ports', pascalName);
     await writeIfNotExists(
         path.join(portsPath, 'index.ts'),
         portsIndexTemplate
@@ -235,7 +269,7 @@ export default async function generateCrud() {
     );
 
     // 3. Create Repository
-    const repoPath = path.join(contextPath, 'Infrastructure', 'Http', 'Repositories');
+    const repoPath = path.join(contextPath, 'Infrastructure/Http/Repositories');
     const datasourceImport = datasource.from === 'core'
         ? '$core/Datasource'
         : `\$${context}/Infrastructure/Http/Datasource`;
@@ -253,12 +287,13 @@ export default async function generateCrud() {
     await updateIndexTs(repoPath);
 
     // 4. Create Service
-    const servicePath = path.join(contextPath, 'Application', 'Services');
+    const servicePath = path.join(contextPath, 'Application/Services');
     await writeIfNotExists(
         path.join(servicePath, `${pascalName}Service.ts`),
         serviceTemplate
             .replace(/{{name}}/g, pascalName)
             .replace(/{{camelName}}/g, camelName)
+            .replace(/{{context}}/g, context)
     );
     await updateIndexTs(servicePath);
 
@@ -317,11 +352,12 @@ const Schema = createSchemaFactory(createRules(validationMessagesI18n));`;
     }
     await updateIndexTs(schemaPath);
 
-    // 6. Create Presenter
+    // 6. Create Presenter - use correct template based on type
+    const presenterTemplate = presenterType === 'package'
+        ? presenterWithoutCoreTemplate
+        : presenterWithCoreTemplate;
+
     const presenterFactory = presenterType === 'package' ? 'createPresenter' : presenterType;
-    const presenterImport = presenterType === 'package'
-        ? '@azure-net/kit'
-        : '$core/Presenter';
 
     await writeIfNotExists(
         path.join(deliveryModulePath, `${pascalName}Presenter.ts`),
@@ -329,7 +365,6 @@ const Schema = createSchemaFactory(createRules(validationMessagesI18n));`;
             .replace(/{{name}}/g, pascalName)
             .replace(/{{context}}/g, context)
             .replace(/{{presenterFactory}}/g, presenterFactory)
-            .replace(/{{presenterImport}}/g, presenterImport)
     );
 
     // Create module index
@@ -340,13 +375,13 @@ const Schema = createSchemaFactory(createRules(validationMessagesI18n));`;
 
     // 7. Setup Providers
     // Ensure DatasourceProvider
-    const datasourceProviderPath = path.join(contextPath, 'Infrastructure', 'Providers', 'DatasourceProvider.ts');
+    const datasourceProviderPath = path.join(contextPath, 'Infrastructure/Providers/DatasourceProvider.ts');
     if (!(await fs.access(datasourceProviderPath).then(() => true).catch(() => false))) {
         const datasourceProviderContent = `import { createBoundaryProvider } from '@azure-net/kit';
 import { ${datasource.name} } from '${datasource.from === 'core' ? '$core/Datasource' : '../Http/Datasource'}';
 
 export const DatasourceProvider = createBoundaryProvider('${contextName}DatasourceProvider', () => ({
-\t${datasource.name}: () => new ${datasource.name}()
+\t${datasource.name}: () => DatasourceProvider.${datasource.name}
 }));`;
         await writeIfNotExists(datasourceProviderPath, datasourceProviderContent);
         await updateIndexTs(path.dirname(datasourceProviderPath));
@@ -357,7 +392,7 @@ export const DatasourceProvider = createBoundaryProvider('${contextName}Datasour
     await addToProvider(
         infraProvider.path,
         `${pascalName}Repository`,
-        '../Http/Repositories',
+        '$' + context + '/Infrastructure/Http/Repositories',
         `DatasourceProvider.${datasource.name}`
     );
 
@@ -366,7 +401,7 @@ export const DatasourceProvider = createBoundaryProvider('${contextName}Datasour
     await addToProvider(
         appProvider.path,
         `${pascalName}Service`,
-        '../Services',
+        '$' + context + '/Application/Services',
         `InfrastructureProvider.${pascalName}Repository`
     );
 

package/src/commands/generate/generateDatasource.js

@@ -1,18 +1,27 @@
 import prompts from 'prompts';
-import { selectContext, getContextPath, toPascalCase } from '../../utils/contextUtils.js';
-import { writeIfNotExists, updateIndexTs } from '../../utils/fileUtils.js';
 import path from 'path';
+import { selectContext, getContextPath, toPascalCase, getAvailableFiles, toCamelCase } from '../../utils/contextUtils.js';
+import { writeIfNotExists, updateIndexTs } from '../../utils/fileUtils.js';
+import { ensureProvider, addToProvider } from '../../utils/providerUtils.js';
 
-const datasourceTemplate = `import { BaseHttpDatasource } from '@azure-net/kit/infra';
-import { HttpService } from '@azure-net/kit/infra';
+const datasourceWithResponseTemplate = `import { BaseHttpDatasource, type CreateRequestCallbackType } from '@azure-net/kit/infra';
+import { {{responseClass}}, type {{responseInterface}} } from '{{responseImport}}';
+
+export class {{name}}Datasource extends BaseHttpDatasource {
+\tconstructor(private http: HttpService) {
+\t\tsuper({ http });
+\t}
+
+\tasync createRequest<T>(callback: CreateRequestCallbackType<{{responseInterface}}<T>>) {
+\t\treturn new {{responseClass}}<T>(await this.createRawRequest<{{responseInterface}}<T>>(callback));
+\t}
+}`;
+
+const datasourceWithoutResponseTemplate = `import { BaseHttpDatasource } from '@azure-net/kit/infra';
 
 export class {{name}}Datasource extends BaseHttpDatasource {
-\tconstructor() {
-\t\tsuper({ 
-\t\t\thttp: new HttpService({ 
-\t\t\t\tbaseUrl: 'https://api.example.com'
-\t\t\t}) 
-\t\t});
+\tconstructor(private http: HttpService) {
+\t\tsuper({ http });
 \t}
 }`;
 
@@ -26,16 +35,121 @@ export default async function generateDatasource() {
     });
 
     const pascalName = toPascalCase(name);
+    const camelName = toCamelCase(name);
     const contextPath = getContextPath(context);
+
+    // Get available responses
+    const coreResponses = await getAvailableFiles(
+        path.join(process.cwd(), 'src/app/core/Response')
+    );
+
+    const contextResponses = context !== 'core'
+        ? await getAvailableFiles(path.join(contextPath, 'Infrastructure/Response'))
+        : [];
+
+    const allResponses = [
+        ...coreResponses.map(r => ({
+            title: `${r} (core)`,
+            value: { name: r, from: 'core' }
+        })),
+        ...contextResponses.map(r => ({
+            title: `${r} (${context})`,
+            value: { name: r, from: context }
+        }))
+    ];
+
+    if (allResponses.length === 0) {
+        console.error('❌ No responses available. Create a response first with make:response');
+        return;
+    }
+
+    const { response } = await prompts({
+        type: 'select',
+        name: 'response',
+        message: 'Select response for datasource:',
+        choices: allResponses
+    });
+
+    // Determine interface name - typically IBackendApiDataSourceResponse or similar
+    const responseInterface = `I${response.name.replace('Response', '')}Response`;
+
     const datasourcePath = context === 'core'
         ? path.join(contextPath, 'Datasource')
         : path.join(contextPath, 'Infrastructure', 'Http', 'Datasource');
 
-    const content = datasourceTemplate.replace(/{{name}}/g, pascalName);
-    const filePath = path.join(datasourcePath, `${pascalName}Datasource.ts`);
+    const responseImport = response.from === 'core'
+        ? '$core/Response'
+        : context === 'core'
+            ? '../Response'
+            : '../../Response';
+
+    const content = datasourceWithResponseTemplate
+        .replace(/{{name}}/g, pascalName)
+        .replace(/{{responseClass}}/g, response.name)
+        .replace(/{{responseInterface}}/g, responseInterface)
+        .replace(/{{responseImport}}/g, responseImport);
 
+    const filePath = path.join(datasourcePath, `${pascalName}Datasource.ts`);
     await writeIfNotExists(filePath, content);
     await updateIndexTs(datasourcePath);
 
+    // If not in core, ensure DatasourceProvider exists
+    if (context !== 'core') {
+        const contextName = toPascalCase(context);
+        const providerPath = path.join(contextPath, 'Infrastructure/Providers/DatasourceProvider.ts');
+
+        if (!(await fs.access(providerPath).then(() => true).catch(() => false))) {
+            const providerContent = `import { createBoundaryProvider } from '@azure-net/kit';
+import { HttpService } from '@azure-net/kit/infra';
+import { ${pascalName}Datasource } from '../Http/Datasource';
+
+export const DatasourceProvider = createBoundaryProvider('${contextName}DatasourceProvider', () => ({
+\t${pascalName}Datasource: () => new ${pascalName}Datasource(
+\t\tnew HttpService({ baseUrl: 'https://api.example.com' })
+\t)
+}));`;
+            await writeIfNotExists(providerPath, providerContent);
+            await updateIndexTs(path.dirname(providerPath));
+        } else {
+            // Add datasource to existing provider
+            await addDatasourceToProvider(providerPath, pascalName);
+        }
+    }
+
     console.log(`✅ Datasource created at ${filePath}`);
+}
+
+async function addDatasourceToProvider(providerPath, datasourceName) {
+    let content = await fs.readFile(providerPath, 'utf-8');
+
+    // Add import if not exists
+    if (!content.includes(`${datasourceName}Datasource`)) {
+        const importStatement = `import { ${datasourceName}Datasource } from '../Http/Datasource';`;
+        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${datasourceName}Datasource: () => new ${datasourceName}Datasource(
+\t\tnew HttpService({ baseUrl: 'https://api.example.com' })
+\t)`;
+
+    if (!content.includes(`${datasourceName}Datasource:`)) {
+        const returnIndex = content.indexOf('=> ({');
+        const endOfReturn = content.indexOf('})', returnIndex);
+        const beforeEnd = content.lastIndexOf('\n', endOfReturn);
+
+        // Check if there are existing entries
+        const servicesSection = content.substring(returnIndex, endOfReturn);
+        const hasServices = servicesSection.includes(':');
+
+        if (hasServices) {
+            content = content.slice(0, beforeEnd) + ',\n' + factoryLine + content.slice(beforeEnd);
+        } else {
+            content = content.slice(0, beforeEnd + 1) + factoryLine + content.slice(beforeEnd);
+        }
+    }
+
+    await fs.writeFile(providerPath, content, 'utf-8');
 }

package/src/commands/generate/generatePresenter.js

@@ -10,7 +10,7 @@ export const {{name}}Presenter = {{corePresenter}}('{{name}}Presenter', ({ creat
 \t{{serviceInit}}
 \t
 \tconst example = async () => {
-\t\t// Implement presenter logic
+\t\t// Using async helpers from core presenter factory
 \t\treturn await createAsyncResource(Promise.resolve({}));
 \t};
 \t
@@ -24,8 +24,8 @@ export const {{name}}Presenter = createPresenter('{{name}}Presenter', () => {
 \t{{serviceInit}}
 \t
 \tconst example = async () => {
-\t\t// Implement presenter logic
-\t\treturn {};
+\t\t// Direct method without async helpers
+\t\treturn await Promise.resolve({});
 \t};
 \t
 \treturn { example };
@@ -65,12 +65,12 @@ export default async function generatePresenter() {
     // Get available services
     const contextPath = getContextPath(context);
     const services = await getAvailableFiles(
-        path.join(contextPath, 'Application', 'Services')
+        path.join(contextPath, 'Application/Services')
     );
 
     const serviceChoices = [
         { title: 'Without service', value: null },
-        ...services.map(s => ({ title: `${s}`, value: s }))
+        ...services.map(s => ({ title: s, value: s }))
     ];
 
     const { service } = await prompts({

package/src/commands/generate/generateResponse.js

@@ -1,9 +1,9 @@
 import prompts from 'prompts';
+import path from 'path';
 import { selectContext, getContextPath, toPascalCase } from '../../utils/contextUtils.js';
 import { writeIfNotExists, updateIndexTs } from '../../utils/fileUtils.js';
-import path from 'path';
 
-const responseTemplate = `import { ResponseBuilder } from '@azure-net/kit';
+const responseTemplate = `import { ResponseBuilder } from '@azure-net/kit/infra';
 
 export interface I{{name}}Response<T = unknown> {
 \tdata: T;
@@ -23,14 +23,14 @@ export default async function generateResponse() {
     const { name } = await prompts({
         type: 'text',
         name: 'name',
-        message: 'Response name (PascalCase):'
+        message: 'Response name (without "Response" suffix):'
     });
 
     const pascalName = toPascalCase(name);
     const contextPath = getContextPath(context);
     const responsePath = context === 'core'
-        ? path.join(contextPath, 'Responses')
-        : path.join(contextPath, 'Infrastructure', 'Responses');
+        ? path.join(contextPath, 'Response')
+        : path.join(contextPath, 'Infrastructure/Response');
 
     const content = responseTemplate.replace(/{{name}}/g, pascalName);
     const filePath = path.join(responsePath, `${pascalName}Response.ts`);

package/src/commands/init/initSchema.js

@@ -1,7 +1,7 @@
 import { writeIfNotExists } from '../../utils/fileUtils.js';
 import path from 'path';
 
-const schemaPath = path.join(process.cwd(), 'src/app/core/Schemas/Schema.ts');
+const schemaPath = path.join(process.cwd(), 'src/app/core/Schema/Schema.ts');
 
 const schemaTemplate = `import { createSchemaFactory } from '@azure-net/kit';
 import { createRules, validationMessagesI18n } from '@azure-net/kit/schema';
@@ -11,7 +11,7 @@ export const Schema = createSchemaFactory(createRules(validationMessagesI18n));`
 export default async function initSchema() {
     await writeIfNotExists(schemaPath, schemaTemplate);
     await writeIfNotExists(
-        path.join(process.cwd(), 'src/app/core/Schemas/index.ts'),
+        path.join(process.cwd(), 'src/app/core/Schema/index.ts'),
         `export * from './Schema';`
     );
 

package/src/utils/contextUtils.js

@@ -40,13 +40,28 @@ export async function getAvailableFiles(dir, pattern = '.ts') {
     }
 }
 
+// Fixed to preserve PascalCase properly
 export function toPascalCase(str) {
-    return str
-        .split(/[-_\s]+/)
-        .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+    // If already in PascalCase with multiple words, preserve it
+    if (/^[A-Z][a-z]+(?:[A-Z][a-z]+)*$/.test(str)) {
+        return str;
+    }
+
+    // Split by common delimiters but preserve existing camelCase/PascalCase
+    const words = str.split(/[-_\s]+/);
+    return words
+        .map((word, index) => {
+            // If word is already in camelCase or PascalCase, preserve it
+            if (/[a-z][A-Z]/.test(word)) {
+                return word.charAt(0).toUpperCase() + word.slice(1);
+            }
+            // Otherwise capitalize first letter
+            return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+        })
         .join('');
 }
 
+// Fixed to preserve camelCase properly
 export function toCamelCase(str) {
     const pascal = toPascalCase(str);
     return pascal.charAt(0).toLowerCase() + pascal.slice(1);

package/src/utils/providerUtils.js

@@ -68,8 +68,13 @@ export const ${varName} = createBoundaryProvider(
 export async function addToProvider(providerPath, serviceName, importPath, dependency = null) {
     let content = await fs.readFile(providerPath, 'utf-8');
 
+    // Use alias import path instead of relative
+    const aliasImportPath = importPath.startsWith('$') ? importPath : importPath.startsWith('../')
+        ? importPath  // Keep relative if it's internal to the same layer
+        : importPath;
+
     // Add import if not exists
-    const importStatement = `import { ${serviceName} } from '${importPath}';`;
+    const importStatement = `import { ${serviceName} } from '${aliasImportPath}';`;
     if (!content.includes(serviceName)) {
         const lastImportIndex = content.lastIndexOf('import ');
         const endOfImportLine = content.indexOf('\n', lastImportIndex);