Many popular projects and companies have greatly implemented Microservices architecture. One of its benefits is that we can create a service with a single responsibility for specific business logic. So whenever the business has a new feature, we can create a new service loosely coupled with other microservices. Another benefit of microservices is that we can deploy them independently. It means we can use whatever languages or frameworks that a service sees fit. But in practice, companies usually define a default language/framework for their microservices. This strategy enables engineers to build a service quickly, and it is useful to increase productivity and maintainability with limited engineer resources. When the need for new services is high, engineers will have to write many boilerplate codes of the same framework. Therefore, we can create a code generator to reduce repetition, so engineers can focus only on developing a microservice's business logic. We can also establish a code convention by defining the folder structure and design pattern within its template and workflow with a code generator. Getting started with Yeoman is a scaffolding tool that will help you kickstart new projects with any tech stacks. It is a module, and you can install it from npm: Yeoman Node.js npm install -g yo After you’ve installed it, you can run Yeoman by the command yo and it will list all the globally installed generators. For example, you can try a generator I have built to generate a microservice with and by cloning , then run in the directory, Express.js Typescript the repo here npm link Now you can run the generator with . And the prompts below will be shown to ask for your customization. yo ts-express The process will then continue to write boilerplate files from templates and installing dependencies until the message below is displayed. Creating a new generator A Yeoman generator is simply a Node.js module. To create a generator, you have to create a new node project by running and set the name with prefix (e.g. ). npm init generator- generator-microservice A generator requires Yeoman dependency, which you can install by running . Yeoman will automatically detect the main generator and sub-generators if you follow the folder structures below. npm install yeoman-generator ├───package.json
└───generators/
    ├───app/
    │   └───index.js
    └───route/
        └───index.js is the NPM manifest file for the generator project. package.json is where the main generator workflow is written. It can be executed by running . generators/app/index.js yo microservice is where the sub-generator workflow is written. It can be executed by running . generators/route/index.js yo microservice:route In the generator, you should create a class that extends the Yeoman base generator. Then we can define the tasks by creating methods inside the class. Each task will run in sequence according to the order in which it is written. You can name your methods anything, or you can follow the reserved Yeoman method names. Yeoman uses these method names to keep task priority in sequence; the names in order are , , , , , , , and . If your method names don’t match the reserved names, they will run under the task priority. initializing prompting configuring default writing conflicts install end default 💡 Name a method with underscore prefix ( ) to create a helper method which won’t be listed as a task Pro Tip: _helper_method Interacting with users The Yeoman generator we are building is a CLI app, so users should interact or define their customization via terminal. Yeoman provides three approaches for user interaction; they are: ( ) Arguments are passed directly after the generator command. To receive an argument, we must call in the class constructor. Then we can get the data from . Arguments yo microservice [argument] this.argument(<name>, <options>) this.options[name] ( ) Options are passed as command-line flags. Similar to arguments, we must call in the constructor. Then it will be accessible from . Options yo microservice --[option] this.option(<name>, <options>) this.options[name] Prompts are a series of questions asked to the user in sequence. It is the most recommended approach for user interaction as it has a better user experience and supports a conditional question. It also supports multiple question types like radio, checkbox, etc., as it is based on . We can call which receives an array of prompts as an argument. It is asynchronous, and we should call it in the task. When the user has finished answering the prompts, the method will return the answers object. Prompts Inquirer.js this.prompt() prompting Here is an example of using argument, option, and prompt methods to receive the of the microservice. name Generator = ( ); { (args, opts) { (args, opts); .argument( , { : , : , : , : ,
    }); .log( , .options.name); .option( , { : , : , : , : ,
    }); .log( , .options.anotherName);
  } prompting() { .answers = .prompt([
      { : , : , : , : ,
      },
    ]); .log( , .answers.name);
  }
} .exports = MicroserviceGenerator const require 'yeoman-generator' class MicroserviceGenerator extends Generator constructor super // yo microservice Example this 'name' type String description 'Microservice Name' required true default 'Example' console 'Name as argument' this // yo microservice --another-name=Example // yo microservice -n=Example this 'anotherName' alias 'n' type String description 'Microservice Name' default 'Example' console 'Name as option' this async // > yo microservice // ? What is the name of the microservice? (Example) this await this name 'name' type 'input' default 'Example' message 'What is the name of the microservice?' console 'Name as prompt' this module 💡 To give better experience for the user, prompts can display multiple types of question, conditional question, and answer validation. You can follow the documentation . Pro Tip: here Configuring user customization data After we received the user’s customization data, we might need to process and configure them before using them further in other tasks. Common tasks to be handled in the configuration step: Create new variables based on user data to be passed to template files. Combine user data from arguments, options, and answers. Save user answers and config data in Yeoman config file ( ) to be used for future execution or from other generators/sub-generators. .yo-rc.json We can code these tasks in the method like below. configuring Generator = ( ); { configuring() { { name } = .options; title = ; .answers = {
      ...this.config.getAll(), ...this.answers,
      name,
      title,
    }; .config.set( .answers);
  }
} .exports = MicroserviceGenerator const require 'yeoman-generator' class MicroserviceGenerator extends Generator // ... other methods // creating new variables const this const `ms- ` ${name.toLowerCase()} // will output as "ms-example" // combining user data this // getting saved config data // saving to config file this this module With this method, a file will be generated inside the project, which will look like this. .yo-rc.json { : { : , : }
} "generator-microservice" "name" "Example" "title" "ms-example" Creating template files In our generator project, we can put template files inside a generator or sub-generator templates directory like below. └───generators/
    ├───app/
    │   ├───templates/
    │   │   ├───index.js
    │   │   └───package.json
    │   └───index.js A template file can be any file with any extension. Besides boilerplate codes, we can also put project config and manifest files as templates. Yeoman uses for its templating syntax. With EJS, we can compile a JS code in a template. So we can pass variables or have conditional writing in the template. Here is an example of EJS usage in a file template, which is a microservice environment variables file. EJS .env # ------------------------------------------------------------------
