@azure-net/cli 2.3.63 → 4.0.0-1

package/src/commands/generate/generateModuleBase.js

@@ -1,152 +0,0 @@
-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

@@ -1,110 +0,0 @@
-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/generatePresenter.js

@@ -1,86 +0,0 @@
-import prompts from 'prompts';
-import path from 'path';
-import {selectContext, getContextPath, toPascalCase, getAvailableFiles, toKebabCase} from '../../utils/contextUtils.js';
-import { writeIfNotExists, updateCoreIndex } from '../../utils/fileUtils.js';
-
-const presenterWithCoreTemplate = `import { {{corePresenter}} } from '$core/presenters';
-import { ApplicationProvider } from '\${{context}}/application';
-
-export const {{name}}Presenter = {{corePresenter}}('{{name}}Presenter', ({ createAsyncResource, createAsyncAction }) => {
-\tconst { /* extract services from ApplicationProvider */ } = ApplicationProvider();
-\t
-\tconst example = async () => {
-\t\t// Using async helpers from core presenter factory
-\t\treturn await createAsyncResource(Promise.resolve({}));
-\t};
-\t
-\treturn { example };
-});`;
-
-const presenterWithPackageTemplate = `import { createPresenter } from '@azure-net/kit';
-import { ApplicationProvider } from '\${{context}}/application';
-
-export const {{name}}Presenter = createPresenter('{{name}}Presenter', () => {
-\tconst { /* extract services from ApplicationProvider */ } = ApplicationProvider();
-\t
-\tconst example = async () => {
-\t\t// Direct method without async helpers
-\t\treturn await Promise.resolve({});
-\t};
-\t
-\treturn { example };
-});`;
-
-export default async function generatePresenter() {
-    const context = await selectContext('Select context for presenter:');
-
-    const { name } = await prompts({
-        type: 'text',
-        name: 'name',
-        message: 'Module name (will create folder in delivery):'
-    });
-
-    // Check for core presenters
-    const corePresenters = await getAvailableFiles(
-        path.join(process.cwd(), 'src/core/presenters')
-    );
-
-    const presenterChoices = [
-        { title: 'Use createPresenter from package', value: 'package' },
-        ...corePresenters.map(p => ({ title: `Use ${p} from core`, value: p }))
-    ];
-
-    const { presenterType } = await prompts({
-        type: 'select',
-        name: 'presenterType',
-        message: 'Select presenter factory:',
-        choices: presenterChoices
-    });
-
-    const pascalName = toPascalCase(name);
-    const moduleLower = toKebabCase(pascalName);
-    const contextPath = getContextPath(context);
-    const modulePath = path.join(contextPath, 'delivery', moduleLower);
-    const filePath = path.join(modulePath, `${pascalName}Presenter.ts`);
-
-    const content = presenterType === 'package'
-        ? presenterWithPackageTemplate
-            .replace(/{{name}}/g, pascalName)
-            .replace(/{{context}}/g, context)
-        : presenterWithCoreTemplate
-            .replace(/{{name}}/g, pascalName)
-            .replace(/{{corePresenter}}/g, presenterType)
-            .replace(/{{context}}/g, context);
-
-    await writeIfNotExists(filePath, content);
-    await writeIfNotExists(
-        path.join(modulePath, 'index.ts'),
-        `export * from './${pascalName}Presenter';`
-    );
-
-    // Update core index
-    await updateCoreIndex();
-
-    console.log(`✅ Presenter created at ${filePath}`);
-    console.log(`\n💡 Remember to extract needed services from ApplicationProvider in the presenter.`);
-}

package/src/commands/generate/generateRepository.js

