bancolombia/scaffold-clean-architecture

Gradle plugin to create a clean application in Java that already works, It follows our best practices!

Scaffolding of Clean Architecture

Gradle plugin to create a java and kotlin application based on Clean Architecture following our best practices!

• Scaffolding of Clean Architecture
• Plugin Implementation
• Tasks
  • Generate Project
  • Generate Model for Java and Kotlin
  • Generate Use Case for Java and Kotlin
  • Generate Driven Adapter
  • Generate Entry Point
  • Generate Helper
  • Generate Pipeline
  • Generate Acceptance Test
  • Generate Performance Test
  • Validate Structure
  • Delete Module
  • Update Project
• How can I help?
• Whats Next?

Plugin Implementation

To use the plugin you need Gradle version 8.2 or later, to start add the following section into your build.gradle file.

plugins {
    id "co.com.bancolombia.cleanArchitecture" version "3.16.1"
}

Or if is a new project execute this script in the root directory of your project.

echo "plugins {
    id \"co.com.bancolombia.cleanArchitecture\" version \"3.16.1\"
}" > build.gradle

To use the plugin you need Gradle version 6.9 or later, to start add the following section into your build.gradle.kts file.

plugins {
    id("co.com.bancolombia.cleanArchitecture") version "3.16.1"
}

Or if is a new project execute this script in the root directory of your project.

echo "plugins {
    id(\"co.com.bancolombia.cleanArchitecture\") version \"3.16.1\"
}" > build.gradle.kts

Tasks

The Scaffolding Clean Architecture plugin will allow you run 8 tasks:

Generate Project

The cleanArchitecture | ca task will generate a clean architecture structure in your project, this task has four optional parameters; package , type, name and coverage. If you run this task on an existing project it will override the main.gradle, build.gradle and gradle.properties files.

• package = <package.we.need>: You can specify the main or default package of your project. Default Value = co.com.bancolombia

• type = <imperative | reactive>: With this parameter the task will generate a POO project. Default Value = reactive

• name = NameProject: This parameter is going to specify the name of the project. Default Value = cleanArchitecture

• lombok = <true | false>: Specify if you want to use this plugin . Default Value = true

• metrics = <true | false>: Specify if you want to enable this feature with micrometer . Default Value = true

• language = <JAVA | KOTLIN>: Specify if you want to use this plugin . Default Value = JAVA

• javaVersion = <VERSION_17 | VERSION_21>: Java version . Default Value = VERSION_17

gradle cleanArchitecture --package=co.com.bancolombia --type=reactive --name=NameProject --lombok=true
gradle ca --package=co.com.bancolombia --type=reactive --name=NameProject --lombok=true

The structure will look like this for java:

📦NameProject
┣ 📂applications
┃ ┗ 📂app-service
┃ ┃ ┣ 📂src
┃ ┃ ┃ ┣ 📂main
┃ ┃ ┃ ┃ ┣ 📂java
┃ ┃ ┃ ┃ ┃ ┗ 📂[package]
┃ ┃ ┃ ┃ ┃ ┃ ┣ 📂config
┃ ┃ ┃ ┃ ┃ ┃ ┃ ┗ 📜[configs and beans]
┃ ┃ ┃ ┃ ┃ ┃ ┗ 📜MainApplication.java
┃ ┃ ┃ ┃ ┗ 📂resources
┃ ┃ ┃ ┃ ┃ ┣ 📜[properties]
┃ ┃ ┃ ┗ 📂test
┃ ┃ ┃ ┃ ┗ 📂java
┃ ┃ ┃ ┃ ┃ ┗ 📂[package]
┃ ┃ ┗ 📜build.gradle
┣ 📂deployment
┃ ┣ 📜[Dockerfile, Pipelines as a code]
┣ 📂domain
┃ ┣ 📂model
┃ ┃ ┣ 📂src
┃ ┃ ┃ ┣ 📂main
┃ ┃ ┃ ┃ ┗ 📂java
┃ ┃ ┃ ┃ ┃ ┗ 📂[package]
┃ ┃ ┃ ┗ 📂test
┃ ┃ ┃ ┃ ┗ 📂java
┃ ┃ ┃ ┃ ┃ ┗ 📂[package]
┃ ┃ ┗ 📜build.gradle
┃ ┗ 📂usecase
┃ ┃ ┣ 📂src
┃ ┃ ┃ ┣ 📂main
┃ ┃ ┃ ┃ ┗ 📂java
┃ ┃ ┃ ┃ ┃ ┗ 📂[package]
┃ ┃ ┃ ┗ 📂test
┃ ┃ ┃ ┃ ┗ 📂java
┃ ┃ ┃ ┃ ┃ ┗ 📂[package]
┃ ┃ ┃ ┃ ┃ ┃ ┗ 📂usecase
┃ ┃ ┗ 📜build.gradle
┣ 📂infrastructure
┃ ┣ 📂driven-adapters
┃ ┣ 📂entry-points
┃ ┗ 📂helpers
┣ 📜.gitignore
┣ 📜build.gradle
┣ 📜gradle.properties
┣ 📜lombok.config
┣ 📜main.gradle
┣ 📜README.md
┗ 📜settings.gradle

The structure will look like this for kotlin:

📦NameProject
┣ 📂applications
┃ ┗ 📂app-service
┃ ┃ ┣ 📂src
┃ ┃ ┃ ┣ 📂main
┃ ┃ ┃ ┃ ┣ 📂kotlin
┃ ┃ ┃ ┃ ┃ ┗ 📂[package]
┃ ┃ ┃ ┃ ┃ ┃ ┣ 📂config
┃ ┃ ┃ ┃ ┃ ┃ ┃ ┗ 📜[configs and beans]
┃ ┃ ┃ ┃ ┃ ┃ ┗ 📜MainApplication.kt
┃ ┃ ┃ ┃ ┗ 📂resources
┃ ┃ ┃ ┃ ┃ ┣ 📜[properties]
┃ ┃ ┃ ┗ 📂test
┃ ┃ ┃ ┃ ┗ 📂kotlin
┃ ┃ ┃ ┃ ┃ ┗ 📂[package]
┃ ┃ ┗ 📜build.gradle.kts
┣ 📂deployment
┃ ┣ 📜[Dockerfile, Pipelines as a code]
┣ 📂domain
┃ ┣ 📂model
┃ ┃ ┣ 📂src
┃ ┃ ┃ ┣ 📂main
┃ ┃ ┃ ┃ ┗ 📂kotlin
┃ ┃ ┃ ┃ ┃ ┗ 📂[package]
┃ ┃ ┃ ┗ 📂test
┃ ┃ ┃ ┃ ┗ 📂kotlin
┃ ┃ ┃ ┃ ┃ ┗ 📂[package]
┃ ┃ ┗ 📜build.gradle.kts
┃ ┗ 📂usecase
┃ ┃ ┣ 📂src
┃ ┃ ┃ ┣ 📂main
┃ ┃ ┃ ┃ ┗ 📂kotlin
┃ ┃ ┃ ┃ ┃ ┗ 📂[package]
┃ ┃ ┃ ┗ 📂test
┃ ┃ ┃ ┃ ┗ 📂kotlin
┃ ┃ ┃ ┃ ┃ ┗ 📂[package]
┃ ┃ ┃ ┃ ┃ ┃ ┗ 📂usecase
┃ ┃ ┗ 📜build.gradle.kts
┣ 📂infrastructure
┃ ┣ 📂driven-adapters
┃ ┣ 📂entry-points
┃ ┗ 📂helpers
┣ 📜.gitignore
┣ 📜build.gradle.kts
┣ 📜gradle.properties
┣ 📜lombok.config
┣ 📜README.md
┗ 📜settings.gradle.kts

Generate Model for Java and Kotlin

The generateModel | gm task will generate a class and interface in model layer, this task has one required parameter name.

   gradle generateModel --name=[modelName]
   gradle gm --name [modelName]

This task will generate something like that:

