generator-codedesignplus 0.0.1-rc.2

package/generators/microservice/core/asyncWorker.mjs

@@ -0,0 +1,87 @@
+import path from 'path';
+import AppSettingsGenerator from './appsettings.mjs';
+import fsSync from 'fs';
+import fs from 'fs/promises';
+import { glob } from 'glob';
+
+export default class AsyncWorkerGenerator {
+
+    constructor(utils, generator) {
+        this._appsettings = new AppSettingsGenerator(utils, generator);
+
+        this._utils = utils;
+        this._generator = generator;
+        this.name = 'grpc';
+    }
+
+    async generate(options) {
+        options = {
+            ...options
+        }        
+
+        const destination = this._generator.destinationPath();
+
+        const asyncWorkerProjectPathDestination = path.join(destination, options.paths.src.asyncWorker);
+        const asyncWorkerTestProjectPathDestination = path.join(destination, options.paths.tests.asyncWorker);
+        const asyncWorkerIntegrationTestProjectPathDestination = path.join(destination, options.paths.integrationTests.asyncWorker);
+
+        const ignores = this._getIgnores();
+
+        if (!fsSync.existsSync(asyncWorkerProjectPathDestination)) {
+            const templateAsyncWorkerProject = this._generator.templatePath('microservice/src/entrypoints/CodeDesignPlus.Net.Microservice.AsyncWorker');
+
+            await this._generateFiles(templateAsyncWorkerProject, ignores, options, asyncWorkerProjectPathDestination);
+        }
+
+        if (!fsSync.existsSync(asyncWorkerTestProjectPathDestination)) {
+            const templateAsyncWorkerProject = this._generator.templatePath('microservice/tests/unit/CodeDesignPlus.Net.Microservice.AsyncWorker.Test');
+
+            await this._generateFiles(templateAsyncWorkerProject, ignores, options, asyncWorkerTestProjectPathDestination);
+        }
+
+        if (!fsSync.existsSync(asyncWorkerIntegrationTestProjectPathDestination)) {
+            const templateAsyncWorkerProject = this._generator.templatePath('microservice/tests/integration/CodeDesignPlus.Net.Microservice.AsyncWorker.Test');
+
+            await this._generateFiles(templateAsyncWorkerProject, ignores, options, asyncWorkerIntegrationTestProjectPathDestination);
+        }
+        
+        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']);
+        await this._generator.spawnCommand('dotnet', ['sln', `${destination}/${options.solution}.sln`, 'add', `${asyncWorkerIntegrationTestProjectPathDestination}`, '--solution-folder', 'tests/integration']);
+    }
+
+    async _generateFiles(templateAsyncWorkerProject, ignores, options, asyncWorkerProjectPathDestination) {
+        
+        const files = glob.sync('**', { dot: true, nodir: true, cwd: templateAsyncWorkerProject, ignore: ignores });
+
+        await this._utils.generateFiles(options, options.solution, templateAsyncWorkerProject, asyncWorkerProjectPathDestination, files);
+
+        await this._appsettings.generate(options, [options.paths.src.asyncWorker]);
+    }
+
+    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]);
+        }
+
+        return ignores;
+    }
+}

package/generators/microservice/core/command.mjs

@@ -0,0 +1,54 @@
+import { glob } from 'glob';
+import path from 'path';
+import RepositoryGenerator from './repository.mjs';
+
+export default class CommandGenerator {
+
+    constructor(utils, generator) {
+        this._utils = utils;
+        this._generator = generator;
+        this.name = 'command';
+        this._repositoryGenerator = new RepositoryGenerator(this._utils, this._generator);
+    }
+
+    async generate(options) {
+
+        for (const key in options.commands) {
+            const handler = options.commands[key];
+            const command = handler.command;
+
+            const ns = `${options.solution}.Application.${options.aggregate.name}.Commands.${command.name}`;
+
+            await this._generator.fs.copyTplAsync(
+                this._generator.templatePath('command/ItemCommand.cs'),
+                this._generator.destinationPath(path.join(options.paths.src.application, options.aggregate.name, `Commands`, command.name, command.file)),
+                {
+                    ns: ns,
+                    name: command.fullname,
+
+                }
+            );
+
+            await this._generator.fs.copyTplAsync(
+                this._generator.templatePath('command/ItemCommandHandler.cs'),
+                this._generator.destinationPath(path.join(options.paths.src.application, options.aggregate.name, `Commands`, command.name, handler.file)),
+                {
+                    ns: ns,
+                    name: command.fullname,
+                    handler: handler.fullname,
+                    repository: options.repository.interface
+                }
+            );
+
+            this._utils.addUsing(options.paths.src.rest, ns);
+        }
+
+        // await this._repositoryGenerator.generate(options);
+    }
+
+    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('commands', { type: String, alias: 'cs', required: true, description: 'Comma-separated list of commands representing actions from the user or system.' });
+    }
+}