@@ -1,76 +0,0 @@
-import prompts from 'prompts';
-import path from 'path';
-import { selectContext, getContextPath, toPascalCase, getAvailableFiles, toCamelCase } from '../../utils/contextUtils.js';
-import { writeIfNotExists, updateIndexTs, updateCoreIndex } from '../../utils/fileUtils.js';
-
-const repositoryTemplate = `import { {{datasource}} } from '{{datasourceImport}}';
-
-export class {{name}}Repository {
-\tconstructor(private {{datasourceVar}}: {{datasource}}) {}
-\t
-\tpublic async example() {
-\t\treturn this.{{datasourceVar}}.createRequest(({ http }) => 
-\t\t\thttp.get('/endpoint')
-\t\t).then(res => res.getData());
-\t}
-}`;
-
-export default async function generateRepository() {
-    const context = await selectContext('Select context for repository:');
-
-    const { name } = await prompts({
-        type: 'text',
-        name: 'name',
-        message: 'Repository name (without "Repository" suffix):'
-    });
-
-    // 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 } }))
-    ];
-
-    if (allDatasources.length === 0) {
-        console.error('❌ No datasources available. Create a datasource first.');
-        return;
-    }
-
-    const { datasource } = await prompts({
-        type: 'select',
-        name: 'datasource',
-        message: 'Select datasource:',
-        choices: allDatasources
-    });
-
-    const pascalName = toPascalCase(name);
-    const repoPath = path.join(contextPath, 'infrastructure/http/repositories');
-    const filePath = path.join(repoPath, `${pascalName}Repository.ts`);
-
-    // Generate repository
-    const datasourceImport = datasource.from === 'core'
-        ? '$core/datasources'
-        : `\${context}/infrastructure/http/datasources`;
-
-    const content = repositoryTemplate
-        .replace(/{{name}}/g, pascalName)
-        .replace(/{{datasource}}/g, datasource.name)
-        .replace(/{{datasourceImport}}/g, datasourceImport)
-        .replace(/{{datasourceVar}}/g, toCamelCase(datasource.name));
-
-    await writeIfNotExists(filePath, content);
-    await updateIndexTs(repoPath);
-
-    // Update core index
-    await updateCoreIndex();
-
-    console.log(`✅ Repository created at ${filePath}`);
-    console.log(`\n💡 Remember to manually add this repository to InfrastructureProvider when needed.`);
-}

package/src/commands/generate/generateResponse.js

@@ -1,41 +0,0 @@
-import prompts from 'prompts';
-import path from 'path';
-import { selectContext, getContextPath, toPascalCase } from '../../utils/contextUtils.js';
-import { writeIfNotExists, updateIndexTs, updateCoreIndex } from '../../utils/fileUtils.js';
-
-const responseTemplate = `import { ResponseBuilder } from '@azure-net/kit/infra';
-
-export class {{name}}Response<TData = unknown, TMeta = unknown> extends ResponseBuilder<TData, TMeta, TData> {
-}`;
-
-export default async function generateResponse() {
-    const context = await selectContext('Select context for response (or core):');
-
-    const { name } = await prompts({
-        type: 'text',
-        name: 'name',
-        message: 'Response name (without "Response" suffix):'
-    });
-
-    const pascalName = toPascalCase(name);
-    const contextPath = context === 'core'
-        ? path.join(process.cwd(), 'src/core')
-        : getContextPath(context);
-
-    const responsePath = context === 'core'
-        ? path.join(contextPath, 'responses')
-        : path.join(contextPath, 'infrastructure/responses');
-
-    const content = responseTemplate.replace(/{{name}}/g, pascalName);
-    const filePath = path.join(responsePath, `${pascalName}Response.ts`);
-
-    await writeIfNotExists(filePath, content);
-    await updateIndexTs(responsePath);
-
-    // Update core index if needed
-    if (context === 'core') {
-        await updateCoreIndex();
-    }
-
-    console.log(`✅ Response created at ${filePath}`);
-}

package/src/commands/generate/generateSchema.js

