@azure-net/cli 2.0.4 → 2.0.6

package/bin/azure-net.js

@@ -18,7 +18,10 @@ import {
     generateSchema,
     generatePresenter,
     generateModule,
-    generateCrud
+    generateCrudBase,
+    generateCrudPresenter,
+    generatePresenterByService,
+    generateServiceByRepo
 } from '../src/commands/generate/index.js';
 
 const program = new Command();
@@ -32,7 +35,7 @@ program
 program
     .command('init:lint')
     .description('Setup linting and commit tools')
-    .action(initLint)
+    .action(initLint);
 
 program
     .command('init:structure')
@@ -113,8 +116,23 @@ program
     .action(generateModule);
 
 program
-    .command('make:crud')
-    .description('Generate CRUD module')
-    .action(generateCrud);
+    .command('make:crud-base')
+    .description('Generate CRUD repository and service')
+    .action(generateCrudBase);
+
+program
+    .command('make:crud-presenter')
+    .description('Generate CRUD presenter for existing service')
+    .action(generateCrudPresenter);
+
+program
+    .command('make:presenter-by-service')
+    .description('Generate presenter from existing service')
+    .action(generatePresenterByService);
+
+program
+    .command('make:service-by-repo')
+    .description('Generate service from existing repository')
+    .action(generateServiceByRepo);
 
 program.parse();

package/package.json

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

package/src/commands/generate/generateCrudBase.js

@@ -0,0 +1,188 @@
+import prompts from 'prompts';
+import path from 'path';
+import { selectContext, getContextPath, toPascalCase, toCamelCase, getAvailableFiles } from '../../utils/contextUtils.js';
+import { writeIfNotExists, updateIndexTs } from '../../utils/fileUtils.js';
+
+// Templates for CRUD base generation
+const entityTemplate = `export interface I{{name}} {
+\tid: number;
+\t// Add entity fields here
+\tcreated_at: string;
+\tupdated_at: string;
+}`;
+
+const portsIndexTemplate = `import type { I{{name}} } from '\${{context}}/Domain/Entities/{{name}}';
+
+export interface I{{name}}Collection {
+\tdata: I{{name}}[];
+\ttotal: number;
+}
+
+export interface I{{name}}CollectionQuery {
+\tpage?: number;
+\tperPage?: number;
+\t[key: string]: unknown;
+}
+
+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[key: string]: unknown;
+}`;
+
+const repositoryTemplate = `import { {{datasource}} } from '{{datasourceImport}}';
+import type { I{{name}} } from '\${{context}}/Domain/Entities/{{name}}';
+import type { 
+\tI{{name}}Collection,
+\tI{{name}}CollectionQuery,
+\tI{{name}}CreateRequest,
+\tI{{name}}UpdateRequest
+} from '\${{context}}/Domain/Ports/{{name}}';
+
+export class {{name}}Repository {
+\tprivate endpoint = '{{endpoint}}';
+\t
+\tconstructor(private {{datasourceVar}}: {{datasource}}) {}
+\t
+\tpublic async collection(query?: I{{name}}CollectionQuery) {
+\t\treturn this.{{datasourceVar}}.createRequest<I{{name}}Collection>(({ http, query: q }) => 
+\t\t\thttp.get(\`\${this.endpoint}\${q.build(query || {})}\`)
+\t\t).then(res => res.getData());
+\t}
+\t
+\tpublic async resource(id: number) {
+\t\treturn this.{{datasourceVar}}.createRequest<I{{name}}>(({ http }) => 
+\t\t\thttp.get(\`\${this.endpoint}/\${id}\`)
+\t\t).then(res => res.getData());
+\t}
+\t
+\tpublic async create(data: I{{name}}CreateRequest) {
+\t\treturn this.{{datasourceVar}}.createRequest<I{{name}}>(({ http }) => 
+\t\t\thttp.post(this.endpoint, { json: data })
+\t\t).then(res => res.getData());
+\t}
+\t
+\tpublic async update(id: number, data: I{{name}}UpdateRequest) {
+\t\treturn this.{{datasourceVar}}.createRequest<I{{name}}>(({ http }) => 
+\t\t\thttp.put(\`\${this.endpoint}/\${id}\`, { json: data })
+\t\t).then(res => res.getData());
+\t}
+\t
+\tpublic async remove(id: number) {
+\t\treturn this.{{datasourceVar}}.createRequest<void>(({ http }) => 
+\t\t\thttp.delete(\`\${this.endpoint}/\${id}\`)
+\t\t).then(() => undefined);
+\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 collection: {{name}}Repository['collection'];
+\tdeclare resource: {{name}}Repository['resource'];
+\tdeclare create: {{name}}Repository['create'];
+\tdeclare update: {{name}}Repository['update'];
+\tdeclare remove: {{name}}Repository['remove'];
+}`;
+
+export default async function generateCrudBase() {
+    const context = await selectContext('Select context for CRUD base:');
+
+    const { name } = await prompts({
+        type: 'text',
+        name: 'name',
+        message: 'Entity name (PascalCase):'
+    });
+
+    const { endpoint } = await prompts({
+        type: 'text',
+        name: 'endpoint',
+        message: 'API endpoint (e.g. /api/users):'
+    });
+
+    // Get available datasources
+    const contextPath = getContextPath(context);
+    const sharedDatasources = await getAvailableFiles(
+        path.join(process.cwd(), 'src/app/shared/Datasource')
+    );
+    const contextDatasources = await getAvailableFiles(
+        path.join(contextPath, 'Infrastructure/Http/Datasource')
+    );
+
+    const allDatasources = [
+        ...sharedDatasources.map(d => ({ title: `${d} (shared)`, value: { name: d, from: 'shared' } })),
+        ...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);
+
+    console.log('\n🚀 Generating CRUD base (repository & service)...\n');
+
+    // 1. Create Entity
+    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);
+    await writeIfNotExists(
+        path.join(portsPath, 'index.ts'),
+        portsIndexTemplate
+            .replace(/{{name}}/g, pascalName)
+            .replace(/{{context}}/g, context)
+    );
+
+    // 3. Create Repository
+    const repoPath = path.join(contextPath, 'Infrastructure/Http/Repositories');
+    const datasourceImport = datasource.from === 'shared'
+        ? '$shared/Datasource'
+        : `\$${context}/Infrastructure/Http/Datasource`;
+
+    await writeIfNotExists(
+        path.join(repoPath, `${pascalName}Repository.ts`),
+        repositoryTemplate
+            .replace(/{{name}}/g, pascalName)
+            .replace(/{{context}}/g, context)
+            .replace(/{{endpoint}}/g, endpoint)
+            .replace(/{{datasource}}/g, datasource.name)
+            .replace(/{{datasourceImport}}/g, datasourceImport)
+            .replace(/{{datasourceVar}}/g, toCamelCase(datasource.name))
+    );
+    await updateIndexTs(repoPath);
+
+    // 4. 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);
+
+    console.log(`✅ CRUD 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`);
+    console.log(`   3. Use 'make:crud-presenter' to create the CRUD presenter`);
+}

package/src/commands/generate/generateCrudPresenter.js

@@ -0,0 +1,220 @@
+import prompts from 'prompts';
+import path from 'path';
+import fs from 'fs/promises';
+import { selectContext, getContextPath, toPascalCase, getAvailableFiles, getApplicationProviderServices } from '../../utils/contextUtils.js';
+import { writeIfNotExists } from '../../utils/fileUtils.js';
+
+const createSchemaTemplate = `import { {{schemaFactory}} } from '{{schemaImport}}';
+import type { I{{name}}CreateRequest } from '\${{context}}/Domain/Ports/{{entity}}';
+
+export const Create{{name}}Schema = {{schemaFactory}}<I{{name}}CreateRequest>()
+\t.rules((rules) => ({
+\t\t// Add validation rules here
+\t}))
+\t.create();`;
+
+const updateSchemaTemplate = `import { {{schemaFactory}} } from '{{schemaImport}}';
+import type { I{{name}}UpdateRequest } from '\${{context}}/Domain/Ports/{{entity}}';
+
+export const Update{{name}}Schema = {{schemaFactory}}<I{{name}}UpdateRequest>()
+\t.rules((rules) => ({
+\t\t// Add validation rules here
+\t}))
+\t.create();`;
+
+const presenterWithSharedTemplate = `import { {{presenterFactory}} } from '$shared/Presenter';
+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 = {{presenterFactory}}('{{name}}Presenter', ({ createAsyncResource, createAsyncAction }) => {
+\tconst { {{serviceName}} } = ApplicationProvider();
+\t
+\tconst collection = async (query?: I{{name}}CollectionQuery) => 
+\t\tawait createAsyncResource({{serviceName}}.collection(query));
+\t
+\tconst resource = async (id: number) => 
+\t\tawait createAsyncResource({{serviceName}}.resource(id));
+\t
+\tconst create = async (request: I{{name}}CreateRequest) =>
+\t\tawait createAsyncAction({{serviceName}}.create(Create{{name}}Schema.from(request).json()));
+\t
+\tconst update = async (id: number, request: I{{name}}UpdateRequest) =>
+\t\tawait createAsyncAction({{serviceName}}.update(id, Update{{name}}Schema.from(request).json()));
+\t
+\tconst remove = async (id: number) => 
+\t\tawait createAsyncAction({{serviceName}}.remove(id));
+\t
+\treturn { collection, resource, create, update, remove };
+});`;
+
+const presenterWithoutSharedTemplate = `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 { {{serviceName}} } = ApplicationProvider();
+\t
+\tconst collection = async (query?: I{{name}}CollectionQuery) => 
+\t\tawait {{serviceName}}.collection(query);
+\t
+\tconst resource = async (id: number) => 
+\t\tawait {{serviceName}}.resource(id);
+\t
+\tconst create = async (request: I{{name}}CreateRequest) =>
+\t\tawait {{serviceName}}.create(Create{{name}}Schema.from(request).json());
+\t
+\tconst update = async (id: number, request: I{{name}}UpdateRequest) =>
+\t\tawait {{serviceName}}.update(id, Update{{name}}Schema.from(request).json());
+\t
+\tconst remove = async (id: number) => 
+\t\tawait {{serviceName}}.remove(id);
+\t
+\treturn { collection, resource, create, update, remove };
+});`;
+
+export default async function generateCrudPresenter() {
+    const context = await selectContext('Select context for CRUD 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 CRUD:',
+        choices: services.map(s => ({ title: s, value: s }))
+    });
+
+    // Extract entity name from service name
+    const entityName = service.replace('Service', '');
+    const pascalName = toPascalCase(entityName);
+
+    // Get schema factory
+    const sharedSchemas = await getAvailableFiles(
+        path.join(process.cwd(), 'src/app/shared/Schema')
+    );
+
+    const { schemaType } = await prompts({
+        type: 'select',
+        name: 'schemaType',
+        message: 'Select schema factory:',
+        choices: [
+            { title: 'Use createSchemaFactory from package', value: 'package' },
+            ...sharedSchemas.map(s => ({ title: `Use ${s} from shared`, value: s }))
+        ]
+    });
+
+    // Get presenter factory
+    const sharedPresenters = await getAvailableFiles(
+        path.join(process.cwd(), 'src/app/shared/Presenter')
+    );
+
+    const { presenterType } = await prompts({
+        type: 'select',
+        name: 'presenterType',
+        message: 'Select presenter factory:',
+        choices: [
+            { title: 'Use createPresenter from package', value: 'package' },
+            ...sharedPresenters.map(p => ({ title: `Use ${p} from shared`, value: p }))
+        ]
+    });
+
+    const contextPath = getContextPath(context);
+    const deliveryModulePath = path.join(contextPath, 'Delivery', pascalName);
+    const schemaPath = path.join(deliveryModulePath, 'Schema');
+
+    console.log('\n🚀 Generating CRUD presenter...\n');
+
+    // Create schemas
+    const schemaFactory = schemaType === 'package' ? 'Schema' : schemaType;
+    const schemaImport = schemaType === 'package'
+        ? '@azure-net/kit'
+        : '$shared/Schema';
+
+    if (schemaType === 'package') {
+        const schemaImportFull = `import { createSchemaFactory } from '@azure-net/kit';
+import { createRules, validationMessagesI18n } from '@azure-net/kit/schema';
+
+const Schema = createSchemaFactory(createRules(validationMessagesI18n));`;
+
+        await writeIfNotExists(
+            path.join(schemaPath, `Create${pascalName}Schema.ts`),
+            schemaImportFull + '\n' + createSchemaTemplate
+                .replace('import { {{schemaFactory}} } from \'{{schemaImport}}\';\n', '')
+                .replace(/{{name}}/g, pascalName)
+                .replace(/{{context}}/g, context)
+                .replace(/{{entity}}/g, pascalName)
+                .replace(/{{schemaFactory}}/g, 'Schema')
+        );
+
+        await writeIfNotExists(
+            path.join(schemaPath, `Update${pascalName}Schema.ts`),
+            schemaImportFull + '\n' + updateSchemaTemplate
+                .replace('import { {{schemaFactory}} } from \'{{schemaImport}}\';\n', '')
+                .replace(/{{name}}/g, pascalName)
+                .replace(/{{context}}/g, context)
+                .replace(/{{entity}}/g, pascalName)
+                .replace(/{{schemaFactory}}/g, 'Schema')
+        );
+    } else {
+        await writeIfNotExists(
+            path.join(schemaPath, `Create${pascalName}Schema.ts`),
+            createSchemaTemplate
+                .replace(/{{name}}/g, pascalName)
+                .replace(/{{context}}/g, context)
+                .replace(/{{entity}}/g, pascalName)
+                .replace(/{{schemaFactory}}/g, schemaFactory)
+                .replace(/{{schemaImport}}/g, schemaImport)
+        );
+
+        await writeIfNotExists(
+            path.join(schemaPath, `Update${pascalName}Schema.ts`),
+            updateSchemaTemplate
+                .replace(/{{name}}/g, pascalName)
+                .replace(/{{context}}/g, context)
+                .replace(/{{entity}}/g, pascalName)
+                .replace(/{{schemaFactory}}/g, schemaFactory)
+                .replace(/{{schemaImport}}/g, schemaImport)
+        );
+    }
+    await updateIndexTs(schemaPath);
+
+    // Create Presenter
+    const presenterTemplate = presenterType === 'package'
+        ? presenterWithoutSharedTemplate
+        : presenterWithSharedTemplate;
+
+    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';\nexport * from './Schema';`
+    );
+
+    console.log(`✅ CRUD presenter for ${pascalName} created successfully!`);
+}