package/generators/microservice/core/consumer.mjs

@@ -0,0 +1,73 @@
+import EntityGenerator from './entity.mjs';
+import DomainEventGenerator from './domainEvent.mjs';
+import AggregateGenerator from './aggregate.mjs';
+import RepositoryGenerator from './repository.mjs';
+import CommandGenerator from './command.mjs';
+import { AggregateModel, DomainEventModel, RepositoryModel, CommandHandlerModel } from '../types/index.mjs';
+import path from 'path';
+
+export default class ConsumerGenerator {
+
+    constructor(utils, generator) {
+        this._utils = utils;
+        this._generator = generator;
+        this._entityGenerator = new EntityGenerator(this._utils, this._generator);
+        this._domainEventGenerator = new DomainEventGenerator(this._utils, this._generator);
+        this._aggregateGenerator = new AggregateGenerator(this._utils, this._generator);
+        this._repositoryGenerator = new RepositoryGenerator(this._utils, this._generator);
+        this._commandGenerator = new CommandGenerator(this._utils, this._generator);
+        this.name = 'consumer';
+    }
+
+    async generate(options) {
+        
+        if (options.enableAsyncWorker) {
+            
+            options = {
+                ...options,
+                aggregate: AggregateModel.from(options.consumer.aggregate),
+                domainEvents: DomainEventModel.from(options.consumer.domainEvent),
+                repository: RepositoryModel.from(options.consumer.aggregate),
+                commands: CommandHandlerModel.from(options.consumer.command),
+                isConsumer: true
+            }
+            
+            await this._generator.fs.copyTplAsync(
+                this._generator.templatePath('consumer/ItemHandler.cs'),
+                this._generator.destinationPath(path.join(options.paths.src.asyncWorker, `Consumers`, options.consumer.file)),
+                {
+                    ns: `${options.solution}.AsyncWorker.Consumers`,
+                    name: options.consumer.fullname,
+                    action: options.consumer.action,
+                    aggregate: options.consumer.aggregate,
+                    domainEvent: `${options.consumer.domainEvent}DomainEvent`,
+                    solution: options.solution
+                }
+            );
+
+            await this._aggregateGenerator.generate(options);
+
+            await this._repositoryGenerator.generate(options);
+
+            await this._commandGenerator.generate(options);
+
+            await this._domainEventGenerator.generate(options);
+        }
+    }
+
+    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.options = {
+            ...this._generator.options,
+            consumer: {
+                aggregate: this._generator.options['consumerAggregate'],
+                consumer: this._generator.options['consumerName'],
+                action: this._generator.options['consumerAction'],
+            },
+            enableAsyncWorker: this._generator.options.consumerName !== undefined && this._generator.options.consumerName !== null
+        };
+    }
+}

package/generators/microservice/core/controller.mjs

@@ -0,0 +1,25 @@
+import path from 'path';
+export default class ControllerGenerator {
+
+    constructor(utils, generator) {
+        this._utils = utils;
+        this._generator = generator;
+        this.name = 'controller';
+    }
+
+    async generate(options) {
+
+        await this._generator.fs.copyTplAsync(
+            this._generator.templatePath('controller/ItemController.cs'),
+            this._generator.destinationPath(path.join(options.paths.src.rest, `Controllers`, options.controller.file)),
+            {
+                ns: `${options.solution}.Rest.Controllers`,
+                name: options.controller.fullname
+            }
+        );
+    }
+
+    getArguments() {
+        this._generator.option('controller', { type: String, alias: 'cr', required: true, description: 'The name of the controller to create.' });
+    }
+}

package/generators/microservice/core/core.mjs

