booking-microservices/2-modular-monolith-architecture-style/README.md

🪁 Modular Monolith Architecture Style

In Modular Monolith Architecture, the application is divided into modules, each responsible for a specific functionality. However, the entire application is still deployed as a single unit.

Table of Contents

• Key Features
• When to Use
• Challenges
• Modular Monolith Architecture Design
• Development Setup
  • Dotnet Tools Packages
  • Husky
  • Upgrade Nuget Packages
• How to Run
  • Docker Compose
  • Build
  • Run
  • Test
• Documentation Apis

Key Features

1. Modular Design: The application is divided into modules, each responsible for a specific functionality.
2. Loose Coupling: Modules interact through well-defined interfaces, improving maintainability.
3. Single Deployment: The entire application is still deployed as one unit.
4. Shared Database: Typically uses a single database, but modules can have their own schemas or tables.

When to Use

1. Medium to Large Projects: Suitable for applications with growing complexity but not ready for microservices.
2. Better Maintainability: Ideal for teams wanting a more organized and maintainable codebase than a traditional monolith.
3. Future-Proofing: A stepping stone toward microservices, allowing teams to prepare for future scalability.
4. Single Team or Small Teams: Works well for teams that want modularity without the overhead of distributed systems.

Challenges

• Still a single deployment unit, so scaling is limited.
• Requires careful design to avoid tight coupling between modules.
• Not as scalable or fault-tolerant as microservices.

Modular Monolith Architecture Design

Development Setup

Dotnet Tools Packages

For installing our requirement packages with .NET cli tools, we need to install dotnet tool manifest.

dotnet new tool-manifest

And after that we can restore our dotnet tools packages with .NET cli tools from .config folder and dotnet-tools.json file.

dotnet tool restore

Husky

Here we use husky to handel some pre commit rules and we used conventional commits rules and formatting as pre commit rules, here in package.json. of course, we can add more rules for pre commit in future. (find more about husky in the documentation) We need to install husky package for manage pre commits hooks and also I add two packages @commitlint/cli and @commitlint/config-conventional for handling conventional commits rules in package.json. Run the command bellow in the root of project to install all npm dependencies related to husky:

npm install

Note: In the root of project we have .husky folder and it has commit-msg file for handling conventional commits rules with provide user friendly message and pre-commit file that we can run our scripts as a pre-commit hooks. that here we call format script from package.json for formatting purpose.

Upgrade Nuget Packages

For upgrading our nuget packages to last version, we use the great package dotnet-outdated. Run the command below in the root of project to upgrade all of packages to last version:

dotnet outdated -u

How to Run

Docker Compose

To run this app in Docker, use the docker-compose.yaml and execute the below command at the root of the application:

docker-compose -f ./deployments/docker-compose/docker-compose.yaml up -d

Build

To build all modules, run this command in the root of the project:

dotnet build

Run

To run all modules, run this command in the root of the Api folder where the csproj file is located:

dotnet run

Test

To test all modules, run this command in the root of the project:

dotnet test

Documentation Apis

Each microservice provides API documentation and navigate to /swagger for Swagger OpenAPI or /scalar/v1 for Scalar OpenAPI to visit list of endpoints.

As part of API testing, I created the booking.rest file which can be run with the REST Client VSCode plugin.