package/src/commands/generate/generateDatasource.js

@@ -1,32 +1,20 @@
 import prompts from 'prompts';
 import path from 'path';
-import { selectContext, getContextPath, toPascalCase, getAvailableFiles, toCamelCase } from '../../utils/contextUtils.js';
+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 });
-\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(private http: HttpService) {
-\t\tsuper({ http });
-\t}
-}`;
-
 export default async function generateDatasource() {
-    const context = await selectContext();
+    const context = await selectContext('Select context for datasource (or shared):');
 
     const { name } = await prompts({
         type: 'text',
@@ -35,22 +23,23 @@ export default async function generateDatasource() {
     });
 
     const pascalName = toPascalCase(name);
-    const camelName = toCamelCase(name);
-    const contextPath = getContextPath(context);
+    const contextPath = context === 'shared'
+        ? path.join(process.cwd(), 'src/app/shared')
+        : getContextPath(context);
 
     // Get available responses
-    const coreResponses = await getAvailableFiles(
-        path.join(process.cwd(), 'src/app/core/Response')
+    const sharedResponses = await getAvailableFiles(
+        path.join(process.cwd(), 'src/app/shared/Response')
     );
 
-    const contextResponses = context !== 'core'
+    const contextResponses = context !== 'shared'
         ? await getAvailableFiles(path.join(contextPath, 'Infrastructure/Response'))
         : [];
 
     const allResponses = [
-        ...coreResponses.map(r => ({
-            title: `${r} (core)`,
-            value: { name: r, from: 'core' }
+        ...sharedResponses.map(r => ({
+            title: `${r} (shared)`,
+            value: { name: r, from: 'shared' }
         })),
         ...contextResponses.map(r => ({
             title: `${r} (${context})`,
@@ -70,18 +59,16 @@ 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'
+    const datasourcePath = context === 'shared'
         ? 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'
-            : '../../Response';
+    const responseImport = response.from === 'shared'
+        ? context === 'shared' ? '../Response' : '$shared/Response'
+        : `\$${context}/Infrastructure/Response`;
 
     const content = datasourceWithResponseTemplate
         .replace(/{{name}}/g, pascalName)
@@ -93,63 +80,5 @@ 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');
 }

package/src/commands/generate/generateModule.js

@@ -6,11 +6,13 @@ import generateSchema from './generateSchema.js';
 
 export default async function generateModule() {
     console.log('🚀 Generating complete module...\n');
+    console.log('⚠️  Note: This will create repository, service, presenter and schemas.');
+    console.log('    You will need to manually wire them in the providers.\n');
 
     const { confirm } = await prompts({
         type: 'confirm',
         name: 'confirm',
-        message: 'This will create repository, service, presenter and schemas. Continue?'
+        message: 'Continue?'
     });
 
     if (confirm) {
@@ -19,5 +21,11 @@ export default async function generateModule() {
         await generatePresenter();
         await generateSchema(); // Create schema
         await generateSchema(); // Update schema
+
+        console.log('\n✅ Module generation complete!');
+        console.log('\n💡 Remember to:');
+        console.log('   1. Add repository to InfrastructureProvider');
+        console.log('   2. Add service to ApplicationProvider');
+        console.log('   3. Update presenter to use the service from ApplicationProvider');
     }
 }