# General
# ------------------------------------------------------------------
SERVICE_NAME=<%= name %>
PORT=3000
LOG_LEVEL=debug

<%_ if (hasDb) { _%>
# ------------------------------------------------------------------
# Database
# ------------------------------------------------------------------
DATABASE_HOST=<%= dbHost %>
DATABASE_PORT=<%= dbPort %>
DATABASE_NAME=<%= dbName %>
DATABASE_USERNAME=<%= dbUser %>
DATABASE_PASSWORD=<%= dbPassword %>
<%_ } _%> In the file above, we can easily write a value from a variable with EJS syntax . We can also see that the database config block (line 9–16) will only be written when variable resolve to . <%= hasDb true 💡 We can use instead of Pro Tip: <%_ _%> <% %> to clear out whitespace (empty line) around it. Generating boilerplate from templates For this step, we can finally generate the microservice boilerplate from our template files. We only need to copy the files from the templates directory into the target directory while passing variables that we have received and configured from the user. To do this, we can code inside the task priority like below. writing Generator = ( ); { writing() { templates = [ , , , , , , , , , ,
    ];

    templates.forEach( { .fs.copyTpl( .templatePath(filePath), .destinationPath(filePath), .answers,
      );
    });
  }
} .exports = MicroserviceGenerator const require 'yeoman-generator' class MicroserviceGenerator extends Generator // ...other tasks const '.dockerignore' '.env' '.eslintrc.yml' 'Dockerfile' 'package.json' 'tsconfig.json' 'tslint.json' 'config/index.ts' 'src/index.ts' 'src/routes/index.ts' ( ) => filePath this this this this module As we can see, we are using Yeoman’s built-in method to copy template files that receive three params: source path, target path, and template variables. Yeoman also provide path resolver functions to get the current generator’s templates path ( ) and its target path ( ). this.fs.copyTpl this.templatePath this.destinationPath Setting up the generated microservice After generating the microservice boilerplate project, we can install the dependencies needed to start running in this step. From what I learned, we have two different approaches to manage dependencies of the generated microservice, Install dependencies with exact versions pre-defined by the generator. With this approach, we can create the file as a template where all the dependencies are defined. So we will only call in the task. package.json this.npmInstall() install Install dependencies with the latest versions every time the generator runs. To do this, we can pass a list of dependency names to be passed to function as a param. this.npmInstall Using the second approach, you can see the example of implementing it in the task below. install Generator = ( ); { install() { devDependencies = [ , , , , , , , , , , , ,
    ]; dependencies = [ , , , , ,
    ]; .npmInstall(devDependencies, { : }); .npmInstall(dependencies);
  }

  end() { .log( );
  }
} .exports = MicroserviceGenerator; const require 'yeoman-generator' class MicroserviceGenerator extends Generator // ...other tasks const '@types/cors' '@types/express' '@types/jest' '@typescript-eslint/eslint-plugin' '@typescript-eslint/parser' 'eslint' 'eslint-config-airbnb-base' 'eslint-plugin-import' 'jest' 'ts-jest' 'ts-node' 'typescript' const 'body-parser' 'cors' 'dotenv' 'express' 'joi' this 'save-dev' true this this 'Your microservice is ready!' module With the example above, we can differentiate dependencies into dev dependencies to be installed separately. We can also code the end task to print a message to the user indicating the generator process has successfully ended. Creating and composing a sub-generator Now that we have finished creating the main microservice generator, we can create a sub-generator. It is useful to generate an app component in an existing project like routes, data model, service, etc. We can also create a sub-generator to make the generator more modularized, as it can be composed with the main generator. Here is an example of a sub-generator module for creating a route/endpoint in a microservice. Generator = ( ); { prompting() { .log( ); .answers = .prompt([
      { : , : , : , : ,
      },
      { : , : , : [ , , , , ], : , : ,
      },
    ]);
  }

  configuring() { { routeMethod, routeName } = .answers; routeTitle = ; .answers = {
      ...this.answers,
      routeTitle,
    }; .config.set( .answers);
  }

  _writeCode() { { routeMethod, routeName } = .answers; .fs.copyTpl( .templatePath( ), .destinationPath( ), .answers,
    ); .fs.copyTpl( .templatePath( ), .destinationPath( ), .answers,
    ); .fs.copyTpl( .templatePath( ), .destinationPath( ), .answers,
    );
  }

  _writeTest() { { routeMethod, routeName } = .answers; .fs.copyTpl( .templatePath( ), .destinationPath( ), .answers,
    );
  }

  writing() { .log( ); ._writeCode(); ._writeTest();
  }

  end() { .log( );
  }
} .exports = RouteGenerator; const require 'yeoman-generator' class RouteGenerator extends Generator async this '--- Generate a route ---' this await this name 'routeName' type 'input' default 'healthcheck' message 'What is the name of the route?' name 'routeMethod' type 'list' choices 'get' 'post' 'delete' 'patch' 'put' default 'get' message 'What is the method of the route?' const this const ` / ` ${routeMethod.toUpperCase()} ${routeName} this this this const this this this 'src/routes/name/index.ts' this `src/routes/ /index.ts` ${routeName} this this this 'src/routes/name/method/index.ts' this `src/routes/ / /index.ts` ${routeName} ${routeMethod} this this this 'src/routes/name/method/handler.ts' this `src/routes/ / /handler.ts` ${routeName} ${routeMethod} this const this this this 'test/routes/name/method/handler.test.ts' this `test/routes/ / /handler.test.ts` ${routeName} ${routeMethod} this this `Generating route for ` ${ .answers.routeTitle} this this this this `Route has been generated` ${ .answers.routeTitle} this module As we can see, the sub-generator module has the same concept as the main generator. It has user interaction, configuring data, and copying template tasks. Therefore we can combine it with our main generator to run their tasks in the same order. To do this, we only need to call function in the task like below. this.composeWith() initializing Generator = ( ); { initializing() { .composeWith( .resolve( ));
  } } .exports = MicroserviceGenerator; const require 'yeoman-generator' class MicroserviceGenerator extends Generator // ...constructor this require '../route' // ...other tasks module 💡 Pro Tip: You can use Yeoman config file .yo-rc.json to combine data from both generators. I hope now you can try to create your own microservice generator with Yeoman. I am sure it worth the extra effort to help increase the velocity of your team. Feel free to contribute to my example repository. You can also ask me anything there. References https://microservices.io/ https://yeoman.io/ Also published at https://iksena.medium.com/generate-microservices-quickly-with-yeoman-bc8b8453ea80?sk=6f0d29d93020a616e98999a76f8c6c57

Stacks

AirBnB

Super

Target

Velocity

Read My Stories

Too Long; Didn't Read

Make resilience your competitive advantage

How to Quickly Generate Microservices with Yeoman

About Author

Comments

TOPICS

THIS ARTICLE WAS FEATURED IN

Related Stories

Untitled Story

An Open-Source Collection of Boilerplate Repositories to Help Set Up Your Next Project

Android CI/CD Boilerplate for Publishing via Fastlane

Fast Development With NodeJS: NestJS Boilerplate

How To Create a Simple Application Using Golangspell

How to get Rid of Boilerplate in Integration Tests with DBUnit and Custom Annotation.

An Open-Source Collection of Boilerplate Repositories to Help Set Up Your Next Project

Android CI/CD Boilerplate for Publishing via Fastlane

Fast Development With NodeJS: NestJS Boilerplate

How To Create a Simple Application Using Golangspell

How to get Rid of Boilerplate in Integration Tests with DBUnit and Custom Annotation.

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps