eva4j 1.0.0

package/templates/base/docker/docker-compose.yml.ejs

@@ -0,0 +1,41 @@
+<% if (features.includeDocker && dependencies.includes('data-jpa') && databaseType !== 'h2') { %>version: '3.8'
+
+services:
+<% if (databaseType === 'postgresql') { %>  postgres:
+    image: postgres:16-alpine
+    container_name: <%= artifactId %>-postgres
+    environment:
+      POSTGRES_DB: <%= databaseName %>
+      POSTGRES_USER: <%= databaseUsername %>
+      POSTGRES_PASSWORD: <%= databasePassword %>
+    ports:
+      - "5432:5432"
+    volumes:
+      - postgres-data:/var/lib/postgresql/data
+    networks:
+      - <%= artifactId %>-network
+<% } else if (databaseType === 'mysql') { %>  mysql:
+    image: mysql:8.0
+    container_name: <%= artifactId %>-mysql
+    environment:
+      MYSQL_DATABASE: <%= databaseName %>
+      MYSQL_USER: <%= databaseUsername %>
+      MYSQL_PASSWORD: <%= databasePassword %>
+      MYSQL_ROOT_PASSWORD: <%= databasePassword %>
+    ports:
+      - "3306:3306"
+    volumes:
+      - mysql-data:/var/lib/mysql
+    networks:
+      - <%= artifactId %>-network
+<% } %>
+
+volumes:
+<% if (databaseType === 'postgresql') { %>  postgres-data:
+<% } else if (databaseType === 'mysql') { %>  mysql-data:
+<% } %>
+
+networks:
+  <%= artifactId %>-network:
+    driver: bridge
+<% } %>

package/templates/base/gradle/build.gradle.ejs

@@ -0,0 +1,70 @@
+plugins {
+    id 'java'
+    id 'org.springframework.boot' version '<%= springBootVersion %>'
+    id 'io.spring.dependency-management' version '<%= dependencyManagementVersion %>'
+}
+
+group = '<%= groupId %>'
+version = '<%= version %>'
+
+java {
+    toolchain {
+        languageVersion = JavaLanguageVersion.of(<%= javaVersion %>)
+    }
+}
+
+configurations {
+    compileOnly {
+        extendsFrom annotationProcessor
+    }
+}
+
+repositories {
+    mavenCentral()
+}
+
+dependencyManagement {
+    imports {
+<% if (typeof isDetached === 'undefined' || !isDetached) { %>        mavenBom "org.springframework.modulith:spring-modulith-bom:<%= springModulithVersion %>"
+<% } %>        mavenBom "org.springframework.cloud:spring-cloud-dependencies:<%= springCloudVersion %>"
+    }
+}
+
+dependencies {
+    implementation 'org.springframework.boot:spring-boot-starter'
+    
+<% if (typeof isDetached === 'undefined' || !isDetached) { %>    // Spring Modulith - Mandatory
+    implementation 'org.springframework.modulith:spring-modulith-starter-core'
+    implementation 'org.springframework.modulith:spring-modulith-starter-jpa'
+    testImplementation 'org.springframework.modulith:spring-modulith-starter-test'
+
+<% } %>    // Spring Cloud OpenFeign
+    implementation 'org.springframework.cloud:spring-cloud-starter-openfeign'
+<% if (features.hasKafka) { %>
+    // Kafka
+    implementation 'org.springframework.kafka:spring-kafka'
+    testImplementation 'org.springframework.kafka:spring-kafka-test'
+
+<% } %><% if (dependencies.includes('web')) { %>    implementation 'org.springframework.boot:spring-boot-starter-web'
+<% } %><% if (dependencies.includes('data-jpa')) { %>    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
+<% } %><% if (dependencies.includes('security')) { %>    implementation 'org.springframework.boot:spring-boot-starter-security'
+<% } %><% if (dependencies.includes('validation')) { %>    implementation 'org.springframework.boot:spring-boot-starter-validation'
+<% } %><% if (dependencies.includes('actuator')) { %>    implementation 'org.springframework.boot:spring-boot-starter-aop'
+<% } %><% if (features.includeDevtools) { %>    developmentOnly 'org.springframework.boot:spring-boot-devtools'
+<% } %><% if (features.includeLombok) { %>    
+    compileOnly 'org.projectlombok:lombok'
+    annotationProcessor 'org.projectlombok:lombok'
+<% } %><% if (dependencies.includes('data-jpa')) { %>    
+    runtimeOnly '<%= databaseDriver %>'
+<% } %><% if (features.includeSwagger) { %>    
+    implementation 'org.springdoc:springdoc-openapi-starter-webmvc-ui:2.3.0'
+<% } %>    
+    testImplementation 'org.springframework.boot:spring-boot-starter-test'
+<% if (dependencies.includes('security')) { %>    testImplementation 'org.springframework.security:spring-security-test'
+<% } %><% if (testing.includeTestcontainers && dependencies.includes('data-jpa')) { %>    testImplementation 'org.testcontainers:testcontainers:1.19.3'
+    testImplementation 'org.testcontainers:<%= databaseTestcontainer %>:1.19.3'
+<% } %>}
+
+tasks.named('test') {
+    useJUnitPlatform()
+}

