@azure-net/cli 2.3.61 → 2.3.62

package/bin/azure-net.js

@@ -21,7 +21,12 @@ import {
     generatePresenter,
     generateModule,
     generateCrudBase,
-    generateCrudPresenter
+    generateCrudPresenter,
+    generateModuleBase,
+    generateModulePresenter,
+    generateComponent,
+    generateWidget,
+    generateDesignComponent
 } from '../src/commands/generate/index.js';
 
 const program = new Command();
@@ -130,4 +135,29 @@ program
     .description('Generate CRUD presenter for existing service')
     .action(generateCrudPresenter);
 
+program
+    .command('make:module-base')
+    .description('Generate repository and service for a module')
+    .action(generateModuleBase);
+
+program
+    .command('make:module-presenter')
+    .description('Generate presenter for existing service')
+    .action(generateModulePresenter);
+
+program
+    .command('make:component')
+    .description('Generate UI component')
+    .action(generateComponent);
+
+program
+    .command('make:widget')
+    .description('Generate UI widget')
+    .action(generateWidget);
+
+program
+    .command('make:design-component')
+    .description('Generate design system component')
+    .action(generateDesignComponent);
+
 program.parse();

package/package.json

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

package/src/commands/generate/generateComponent.js

@@ -0,0 +1,53 @@
+import prompts from 'prompts';
+import path from 'path';
+import { selectContext } from '../../utils/contextUtils.js';
+import { writeIfNotExists } from '../../utils/fileUtils.js';
+
+const componentTemplate = `<script lang="ts">
+\timport './style.scss';
+</script>
+
+{{componentName}}
+`;
+
+const styleTemplate = `// Add your styles here
+`;
+
+export default async function generateComponent() {
+    const context = await selectContext('Select context for component:');
+
+    const { componentPath } = await prompts({
+        type: 'text',
+        name: 'componentPath',
+        message: 'Component path (e.g. reviews/modals/ReviewModal):',
+        validate: value => value.length > 0 ? true : 'Path cannot be empty'
+    });
+
+    // Parse the path
+    const normalizedPath = componentPath.replace(/\\/g, '/');
+    const pathParts = normalizedPath.split('/');
+    const componentName = pathParts[pathParts.length - 1];
+
+    // Build the full path: src/app/{context}/ui/components/{path}
+    const contextUiPath = path.join(process.cwd(), 'src/app', context, 'ui/components');
+    const fullComponentPath = path.join(contextUiPath, normalizedPath);
+
+    console.log(`\n🚀 Generating component: ${componentName}...\n`);
+
+    // Create Component.svelte
+    await writeIfNotExists(
+        path.join(fullComponentPath, 'Component.svelte'),
+        componentTemplate.replace(/{{componentName}}/g, componentName)
+    );
+
+    // Create style.scss
+    await writeIfNotExists(
+        path.join(fullComponentPath, 'style.scss'),
+        styleTemplate
+    );
+
+    console.log(`✅ Component created at: ${fullComponentPath}`);
+    console.log(`\n💡 Files created:`);
+    console.log(`   - Component.svelte`);
+    console.log(`   - style.scss`);
+}

package/src/commands/generate/generateDesignComponent.js

@@ -0,0 +1,53 @@
+import prompts from 'prompts';
+import path from 'path';
+import { selectContext } from '../../utils/contextUtils.js';
+import { writeIfNotExists } from '../../utils/fileUtils.js';
+
+const designComponentTemplate = `<script lang="ts">
+\timport './style.scss';
+</script>
+
+{{componentName}}
+`;
+
+const styleTemplate = `// Add your styles here
+`;
+
+export default async function generateDesignComponent() {
+    const context = await selectContext('Select context for design component:');
+
+    const { componentPath } = await prompts({
+        type: 'text',
+        name: 'componentPath',
+        message: 'Design component path (e.g. Button/Themes/PrimaryButton):',
+        validate: value => value.length > 0 ? true : 'Path cannot be empty'
+    });
+
+    // Parse the path
+    const normalizedPath = componentPath.replace(/\\/g, '/');
+    const pathParts = normalizedPath.split('/');
+    const componentName = pathParts[pathParts.length - 1];
+
+    // Build the full path: src/app/{context}/ui/design/{path}
+    const contextUiPath = path.join(process.cwd(), 'src/app', context, 'ui/design');
+    const fullComponentPath = path.join(contextUiPath, normalizedPath);
+
+    console.log(`\n🚀 Generating design component: ${componentName}...\n`);
+
+    // Create Component.svelte
+    await writeIfNotExists(
+        path.join(fullComponentPath, 'Component.svelte'),
+        designComponentTemplate.replace(/{{componentName}}/g, componentName)
+    );
+
+    // Create style.scss
+    await writeIfNotExists(
+        path.join(fullComponentPath, 'style.scss'),
+        styleTemplate
+    );
+
+    console.log(`✅ Design component created at: ${fullComponentPath}`);
+    console.log(`\n💡 Files created:`);
+    console.log(`   - Component.svelte`);
+    console.log(`   - style.scss`);
+}