@@ -0,0 +1,98 @@
+import AggregateGenerator from './aggregate.mjs';
+import CommandGenerator from './command.mjs';
+import QueryGenerator from './query.mjs';
+import ConsumerGenerator from './consumer.mjs';
+import ControllerGenerator from './controller.mjs';
+import DtoGenerator from './dataTransferObject.mjs';
+import DomainEventGenerator from './domainEvent.mjs';
+import EntityGenerator from './entity.mjs';
+import RepositoryGenerator from './repository.mjs';
+import MicroserviceGenerator from './microservice.mjs';
+import ValueObjectGenerator from './valueObject.mjs';
+import AsyncWorkerGenerator from './asyncWorker.mjs';
+import GrpcGenerator from './grpc.mjs';
+import ProtoGenerator from './proto.mjs';
+import figlet from 'figlet';
+import boxen from 'boxen';
+
+export default class Core {
+
+    constructor(utils, generator) {
+        this._utils = utils;
+        this._generator = generator;
+    }
+
+    arguments() {
+        console.log(figlet.textSync('CodeDesignPlus'));
+
+        if (this._generator.options.help)
+            console.log(boxen(
+                'Welcome to the CodeDesignPlus Microservice Archetype Generator (v1.0)\n\n' +
+                'This generator helps developers quickly create resources for microservices following best practices in the CodeDesignPlus architecture.\n\n' +
+                'Available Commands:\n\n' +
+                ' - yo codedesignplus:microservice microservice  | Creates the base structure for a new microservice, choosing between CRUD or custom patterns.\n' +
+                ' - yo codedesignplus:microservice aggregate     | Creates a new aggregate within an existing microservice.\n' +
+                ' - yo codedesignplus:microservice entity        | Creates one or more entities.\n' +
+                ' - yo codedesignplus:microservice valueObject   | Creates one or more value objects.\n' +
+                ' - yo codedesignplus:microservice domainEvent   | Creates one or more domain events associated with an aggregate.\n' +
+                ' - yo codedesignplus:microservice repository    | Creates a repository for a specific aggregate.\n' +
+                ' - yo codedesignplus:microservice controller    | Creates a controller to handle incoming requests.\n' +
+                ' - yo codedesignplus:microservice proto         | Creates a .proto file for a gRPC service.\n' +
+                ' - yo codedesignplus:microservice consumer      | Creates a consumer that reacts to domain events.\n' +
+                ' - yo codedesignplus:microservice query         | Creates one or more queries to retrieve data.\n' +
+                ' - yo codedesignplus:microservice command       | Creates one or more commands to perform actions that change the system state.\n' +
+                ' - yo codedesignplus:microservice dto           | Creates one or more Data Transfer Objects (DTOs) to transfer data.\n\n' +
+                ' - yo codedesignplus:microservice grpc          | Creates a gRPC project.\n' +
+                ' - yo codedesignplus:microservice asyncWorker   | Creates an async worker project.\n\n' +
+                'Usage:\n\n' +
+                'To use a command, run `yo codedesignplus:microservice <command> --option1 <value> --option2 <value>`.\n\n' +
+                'For more details on each command and its options, use the `--help` flag after the specific command (e.g., `yo codedesignplus:microservice microservice --help`).\n\n',
+
+                { padding: 1, margin: 1, borderStyle: 'round' }
+            ));
+
+        this._generator.argument('template', {
+            type: String,
+            alias: 't',
+            description: 'The type of component to generate.',
+            required: true
+        });
+
+        if (this._generator.options.template) {
+            const generatorsMap = {
+                'aggregate': AggregateGenerator,
+                'command': CommandGenerator,
+                'consumer': ConsumerGenerator,
+                'controller': ControllerGenerator,
+                'dto': DtoGenerator,
+                'domainEvent': DomainEventGenerator,
+                'entity': EntityGenerator,
+                'microservice': MicroserviceGenerator,
+                'proto': ProtoGenerator,
+                'query': QueryGenerator,
+                'repository': RepositoryGenerator,
+                'valueObject': ValueObjectGenerator,
+                'grpc': GrpcGenerator,
+                'asyncWorker': AsyncWorkerGenerator
+            };
+
+            this._generator.option('organization', { type: String, alias: 'o', required: true, description: 'The organization or company name used in the microservice\'s namespace' });
+            this._generator.option('microservice', { type: String, alias: 'm', required: true, description: 'The name of the microservice, used in the namespace' });
+            
+            const generatorClass = generatorsMap[this._generator.options.template];
+            
+            if (!generatorClass)
+                throw new Error(`The resource ${this._generator.options.template} is not supported`);
+
+            const generatorInstance = new generatorClass(this._utils, this._generator);
+
+            generatorInstance.getArguments();
+
+            return [generatorInstance, {
+                ...this._generator.options,
+            }];
+        }
+
+        return [null, null];
+    }
+}

