@azure-net/cli 2.0.4 → 2.0.5

package/package.json

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

package/src/commands/generate/generateCrud.js

@@ -3,9 +3,9 @@ import fs from 'fs/promises';
 import path from 'path';
 import { selectContext, getContextPath, toPascalCase, toCamelCase, getAvailableFiles } from '../../utils/contextUtils.js';
 import { writeIfNotExists, updateIndexTs, ensureIndexExports } from '../../utils/fileUtils.js';
-import { ensureProvider, addToProvider } from '../../utils/providerUtils.js';
+import { ensureProvider, addToProvider, ensureDatasourceProvider } from '../../utils/providerUtils.js';
 
-// Templates for CRUD generation
+// Templates remain the same as before...
 const entityTemplate = `export interface I{{name}} {
 \tid: number;
 \t// Add entity fields here
@@ -114,7 +114,6 @@ export const Update{{name}}Schema = {{schemaFactory}}<I{{name}}UpdateRequest>()
 \t}))
 \t.create();`;
 
-// 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';
@@ -145,7 +144,6 @@ 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';
@@ -308,7 +306,6 @@ export default async function generateCrud() {
         : '$core/Schema';
 
     if (schemaType === 'package') {
-        // Add the import for createSchemaFactory and rules
         const schemaImportFull = `import { createSchemaFactory } from '@azure-net/kit';
 import { createRules, validationMessagesI18n } from '@azure-net/kit/schema';
 
@@ -352,7 +349,7 @@ const Schema = createSchemaFactory(createRules(validationMessagesI18n));`;
     }
     await updateIndexTs(schemaPath);
 
-    // 6. Create Presenter - use correct template based on type
+    // 6. Create Presenter
     const presenterTemplate = presenterType === 'package'
         ? presenterWithoutCoreTemplate
         : presenterWithCoreTemplate;
@@ -375,24 +372,14 @@ const Schema = createSchemaFactory(createRules(validationMessagesI18n));`;
 
     // 7. Setup Providers
     // Ensure DatasourceProvider
-    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}: () => DatasourceProvider.${datasource.name}
-}));`;
-        await writeIfNotExists(datasourceProviderPath, datasourceProviderContent);
-        await updateIndexTs(path.dirname(datasourceProviderPath));
-    }
+    await ensureDatasourceProvider(context, datasource.name, datasource.from === 'core');
 
     // Ensure InfrastructureProvider
-    const infraProvider = await ensureProvider(context, 'Infrastructure', {});
+    const infraProvider = await ensureProvider(context, 'Infrastructure', { hasDatasource: true });
     await addToProvider(
         infraProvider.path,
         `${pascalName}Repository`,
-        '$' + context + '/Infrastructure/Http/Repositories',
+        `\$${context}/Infrastructure/Http/Repositories`,
         `DatasourceProvider.${datasource.name}`
     );
 
@@ -401,7 +388,7 @@ export const DatasourceProvider = createBoundaryProvider('${contextName}Datasour
     await addToProvider(
         appProvider.path,
         `${pascalName}Service`,
-        '$' + context + '/Application/Services',
+        `\$${context}/Application/Services`,
         `InfrastructureProvider.${pascalName}Repository`
     );
 

package/src/commands/generate/generateDatasource.js

@@ -1,15 +1,21 @@
 import prompts from 'prompts';
 import path from 'path';
-import { selectContext, getContextPath, toPascalCase, getAvailableFiles, toCamelCase } from '../../utils/contextUtils.js';
+import fs from 'fs/promises';
+import { selectContext, getContextPath, toPascalCase, getAvailableFiles } from '../../utils/contextUtils.js';
 import { writeIfNotExists, updateIndexTs } from '../../utils/fileUtils.js';
-import { ensureProvider, addToProvider } from '../../utils/providerUtils.js';
 
 const datasourceWithResponseTemplate = `import { BaseHttpDatasource, type CreateRequestCallbackType } from '@azure-net/kit/infra';
 import { {{responseClass}}, type {{responseInterface}} } from '{{responseImport}}';
+import { HttpService } from '@azure-net/kit/infra';
 
 export class {{name}}Datasource extends BaseHttpDatasource {
-\tconstructor(private http: HttpService) {
-\t\tsuper({ http });
+\tconstructor(config?: { baseUrl?: string; [key: string]: unknown }) {
+\t\tsuper({ 
+\t\t\thttp: new HttpService({ 
+\t\t\t\tbaseUrl: config?.baseUrl || 'https://api.example.com',
+\t\t\t\t...config
+\t\t\t}) 
+\t\t});
 \t}
 
 \tasync createRequest<T>(callback: CreateRequestCallbackType<{{responseInterface}}<T>>) {
@@ -17,14 +23,6 @@ export class {{name}}Datasource extends BaseHttpDatasource {
 \t}
 }`;
 
-const datasourceWithoutResponseTemplate = `import { BaseHttpDatasource } from '@azure-net/kit/infra';
-
-export class {{name}}Datasource extends BaseHttpDatasource {
-\tconstructor(private http: HttpService) {
-\t\tsuper({ http });
-\t}
-}`;
-
 export default async function generateDatasource() {
     const context = await selectContext();
 
@@ -35,7 +33,6 @@ export default async function generateDatasource() {
     });
 
     const pascalName = toPascalCase(name);
-    const camelName = toCamelCase(name);
     const contextPath = getContextPath(context);
 
     // Get available responses
@@ -70,17 +67,17 @@ export default async function generateDatasource() {
         choices: allResponses
     });
 