package/templates/base/gradle/settings.gradle.ejs

@@ -0,0 +1 @@
+rootProject.name = '<%= artifactId %>'

package/templates/base/resources/application-develop.yml.ejs

@@ -0,0 +1,5 @@
+spring:
+  config:
+    import:
+      - "classpath:parameters/develop/db.yaml"
+      - "classpath:parameters/develop/cors.yml"

package/templates/base/resources/application-local.yml.ejs

@@ -0,0 +1,5 @@
+spring:
+  config:
+    import:
+      - "classpath:parameters/local/db.yaml"
+      - "classpath:parameters/local/cors.yml"

package/templates/base/resources/application-production.yml.ejs

@@ -0,0 +1,9 @@
+spring:
+  config:
+    import:
+      - "classpath:parameters/production/db.yaml"
+      - "classpath:parameters/production/cors.yml"
+
+springdoc:
+  swagger-ui:
+    enabled: false

package/templates/base/resources/application-test.yml.ejs

@@ -0,0 +1,5 @@
+spring:
+  config:
+    import:
+      - "classpath:parameters/test/db.yaml"
+      - "classpath:parameters/test/cors.yml"

package/templates/base/resources/application.yml.ejs

@@ -0,0 +1,31 @@
+server:
+  port: <%= serverPort %>
+  servlet:
+    context-path: /
+
+springdoc:
+  swagger-ui:
+    path: /swagger-ui.html
+    enabled: true
+  api-docs:
+    path: /api-docs
+
+management:
+  endpoint:
+    health:
+      probes:
+        enabled: true
+      show-details: always
+  endpoints:
+    web:
+      exposure:
+        include: "health"
+
+spring:
+  threads:
+    virtual:
+      enabled: true
+  application:
+    name: <%= artifactId %>
+  profiles:
+    active: ${PROFILE:local}

package/templates/base/resources/parameters/develop/cors.yml.ejs

@@ -0,0 +1,4 @@
+cors:
+  allowedOrigins: http://localhost:4200, http://localhost:5173
+  allowedMethods: POST, GET, PATCH, DELETE, PUT
+  allowedHeaders: "*"

package/templates/base/resources/parameters/develop/db.yaml.ejs

@@ -0,0 +1,21 @@
+<% if (dependencies.includes('data-jpa')) { %>spring:
+  datasource:
+    url: ${DB_URL:<%= databaseUrl %>}
+    username: ${DB_USERNAME:<%= databaseUsername %>}
+    password: ${DB_PASSWORD:<%= databasePassword %>}
+    driver-class-name: <%= databaseDriverClass %>
+  
+  jpa:
+    hibernate:
+      ddl-auto: update
+    show-sql: false
+    properties:
+      hibernate:
+        format_sql: false
+        dialect: <%= hibernateDialect %>
+
+logging:
+  level:
+    root: INFO
+    <%= packageName %>: DEBUG
+<% } %>

package/templates/base/resources/parameters/develop/kafka.yml.ejs

@@ -0,0 +1,26 @@
+spring:
+  kafka:
+    bootstrap-servers:
+      - localhost:9092 # Lista de brokers Kafka
+    producer:
+      properties:
+        spring.json.add.type.headers: false
+      key-serializer: org.apache.kafka.common.serialization.StringSerializer
+      value-serializer: org.springframework.kafka.support.serializer.JsonSerializer
+      retries: 3
+    consumer:
+      group-id: <%= projectName %>-api-group
+      auto-offset-reset: earliest
+      enable-auto-commit: false
+      key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
+      value-deserializer: org.springframework.kafka.support.serializer.JsonDeserializer
+      properties:
+        spring.json.trusted.packages: "*"
+        spring.json.use.type.headers: false
+        spring.json.value.default.type: <%= packageName %>.shared.infrastructure.eventEnvelope.EventEnvelope
+    listener:
+      ack-mode: manual
+      concurrency: 3
+      retry:
+        max-attempts: 2
+        backoff-delay: 1500

package/templates/base/resources/parameters/local/cors.yml.ejs

@@ -0,0 +1,4 @@
+cors:
+  allowedOrigins: http://localhost:4200, http://localhost:5173
+  allowedMethods: POST, GET, PATCH, DELETE, PUT
+  allowedHeaders: "*"

package/templates/base/resources/parameters/local/db.yaml.ejs

@@ -0,0 +1,21 @@
+<% if (dependencies.includes('data-jpa')) { %>spring:
+  datasource:
+    url: <%= databaseUrl %>
+    username: <%= databaseUsername %>
+    password: <%= databasePassword %>
+    driver-class-name: <%= databaseDriverClass %>
+  
+  jpa:
+    hibernate:
+      ddl-auto: update
+    show-sql: true
+    properties:
+      hibernate:
+        format_sql: true
+        dialect: <%= hibernateDialect %>
+
+logging:
+  level:
+    root: INFO
+    <%= packageName %>: DEBUG
+<% } %>

package/templates/base/resources/parameters/local/kafka.yml.ejs

@@ -0,0 +1,26 @@
+spring:
+  kafka:
+    bootstrap-servers:
+      - localhost:9092 # Lista de brokers Kafka
+    producer:
+      properties:
+        spring.json.add.type.headers: false
+      key-serializer: org.apache.kafka.common.serialization.StringSerializer
+      value-serializer: org.springframework.kafka.support.serializer.JsonSerializer
+      retries: 3
+    consumer:
+      group-id: <%= projectName %>-api-group
+      auto-offset-reset: earliest
+      enable-auto-commit: false
+      key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
+      value-deserializer: org.springframework.kafka.support.serializer.JsonDeserializer
+      properties:
+        spring.json.trusted.packages: "*"
+        spring.json.use.type.headers: false
+        spring.json.value.default.type: <%= packageName %>.shared.infrastructure.eventEnvelope.EventEnvelope
+    listener:
+      ack-mode: manual
+      concurrency: 3
+      retry:
+        max-attempts: 2
+        backoff-delay: 1500

package/templates/base/resources/parameters/production/cors.yml.ejs

@@ -0,0 +1,4 @@
+cors:
+  allowedOrigins: http://localhost:4200, http://localhost:5173
+  allowedMethods: POST, GET, PATCH, DELETE, PUT
+  allowedHeaders: "*"

package/templates/base/resources/parameters/production/db.yaml.ejs

