generator-codedesignplus 0.0.1-rc.2

package/generators/microservice/core/microservice.mjs

@@ -0,0 +1,212 @@
+import { glob } from 'glob';
+import path from 'path';
+import ErrorsGenerator from './errors.mjs';
+import AppSettingsGenerator from './appsettings.mjs';
+import AggregateGenerator from './aggregate.mjs';
+import CommandGenerator from './command.mjs';
+import QueryGenerator from './query.mjs';
+import ControllerGenerator from './controller.mjs';
+import DtoGenerator from './dataTransferObject.mjs';
+import ValueObjectGenerator from './valueObject.mjs';
+import DomainEventGenerator from './domainEvent.mjs';
+import EntityGenerator from './entity.mjs';
+import RepositoryGenerator from './repository.mjs';
+import ProtoGenerator from './proto.mjs';
+import ConsumerGenerator from './consumer.mjs';
+
+import fs from 'fs/promises';
+import { toPascalCase } from '../types/base.mjs';
+
+export default class MicroserviceGenerator {
+
+    constructor(utils, generator) {
+        this._utils = utils;
+        this._generator = generator;
+        this._errorGenerator = new ErrorsGenerator(utils, generator);
+        this._appsettings = new AppSettingsGenerator(utils, generator);
+        this._consumerGenerator = new ConsumerGenerator(utils, generator);
+        this._protoGenerator = new ProtoGenerator(utils, generator);
+        this.name = 'microservice';
+    }
+
+    getArguments() {
+        this._generator.option('is-crud', { type: Boolean, alias: 'ic', required: false, description: 'Indicates that the microservice will be a CRUD, generating the basic structure for data management operations.' });
+        this._generator.option('enable-grpc', { type: Boolean, alias: 'eg', required: true, description: 'Enables the gRPC API for the microservice, which offers a high-performance communication protocol.' });
+        this._generator.option('enable-async-worker', { type: Boolean, alias: 'eaw', required: true, description: 'Enables an asynchronous worker for handling background tasks and events, improving scalability.' });
+        this._generator.option('aggregate', { type: String, alias: 'a', required: true, description: 'The name of the microservice\'s root aggregate, essential for domain organization.' });
+                
+        this._appsettings.getArguments();
+        
+        if (this._generator.options.enableAsyncWorker)
+            this._consumerGenerator.getArguments();
+        
+        const aggregate = toPascalCase(this._generator.options.aggregate);
+        
+        this._generator.options = {
+            ...this._generator.options,
+            aggregate: aggregate,
+            domainEvents: `${aggregate}Created, ${aggregate}Updated, ${aggregate}Deleted`,
+            commands: `Create${aggregate}, Update${aggregate}, Delete${aggregate}`,
+            queries: `Get${aggregate}ById, GetAll${aggregate}`,
+        }
+        if (!this._generator.options.isCrud) {
+            this._generator.option('domainEvents', { type: String, alias: 'de', required: true, description: 'Comma-separated list of domain events, fundamental in asynchronous communication between microservices.' });
+            this._generator.option('entities', { type: String, alias: 'e', required: true, description: 'Comma-separated list of entities.' });
+            this._generator.option('commands', { type: String, alias: 'cs', required: false, description: 'Comma-separated list of commands representing actions from the user or system.' });
+            this._generator.option('queries', { type: String, alias: 'q', required: false, description: 'Comma-separated list of queries, representing requests for information from the system.' });
+        }
+        
+        this._generator.options = {
+            ...this._generator.options,
+            repository: aggregate,
+            controller: aggregate,
+            dataTransferObject: aggregate,
+            protoName: aggregate
+        }
+    }
+
+    async generate(options) {
+        const namespace = `${options.organization}.Net.Microservice.${options.microservice}`;
+
+        const template = this._generator.templatePath('microservice');
+
+        const destination = path.join(this._generator.destinationRoot(), namespace);
+
+        const ignores = this._getIgnores();
+
+        const files = glob.sync('**', { dot: true, nodir: true, cwd: template, ignore: ignores });
+
+        await this._utils.generateFiles(options, namespace, template, destination, files);
+
+        this._generator.destinationRoot(destination);
+
+        await this._errorGenerator.generate(options);
+
+        await this._appsettings.generate(options);
+
+
+        const generatorsMap = {
+            'Aggregate': AggregateGenerator,
+            'Domain Event': DomainEventGenerator,
+            'Entity': EntityGenerator,
+            'Value Object': ValueObjectGenerator,
+            'Repository': RepositoryGenerator,
+            'Data Transfer Object': DtoGenerator,
+            'Command': CommandGenerator,
+            'Query': QueryGenerator,
+            'Controller': ControllerGenerator,
+            'Proto': ProtoGenerator,
+            'Consumer': ConsumerGenerator
+        };
+
+        for (const key in generatorsMap) {
+            const generator = new generatorsMap[key](this._utils, this._generator);
+            
+            await generator.generate(options);
+        }
+
+        await this._createMetadataFile(destination, options);
+    }
+
+    async _createMetadataFile(destination, options) {
+        await this._generator.fs.writeJSON(`${destination}/archetype.json`, {
+            "microservice": options.microservice,
+            "description": "Custom Microservice",
+            "version": "1.0.0",
+            "organization": options.organization,
+            "aggregate": options.aggregate.name,
+            "vault": options.appSettings.vault,
+            "contactName": options.appSettings.contact.name,
+            "contactEmail": options.appSettings.contact.email
+        }, { spaces: 2 });
+    }
+
+    _getIgnores() {
+        const ignores = ['**/bin/**', '**/obj/**'];
+
+        const items = {
+            domain_application: [
+                'src/domain/CodeDesignPlus.Net.Microservice.Application/Errors.cs',
+                'src/domain/CodeDesignPlus.Net.Microservice.Application/Order/Commands/AddProductToOrder/**',
+                'src/domain/CodeDesignPlus.Net.Microservice.Application/Order/Commands/CancelOrder/**',
+                'src/domain/CodeDesignPlus.Net.Microservice.Application/Order/Commands/CompleteOrder/**',
+                'src/domain/CodeDesignPlus.Net.Microservice.Application/Order/Commands/CreateOrder/**',
+                'src/domain/CodeDesignPlus.Net.Microservice.Application/Order/Commands/RemoveProduct/**',
+                'src/domain/CodeDesignPlus.Net.Microservice.Application/Order/Commands/UpdateQuantityProduct/**',
+                'src/domain/CodeDesignPlus.Net.Microservice.Application/Order/Commands/AddProductToOrder/**',
+                'src/domain/CodeDesignPlus.Net.Microservice.Application/Order/Queries/FindOrderById/**',
+                'src/domain/CodeDesignPlus.Net.Microservice.Application/Order/Queries/GetAllOrders/**',
+                'src/domain/CodeDesignPlus.Net.Microservice.Application/Order/DataTransferObjects/*.cs',
+            ],
+            domain_domain: [
+                'src/domain/CodeDesignPlus.Net.Microservice.Domain/Errors.cs',
+                'src/domain/CodeDesignPlus.Net.Microservice.Domain/DataTransferObjects/*.cs',
+                'src/domain/CodeDesignPlus.Net.Microservice.Domain/DomainEvents/*.cs',
+                'src/domain/CodeDesignPlus.Net.Microservice.Domain/Entities/*.cs',
+                'src/domain/CodeDesignPlus.Net.Microservice.Domain/Enums/*.cs',
+                'src/domain/CodeDesignPlus.Net.Microservice.Domain/Repositories/*.cs',
+                'src/domain/CodeDesignPlus.Net.Microservice.Domain/ValueObjects/*.cs',
+                'src/domain/CodeDesignPlus.Net.Microservice.Domain/OrderAggregate.cs',
+            ],
+            domain_infrastructure: [
+                'src/domain/CodeDesignPlus.Net.Microservice.Infrastructure/Repositories/OrderRepository.cs',
+                'src/domain/CodeDesignPlus.Net.Microservice.Infrastructure/Errors.cs'
+            ],
+            entryPoints_asyncWorker: [
+                'src/entrypoints/CodeDesignPlus.Net.Microservice.AsyncWorker/Consumers/**'
+            ],
+            entryPoints_gRpc: [
+                'src/entrypoints/CodeDesignPlus.Net.Microservice.gRpc/Protos/*.proto',
+                'src/entrypoints/CodeDesignPlus.Net.Microservice.gRpc/Services/*.cs'
+            ],
+            entryPoints_Rest: [
+                'src/entrypoints/CodeDesignPlus.Net.Microservice.Rest/Controllers/**'
+            ],
+            integrationTest_asyncWorker: [
+                'tests/integration/CodeDesignPlus.Net.Microservice.AsyncWorker.Test/Consumers/**'
+            ],
+            integrationTest_gRpc: [
+                'tests/integration/CodeDesignPlus.Net.Microservice.gRpc.Test/Protos/**',
+                'tests/integration/CodeDesignPlus.Net.Microservice.gRpc.Test/Services/**'
+            ],
+            integrationTest_rest: [
+                'tests/integration/CodeDesignPlus.Net.Microservice.Rest.Test/Controllers/**'
+            ],
+            unitTest_application: [
+                'tests/unit/CodeDesignPlus.Net.Microservice.Application.Test/Order/Commands/AddProductToOrder/**',
+                'tests/unit/CodeDesignPlus.Net.Microservice.Application.Test/Order/Commands/CancelOrder/**',
+                'tests/unit/CodeDesignPlus.Net.Microservice.Application.Test/Order/Commands/CompleteOrder/**',
+                'tests/unit/CodeDesignPlus.Net.Microservice.Application.Test/Order/Commands/CreateOrder/**',
+                'tests/unit/CodeDesignPlus.Net.Microservice.Application.Test/Order/Commands/RemoveProduct/**',
+                'tests/unit/CodeDesignPlus.Net.Microservice.Application.Test/Order/Commands/UpdateQuantityProduct/**',
+                'tests/unit/CodeDesignPlus.Net.Microservice.Application.Test/Order/Queries/FindOrderById/**',
+                'tests/unit/CodeDesignPlus.Net.Microservice.Application.Test/Order/Queries/GetAllOrders/**',
+                'tests/unit/CodeDesignPlus.Net.Microservice.Application.Test/Order/DataTransferObjects/ClientDto.cs',
+                'tests/unit/CodeDesignPlus.Net.Microservice.Application.Test/Order/DataTransferObjects/OrderDto.cs',
+                'tests/unit/CodeDesignPlus.Net.Microservice.Application.Test/Order/DataTransferObjects/ProductDto.cs',
+            ],
+            unitTest_domain: [
+                'tests/unit/CodeDesignPlus.Net.Microservice.Domain.Test/DomainEvents/*.cs',
+                'tests/unit/CodeDesignPlus.Net.Microservice.Domain.Test/OrderAggregateTest.cs',
+            ],
+            unitTest_infrastructure: [
+                'tests/unit/CodeDesignPlus.Net.Microservice.Infrastructure.Test/Repositories/*.cs',
+            ],
+            unitTest_asyncWorker: [
+                'tests/unit/CodeDesignPlus.Net.Microservice.AsyncWorker.Test/Consumers/*.cs',
+            ],
+            unitTest_gRpc: [
+                'tests/unit/CodeDesignPlus.Net.Microservice.gRpc.Test/Services/*.cs',
+            ],
+            unitTest_rest: [
+                'tests/unit/CodeDesignPlus.Net.Microservice.Rest.Test/Controllers/*.cs',
+            ]
+        }
+
+        for (const key in items) {
+            ignores.push(...items[key]);
+        }
+
+        return ignores;
+    }
+}

package/generators/microservice/core/proto.mjs

@@ -0,0 +1,61 @@
+import path from 'path';
+import Xml from './xml.mjs';
+
+export default class ProtoGenerator {
+
+    constructor(utils, generator) {
+        this._utils = utils;
+        this._generator = generator;
+        this.name = 'proto';
+    }
+
+    async generate(options) {
+        if (options.enableGrpc) {
+            const solution = `${options.solution}.gRpc`;
+
+            await this._generator.fs.copyTplAsync(
+                this._generator.templatePath('grpc/grpc.proto'),
+                this._generator.destinationPath(path.join(options.paths.src.grpc, 'Protos', options.proto.file)),
+                {
+                    ns: solution,
+                    name: options.proto.fullname
+                }
+            );
+
+            await this._generator.fs.copyTplAsync(
+                this._generator.templatePath('grpc/grpc.proto'),
+                this._generator.destinationPath(path.join(options.paths.integrationTests.grpc, 'Protos', options.proto.file)),
+                {
+                    ns: `${solution}.Test`,
+                    name: options.proto.fullname
+                }
+            );
+
+            await this._generator.fs.copyTplAsync(
+                this._generator.templatePath('grpc/ItemService.cs'),
+                this._generator.destinationPath(path.join(options.paths.src.grpc, 'Services', `${options.proto.name}Service.cs`)),
+                {
+                    ns: `${solution}.Services`,
+                    name: options.proto.name
+                }
+            );
+
+            const grpcProject = new Xml(`${this._generator.destinationPath()}/${options.paths.src.grpc}/${solution}.csproj`);
+
+            await grpcProject.addProtobuf(`Protos\\${options.proto.file}`);
+
+            const grpcTestProject = new Xml(`${this._generator.destinationPath()}/${options.paths.integrationTests.grpc}/${solution}.Test.csproj`);
+
+            await grpcTestProject.addProtobuf(`Protos\\${options.proto.file}`);
+        }
+    }
+
+    getArguments() {
+        this._generator.option('proto-name', { type: String, alias: 'p', required: true, description: 'The base name of the .proto file.' });
+    
+        this._generator.options = {
+            ...this._generator.options,
+            enableGrpc: this._generator.options.protoName !== undefined && this._generator.options.protoName !== null
+        }
+    }
+}