📦domain
┣ 📂model
┃ ┣ 📂src
┃ ┃ ┣ 📂main
┃ ┃ ┃ ┗ 📂java
┃ ┃ ┃ ┃ ┗ 📂[package]
┃ ┃ ┃ ┃ ┃ ┗ 📂model
┃ ┃ ┃ ┃ ┃ ┃ ┣ 📂gateways
┃ ┃ ┃ ┃ ┃ ┃ ┃ ┗ 📜ModelRepository.java
┃ ┃ ┃ ┃ ┃ ┃ ┗ 📜Model.java
┃ ┃ ┗ 📂test
┃ ┃ ┃ ┗ 📂java
┃ ┃ ┃ ┃ ┗ 📂[package]
┃ ┃ ┃ ┃ ┃ ┗ 📂model
┃ ┗ 📜build.gradle

This task will generate something like that for kotlin:

📦domain
┣ 📂model
┃ ┣ 📂src
┃ ┃ ┣ 📂main
┃ ┃ ┃ ┗ 📂kotlin
┃ ┃ ┃ ┃ ┗ 📂[package]
┃ ┃ ┃ ┃ ┃ ┗ 📂model
┃ ┃ ┃ ┃ ┃ ┃ ┣ 📂gateways
┃ ┃ ┃ ┃ ┃ ┃ ┃ ┗ 📜ModelRepository.kt
┃ ┃ ┃ ┃ ┃ ┃ ┗ 📜Model.kt
┃ ┃ ┗ 📂test
┃ ┃ ┃ ┗ 📂kotlin
┃ ┃ ┃ ┃ ┗ 📂[package]
┃ ┃ ┃ ┃ ┃ ┗ 📂model
┃ ┗ 📜build.gradle.kts

Generate Use Case for Java and Kotlin

The generateUseCase | guc task will generate a class in model layer, this task has one required parameter name.

   gradle generateUseCase --name=[useCaseName]
   gradle guc --name [useCaseName]

This task will generate something like that:

📦domain
┗ 📂usecase
┃ ┣ 📂src
┃ ┃ ┣ 📂main
┃ ┃ ┃ ┗ 📂java
┃ ┃ ┃ ┃ ┗ 📂[package]
┃ ┃ ┃ ┃ ┃ ┗ 📂usecase
┃ ┃ ┃ ┃ ┃ ┃ ┗ 📂business
┃ ┃ ┃ ┃ ┃ ┃ ┃ ┗ 📜BusinessUseCase.java
┃ ┃ ┗ 📂test
┃ ┃ ┃ ┗ 📂java
┃ ┃ ┃ ┃ ┗ 📂[package]
┃ ┃ ┃ ┃ ┃ ┗ 📂usecase
┃ ┃ ┃ ┃ ┃ ┃ ┗ 📂business
┃ ┗ 📜build.gradle

This task will generate something like that for kotlin:

📦domain
┗ 📂usecase
┃ ┣ 📂src
┃ ┃ ┣ 📂main
┃ ┃ ┃ ┗ 📂kotlin
┃ ┃ ┃ ┃ ┗ 📂[package]
┃ ┃ ┃ ┃ ┃ ┗ 📂usecase
┃ ┃ ┃ ┃ ┃ ┃ ┗ 📂business
┃ ┃ ┃ ┃ ┃ ┃ ┃ ┗ 📜BusinessUseCase.kt
┃ ┃ ┗ 📂test
┃ ┃ ┃ ┗ 📂kotlin
┃ ┃ ┃ ┃ ┗ 📂[package]
┃ ┃ ┃ ┃ ┃ ┗ 📂usecase
┃ ┃ ┃ ┃ ┃ ┃ ┗ 📂business
┃ ┗ 📜build.gradle.kts

Generate Driven Adapter

The generateDrivenAdapter | gda task will generate a module in Infrastructure layer, this task has one required parameter type.
Whether you'll use generic one also parameter name is required.

   gradle generateDrivenAdapter --type=[drivenAdapterType]
   gradle gda --type [drivenAdapterType]

Reference for drivenAdapterType	Name	Additional Options	Java	Kotlin
generic	Empty Driven Adapter	--name [name]	☑	☑
asynceventbus	Async Event Bus		☑	☑
binstash	Bin Stash		☑	☑
cognitotokenprovider	Generador de token de cognito		☑
dynamodb	Dynamo DB adapter		☑	☑
jpa	JPA Repository	--secret [true-false]	☑	☑
kms	AWS Key Management Service		☑	☑
ktor	HTTP client for kotlin		☐	☑
mongodb	Mongo Repository	--secret [true-false]	☑	☑
mq	JMS MQ Client to send messages		☑	☑
r2dbc	R2dbc Postgresql Client		☑	☑
redis	Redis	--mode [template-repository] --secret [true-false]	☑	☑
restconsumer	Rest Client Consumer	--url [url] --from-swagger swagger.yaml	☑	☑
rsocket	RSocket Requester		☑	☑
s3	AWS Simple Storage Service		☑	☑
secrets	Secrets Manager Bancolombia	--secrets-backend [backend] Valid options for backend are "aws_secrets_manager" (default) or "vault".	☑	☑
sqs	SQS message sender		☑	☑

This task will generate something like that:

📦infrastructure
┣ 📂driven-adapters
┃ ┗ 📂jpa-repository
┃ ┃ ┣ 📂src
┃ ┃ ┃ ┣ 📂main
┃ ┃ ┃ ┃ ┗ 📂java
┃ ┃ ┃ ┃ ┃ ┗ 📂[package]
┃ ┃ ┃ ┃ ┃ ┃ ┗ 📂jpa
┃ ┃ ┃ ┃ ┃ ┃ ┃ ┣ 📂config
┃ ┃ ┃ ┃ ┃ ┃ ┃ ┃ ┗ 📜DBSecret.java
┃ ┃ ┃ ┃ ┃ ┃ ┃ ┣ 📂helper
┃ ┃ ┃ ┃ ┃ ┃ ┃ ┃ ┗ 📜AdapterOperations.java
┃ ┃ ┃ ┃ ┃ ┃ ┃ ┣ 📜JPARepository.java
┃ ┃ ┃ ┃ ┃ ┃ ┃ ┗ 📜JPARepositoryAdapter.java
┃ ┃ ┃ ┗ 📂test
┃ ┃ ┃ ┃ ┗ 📂java
┃ ┃ ┃ ┃ ┃ ┗ 📂[package]
┃ ┃ ┃ ┃ ┃ ┃ ┗ 📂jpa
┃ ┃ ┃ ┃ ┃ ┃ ┃ ┗ 📂helper
┃ ┃ ┗ 📜build.gradle

Generate Entry Point

The generateEntryPoint | gep task will generate a module in Infrastructure layer, this task has one required parameter type.
Whether you'll use generic one also parameter name is required.

gradle generateEntryPoint --type=[entryPointType]
gradle gep --type [entryPointType]

Reference for entryPointType	Name	Additional Options	Java	Kotlin
generic	Empty Entry Point	--name [name]	☑	☑
asynceventhandler	Async Event Handler		☑	☑
graphql	API GraphQL	--pathgql [name path] default /graphql	☑	☑
kafka	Kafka Consumer		☑
mq	JMS MQ Client to listen messages		☑	☑
restmvc	API REST (Spring Boot Starter Web)	--server [serverOption] default undertow --authorization [true-false] --from-swagger swagger.yaml	☑	☑
rsocket	Rsocket Controller Entry Point		☑	☑
sqs	SQS Listener		☑	☑
webflux	API REST (Spring Boot Starter WebFlux)	--router [true, false] default true --authorization [true-false] --from-swagger swagger.yaml	☑	☑

Additionally, if you'll use a restmvc, you can specify the web server on which the application will run. By default, undertow.

   gradle generateEntryPoint --type=restmvc --server=[serverOption]
   gradle gep --type=restmvc --server=[serverOption]

Reference for serverOption	Name
undertow	Undertow server (default)
tomcat	Tomcat server
jetty	Jetty server

This task will generate something like that:

📦infrastructure
┣ 📂entry-points
┃ ┗ 📂generic
┃ ┃ ┣ 📂src
┃ ┃ ┃ ┣ 📂main
┃ ┃ ┃ ┃ ┗ 📂java
┃ ┃ ┃ ┃ ┃ ┗ 📂[package]
┃ ┃ ┃ ┃ ┃ ┃ ┗ 📂generic
┃ ┃ ┃ ┗ 📂test
┃ ┃ ┃ ┃ ┗ 📂java
┃ ┃ ┃ ┃ ┃ ┗ 📂[package]
┃ ┃ ┃ ┃ ┃ ┃ ┗ 📂generic
┃ ┃ ┗ 📜build.gradle

Generate Helper

The generateHelper | gh task will generate a module in Infrastructure layer, this task has one required parameter name.

   gradle generateHelper --name=[helperName]
   gradle gh --name=[helperName]

Generate Pipeline

The generatePipeline | gpl task will generate CI pipeline inside the folder "./deployment/", this task has one required parameter type and one optional parameter monoRepo by default is false.

   gradle generatePipeline --type=[pipelineType] --monoRepo=[true | false]
   gradle gpl --type=[pipelineType]  --monoRepo=[true | false]

Reference for pipelineType	Name
azure	Azure Pipeline
circleci	CircleCI Pipeline
github	GitHub Action
jenkins	Jenkins Pipeline

Generate Acceptance Test

The generateAcceptanceTest | gat task will generate subproject by karate framework inside the folder "./deployment/", this task has one optional parameter, name.

• name = NameAcceptanceTestProject: This parameter is going to specify the name of the acceptance test project. Default Value = acceptanceTest

      gradle generateAcceptanceTest --name=[acceptanceTestProjectName]
      gradle gat --name=[acceptanceTestProjectName] 

Karate is an open-source tool to combine API test-automation, mocks, performance-testing and even UI automation into a single, unified framework. The BDD syntax popularized by Cucumber is language-neutral, and easy for even non-programmers. Assertions and HTML reports are built-in, and you can run tests in parallel for speed.

Generate Performance Test

The generatePerformanceTest | gpt task will generate Performance test inside the folder "./performance-test/", this task has one required parameter type.

   gradle generatePerformanceTest --type=[performanceType]
   gradle gpt --type=[performanceType]

| Reference for **performanceType** | Name                    |
| --------------------------------- | ----------------------- |
| jmeter                            | Jmeter Performance Test |

Validate Structure

The validateStructure | vs Validate that project references aren't violated.

   gradle validateStructure
   gradle vs

This validation has another best practices verifications, which you can see on the generated ArchitectureTest file within the unit tests of the app-service module.

Dependency Rules

One important point made by Robert C. Martin on Clean Architecture is the Dependency Rule, that can be summarized like this: source code dependencies can only point inwards. Nothing in an inner circle can know anything at all about something in an outer circle. In particular, the name of something declared in an outer circle must not be mentioned by the code in an inner circle.

Having that in mind, the validateStructure | vs task performs the following validations:

1. Model module: to have no dependencies at all.
2. UseCase module: to declare dependency to the Model module ONLY, and no other additional dependencies.
3. Infrastructure Layer modules:
   • Allow declaration of any external dependency.
   • Allow declaration of dependency on Model and/or UseCase modules.
   • Avoid declaration of dependency AppService module.

Whitelisting dependencies:

Some dependencies, specially when working with BOMs (Bills of Materials), are injected transversally to the project, making the validation task to flag failures to rules 1 and 2. To avoid this scenario, or other you may encounter, you can configure a set of whitelisted dependencies.

Example:

1. Let's say you have declared a BOM in your project:

   dependencies {
     implementation(platform("com.myorg:my-bom:0.0.1"))
   }

2. This will make validateStructure | vs to flag a failure indicating an error like this:

   Validating Model Module
    --- Dependency com.myorg:some-bom is not allowed in Model Layer

3. To avoid this, you can white list your BOM like this:

   // build.gradle
   cleanPlugin {
     modelProps {
        whitelistedDependencies = "my-bom, <dep2>, <depN..>"
     }
   }

   Indicating only the name of the dependencies comma-separated.

Delete Module

The deleteModule | dm task will delete a sub project, this task has one required parameter module.

   gradle deleteModule --module=[name]
   gradle dm --module=[name]

Update Project

