generator-codedesignplus 0.1.0 → 0.2.0-alpha.2

package/generators/microservice/core/appsettings.mjs

@@ -39,15 +39,16 @@ export default class AppSettingsGenerator {
         });
 
         try {
-            this.updateConfigVault(path.join('tools', 'vault','config-vault.ps1'), options);
-            this.updateConfigVault(path.join('tools', 'vault','config-vault.sh'), options);
+            this._updateConfigVault(path.join('tools', 'vault','config-vault.ps1'), options);
+            this._updateConfigVault(path.join('tools', 'vault','config-vault.sh'), options);
+            this._updateReadme(options);
         } catch (error) {
             console.log('The vault configuration could not be updated.');
             console.log(error);
         }    
     }
 
-    updateConfigVault(file, options) {
+    _updateConfigVault(file, options) {
         const configFile = this._generator.destinationPath(file);
 
         let config = this._generator.fs.read(configFile);
@@ -64,6 +65,16 @@ export default class AppSettingsGenerator {
         this._generator.fs.write(configFile, config);
     }
 
+    _updateReadme(options) {
+        const readmeFile = this._generator.destinationPath('README.md');
+
+        let readme = this._generator.fs.read(readmeFile);
+
+        readme = readme.replace(/\bms-archetype\b/g, options.appSettings.appName);
+
+        this._generator.fs.write(readmeFile, readme);
+    }
+
     getArguments() {
         this._generator.option('description', { type: String, alias: 'd', required: true, description: 'A detailed description of the microservice providing clear context about its purpose.' });
         this._generator.option('contact-name', { type: String, alias: 'cn', required: true, description: 'Name of the contact person responsible for the microservice.' });

package/generators/microservice/core/asyncWorker.mjs

@@ -1,5 +1,6 @@
 import path from 'path';
 import AppSettingsGenerator from './appsettings.mjs';
+import ConsumerGenerator from './consumer.mjs';
 import fsSync from 'fs';
 import fs from 'fs/promises';
 import { glob } from 'glob';
@@ -8,6 +9,7 @@ export default class AsyncWorkerGenerator {
 
     constructor(utils, generator) {
         this._appsettings = new AppSettingsGenerator(utils, generator);
+        this._consumerGenerator = new ConsumerGenerator(utils, generator);
 
         this._utils = utils;
         this._generator = generator;
@@ -44,6 +46,9 @@ export default class AsyncWorkerGenerator {
 
             await this._generateFiles(templateAsyncWorkerProject, ignores, options, asyncWorkerIntegrationTestProjectPathDestination);
         }
+
+        
+        this._consumerGenerator.generate(options);
         
         await this._generator.spawnCommand('dotnet', ['sln', `${destination}/${options.solution}.sln`, 'add', `${asyncWorkerProjectPathDestination}`, '--solution-folder', 'src/entrypoints']);
         await this._generator.spawnCommand('dotnet', ['sln', `${destination}/${options.solution}.sln`, 'add', `${asyncWorkerTestProjectPathDestination}`, '--solution-folder', 'tests/unit']);
@@ -60,27 +65,15 @@ export default class AsyncWorkerGenerator {
     }
 
     getArguments() {
-
+        this._consumerGenerator.getArguments();
     }
 
     _getIgnores() {
-        const ignores = ['**/bin/**', '**/obj/**'];
-
-        const items = {
-            entryPoints_asyncWorker: [
-                'src/entrypoints/CodeDesignPlus.Net.Microservice.AsyncWorker/Consumers/**'
-            ],
-            integrationTest_asyncWorker: [
-                'tests/integration/CodeDesignPlus.Net.Microservice.AsyncWorker.Test/Consumers/**'
-            ],
-            unitTest_asyncWorker: [
-                'tests/unit/CodeDesignPlus.Net.Microservice.AsyncWorker.Test/Consumers/*.cs',
-            ]
-        }
-
-        for (const key in items) {
-            ignores.push(...items[key]);
-        }
+        const ignores = [
+            '**/bin/**', 
+            '**/obj/**',  
+            '**/Consumers/**'
+        ];
 
         return ignores;
     }

package/generators/microservice/core/consumer.mjs

@@ -51,14 +51,15 @@ export default class ConsumerGenerator {
 
             await this._commandGenerator.generate(options);
 
-            await this._domainEventGenerator.generate(options);
+            await this._domainEventGenerator.generate(options, options.consumer.microservice);
         }
     }
 
     getArguments() {
         this._generator.option('consumer-name', { type: String, required: true, description: 'Name of the event consumer, specifying the type of event it consumes.' });
         this._generator.option('consumer-aggregate', { type: String, required: true, description: 'Aggregate to which the consumer belongs, defining the context of the event.' });
-        this._generator.option('consumer-action', { type: String, required: true, description: 'Action to be performed in the consumer when it receives an event.' });
+        this._generator.option('consumer-action', { type: String, required: true, description: 'Action to be performed in the consumer when it receives an event.' });        
+        this._generator.option('consumer-microservice', { type: String, required: true, description: 'Name of the microservice that publishes the event.' });
 
         this._generator.options = {
             ...this._generator.options,
@@ -66,6 +67,7 @@ export default class ConsumerGenerator {
                 aggregate: this._generator.options['consumerAggregate'],
                 consumer: this._generator.options['consumerName'],
                 action: this._generator.options['consumerAction'],
+                microservice: this._generator.options['consumerMicroservice']
             },
             enableAsyncWorker: this._generator.options.consumerName !== undefined && this._generator.options.consumerName !== null
         };

package/generators/microservice/core/domainEvent.mjs

@@ -9,8 +9,7 @@ export default class DomainEventGenerator {
         this.name = 'domainEvent';
     }
 
-    async generate(options) {
-
+    async generate(options, microservice) {
         const to = options.isConsumer ? options.paths.src.asyncWorker : options.paths.src.domain;
         const ns = options.isConsumer ? `${options.solution}.AsyncWorker.DomainEvents` : `${options.solution}.Domain.DomainEvents`;
 
@@ -18,12 +17,13 @@ export default class DomainEventGenerator {
             const domainEvent = options.domainEvents[key];
 
             await this._generator.fs.copyTplAsync(
-                this._generator.templatePath('domain-event/ItemDomainEvent.cs'),
+                this._generator.templatePath(`domain-event/${options.isConsumer ? 'ItemListenerDomainEvent' : 'ItemDomainEvent'}.cs`),
                 this._generator.destinationPath(path.join(to, `DomainEvents`, domainEvent.file)),
                 {
                     ns: ns,
                     name: domainEvent.fullname,
-                    entity: options.aggregate.fullname
+                    entity: options.aggregate.fullname,
+                    microservice: microservice,
                 }
             );
         }

package/generators/microservice/core/grpc.mjs

@@ -59,6 +59,8 @@ export default class GrpcGenerator {
         
         const files = glob.sync('**', { dot: true, nodir: true, cwd: templateGrpcProject, ignore: ignores });
 
+        console.log(templateGrpcProject, files);
+
         await this._utils.generateFiles(options, options.solution, templateGrpcProject, grpcProjectPathDestination, files);
 
         await this._appsettings.generate(options, [options.paths.src.grpc]);
@@ -72,25 +74,12 @@ export default class GrpcGenerator {
     }
 
     _getIgnores() {
-        const ignores = ['**/bin/**', '**/obj/**'];
-
-        const items = {
-            entryPoints_gRpc: [
-                'src/entrypoints/CodeDesignPlus.Net.Microservice.gRpc/Protos/*.proto',
-                'src/entrypoints/CodeDesignPlus.Net.Microservice.gRpc/Services/*.cs'
-            ],
-            integrationTest_gRpc: [
-                'tests/integration/CodeDesignPlus.Net.Microservice.gRpc.Test/Protos/**',
-                'tests/integration/CodeDesignPlus.Net.Microservice.gRpc.Test/Services/**'
-            ],
-            unitTest_gRpc: [
-                'tests/unit/CodeDesignPlus.Net.Microservice.gRpc.Test/Services/*.cs',
-            ]
-        }
-
-        for (const key in items) {
-            ignores.push(...items[key]);
-        }
+        const ignores = [
+            '**/bin/**', 
+            '**/obj/**',
+            '**/Protos/**',
+            '**/Services/**'
+        ];
 
         return ignores;
     }

package/generators/microservice/core/utils.mjs

@@ -1,5 +1,6 @@
 import { findUp } from 'find-up';
 import fs from 'fs/promises';
+import fsSync from 'fs';
 import path from 'path';
 import {
     AggregateModel,
@@ -16,8 +17,6 @@ import {
 } from '../types/index.mjs';
 import { AppSettingsModel } from '../types/appsettings.mjs';
 
-
-
 export default class Utils {
     constructor(generator) {
         this._generator = generator;
@@ -35,28 +34,24 @@ export default class Utils {
         this._generator.destinationRoot(pathBaseDir);
     }
 
-    async readArchetypeMetadata() {
-        const archetypeFile = await findUp('archetype.json');
-
-        if (!archetypeFile)
-            throw new Error('No se encontró el archivo archetype.json');
-
-        return await this._generator.fs.readJSON(archetypeFile);
-    }
-
     async getOptions(answers) {
-        const archetypeValues = this._generator.fs.readJSON(`${path.join(this._generator.destinationRoot())}/archetype.json`);
-
-        answers = { 
-            ...answers,  
-            organization: archetypeValues.organization,
-            microservice: archetypeValues.microservice,
-            description: archetypeValues.description,
-            organization: archetypeValues.organization,
-            aggregate: answers.aggregate ?? archetypeValues.aggregate,
-            vault: archetypeValues.vault,
-            contactName: archetypeValues.contactName,
-            contactEmail: archetypeValues.contactEmail
+        const pathJson = path.join(this._generator.destinationRoot(), 'archetype.json');
+
+        if (!fsSync.existsSync(pathJson))
+            throw new Error('⚠️ File archetype.json not found, using the answers provided.');
+
+        const archetypeValues = this._generator.fs.readJSON(pathJson);
+
+        answers = {
+            ...answers,
+            organization: archetypeValues?.organization ?? answers.organization,
+            microservice: archetypeValues?.microservice ?? answers.microservice,
+            description: archetypeValues?.description ?? answers.description,
+            organization: archetypeValues?.organization ?? answers.organization,
+            aggregate: answers.aggregate ?? archetypeValues?.aggregate,
+            vault: archetypeValues?.vault ?? answers.vault,
+            contactName: archetypeValues?.contactName ?? answers.contactName,
+            contactEmail: archetypeValues?.contactEmail ?? answers.contactEmail
         };
 
         const organization = this.toPascalCase(answers.organization);

package/generators/microservice/templates/domain-event/ItemDomainEvent.cs

@@ -4,7 +4,7 @@
 public class <%= name %>(
      Guid aggregateId,
      Guid? eventId = null,
-     DateTime? occurredAt = null,
+     Instant? occurredAt = null,
      Dictionary<string, object>? metadata = null
 ) : DomainEvent(aggregateId, eventId, occurredAt, metadata)
 {

package/generators/microservice/templates/domain-event/ItemListenerDomainEvent.cs

@@ -0,0 +1,15 @@
+namespace <%= ns %>;
+
+[EventKey<<%= entity %>>(1, "<%= name %>", "<%= microservice %>")]
+public class <%= name %>(
+     Guid aggregateId,
+     Guid? eventId = null,
+     Instant? occurredAt = null,
+     Dictionary<string, object>? metadata = null
+) : DomainEvent(aggregateId, eventId, occurredAt, metadata)
+{
+    public static <%= name %> Create(Guid aggregateId)
+    {
+        return new <%= name %>(aggregateId);
+    }
+}

package/generators/microservice/types/consumer.mjs

@@ -4,15 +4,17 @@ export class ConsumerModel extends BaseModel {
     constructor(data) {
         super();
 
+        
         this.sufix = 'Handler';
         this.name = this._validate(data.consumer, this.sufix);
         this.fullname = `${this.name}${this.sufix}`;
         this.file = `${this.fullname}.cs`;
-
+        
         this.aggregate =  `${this._validate(toPascalCase(data.aggregate), 'Aggregate')}`;
         this.action = data.action.toLowerCase();
         this.domainEvent = `${this._validate(toPascalCase(this.name), 'DomainEvent')}`;
         this.command = toPascalCase(data.action);
+        this.microservice = data.microservice.toLowerCase();
     }
 
     static from(data) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "generator-codedesignplus",
-  "version": "0.1.0",
+  "version": "0.2.0-alpha.2",
   "description": "Yeoman generator for creating microservices based on the CodeDesignPlus.Net.Microservice archetype.",
   "private": false,
   "main": "generators/index.mjs",