package/generators/microservice/core/query.mjs

@@ -0,0 +1,59 @@
+import path from 'path';
+import DtoGenerator from './dataTransferObject.mjs';
+import { glob } from 'glob';
+
+export default class QueryGenerator {
+
+    constructor(utils, generator) {
+        this._utils = utils;
+        this._generator = generator;
+        this.name = 'query';
+    }
+
+    async generate(options) {
+
+        await new DtoGenerator(this._utils, this._generator).generate(options);        
+
+        for (const key in options.queries) {
+            const handler = options.queries[key];
+            const query = handler.query;
+
+            const ns = `${options.solution}.Application.${options.aggregate.name}.Queries.${query.name}`;
+
+            await this._generator.fs.copyTplAsync(
+                this._generator.templatePath('query/ItemQuery.cs'),
+                this._generator.destinationPath(path.join(options.paths.src.application, options.aggregate.name, `Queries`, query.name, query.file)),
+                {
+                    ns: ns,
+                    name: query.fullname,
+                    dto: options.dataTransferObject.fullname
+                }
+            );
+
+            await this._generator.fs.copyTplAsync(
+                this._generator.templatePath('query/ItemQueryHandler.cs'),
+                this._generator.destinationPath(path.join(options.paths.src.application, options.aggregate.name, `Queries`, query.name, handler.file)),
+                {
+                    ns: ns,
+                    name: query.fullname,
+                    handler: handler.fullname,
+                    dto: options.dataTransferObject.fullname,
+                    repository: options.repository.interface
+                }
+            );
+            
+            this._utils.addUsing(options.paths.src.rest, ns);
+        }
+    }
+
+    getArguments() {
+        this._generator.option('aggregate', { type: String, alias: 'a', required: true, description: 'The name of the microservice\'s root aggregate, essential for domain organization.' });
+        this._generator.option('repository', { type: String, alias: 'r', required: true, description: 'The name of the aggregate for which the repository is created or queried.' });
+        this._generator.option('queries', { type: String, alias: 'q', required: true, description: 'Comma-separated list of queries, representing requests for information from the system.' });
+
+        this._generator.options = {
+            ...this._generator.options,
+            dataTransferObject: this._generator.options.aggregate
+        }
+    }
+}