@@ -1,96 +0,0 @@
-import prompts from 'prompts';
-import path from 'path';
-import fs from 'fs/promises';
-import { selectContext, getContextPath, toPascalCase, getAvailableFiles } from '../../utils/contextUtils.js';
-import { writeIfNotExists, updateIndexTs } from '../../utils/fileUtils.js';
-
-const schemaWithCoreTemplate = `import { {{coreSchema}} } from '\$core/schemas';
-
-export const {{name}}Schema = {{coreSchema}}()
-\t.rules((rules) => ({
-\t\t// Add validation rules here
-\t}))
-\t.create();`;
-
-const schemaWithPackageTemplate = `import { createSchemaFactory } from '@azure-net/kit';
-import { createRules, validationMessagesI18n } from '@azure-net/kit/schema';
-
-const Schema = createSchemaFactory(createRules(validationMessagesI18n));
-
-export const {{name}}Schema = Schema()
-\t.rules((rules) => ({
-\t\t// Add validation rules here
-\t}))
-\t.create();`;
-
-export default async function generateSchema() {
-    const context = await selectContext('Select context for schema:');
-
-    if (context === 'core') {
-        console.error('❌ Cannot create schema in core. Choose a specific context.');
-        return;
-    }
-
-    const { module } = await prompts({
-        type: 'text',
-        name: 'module',
-        message: 'Module name (folder in delivery):'
-    });
-
-    const { name } = await prompts({
-        type: 'text',
-        name: 'name',
-        message: 'Schema name (without "Schema" suffix):'
-    });
-
-    // Check for core schemas
-    const coreSchemas = await getAvailableFiles(
-        path.join(process.cwd(), 'src/core/schemas')
-    );
-
-    const choices = [
-        { title: 'Use createSchemaFactory from package', value: 'package' },
-        ...coreSchemas.map(s => ({ title: `Use ${s} from core`, value: s }))
-    ];
-
-    const { schemaType } = await prompts({
-        type: 'select',
-        name: 'schemaType',
-        message: 'Select schema factory:',
-        choices
-    });
-
-    const pascalName = toPascalCase(name);
-    const moduleName = toPascalCase(module);
-    const moduleLower = moduleName.toLowerCase();
-    const entityLower = moduleName.toLowerCase();
-    const contextPath = getContextPath(context);
-    const schemaPath = path.join(contextPath, 'delivery', moduleLower, 'schema');
-    const filePath = path.join(schemaPath, `${pascalName}Schema.ts`);
-
-    const content = schemaType === 'package'
-        ? schemaWithPackageTemplate
-            .replace(/{{name}}/g, pascalName)
-            .replace(/{{context}}/g, context)
-            .replace(/{{entityLower}}/g, entityLower)
-        : schemaWithCoreTemplate
-            .replace(/{{name}}/g, pascalName)
-            .replace(/{{context}}/g, context)
-            .replace(/{{entityLower}}/g, entityLower)
-            .replace(/{{coreSchema}}/g, schemaType);
-
-    await writeIfNotExists(filePath, content);
-    await updateIndexTs(schemaPath);
-
-    // Update module index
-    const moduleIndexPath = path.join(contextPath, 'delivery', moduleLower, 'index.ts');
-    if (await fs.access(moduleIndexPath).then(() => true).catch(() => false)) {
-        let indexContent = await fs.readFile(moduleIndexPath, 'utf-8');
-        if (!indexContent.includes(`export * from './schema'`)) {
-            indexContent += `\nexport * from './schema';`;
-            await fs.writeFile(moduleIndexPath, indexContent, 'utf-8');
-        }
-    }
-
-    console.log(`✅ Schema created at ${filePath}`);
-}

package/src/commands/generate/generateService.js

@@ -1,71 +0,0 @@
-import prompts from 'prompts';
-import path from 'path';
-import { selectContext, getContextPath, toPascalCase, getAvailableFiles } from '../../utils/contextUtils.js';
-import { writeIfNotExists, updateIndexTs } from '../../utils/fileUtils.js';
-
-const serviceTemplate = `import { ClassMirror } from '@azure-net/kit';
-import { {{repository}} } from '\${{context}}/infrastructure/http/repositories';
-
-export class {{name}}Service extends ClassMirror<{{repository}}> {
-\tconstructor(private {{repositoryVar}}: {{repository}}) {
-\t\tsuper({{repositoryVar}});
-\t}
-\t
-\tdeclare example: {{repository}}['example'];
-}`;
-
-const serviceWithoutRepoTemplate = `export class {{name}}Service {
-\tconstructor() {}
-\t
-\tpublic async example() {
-\t\t// Implement service logic
-\t\treturn {};
-\t}
-}`;
-
-export default async function generateService() {
-    const context = await selectContext('Select context for service:');
-
-    const { name } = await prompts({
-        type: 'text',
-        name: 'name',
-        message: 'Service name (without "Service" suffix):'
-    });
-
-    // Get available repositories
-    const contextPath = getContextPath(context);
-    const repositories = await getAvailableFiles(
-        path.join(contextPath, 'infrastructure', 'http', 'repositories')
-    );
-
-    const choices = [
-        { title: 'Without repository', value: null },
-        ...repositories.map(r => ({ title: `${r}`, value: r }))
-    ];
-
-    const { repository } = await prompts({
-        type: 'select',
-        name: 'repository',
-        message: 'Select repository:',
-        choices
-    });
-
-    const pascalName = toPascalCase(name);
-    const servicePath = path.join(contextPath, 'application', 'services');
-    const filePath = path.join(servicePath, `${pascalName}Service.ts`);
-
-    // Generate service
-    const content = repository
-        ? serviceTemplate
-            .replace(/{{name}}/g, pascalName)
-            .replace(/{{repository}}/g, repository)
-            .replace(/{{repositoryVar}}/g, repository.charAt(0).toLowerCase() + repository.slice(1))
-            .replace(/{{context}}/g, context)
-        : serviceWithoutRepoTemplate.replace(/{{name}}/g, pascalName);
-
-    await writeIfNotExists(filePath, content);
-    await updateIndexTs(servicePath);
-
-    console.log(`✅ Service created at ${filePath}`);
-    console.log(`\n💡 Remember to manually add this service to ApplicationProvider when needed.`);
-}

package/src/commands/generate/generateWidget.js

@@ -1,53 +0,0 @@
-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`);
-}