-    // Determine interface name - typically IBackendApiDataSourceResponse or similar
+    // Determine interface name
     const responseInterface = `I${response.name.replace('Response', '')}Response`;
 
     const datasourcePath = context === 'core'
         ? path.join(contextPath, 'Datasource')
-        : path.join(contextPath, 'Infrastructure', 'Http', 'Datasource');
+        : path.join(contextPath, 'Infrastructure/Http/Datasource');
 
     const responseImport = response.from === 'core'
-        ? '$core/Response'
+        ? context === 'core' ? '../Response' : '$core/Response'
         : context === 'core'
-            ? '../Response'
+            ? `../contexts/${context}/Infrastructure/Response`
             : '../../Response';
 
     const content = datasourceWithResponseTemplate
@@ -93,63 +90,6 @@ export default async function generateDatasource() {
     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');
+    console.log(`\n💡 Remember to configure the datasource in DatasourceProvider when using it in repositories.`);
 }

package/src/commands/generate/generateRepository.js

@@ -3,7 +3,7 @@ import fs from 'fs/promises';
 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';
+import { ensureProvider, addToProvider, ensureDatasourceProvider } from '../../utils/providerUtils.js';
 
 const repositoryTemplate = `import { {{datasource}} } from '{{datasourceImport}}';
 
@@ -37,7 +37,7 @@ export default async function generateRepository() {
         path.join(process.cwd(), 'src/app/core/Datasource')
     );
     const contextDatasources = await getAvailableFiles(
-        path.join(contextPath, 'Infrastructure', 'Http', 'Datasource')
+        path.join(contextPath, 'Infrastructure/Http/Datasource')
     );
 
     const allDatasources = [
@@ -59,7 +59,7 @@ export default async function generateRepository() {
 
     const pascalName = toPascalCase(name);
     const contextName = toPascalCase(context);
-    const repoPath = path.join(contextPath, 'Infrastructure', 'Http', 'Repositories');
+    const repoPath = path.join(contextPath, 'Infrastructure/Http/Repositories');
     const filePath = path.join(repoPath, `${pascalName}Repository.ts`);
 
     // Generate repository
@@ -77,24 +77,14 @@ export default async function generateRepository() {
     await updateIndexTs(repoPath);
 
     // Ensure DatasourceProvider exists
-    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}()
-}));`;
-        await writeIfNotExists(datasourceProviderPath, datasourceProviderContent);
-        await updateIndexTs(path.dirname(datasourceProviderPath));
-    }
+    await ensureDatasourceProvider(context, datasource.name, datasource.from === 'core');
 
     // Ensure InfrastructureProvider and add repository
     const infraProvider = await ensureProvider(context, 'Infrastructure', { hasDatasource: true });
     await addToProvider(
         infraProvider.path,
         `${pascalName}Repository`,
-        '../Http/Repositories',
+        `\$${context}/Infrastructure/Http/Repositories`,
         `DatasourceProvider.${datasource.name}`
     );
 

package/src/utils/providerUtils.js

@@ -35,7 +35,6 @@ function generateProviderContent(context, layer, dependencies) {
 
     let imports = [`import { createBoundaryProvider } from '@azure-net/kit';`];
     let deps = [];
-    let depParams = '';
 
     if (dependencies.hasDatasource && layer === 'Infrastructure') {
         imports.push(`import { DatasourceProvider } from './DatasourceProvider';`);
@@ -47,10 +46,7 @@ function generateProviderContent(context, layer, dependencies) {
         deps.push('InfrastructureProvider');
     }
 
-    if (deps.length > 0) {
-        depParams = `{ ${deps.join(', ')} }`;
-    }
-
+    const depParams = deps.length > 0 ? `{ ${deps.join(', ')} }` : '';
     const dependsOnStr = deps.length > 0
         ? `,\n\t{ dependsOn: { ${deps.join(', ')} } }`
         : '';
@@ -59,7 +55,7 @@ function generateProviderContent(context, layer, dependencies) {
 
 export const ${varName} = createBoundaryProvider(
 \t'${boundaryName}',
-\t(${depParams ? depParams : ''}) => ({
+\t(${depParams}) => ({
 \t\t// Services will be added here
 \t})${dependsOnStr}
 );`;
@@ -68,17 +64,69 @@ 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 '${aliasImportPath}';`;
-    if (!content.includes(serviceName)) {
-        const lastImportIndex = content.lastIndexOf('import ');
-        const endOfImportLine = content.indexOf('\n', lastImportIndex);
-        content = content.slice(0, endOfImportLine + 1) + importStatement + '\n' + content.slice(endOfImportLine + 1);
+    // Parse existing imports to group them
+    const importRegex = /^import\s+{([^}]+)}\s+from\s+['"]([^'"]+)['"]/gm;
+    const imports = new Map();
+    let match;
+
+    while ((match = importRegex.exec(content)) !== null) {
+        const [fullMatch, importedItems, fromPath] = match;
+        if (!imports.has(fromPath)) {
+            imports.set(fromPath, new Set());
+        }
+        importedItems.split(',').forEach(item => {
+            imports.get(fromPath).add(item.trim());
+        });
+    }
+
+    // Add new import to the map
+    if (!Array.from(imports.values()).some(set => set.has(serviceName))) {
+        if (!imports.has(importPath)) {
+            imports.set(importPath, new Set());
+        }
+        imports.get(importPath).add(serviceName);
+    }
+
+    // Rebuild import section
+    const newImports = [`import { createBoundaryProvider } from '@azure-net/kit';`];
+
+    // Add DatasourceProvider import if exists
+    if (content.includes('DatasourceProvider') && !content.includes("import { DatasourceProvider }")) {
+        newImports.push(`import { DatasourceProvider } from './DatasourceProvider';`);
+    }
+
+    // Add other imports
+    for (const [fromPath, items] of imports) {
+        if (fromPath !== '@azure-net/kit' && !fromPath.includes('DatasourceProvider')) {
+            const itemsStr = Array.from(items).join(', ');
+            newImports.push(`import { ${itemsStr} } from '${fromPath}';`);
+        }
+    }
+
+    // Find where imports end and provider starts
+    const providerStartIndex = content.indexOf('export const');
+    const beforeProvider = content.substring(0, providerStartIndex);
+    const afterProvider = content.substring(providerStartIndex);
+
+    // Check if DatasourceProvider dependency needs to be added
+    let updatedAfterProvider = afterProvider;
+    if (dependency && dependency.includes('DatasourceProvider')) {
+        // Check if provider already has dependencies
+        if (!afterProvider.includes('({ DatasourceProvider })')) {
+            // Add DatasourceProvider to function params
+            updatedAfterProvider = updatedAfterProvider.replace(
+                /createBoundaryProvider\(\s*'[^']+',\s*\(\)/,
+                `createBoundaryProvider(\n\t'$1',\n\t({ DatasourceProvider })`
+            );
+
+            // Add dependsOn if not exists
+            if (!updatedAfterProvider.includes('dependsOn')) {
+                updatedAfterProvider = updatedAfterProvider.replace(
+                    /\)\s*\);$/,
+                    `),\n\t{ dependsOn: { DatasourceProvider } }\n);`
+                );
+            }
+        }
     }
 
     // Add factory method with dependency
@@ -86,27 +134,121 @@ export async function addToProvider(providerPath, serviceName, importPath, depen
         ? `\t\t${serviceName}: () => new ${serviceName}(${dependency})`
         : `\t\t${serviceName}: () => new ${serviceName}()`;
 
-    if (!content.includes(`${serviceName}:`)) {
+    if (!updatedAfterProvider.includes(`${serviceName}:`)) {
         // Find the position to insert
-        const returnIndex = content.indexOf('=> ({');
-        const endOfReturn = content.indexOf('\t})', returnIndex);
+        const returnIndex = updatedAfterProvider.indexOf('=> ({');
+        const endOfReturn = updatedAfterProvider.indexOf('\t})', returnIndex);
 
         // Check if there are existing services
-        const servicesSection = content.substring(returnIndex, endOfReturn);
-        const hasServices = servicesSection.includes(':');
+        const servicesSection = updatedAfterProvider.substring(returnIndex, endOfReturn);
+        const hasServices = servicesSection.includes(':') && !servicesSection.includes('// Services will be added here');
 
         if (hasServices) {
             // Add comma before new service
-            const beforeEnd = content.lastIndexOf('\n', endOfReturn);
-            content = content.slice(0, beforeEnd) + ',\n' + factoryLine + content.slice(beforeEnd);
+            const beforeEnd = updatedAfterProvider.lastIndexOf('\n', endOfReturn);
+            updatedAfterProvider = updatedAfterProvider.slice(0, beforeEnd) + ',\n' + factoryLine + updatedAfterProvider.slice(beforeEnd);
         } else {
             // First service, replace comment
-            content = content.replace(
+            updatedAfterProvider = updatedAfterProvider.replace(
                 '// Services will be added here',
                 factoryLine
             );
         }
     }
 
-    await fs.writeFile(providerPath, content, 'utf-8');
+    // Combine everything
+    const finalContent = newImports.join('\n') + '\n\n' + updatedAfterProvider;
+    await fs.writeFile(providerPath, finalContent, 'utf-8');
+}
+
+export async function ensureDatasourceProvider(context, datasourceName, isFromCore = true) {
+    const contextName = toPascalCase(context);
+    const contextPath = path.join(process.cwd(), 'src/app/contexts', context);
+    const providerPath = path.join(contextPath, 'Infrastructure/Providers/DatasourceProvider.ts');
+
+    try {
+        await fs.access(providerPath);
+        // Provider exists, add datasource if needed
+        await addDatasourceToProvider(providerPath, datasourceName, isFromCore);
+    } catch {
+        // Create new DatasourceProvider
+        const content = `import { createBoundaryProvider } from '@azure-net/kit';
+import { ${datasourceName} } from '${isFromCore ? '$core' : '../Http/Datasource'}';
+
+export const DatasourceProvider = createBoundaryProvider('${contextName}DatasourceProvider', () => ({
+\t${datasourceName}: () => new ${datasourceName}({})
+}));`;
+
+        await writeIfNotExists(providerPath, content);
+        await updateIndexTs(path.dirname(providerPath));
+    }
+}
+
+async function addDatasourceToProvider(providerPath, datasourceName, isFromCore = true) {
+    let content = await fs.readFile(providerPath, 'utf-8');
+
+    // Check if datasource already exists
+    if (content.includes(`${datasourceName}:`)) {
+        return;
+    }
+
+    // Parse existing imports to group them
+    const importRegex = /^import\s+{([^}]+)}\s+from\s+['"]([^'"]+)['"]/gm;
+    const imports = new Map();
+    let match;
+
+    while ((match = importRegex.exec(content)) !== null) {
+        const [fullMatch, importedItems, fromPath] = match;
+        if (!imports.has(fromPath)) {
+            imports.set(fromPath, new Set());
+        }
+        importedItems.split(',').forEach(item => {
+            imports.get(fromPath).add(item.trim());
+        });
+    }
+
+    // Add datasource to imports
+    const importPath = isFromCore ? '$core' : '../Http/Datasource';
+    if (!imports.has(importPath)) {
+        imports.set(importPath, new Set());
+    }
+    imports.get(importPath).add(datasourceName);
+
+    // Rebuild import section
+    const newImports = [`import { createBoundaryProvider } from '@azure-net/kit';`];
+    for (const [fromPath, items] of imports) {
+        if (fromPath !== '@azure-net/kit') {
+            const itemsStr = Array.from(items).join(', ');
+            newImports.push(`import { ${itemsStr} } from '${fromPath}';`);
+        }
+    }
+
+    // Find provider content
+    const providerStartIndex = content.indexOf('export const');
+    const afterProvider = content.substring(providerStartIndex);
+
+    // Add factory method
+    const factoryLine = `\t${datasourceName}: () => new ${datasourceName}({})`;
+
+    const returnIndex = afterProvider.indexOf('=> ({');
+    const endOfReturn = afterProvider.indexOf('})', returnIndex);
+
+    // Check if there are existing services
+    const servicesSection = afterProvider.substring(returnIndex, endOfReturn);
+    const hasServices = servicesSection.includes(':');
+
+    let updatedAfterProvider = afterProvider;
+    if (hasServices) {
+        // Add comma before new service
+        const beforeEnd = updatedAfterProvider.lastIndexOf('\n', endOfReturn);
+        updatedAfterProvider = updatedAfterProvider.slice(0, beforeEnd) + ',\n' + factoryLine + updatedAfterProvider.slice(beforeEnd);
+    } else {
+        // First service
+        const insertPoint = returnIndex + '=> ({\n'.length;
+        updatedAfterProvider = updatedAfterProvider.slice(0, insertPoint) + factoryLine + '\n' + updatedAfterProvider.slice(insertPoint);
+    }
+
+    // Combine everything
+    const finalContent = newImports.join('\n') + '\n\n' + updatedAfterProvider;
+    await fs.writeFile(providerPath, finalContent, 'utf-8');
 }