package/generators/microservice/core/repository.mjs

@@ -0,0 +1,41 @@
+import path from 'path';
+export default class RepositoryGenerator {
+
+    constructor(utils, generator) {
+        this._utils = utils;
+        this._generator = generator;
+        this.name = 'repository';
+    }
+
+    async generate(options) {
+
+        if (!options.repository)
+            return;
+
+        //Create Interface Repository        
+        await this._generator.fs.copyTplAsync(
+            this._generator.templatePath(`repository/IItemRepository.cs`),
+            this._generator.destinationPath(path.join(options.paths.src.domain, `Repositories`, options.repository.fileInterface)),
+            {
+                ns: `${options.solution}.Domain.Repositories`,
+                name: options.repository.interface,
+            }
+        );
+
+        //Create Implementation
+        await this._generator.fs.copyTplAsync(
+            this._generator.templatePath(`repository/ItemRepository.cs`),
+            this._generator.destinationPath(path.join(options.paths.src.infrastructure, `Repositories`, options.repository.file)),
+            {
+                ns: `${options.solution}.Infrastructure.Repositories`,
+                name: options.repository.fullname,
+                interface: options.repository.interface
+            }
+        );
+    }
+
+    
+    getArguments() {
+        this._generator.option('repository', { type: String, alias: 'r', required: true, description: 'The name of the aggregate for which the repository is created or queried.' });
+    }
+}