@@ -0,0 +1,21 @@
+<% if (dependencies.includes('data-jpa')) { %>spring:
+  datasource:
+    url: ${DB_URL}
+    username: ${DB_USERNAME}
+    password: ${DB_PASSWORD}
+    driver-class-name: <%= databaseDriverClass %>
+  
+  jpa:
+    hibernate:
+      ddl-auto: validate
+    show-sql: false
+    properties:
+      hibernate:
+        format_sql: false
+        dialect: <%= hibernateDialect %>
+
+logging:
+  level:
+    root: WARN
+    <%= packageName %>: INFO
+<% } %>

package/templates/base/resources/parameters/production/kafka.yml.ejs

@@ -0,0 +1,26 @@
+spring:
+  kafka:
+    bootstrap-servers:
+      - localhost:9092 # Lista de brokers Kafka
+    producer:
+      properties:
+        spring.json.add.type.headers: false
+      key-serializer: org.apache.kafka.common.serialization.StringSerializer
+      value-serializer: org.springframework.kafka.support.serializer.JsonSerializer
+      retries: 3
+    consumer:
+      group-id: <%= projectName %>-api-group
+      auto-offset-reset: earliest
+      enable-auto-commit: false
+      key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
+      value-deserializer: org.springframework.kafka.support.serializer.JsonDeserializer
+      properties:
+        spring.json.trusted.packages: "*"
+        spring.json.use.type.headers: false
+        spring.json.value.default.type: <%= packageName %>.shared.infrastructure.eventEnvelope.EventEnvelope
+    listener:
+      ack-mode: manual
+      concurrency: 3
+      retry:
+        max-attempts: 2
+        backoff-delay: 1500

package/templates/base/root/README.md.ejs