package/generators/microservice/core/dataTransferObject.mjs

@@ -0,0 +1,31 @@
+import path from 'path';
+import { glob } from 'glob';
+
+export default class DtoGenerator {
+
+    constructor(utils, generator) {
+        this._utils = utils;
+        this._generator = generator;
+        this.name = 'dataTransferObject';
+    }
+
+    async generate(options) {
+
+        const ns = `${options.solution}.Application.${options.aggregate.name}.DataTransferObjects`;
+        await this._generator.fs.copyTplAsync(
+            this._generator.templatePath('data-transfer-object/ItemDto.cs'),
+            this._generator.destinationPath(path.join(options.paths.src.application, options.aggregate.name, `DataTransferObjects`, options.dataTransferObject.file)),
+            {
+                ns: ns,
+                name: options.dataTransferObject.fullname
+            }
+        );
+
+        this._utils.addUsing(options.paths.src.application, 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('dataTransferObject', { type: String, alias: 'dto', required: true, description: 'A comma-separated list of Data Transfer Object names to be generated.' });
+    }
+}

package/generators/microservice/core/domainEvent.mjs

@@ -0,0 +1,36 @@
+import { glob } from 'glob';
+import path from 'path';
+
+export default class DomainEventGenerator {
+
+    constructor(utils, generator) {
+        this._utils = utils;
+        this._generator = generator;
+        this.name = 'domainEvent';
+    }
+
+    async generate(options) {
+
+        const to = options.isConsumer ? options.paths.src.asyncWorker : options.paths.src.domain;
+        const ns = options.isConsumer ? `${options.solution}.AsyncWorker.DomainEvents` : `${options.solution}.Domain.DomainEvents`;
+
+        for (const key in options.domainEvents) {
+            const domainEvent = options.domainEvents[key];
+
+            await this._generator.fs.copyTplAsync(
+                this._generator.templatePath('domain-event/ItemDomainEvent.cs'),
+                this._generator.destinationPath(path.join(to, `DomainEvents`, domainEvent.file)),
+                {
+                    ns: ns,
+                    name: domainEvent.fullname,
+                    entity: options.aggregate.fullname
+                }
+            );
+        }
+    }
+
+    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('domainEvents', { type: String, alias: 'de', required: true, description: 'Comma-separated list of domain events, fundamental in asynchronous communication between microservices.' });
+    }
+}

package/generators/microservice/core/dotnet.mjs

@@ -0,0 +1,56 @@
+import { spawnSync } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+
+export default class DotNet {
+
+    constructor(generator) {
+        this._generator = generator;
+    }
+
+    removeProjects(options) {
+        this._generator.on('end', () => {
+
+            if (!options.enableGrpc)
+                this._removeProject('gRpc');
+
+            if (!options.enableAsyncWorker)
+                this._removeProject('AsyncWorker');
+
+        });
+    }
+
+    _removeProject(name) {
+        const cwd = this._generator.destinationRoot();
+
+        const results = spawnSync("dotnet", ["sln", "list"], { cwd: cwd });
+
+        if (results.error) 
+            return;
+                
+        if (results.status !== 0) 
+            return;
+        
+        const solutionProjects = results.stdout.toString().trim().split('\n').slice(1).map(project => project.replace('\r', ''));
+        const projects = solutionProjects.filter(project => project.includes(name));
+
+        for (const project of projects) {
+            const removeResult = spawnSync("dotnet", ["sln", "remove", project], { cwd: cwd });
+
+            if (removeResult.error) 
+                return;
+        
+            if (removeResult.status !== 0) 
+                return;
+
+            const projectPath = path.join(this._generator.destinationRoot(), path.dirname(project));
+
+            if (fs.existsSync(projectPath))
+                fs.rm(projectPath, { recursive: true }, (err) => {
+                    if (err)
+                        console.error(err);
+                });
+        }
+    }
+
+}

package/generators/microservice/core/entity.mjs

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

package/generators/microservice/core/errors.mjs