package/generators/microservice/core/utils.mjs

@@ -0,0 +1,196 @@
+import { findUp } from 'find-up';
+import fs from 'fs/promises';
+import path from 'path';
+import {
+    AggregateModel,
+    CommandHandlerModel,
+    ControllerModel,
+    DataTransferObjectModel,
+    DomainEventModel,
+    EntityModel,
+    ProtoModel,
+    QueryHandlerModel,
+    RepositoryModel,
+    ValueObjectModel,
+    ConsumerModel
+} from '../types/index.mjs';
+import { AppSettingsModel } from '../types/appsettings.mjs';
+
+
+
+export default class Utils {
+    constructor(generator) {
+        this._generator = generator;
+    }
+
+    async setPathBase() {
+        const filePath = await findUp('archetype.json');
+
+        if (!filePath) {
+            return this._generator.destinationRoot();
+        }
+
+        const pathBaseDir = path.dirname(filePath);
+
+        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 organization = this.toPascalCase(answers.organization);
+        const microservice = this.toPascalCase(answers.microservice);
+
+        const solution = `${organization}.Net.Microservice.${microservice}`;
+
+        let options = {
+            "organization": organization,
+            "microservice": microservice,
+            "solution": solution,
+            "paths": {
+                "src": {
+                    "domain": path.join('src', 'domain', `${solution}.Domain`),
+                    "application": path.join('src', 'domain', `${solution}.Application`),
+                    "infrastructure": path.join('src', 'domain', `${solution}.Infrastructure`),
+                    "rest": path.join('src', 'entrypoints', `${solution}.Rest`),
+                    "grpc": path.join('src', 'entrypoints', `${solution}.gRpc`),
+                    "asyncWorker": path.join('src', 'entrypoints', `${solution}.AsyncWorker`)
+                },
+                "tests": {
+                    "domain": path.join('tests', 'unit', `${solution}.Domain.Test`),
+                    "application": path.join('tests', 'unit', `${solution}.Application.Test`),
+                    "infrastructure": path.join('tests', 'unit', `${solution}.Infrastructure.Test`),
+                    "rest": path.join('tests', 'unit', `${solution}.Rest.Test`),
+                    "grpc": path.join('tests', 'unit', `${solution}.gRpc.Test`),
+                    "asyncWorker": path.join('tests', 'unit', `${solution}.AsyncWorker.Test`)
+                },
+                "integrationTests": {
+                    "rest": path.join('tests', 'integration', `${solution}.Rest.Test`),
+                    "grpc": path.join('tests', 'integration', `${solution}.gRpc.Test`),
+                    "asyncWorker": path.join('tests', 'integration', `${solution}.AsyncWorker.Test`)
+                }
+            },
+            "aggregate": AggregateModel.from(answers.aggregate),
+            "domainEvents": DomainEventModel.from(answers.domainEvents),
+            "entities": EntityModel.from(answers.entities),
+            "valueObjects": ValueObjectModel.from(answers.valueObjects),
+            "commands": CommandHandlerModel.from(answers.commands),
+            "queries": QueryHandlerModel.from(answers.queries),
+            "enableGrpc": answers.enableGrpc,
+            "enableAsyncWorker": answers.enableAsyncWorker,
+            "consumer": answers.enableAsyncWorker ? ConsumerModel.from(answers.consumer) : answers.consumer,
+            "repository": RepositoryModel.from(answers.repository),
+            "dataTransferObject": DataTransferObjectModel.from(answers.dataTransferObject),
+            "controller": ControllerModel.from(answers.controller),
+            "proto": ProtoModel.from(answers.protoName),
+            "appSettings": AppSettingsModel.from(answers)
+        };
+
+        return options;
+    }
+
+    async addUsing(src, ns) {
+
+        const filePath = path.join(this._generator.destinationRoot(), src, 'Usings.cs');
+
+        let content = this._generator.fs.read(filePath);
+
+        const lineToAdd = `global using ${ns};`;
+
+        if (!content.includes(lineToAdd)) {
+            content += `\n${lineToAdd}`;
+            this._generator.fs.write(filePath, content, { flag: 'w', mode: 0o666 });
+        }
+    }
+
+    async getClassName(path) {
+        const content = this._generator.fs.read(path);
+
+        const classNameMatch = content.match(/public class (\w+)/);
+        const className = classNameMatch[1];
+
+        return className;
+    }
+
+    toPascalCase = (str) =>
+        str
+            .match(/[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/g)
+            .map((x) => x.charAt(0).toUpperCase() + x.slice(1).toLowerCase())
+            .join("");
+
+
+    _getTransformations(options, namespace) {
+        let transformations = [
+            [/CodeDesignPlus\.Net\.Microservice(?!\.Commons)/g, namespace],
+        ];
+
+        if (options.entities.length === 0)
+            transformations = [[/global using CodeDesignPlus\.Net\.Microservice\.Domain\.Entities;/g, ''], ...transformations];
+
+        if (options.domainEvents.length === 0)
+            transformations = [[/global using CodeDesignPlus\.Net\.Microservice\.Domain\.DomainEvents;/g, ''], ...transformations];
+
+        return [
+            [/public static void Configure\(\)\s*{\s*([^}]*)}/g, 'public static void Configure() { }'],
+            [/<Protobuf Include="Protos\\org.proto" GrpcServices="Server" \/>/g, ''],
+            [/Protos\\orders.proto/g, `Protos\\${options.proto?.file}`],
+            [/global using CodeDesignPlus\.Net\.Microservice\.Domain\.Enums;/g, ''],
+            [/global using CodeDesignPlus\.Net\.Microservice\.Domain\.DataTransferObjects;/g, ''],
+            [/global using CodeDesignPlus\.Net\.Microservice\.Domain\.ValueObjects;/g, ''],
+            [/global using CodeDesignPlus\.Net\.Microservice\.AsyncWorker\.Consumers;/g, ''],
+            [/global using CodeDesignPlus\.Net\.Microservice\.Application\.Order\.Commands\.AddProductToOrder;/g, ''],
+            [/global using CodeDesignPlus\.Net\.Microservice\.Application\.Order\.Commands\.CancelOrder;/g, ''],
+            [/global using CodeDesignPlus\.Net\.Microservice\.Application\.Order\.Commands\.CompleteOrder;/g, ''],
+            [/global using CodeDesignPlus\.Net\.Microservice\.Application\.Order\.Commands\.CreateOrder;/g, ''],
+            [/global using CodeDesignPlus\.Net\.Microservice\.Application\.Order\.Commands\.RemoveProduct;/g, ''],
+            [/global using CodeDesignPlus\.Net\.Microservice\.Application\.Order\.Commands\.UpdateQuantityProduct;/g, ''],
+            [/global using CodeDesignPlus\.Net\.Microservice\.Application\.Order\.Queries\.FindOrderById;/g, ''],
+            [/global using CodeDesignPlus\.Net\.Microservice\.Application\.Order\.Queries\.GetAllOrders;/g, ''],
+            [/app\.MapGrpcService<OrdersService>\(\)/g, `app.MapGrpcService<${options.proto?.name}Service>()`],
+            [/Order/g, options.aggregate.name],
+            ...transformations
+        ]
+    }
+
+    async generateFiles(options, namespace, template, destination, files) {
+        const transformations = this._getTransformations(options, namespace);
+
+        for (const i in files) {
+            const file = files[i];
+            const src = path.resolve(template, file);
+            const dest = path.resolve(destination, file
+                .replace(/CodeDesignPlus\.Net\.Microservice/g, namespace)
+                .replace(/Order/g, options.microservice)
+                .replace(/orders.proto/g, options.proto?.file)
+            );
+
+            const content = await fs.readFile(src, { encoding: 'utf-8' });
+
+            let transformedContent = transformations.reduce((acc, [regex, replacement]) => acc.replace(regex, replacement), content);
+
+            await fs.mkdir(path.dirname(dest), { recursive: true });
+            await fs.writeFile(dest, transformedContent, { encoding: 'utf-8' });
+        }
+    }
+}