The updateCleanArchitecture | u task will update plugin and dependencies in all sub projects, this task has one optional parameter dependencies if you only want to update some dependencies the dependency need to contain the group, and the artifact for example for the dependency cleanArchitecture you will need to append co.com.bancolombia:cleanArchitecture. It also updates the spring, lombok, gradle and some other dependencies according to the plugin version that you are using, ocassionally it could make changes in other project structural files. We recommend that you commit your changes to git before running this command, but you can skip the verification passing --git false.

   gradle updateCleanArchitecture --dependencies=[dependency1, dependency2, ...]
   gradle u --dependencies=[dependency1, dependency2, ...]

How can I help?

Review the issues, we hear new ideas. Read more Contributing

Analytics

You can help the Contributors Team to prioritize features and improvements by permitting the Contributors team to send gradle tasks usage statistics to Analytics Server. The Contributors Team collect usage statistics unless you explicitly opt in off.

Due to the user input limitations to gradle task, when running any plugin task you will be notified about the analytics recollection, and you have the possibility to disable this recollection. If you enable or disable analytics explicitly, future task executions will not notify you.

To explicitly enable analytics and avoid the notification message

gradle analytics --enabled true
# o gradle a --enabled true

To disable analytics

gradle analytics --enabled false
# # o gradle a --enabled false

What is collected?

Usage analytics include the commands and selected flags for each execution. Usage analytics may include the following information:

• Your operating system (macOS, Linux distribution, Windows) and its version.
• Java vendor name and version.
• Java specification and runtime versions.
• Plugin version.
• Project language (kotlin or java)
• Task name that was run.
• Workspace information like language, user that is running the task.
• For generate use case, generate model, generate helper and delete module tasks, the name will be sent.
• For all tasks, the type and name, the time it took to run the task, and project type (reactive, imperative).

Whats Next?

Read more About Clean Architecure

scaffold-clean-architecture's Issues

New task to generate pipeline for Azure DevOps

We need to crate a pipeline for Azure DevOps, the CI pipeline will have all tasks required to:

1. Build the artifact
2. Prepare Sonar analysis
3. Coverage validation on SonarQube
4. Quality gate validation on SonarQube

To do so, we should have a task to generate the pipeline dynamically and be hable to generate difetent pipelines, for now only the Azure DevOps pipeline

Tarea gradle para generar reporte cobertura con jacoco

Hola!, seria interesante que el scaffold de clean architecture venga ya configurado con la tarea jacoco de gradle para generar el reporte de cobertura de pruebas con todo el consolidado de los módulos del proyecto.

`task jacocoRootReport(type: JacocoReport){

dependsOn = subprojects.test
additionalSourceDirs.setFrom files(subprojects.sourceSets.main.allSource.srcDirs)
sourceDirectories.setFrom files(subprojects.sourceSets.main.allSource.srcDirs)
classDirectories.setFrom files(subprojects.sourceSets.main.output)
executionData.setFrom project.fileTree(dir: '.', include: '**/build/jacoco/test.exec')

reports {
    html.enabled = true
    html.destination = file("${buildDir}/jacoco")
    xml.enabled = true
    xml.destination = file("${buildDir}/jacoco/report.xml")
    csv.enabled = false
}

}`

Error when execute any tasks in Gradle 6.3

When I execute gradle generateModel --name=[name] in gradle version > 6 (6.3), the plgin fails with following error:

• Where:
  Build file '/Users/daniel/Projects/banco/dojo-reactive/build.gradle' line: 23

• What went wrong:
  An exception occurred applying plugin request [id: 'net.saliman.cobertura', version: '3.0.0']

Failed to apply plugin [id 'net.saliman.cobertura']
Could not create task ':generateCoberturaReport'.
> Could not create task of type 'GenerateReportTask'.
> No signature of method: static org.gradle.util.DeprecationLogger.whileDisabled() is applicable for argument types: (net.saliman.gradle.plugin.cobertura.GenerateReportTask$1) values: [net.saliman.gradle.plugin.cobertura.GenerateReportTask$1@1a5e6363]

• Try:
  Run with --stacktrace option to get the stack trace. Run with --info or --debug option to get more log output. Run with --scan to get full insights.

• Get more help at https://help.gradle.org

BUILD FAILED in 2s

FAILURE: Build failed with an exception.

Reactive commons domain model interface mismatch