@@ -0,0 +1,126 @@
+# <%= projectName %>
+
+<%= description %>
+
+## Built with eva4j CLI
+
+This project was generated using [eva4j](https://github.com/your-repo/eva4j), a CLI tool for generating Spring Boot projects with modular architecture.
+
+## Technologies
+
+- **Java**: <%= javaVersion %>
+- **Spring Boot**: <%= springBootVersion %>
+- **Build Tool**: Gradle <%= gradleVersion %>
+<% if (dependencies.includes('data-jpa')) { %>- **Database**: <%= databaseType.toUpperCase() %>
+<% } %><% if (dependencies.includes('web')) { %>- **REST API**: Spring Web
+<% } %><% if (dependencies.includes('security')) { %>- **Security**: Spring Security
+<% } %><% if (features.includeSwagger) { %>- **API Documentation**: Swagger/OpenAPI
+<% } %>
+
+## Project Structure
+
+```
+<%= artifactId %>/
+├── src/
+│   ├── main/
+│   │   ├── java/
+│   │   │   └── <%= packagePath %>/
+│   │   │       ├── <%= applicationClassName %>.java
+│   │   │       ├── common/              # Infrastructure layer
+│   │   │       │   ├── config/
+│   │   │       │   ├── exception/
+│   │   │       │   └── util/
+│   │   │       ├── shared/              # Shared domain layer (generated with first module)
+│   │   │       └── [modules]/           # Domain modules (user, product, etc.)
+│   │   └── resources/
+│   │       └── application.yml
+│   └── test/
+├── build.gradle
+└── docker-compose.yml
+```
+
+## Getting Started
+
+### Prerequisites
+
+- Java <%= javaVersion %> or higher
+- Gradle <%= gradleVersion %> or use included wrapper
+<% if (dependencies.includes('data-jpa') && databaseType !== 'h2') { %>- <%= databaseType.toUpperCase() %> database
+<% } %>
+
+### Running the Application
+
+```bash
+# Using Gradle wrapper
+./gradlew bootRun
+
+# Or build and run
+./gradlew build
+java -jar build/libs/<%= artifactId %>-<%= version %>.jar
+```
+
+<% if (features.includeDocker && dependencies.includes('data-jpa') && databaseType !== 'h2') { %>### Using Docker Compose
+
+Start the database:
+
+```bash
+docker-compose up -d
+```
+<% } %>
+
+### Running Tests
+
+```bash
+./gradlew test
+```
+
+<% if (features.includeSwagger) { %>## API Documentation
+
+Once the application is running, you can access the API documentation at:
+
+- Swagger UI: http://localhost:<%= serverPort %>/swagger-ui.html
+- OpenAPI JSON: http://localhost:<%= serverPort %>/api-docs
+<% } %>
+
+<% if (dependencies.includes('actuator')) { %>## Actuator Endpoints
+
+Health check and metrics are available at:
+
+- Health: http://localhost:<%= serverPort %>/actuator/health
+- Metrics: http://localhost:<%= serverPort %>/actuator/metrics
+<% } %>
+
+## Adding Modules
+
+To add a new domain module (e.g., user, product):
+
+```bash
+eva4j add module user
+```
+
+This will generate:
+- Controller layer (REST endpoints)
+- Service layer (business logic)
+- Repository layer (data access)
+- Model/Entity (domain object)
+- DTOs (data transfer objects)
+- Mapper (entity ↔ DTO conversion)
+- Tests
+
+## Architecture
+
+This project follows a **modular monolith** architecture with **package-by-feature** organization:
+
+- **common**: Infrastructure and technical concerns (config, global exception handling)
+- **shared**: Cross-cutting domain concerns (base entities, value objects, domain exceptions)
+- **[module]**: Feature-based modules (user, product, order, etc.)
+
+Each module is self-contained with its own controller, service, repository, model, and DTOs.
+
+## License
+
+<%= license || 'MIT' %>
+
+## Author
+
+<%= author %>

package/templates/base/root/gitignore.ejs

@@ -0,0 +1,42 @@
+# Gradle
+.gradle/
+build/
+!gradle/wrapper/gradle-wrapper.jar
+!**/src/main/**/build/
+!**/src/test/**/build/
+
+# IDE
+.idea/
+.vscode/
+*.iml
+*.iws
+*.ipr
+out/
+.DS_Store
+
+# Compiled class files
+*.class
+
+# Log files
+*.log
+
+# Package Files
+*.jar
+*.war
+*.nar
+*.ear
+*.zip
+*.tar.gz
+*.rar
+
+# Virtual machine crash logs
+hs_err_pid*
+
+# Spring Boot
+application-local.yml
+application-local.properties
+
+# Environment variables
+.env
+
+# Note: .eva4j.json is tracked to preserve project configuration across team members

package/templates/http-exchange/Adapter.java.ejs

@@ -0,0 +1,39 @@
+package <%= packageName %>.<%= moduleName %>.infrastructure.adapters.<%= portNameCamelCase %>;
+
+import <%= packageName %>.<%= moduleName %>.application.ports.<%= portName %>;
+import org.springframework.stereotype.Component;
+
+@Component
+public class <%= portName %>Adapter implements <%= portName %> {
+
+  private final <%= portName %>FeignClient feignClient;
+
+  public <%= portName %>Adapter(<%= portName %>FeignClient feignClient) {
+    this.feignClient = feignClient;
+  }
+
+  @Override
+  public Object findAll() {
+    return feignClient.findAll();
+  }
+
+  @Override
+  public Object findById(Long id) {
+    return feignClient.findById(id);
+  }
+
+  @Override
+  public Object create(Object request) {
+    return feignClient.create(request);
+  }
+
+  @Override
+  public Object update(Long id, Object request) {
+    return feignClient.update(id, request);
+  }
+
+  @Override
+  public void delete(Long id) {
+    feignClient.delete(id);
+  }
+}

package/templates/http-exchange/Config.java.ejs

@@ -0,0 +1,24 @@
+package <%= packageName %>.<%= moduleName %>.infrastructure.adapters.<%= portNameCamelCase %>;
+
+import feign.Logger;
+import feign.Request;
+import org.springframework.context.annotation.Bean;
+
+import java.util.concurrent.TimeUnit;
+
+public class <%= portName %>Config {
+
+  @Bean
+  public Logger.Level feignLoggerLevel() {
+    return Logger.Level.BASIC;
+  }
+
+  @Bean
+  public Request.Options feignOptions() {
+    return new Request.Options(
+      15, TimeUnit.SECONDS,   // connect timeout
+      15, TimeUnit.SECONDS,   // read timeout
+      true
+    );
+  }
+}

package/templates/http-exchange/FeignClient.java.ejs

@@ -0,0 +1,23 @@
+package <%= packageName %>.<%= moduleName %>.infrastructure.adapters.<%= portNameCamelCase %>;
+
+import org.springframework.cloud.openfeign.FeignClient;
+import org.springframework.web.bind.annotation.*;
+
+@FeignClient(name = "<%= feignClientName %>", url = "${<%= baseUrlProperty %>}", configuration = <%= portName %>Config.class)
+public interface <%= portName %>FeignClient {
+  
+  @GetMapping("/api/resources")
+  Object findAll();
+  
+  @GetMapping("/api/resources/{id}")
+  Object findById(@PathVariable("id") Long id);
+  
+  @PostMapping("/api/resources")
+  Object create(@RequestBody Object request);
+  
+  @PutMapping("/api/resources/{id}")
+  Object update(@PathVariable("id") Long id, @RequestBody Object request);
+  
+  @DeleteMapping("/api/resources/{id}")
+  void delete(@PathVariable("id") Long id);
+}

package/templates/http-exchange/Port.java.ejs

@@ -0,0 +1,14 @@
+package <%= packageName %>.<%= moduleName %>.application.ports;
+
+public interface <%= portName %> {
+  
+  Object findAll();
+  
+  Object findById(Long id);
+  
+  Object create(Object request);
+  
+  Object update(Long id, Object request);
+  
+  void delete(Long id);
+}

package/templates/kafka-event/Event.java.ejs

@@ -0,0 +1,10 @@
+package <%= packageName %>.<%= moduleName %>.application.events;
+
+public record <%= eventClassName %>(
+  // TODO: Add your event fields here
+  // Example:
+  // Long id,
+  // String name,
+  // LocalDateTime createdAt
+) {
+}

package/templates/kafka-event/KafkaConfigBean.java.ejs

@@ -0,0 +1,7 @@
+  @Value("<%= topicSpringProperty %>")
+  private String <%= valueFieldName %>;
+
+  @Bean
+  public NewTopic <%= beanMethodName %>() {
+    return new NewTopic(<%= valueFieldName %>, <%= partitions %>, (short) <%= replicas %>);
+  }

package/templates/kafka-event/KafkaMessageBroker.java.ejs

@@ -0,0 +1,32 @@
+package <%= packageName %>.<%= moduleName %>.infrastructure.adapters.kafkaMessageBroker;
+
+import <%= packageName %>.<%= moduleName %>.application.events.<%= eventClassName %>;
+import <%= packageName %>.<%= moduleName %>.application.ports.MessageBroker;
+import <%= packageName %>.shared.infrastructure.eventEnvelope.EventEnvelope;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.kafka.core.KafkaTemplate;
+import org.springframework.stereotype.Component;
+import org.slf4j.MDC;
+
+@Component
+public class KafkaMessageBroker implements MessageBroker {
+
+  @Value("<%= topicSpringProperty %>")
+  private String <%= topicNameKebab.replace(/-/g, '') %>Topic;
+
+  private final KafkaTemplate<String, Object> kafkaTemplate;
+
+  public KafkaMessageBroker(KafkaTemplate<String, Object> kafkaTemplate) {
+    this.kafkaTemplate = kafkaTemplate;
+  }
+
+  @Override
+  public void publish<%= eventClassName %>(<%= eventClassName %> event) {
+    EventEnvelope<<%= eventClassName %>> envelope = EventEnvelope.of(
+      <%= topicNameKebab.replace(/-/g, '') %>Topic,
+      event,
+      MDC.get("correlationId")
+    );
+    kafkaTemplate.send(<%= topicNameKebab.replace(/-/g, '') %>Topic, envelope);
+  }
+}