package/generators/microservice/core/valueObject.mjs

@@ -0,0 +1,29 @@
+import path from 'path';
+
+export default class ValueObjectGenerator {
+
+    constructor(utils, generator) {
+        this._utils = utils;
+        this._generator = generator;
+        this.name = 'valueObject';
+    }
+
+    async generate(options) {
+        for (const key in options.valueObjects) {
+            const valueObject = options.valueObjects[key];
+            
+            await this._generator.fs.copyTplAsync(
+                this._generator.templatePath('value-object/ItemValueObject.cs'),
+                this._generator.destinationPath(path.join(options.paths.src.domain, `ValueObjects`, valueObject.file)),
+                {
+                    ns: `${options.solution}.Domain.ValueObjects`,
+                    name: valueObject.fullname
+                }
+            );
+        }
+    }
+
+    getArguments() {
+        this._generator.option('valueObjects', { type: String, alias: 'vo', required: true, description: 'Comma-separated list of value object names.' });
+    }
+}

package/generators/microservice/core/xml.mjs

@@ -0,0 +1,48 @@
+import { readFileSync, writeFileSync } from 'fs';
+import { Parser, Builder } from 'xml2js';
+
+export default class Xml {
+    constructor(filePath) {
+        this.filePath = filePath;
+        this.parser = new Parser();
+        this.builder = new Builder();
+    }
+
+    async _parseFile() {
+        const content = readFileSync(this.filePath, 'utf8');
+        this.ast = await this.parser.parseStringPromise(content);
+    }
+
+    _writeFile() {
+        const xml = this.builder.buildObject(this.ast);
+        writeFileSync(this.filePath, xml, 'utf8');
+    }
+
+    async addProtobuf(protoPath, grpcServices = "Server") {
+        await this._parseFile();
+
+        const protoEntry = {
+            Protobuf: {
+                $: {
+                    Include: protoPath,
+                    GrpcServices: grpcServices
+                }
+            }
+        };
+
+        let itemGroup = this.ast.Project.ItemGroup.find(group => group.$ && group.$.Label === "Protos");
+
+        if (itemGroup) {
+            itemGroup.Protobuf = itemGroup.Protobuf || [];
+            itemGroup.Protobuf.push(protoEntry.Protobuf);
+        } else {
+            itemGroup = {
+                $: { Label: "Protos" },
+                Protobuf: [protoEntry.Protobuf]
+            };
+            this.ast.Project.ItemGroup.push(itemGroup);
+        }
+
+        this._writeFile();
+    }
+}