At the current version (1.5.4). When you try to do a:

gradle gda --value 3

The structure created has the following error.

It has a mismatch with the interface created at that path and it does not contain the "emit" method as well.

Upgrade gradle to 6.0 or greater

We need to upgrade the gradle version to 6.0 or greater to solve CVE-2019-16370 vulnerability.

you must validate that after changing the major version of gradle the plugin works fine.

Improve gradle tasks cli usability

Change task numbers options for a short name description.

$ gradle generateDrivenAdapter --value=5

$ gradle generateDrivenAdapter --value=mongodb

Create usage samples on error with existent options.

adapter	description
mongodb	Generates MongoDB Driven Adapter
jpa	Generates JPA Driven Adapter

Generate Driver Adapter JPA Repository

Wrong dependency in build.gradle of helper jpa-repository-commons when generates driver adapters jpa-repository.

Wrong: implementation 'org.springframework.boot:spring-boot-starter-data-mongodb'
Correct: implementation 'org.springframework.boot:spring-boot-starter-data-jpa'

Error validating structure when generate a reactive project.

Error validating structure when generate a reactive project.

➜ $ gradle ca --type reactive

Task :ca
Clean Architecture plugin version: 1.6.9
Package: co.com.bancolombia
Project Type: REACTIVE
Project Name: cleanArchitecture
Project Package: co.com.bancolombia
Applying changes
Changes successfully applied

BUILD SUCCESSFUL in 1s
1 actionable task: 1 executed
➜ $ gradle vs

Task :vs FAILED
Clean Architecture plugin version: 1.6.9
Submodules: app-service
Submodules: model
Submodules: usecase
Project Package: co.com.bancolombia
Validating Model Module
--- Dependency: reactor-core
--- Dependency: reactor-extra

FAILURE: Build failed with an exception.

• What went wrong:
  Execution failed for task ':vs'.

co.com.bancolombia.exceptions.CleanException: Model module is invalid

BUILD FAILED in 1s
1 actionable task: 1 executed

Please remove this dependencies from validation for module model when reactive:
--- Dependency: reactor-core
--- Dependency: reactor-extra

Add net.saliman plugin

El plugin de jacoco es un poco inconsistente y la implementación varía según la version de gradle, por que es preferible implementar el plugin de net.saliman:gradle-cobertura

Driven Adapter for Redis

Describe the solution you'd like
We need to crate a driven adapter for Redis, the driven adapter should be compatibility with imperative and reactive projects.

Complete Task cleanArchitecture

• Complete the generate project structure.

Add Jacoco report unification

Enable creation of MongoDB driven adapter for reactive projects

This gradle plugin allows creation of reactive and imperative projects, but only allows creation of imperative driven adapters. It also apply for JPA Driven Adapter.

Task to generate usecase

Parallel download of dependencies not being used in default gradle wrapper properties

The plugin could be setting the parallel download of dependencies by having the following setting by default in the created Gradle Wrapper Properties file:

org.gradle.parallel=true

It's one of the recommendations to improve Gradle performance shown in this page:

https://guides.gradle.org/performance/

Update gradle wrapper version

Update version of gradle wrapper in the project to the last stable and compatible version

Application build.gradle is getting wrong

As soon as you get all folders with clean architecture task (value in --type field = reactive). Run generateDrivenAdapter task with any option value.

Later you'll see in the application project in build.gradle the dependencies statement is missing what result as an error.

Add Github Actions in pipelines as a code

Add new option in the Generate Pipeline Task ,can follow azure pipeline option to generate that.

Unit Test

Disable Lombok

Some developers don't like Lombok, will be useful to add parameter option to disable this.

Enable JMS

Is your feature request related to a problem? Please describe.
would be great that not only generates event subscriber or message sender for rabbitmq, but also for jms protocol implemented by message brokers like ibm mq

Describe the solution you'd like
Implement a jms driven adapter and an jms entry point according to the clean architecture structure

Task to generate models

Handler and Router

What possibility is there that in webflux you use handler and router or at least allow you to select the option

R2DBC Driven Adapter for reactive projects

Is your feature request related to a problem? Please describe.
reactive projects can´t connection with relational databases with traditional drivers (jdbc, hibernate) because this implementations are blocking . will great to append this issue at the plugin.
A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]

Generate generic entry point

Could be useful if the plugin allow us to create a generic entry point

Task to generate driven adapters

Use Application Server Undertow when generating an imperative structure

By default spring-boot-starter-web use Tomcat application server, we want to generate projects using undertow application server.

Add new documentation to readme file

• Add diagrams about Clean Architecture to readme file (Use links, don`t upload the image to repo)
• Add link to Medium to readme file

Task to generate entry points

Structure error on Application.yaml

At the moment when you generate the clean architecture structure, the plugin creates the file application.yaml in the app-service project, however this file does not have a valid yaml structure.

New Driven adapter to listen an event bus

Upgrade secrets manager dependency

Currently when I generate a driven adapter which uses secrets, this dependency can not be downloaded from maven, I suggest to change this dependency compile 'co.com.bancolombia:secretsmanager:2.1.0' for the dependency described in the open source project secrets-manager.

Extract modules as mustache templates

Remove project templates from java classes, build it as mustache templates for maintainability improve.

New S3 driven adapter

It's necesary interact with AmazonS3 AWS, for the storage of objects. It's important, because can be used fro store, extract any amount data. or other range of use cases!

Decouple secrets manager library usage from JPA driven adapter

• Remove secrets manager from JPA driven adapter.
• Extract secrets manager as an independent driven adapter.
• When generate JPA driven adapter ask for secrets manager driven adapter generation.

New Driven adapter to consume API Rest Service

It would be great to generate a new Driven adapter to consume API Rest Service.

This driven adapter can be even more useful if I can parameterize the consume of a generic service or the consume of an Api Connect service.

JPA Repository has no reference for JPA Repository Adapter

When you create the JPA Repository driven adapter fail to compile because in the jpa repository build.gradle is missing the reference for jpa repository adapter

Change secrets manager implementation

To use AWS secrets using the SecretManager library don´t need a driven adapter and a use case, we just have to use SecretsManager from the bean

Update reactive-commons version

On current version (1.5.4), the plugin is using an old version of reactive commons.

It would be better if you update it to a recent version.

The plugin is not adding the libraries in project main

Missing libraries

com.zaxxer.hikari
org.springframework.orm.jpa

New event subscriptions entry point

When I need an event subscriber as an entry point I need to create a generic entry point and modified it adding reactive commons and creating the handlers and listeners. The plugin should do it for me!

LocalContainerEntityManagerFactoryBean cannot resolve setPackagesToScan

When i'm using the plugin i generated the structure without problem, but when you import the generic jpa driven adapter there is some missing dependendcies like:
compile 'com.zaxxer:HikariCP:3.4.5'
compile group: 'org.springframework', name: 'spring-orm', version: '2.5.1'

This dependencies should go in the app-service layer on the build.gradle file. Also when you import the missing dependencies the method setPackagesToScan it seems to have no implementation for LocalContainerEntityManagerFactoryBean object in Jpaconfig file

Error on Jar generation app-service

When The build is generating from gradle of app-service it doesn't create the folder libs into this

app-service/build/libs

The possible solution is replace the task jar for the next:

task explodedJar(type: Copy) {
with jar
into "${buildDir}/exploded"
}

For more details contact me:

My corporate email --> [email protected]

Generate generic driven adapter

Could be useful if the plugin allow us to create a generic driven adapter and not only the options predefined in the read.me

Integrate with Sonar Scanner

Delete existent entry point or driven adapter

• Create a gradle task to delete an existent entry point or a driven adapter.
• Remove all gradle references from other modules.

Task to validate the project

Include the "UseCase" Word

It´s a bit confusing when you create an use case because it is not clear if in the name has to include or not the word "UseCase" so it'll be helpful if when you create an use case and the plugin automatically add the word UseCase to it, example if i generate the use case Person, the final result would be a class with name PersonUseCase. This would help us to keep classes naming standard

Error on package name at MainApplication class

Using the first command to generate the clean architecture structure, in the MainApplication class at the app-service project has the wrong package name referenced inside the class.

Generate Functional Test