@@ -0,0 +1,37 @@
+export default class ErrorsGenerator {
+
+    constructor(utils, generator) {
+        this._utils = utils;
+        this._generator = generator;
+    }
+
+    async generate(options) {
+        const layers = {
+            'Domain': {
+                "code": '100',
+                "destination": options.paths.src.domain
+            },
+            'Application': {
+                "code": '200',
+                "destination": options.paths.src.application
+            },
+            'Infrastructure': {
+                "code": '300',
+                "destination": options.paths.src.infrastructure
+            }
+        };
+
+        for (const layer in layers) {
+            const { code, destination } = layers[layer];
+
+            this._generator.fs.copyTplAsync(
+                this._generator.templatePath('errors/Error.cs'),
+                this._generator.destinationPath(`${destination}/Errors.cs`),
+                {
+                    ns: `${options.solution}.${layer}`,
+                    code: `${code} : UnknownError`,
+                }
+            );
+        }
+    }
+}

package/generators/microservice/core/grpc.mjs

@@ -0,0 +1,97 @@
+import path from 'path';
+import AppSettingsGenerator from './appsettings.mjs';
+import ProtoGenerator from './proto.mjs';
+import fsSync from 'fs';
+import { glob } from 'glob';
+import { ProtoModel } from '../types/index.mjs';
+
+export default class GrpcGenerator {
+
+    constructor(utils, generator) {
+        this._appsettings = new AppSettingsGenerator(utils, generator);
+        this._protoGenerator = new ProtoGenerator(utils, generator);
+
+        this._utils = utils;
+        this._generator = generator;
+        this.name = 'grpc';
+    }
+
+    async generate(options) {
+        options = {
+            ...options,
+            proto: ProtoModel.from(options.aggregate.name)
+        }        
+
+        const destination = this._generator.destinationPath();
+
+        const grpcProjectPathDestination = path.join(destination, options.paths.src.grpc);
+        const grpcTestProjectPathDestination = path.join(destination, options.paths.tests.grpc);
+        const grpcIntegrationTestProjectPathDestination = path.join(destination, options.paths.integrationTests.grpc);
+
+        const ignores = this._getIgnores();
+
+        if (!fsSync.existsSync(grpcProjectPathDestination)) {
+            const templateGrpcProject = this._generator.templatePath('microservice/src/entrypoints/CodeDesignPlus.Net.Microservice.gRpc');
+
+            await this._generateFiles(templateGrpcProject, ignores, options, grpcProjectPathDestination);
+        }
+
+        if (!fsSync.existsSync(grpcTestProjectPathDestination)) {
+            const templateGrpcProject = this._generator.templatePath('microservice/tests/unit/CodeDesignPlus.Net.Microservice.gRpc.Test');
+
+            await this._generateFiles(templateGrpcProject, ignores, options, grpcTestProjectPathDestination);
+        }
+
+        if (!fsSync.existsSync(grpcIntegrationTestProjectPathDestination)) {
+            const templateGrpcProject = this._generator.templatePath('microservice/tests/integration/CodeDesignPlus.Net.Microservice.gRpc.Test');
+
+            await this._generateFiles(templateGrpcProject, ignores, options, grpcIntegrationTestProjectPathDestination);
+        }
+        
+        this._protoGenerator.generate(options);
+
+        await this._generator.spawnCommand('dotnet', ['sln', `${destination}/${options.solution}.sln`, 'add', `${grpcProjectPathDestination}`, '--solution-folder', 'src/entrypoints']);
+        await this._generator.spawnCommand('dotnet', ['sln', `${destination}/${options.solution}.sln`, 'add', `${grpcTestProjectPathDestination}`, '--solution-folder', 'tests/unit']);
+        await this._generator.spawnCommand('dotnet', ['sln', `${destination}/${options.solution}.sln`, 'add', `${grpcIntegrationTestProjectPathDestination}`, '--solution-folder', 'tests/integration']);
+    }
+
+    async _generateFiles(templateGrpcProject, ignores, options, grpcProjectPathDestination) {
+        
+        const files = glob.sync('**', { dot: true, nodir: true, cwd: templateGrpcProject, ignore: ignores });
+
+        await this._utils.generateFiles(options, options.solution, templateGrpcProject, grpcProjectPathDestination, files);
+
+        await this._appsettings.generate(options, [options.paths.src.grpc]);
+    }
+
+    getArguments() {
+        this._generator.options = {
+            ...this._generator.options,
+            enableGrpc: "true"
+        }
+    }
+
+    _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]);
+        }
+
+        return ignores;
+    }
+}