package/src/commands/generate/generateModuleBase.js

@@ -0,0 +1,152 @@
+import prompts from 'prompts';
+import path from 'path';
+import {
+    selectContext,
+    getContextPath,
+    toPascalCase,
+    toCamelCase,
+    getAvailableFiles,
+    toKebabCase
+} from '../../utils/contextUtils.js';
+import { writeIfNotExists, updateIndexTs, updateCoreIndex } from '../../utils/fileUtils.js';
+
+const entityTemplate = `export interface I{{name}} {
+\tid: number;
+\t// Add entity fields here
+\tcreated_at: string;
+\tupdated_at: string;
+}`;
+
+const repositoryTemplate = `import { {{datasource}} } from '{{datasourceImport}}';
+
+export class {{name}}Repository {
+\tprivate endpoint = '{{endpoint}}';
+\t
+\tconstructor(private {{datasourceVar}}: {{datasource}}) {}
+\t
+\tpublic async example() {
+\t\treturn this.{{datasourceVar}}.createRequest(({ http }) =>
+\t\t\thttp.get(this.endpoint)
+\t\t).then(res => res.getData());
+\t}
+}`;
+
+const serviceTemplate = `import { ClassMirror } from '@azure-net/kit';
+import { {{name}}Repository } from '\${{context}}/infrastructure/http/repositories';
+
+export class {{name}}Service extends ClassMirror<{{name}}Repository> {
+\tconstructor(private {{camelName}}Repository: {{name}}Repository) {
+\t\tsuper({{camelName}}Repository);
+\t}
+\t
+\tdeclare example: {{name}}Repository['example'];
+}`;
+
+export default async function generateModuleBase() {
+    const context = await selectContext('Select context for module base:');
+
+    const { name } = await prompts({
+        type: 'text',
+        name: 'name',
+        message: 'Module name (PascalCase):'
+    });
+
+    const { endpoint } = await prompts({
+        type: 'text',
+        name: 'endpoint',
+        message: 'API endpoint (e.g. /api/users):'
+    });
+
+    const { needEntity } = await prompts({
+        type: 'confirm',
+        name: 'needEntity',
+        message: 'Create domain entity?',
+        initial: true
+    });
+
+    // Get available datasources
+    const contextPath = getContextPath(context);
+    const coreDatasources = await getAvailableFiles(
+        path.join(process.cwd(), 'src/core/datasources')
+    );
+    const contextDatasources = await getAvailableFiles(
+        path.join(contextPath, 'infrastructure/http/datasources')
+    );
+
+    const allDatasources = [
+        ...coreDatasources.map(d => ({ title: `${d} (core)`, value: { name: d, from: 'core' } })),
+        ...contextDatasources.map(d => ({ title: `${d} (${context})`, value: { name: d, from: context } }))
+    ];
+
+    const { datasource } = await prompts({
+        type: 'select',
+        name: 'datasource',
+        message: 'Select datasource:',
+        choices: allDatasources
+    });
+
+    const pascalName = toPascalCase(name);
+    const camelName = toCamelCase(name);
+    const entityLower = toKebabCase(pascalName);
+
+    console.log('\n🚀 Generating module base (repository & service)...\n');
+
+    // 1. Create Domain entity if needed
+    if (needEntity) {
+        const domainPath = path.join(contextPath, 'domain', entityLower);
+        const modelPath = path.join(domainPath, 'model');
+
+        await writeIfNotExists(
+            path.join(modelPath, `I${pascalName}.ts`),
+            entityTemplate.replace(/{{name}}/g, pascalName)
+        );
+
+        await writeIfNotExists(
+            path.join(modelPath, 'index.ts'),
+            `export * from './I${pascalName}';`
+        );
+
+        await writeIfNotExists(
+            path.join(domainPath, 'index.ts'),
+            `export * from './model';`
+        );
+
+        console.log(`✅ Domain entity I${pascalName} created`);
+    }
+
+    // 2. Create Repository
+    const repoPath = path.join(contextPath, 'infrastructure/http/repositories');
+    const datasourceImport = datasource.from === 'core'
+        ? '$core/datasources'
+        : `\$${context}/infrastructure/http/datasources`;
+
+    await writeIfNotExists(
+        path.join(repoPath, `${pascalName}Repository.ts`),
+        repositoryTemplate
+            .replace(/{{name}}/g, pascalName)
+            .replace(/{{endpoint}}/g, endpoint)
+            .replace(/{{datasource}}/g, datasource.name)
+            .replace(/{{datasourceImport}}/g, datasourceImport)
+            .replace(/{{datasourceVar}}/g, toCamelCase(datasource.name))
+    );
+    await updateIndexTs(repoPath);
+
+    // 3. Create Service
+    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);
+
+    // Update core index
+    await updateCoreIndex();
+
+    console.log(`\n✅ Module base for ${pascalName} created successfully!`);
+    console.log(`\n💡 Remember to:`);
+    console.log(`   1. Add ${pascalName}Repository to InfrastructureProvider`);
+    console.log(`   2. Add ${pascalName}Service to ApplicationProvider`);
+}

package/src/commands/generate/generateModulePresenter.js

@@ -0,0 +1,110 @@
+import prompts from 'prompts';
+import path from 'path';
+import {
+    selectContext,
+    getContextPath,
+    toPascalCase,
+    getAvailableFiles,
+    getApplicationProviderServices,
+    toKebabCase
+} from '../../utils/contextUtils.js';
+import { updateIndexTs, writeIfNotExists, updateCoreIndex } from '../../utils/fileUtils.js';
+
+const presenterWithCoreTemplate = `import { {{presenterFactory}} } from '$core/presenters';
+import { ApplicationProvider } from '\${{context}}/application';
+
+export const {{name}}Presenter = {{presenterFactory}}('{{name}}Presenter', ({ createAsyncResource, createAsyncAction }) => {
+\tconst { {{serviceName}} } = ApplicationProvider();
+\t
+\t// Add your presenter methods here
+\t
+\treturn {};
+});`;
+
+const presenterWithoutCoreTemplate = `import { createPresenter } from '@azure-net/kit';
+import { ApplicationProvider } from '\${{context}}/application';
+
+export const {{name}}Presenter = createPresenter('{{name}}Presenter', () => {
+\tconst { {{serviceName}} } = ApplicationProvider();
+\t
+\t// Add your presenter methods here
+\t
+\treturn {};
+});`;
+
+export default async function generateModulePresenter() {
+    const context = await selectContext('Select context for module presenter:');
+
+    // Get available services from ApplicationProvider
+    const services = await getApplicationProviderServices(context);
+
+    if (services.length === 0) {
+        console.error('❌ No services found in ApplicationProvider. Add services manually first.');
+        return;
+    }
+
+    const { service } = await prompts({
+        type: 'select',
+        name: 'service',
+        message: 'Select service for presenter:',
+        choices: services.map(s => ({ title: s, value: s }))
+    });
+
+    const { moduleName } = await prompts({
+        type: 'text',
+        name: 'moduleName',
+        message: 'Module name for presenter (will create folder in delivery):'
+    });
+
+    // Extract entity name from service name
+    const pascalName = toPascalCase(moduleName);
+    const entityLower = toKebabCase(pascalName);
+
+    // Get presenter factory
+    const corePresenters = await getAvailableFiles(
+        path.join(process.cwd(), 'src/core/presenters')
+    );
+
+    const { presenterType } = await prompts({
+        type: 'select',
+        name: 'presenterType',
+        message: 'Select presenter factory:',
+        choices: [
+            { title: 'Use createPresenter from package', value: 'package' },
+            ...corePresenters.map(p => ({ title: `Use ${p} from core`, value: p }))
+        ]
+    });
+
+    const contextPath = getContextPath(context);
+    const deliveryModulePath = path.join(contextPath, 'delivery', entityLower);
+
+    console.log('\n🚀 Generating module presenter...\n');
+
+    // Create Presenter
+    const presenterTemplate = presenterType === 'package'
+        ? presenterWithoutCoreTemplate
+        : presenterWithCoreTemplate;
+
+    const presenterFactory = presenterType === 'package' ? 'createPresenter' : presenterType;
+
+    await writeIfNotExists(
+        path.join(deliveryModulePath, `${pascalName}Presenter.ts`),
+        presenterTemplate
+            .replace(/{{name}}/g, pascalName)
+            .replace(/{{context}}/g, context)
+            .replace(/{{serviceName}}/g, service)
+            .replace(/{{presenterFactory}}/g, presenterFactory)
+    );
+
+    // Create module index
+    await writeIfNotExists(
+        path.join(deliveryModulePath, 'index.ts'),
+        `export * from './${pascalName}Presenter';`
+    );
+
+    // Update core index
+    await updateCoreIndex();
+
+    console.log(`✅ Module presenter for ${pascalName} created successfully!`);
+    console.log(`\n💡 Remember to add presenter methods using the ${service}.`);
+}

package/src/commands/generate/generateWidget.js

@@ -0,0 +1,53 @@
+import prompts from 'prompts';
+import path from 'path';
+import { selectContext } from '../../utils/contextUtils.js';
+import { writeIfNotExists } from '../../utils/fileUtils.js';
+
+const widgetTemplate = `<script lang="ts">
+\timport './style.scss';
+</script>
+
+{{widgetName}}
+`;
+
+const styleTemplate = `// Add your styles here
+`;
+
+export default async function generateWidget() {
+    const context = await selectContext('Select context for widget:');
+
+    const { widgetPath } = await prompts({
+        type: 'text',
+        name: 'widgetPath',
+        message: 'Widget path (e.g. modals/ConfirmModal):',
+        validate: value => value.length > 0 ? true : 'Path cannot be empty'
+    });
+
+    // Parse the path
+    const normalizedPath = widgetPath.replace(/\\/g, '/');
+    const pathParts = normalizedPath.split('/');
+    const widgetName = pathParts[pathParts.length - 1];
+
+    // Build the full path: src/app/{context}/ui/widgets/{path}
+    const contextUiPath = path.join(process.cwd(), 'src/app', context, 'ui/widgets');
+    const fullWidgetPath = path.join(contextUiPath, normalizedPath);
+
+    console.log(`\n🚀 Generating widget: ${widgetName}...\n`);
+
+    // Create Component.svelte
+    await writeIfNotExists(
+        path.join(fullWidgetPath, 'Component.svelte'),
+        widgetTemplate.replace(/{{widgetName}}/g, widgetName)
+    );
+
+    // Create style.scss
+    await writeIfNotExists(
+        path.join(fullWidgetPath, 'style.scss'),
+        styleTemplate
+    );
+
+    console.log(`✅ Widget created at: ${fullWidgetPath}`);
+    console.log(`\n💡 Files created:`);
+    console.log(`   - Component.svelte`);
+    console.log(`   - style.scss`);
+}

package/src/commands/generate/index.js

@@ -6,4 +6,9 @@ export { default as generateSchema } from './generateSchema.js';
 export { default as generatePresenter } from './generatePresenter.js';
 export { default as generateModule } from './generateModule.js';
 export { default as generateCrudBase } from './generateCrudBase.js';
-export { default as generateCrudPresenter } from './generateCrudPresenter.js';
+export { default as generateCrudPresenter } from './generateCrudPresenter.js';
+export { default as generateModuleBase } from './generateModuleBase.js';
+export { default as generateModulePresenter } from './generateModulePresenter.js';
+export { default as generateComponent } from './generateComponent.js';
+export { default as generateWidget } from './generateWidget.js';
+export { default as generateDesignComponent } from './generateDesignComponent.js';