pablo/portfolio-api
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor: replace Spring Boot with Jooby framework

Browse Source 
- Remove Spring Boot dependencies and annotations.
- Implement Jooby MVC controllers and Guice dependency injection.
- Migrate persistence layer to Ebean ORM.
- Configure Flyway migrations and ApiErrorController.
- Update application configuration to HOCON format.
This commit is contained in:
pablo
2026-03-02 16:38:11 +01:00
parent 83070ccbda
commit fa78d0fca2
68 changed files with 1087 additions and 718 deletions
Download Patch File Download Diff File Expand all files Collapse all files

115
bootstrap/pom.xml
View File

@@ -1,12 +1,22 @@
<project>
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>com.pablotj</groupId>
<artifactId>portfolio-api</artifactId>
<version>0.0.1-SNAPSHOT</version>
</parent>
<artifactId>bootstrap</artifactId>
<properties>
<jooby.version>3.6.1</jooby.version>
<postgresql.version>42.7.2</postgresql.version>
<testcontainers.version>1.19.7</testcontainers.version>
</properties>
<dependencies>
<dependency>
<groupId>com.pablotj</groupId>
@@ -14,40 +24,84 @@
<version>${project.version}</version>
</dependency>
<!-- Drivers DB -->
<dependency>
<groupId>io.jooby</groupId>
<artifactId>jooby-netty</artifactId>
<version>${jooby.version}</version>
</dependency>
<dependency>
<groupId>io.jooby</groupId>
<artifactId>jooby-jackson</artifactId>
<version>${jooby.version}</version>
</dependency>
<dependency>
<groupId>io.jooby</groupId>
<artifactId>jooby-jackson</artifactId>
<version>3.6.1</version>
</dependency>
<dependency>
<groupId>io.jooby</groupId>
<artifactId>jooby-hibernate-validator</artifactId>
<version>3.6.1</version>
</dependency>
<dependency>
<groupId>io.jooby</groupId>
<artifactId>jooby-openapi</artifactId>
<version>${jooby.version}</version>
</dependency>
<dependency>
<groupId>io.jooby</groupId>
<artifactId>jooby-logback</artifactId>
<version>${jooby.version}</version>
</dependency>
<dependency>
<groupId>org.postgresql</groupId>
<artifactId>postgresql</artifactId>
<scope>runtime</scope>
<version>${postgresql.version}</version>
</dependency>
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<scope>runtime</scope>
<version>2.2.224</version>
</dependency>
<!-- Swagger/OpenAPI -->
<dependency>
<groupId>org.springdoc</groupId>
<artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
<version>${springdoc.version}</version>
<groupId>io.jooby</groupId>
<artifactId>jooby-hikari</artifactId>
<version>${jooby.version}</version>
</dependency>
<!-- Actuator -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
<groupId>io.jooby</groupId>
<artifactId>jooby-guice</artifactId>
<version>${jooby.version}</version>
</dependency>
<!-- Test -->
<!--
install(new DotenvModule());
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<groupId>io.jooby</groupId>
<artifactId>jooby-dotenv</artifactId>
<version>${jooby.version}</version>
</dependency>-->
<dependency>
<groupId>io.jooby</groupId>
<artifactId>jooby-flyway</artifactId>
<version>${jooby.version}</version>
</dependency>
<dependency>
<groupId>io.jooby</groupId>
<artifactId>jooby-test</artifactId>
<version>${jooby.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.testcontainers</groupId>
<artifactId>postgresql</artifactId>
<version>${testcontainers.version}</version>
<scope>test</scope>
</dependency>
</dependencies>
@@ -55,13 +109,34 @@
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<groupId>io.jooby</groupId>
<artifactId>jooby-maven-plugin</artifactId>
<version>${jooby.version}</version>
<configuration>
<mainClass>com.pablotj.portfolio.bootstrap.PortfolioApplication</mainClass>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-shade-plugin</artifactId>
<version>3.5.1</version>
<executions>
<execution>
<id>jooby-shade</id>
<phase>package</phase>
<goals>
<goal>repackage</goal>
<goal>shade</goal>
</goals>
<configuration>
<createDependencyReducedPom>false</createDependencyReducedPom>
<transformers>
<transformer implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer"/>
<transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
<mainClass>com.pablotj.portfolio.bootstrap.PortfolioApplication</mainClass>
</transformer>
</transformers>
</configuration>
</execution>
</executions>
</plugin>

85
bootstrap/src/main/java/com/pablotj/portfolio/bootstrap/PortfolioApplication.java
View File

@@ -1,16 +1,79 @@
package com.pablotj.portfolio.bootstrap;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.domain.EntityScan;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import com.pablotj.portfolio.bootstrap.certification.CertificationApplicationConfig;
import com.pablotj.portfolio.bootstrap.education.EducationApplicationConfig;
import com.pablotj.portfolio.bootstrap.experience.ExperienceApplicationConfig;
import com.pablotj.portfolio.bootstrap.profile.ProfileApplicationConfig;
import com.pablotj.portfolio.bootstrap.project.ProjectApplicationConfig;
import com.pablotj.portfolio.bootstrap.skill.SkillApplicationConfig;
import com.pablotj.portfolio.infrastructure.config.CorsConfig;
import com.pablotj.portfolio.infrastructure.rest.api.ApiErrorController;
import com.pablotj.portfolio.infrastructure.rest.api.ApiRootController;
import com.pablotj.portfolio.infrastructure.rest.certification.CertificationController;
import com.pablotj.portfolio.infrastructure.rest.education.EducationController;
import com.pablotj.portfolio.infrastructure.rest.experience.ExperienceController;
import com.pablotj.portfolio.infrastructure.rest.profile.ProfileController;
import com.pablotj.portfolio.infrastructure.rest.project.ProjectController;
// Importa el resto de controladores según los tengas listos
import com.pablotj.portfolio.infrastructure.rest.skill.SkillController;
import io.jooby.Jooby;
import io.jooby.flyway.FlywayModule;
import io.jooby.guice.GuiceModule;
import io.jooby.hikari.HikariModule;
import io.jooby.jackson.JacksonModule;
import io.jooby.netty.NettyServer;
import io.jooby.ebean.EbeanModule;
import io.jooby.hibernate.validator.HibernateValidatorModule;
@SpringBootApplication(scanBasePackages = "com.pablotj")
@EnableJpaRepositories(basePackages = {"com.pablotj.portfolio.infrastructure.persistence.*.repo"})
@EntityScan(basePackages = {"com.pablotj.portfolio.infrastructure.persistence.*.entity"})
public class PortfolioApplication {
public class PortfolioApplication extends Jooby {
{
// 1. Servidor y configuración básica
install(new NettyServer());
// 2. Módulos de infraestructura
install(new JacksonModule());
install(new HibernateValidatorModule());
install(new HikariModule());
install(new FlywayModule());
install(new EbeanModule());
// Instalamos tu configuración de CORS que acabamos de arreglar
install(new CorsConfig());
error(ApiErrorController.getHandler());
// 3. Registro de Dependencias (DI)
// Aquí es donde Jooby sabe que cuando alguien pida un Port,
// debe entregar el Adapter de infraestructura.
// Nota: Si usas módulos de Guice en tus ApplicationConfigs,
// asegúrate de que se instalen aquí.
// 4. Módulos de Aplicación (Business Logic / Use Cases)
// Estos módulos deberían contener los bindings de Guice para los servicios
install(new ProfileApplicationConfig());
install(new ProjectApplicationConfig());
install(new CertificationApplicationConfig());
install(new EducationApplicationConfig());
install(new ExperienceApplicationConfig());
install(new SkillApplicationConfig());
// 5. Adaptadores de Entrada (Rutas / Controllers)
// Registramos el controlador raíz para la info de la API
install(new GuiceModule()); // Esto habilita la resolución de @Inject y @Named
path("/api", () -> {
mvc(ApiRootController.class);
mvc(CertificationController.class);
mvc(EducationController.class);
mvc(ExperienceController.class);
mvc(ProfileController.class);
mvc(ProjectController.class);
mvc(SkillController.class);
});
public static void main(String[] args) {
SpringApplication.run(PortfolioApplication.class, args);
}
}
public static void main(final String[] args) {
runApp(args, PortfolioApplication::new);
}
}

37
bootstrap/src/main/java/com/pablotj/portfolio/bootstrap/certification/CertificationApplicationConfig.java
View File

@@ -3,19 +3,34 @@ package com.pablotj.portfolio.bootstrap.certification;
import com.pablotj.portfolio.application.certification.CreateCertificationUseCase;
import com.pablotj.portfolio.application.certification.GetCertificationUseCase;
import com.pablotj.portfolio.domain.certification.port.CertificationRepositoryPort;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import com.pablotj.portfolio.infrastructure.persistence.certification.adapter.CertificationRepositoryAdapter;
import com.pablotj.portfolio.infrastructure.persistence.certification.mapper.CertificationJpaMapper;
import com.pablotj.portfolio.infrastructure.persistence.profile.adapter.ProfileRepositoryAdapter;
import com.pablotj.portfolio.infrastructure.persistence.profile.mapper.ProfileJpaMapper;
import io.jooby.Extension;
import io.jooby.Jooby;
import jakarta.annotation.Nonnull;
import org.mapstruct.factory.Mappers;
@Configuration
public class CertificationApplicationConfig {
public class CertificationApplicationConfig implements Extension {
@Bean
public GetCertificationUseCase getCertificationUseCase(CertificationRepositoryPort repo) {
return new GetCertificationUseCase(repo);
}
@Override
public void install(@Nonnull Jooby app) {
CertificationJpaMapper mapper = Mappers.getMapper(CertificationJpaMapper.class);
app.getServices().put(CertificationJpaMapper.class, mapper);
@Bean
public CreateCertificationUseCase createCertificationUseCase(CertificationRepositoryPort repo) {
return new CreateCertificationUseCase(repo);
CertificationRepositoryAdapter adapter = new CertificationRepositoryAdapter(mapper);
// 1. Registramos la IMPLEMENTACIÓN del repositorio (Adapter)
// Usamos app.require para que Jooby le inyecte el objeto Database de Ebean automáticamente
// 2. Mapeamos la INTERFAZ (Port) a esa instancia en el registro
app.getServices().put(CertificationRepositoryPort.class, adapter);
// 3. Registramos los Casos de Uso
// Al usar app.require, Jooby busca el CertificationRepositoryPort que acabamos de registrar
// y lo inyecta en el constructor de los Use Cases.
app.getServices().put(GetCertificationUseCase.class, new GetCertificationUseCase(adapter));
app.getServices().put(CreateCertificationUseCase.class, new CreateCertificationUseCase(adapter));
}
}

34
bootstrap/src/main/java/com/pablotj/portfolio/bootstrap/education/EducationApplicationConfig.java
View File

@@ -3,19 +3,31 @@ package com.pablotj.portfolio.bootstrap.education;
import com.pablotj.portfolio.application.education.CreateEducationUseCase;
import com.pablotj.portfolio.application.education.GetEducationUseCase;
import com.pablotj.portfolio.domain.education.port.EducationRepositoryPort;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import com.pablotj.portfolio.infrastructure.persistence.certification.adapter.CertificationRepositoryAdapter;
import com.pablotj.portfolio.infrastructure.persistence.certification.mapper.CertificationJpaMapper;
import com.pablotj.portfolio.infrastructure.persistence.education.adapter.EducationRepositoryAdapter;
import com.pablotj.portfolio.infrastructure.persistence.education.mapper.EducationJpaMapper;
import io.jooby.Extension;
import io.jooby.Jooby;
import jakarta.annotation.Nonnull;
import org.mapstruct.factory.Mappers;
@Configuration
public class EducationApplicationConfig {
public class EducationApplicationConfig implements Extension {
@Bean
public GetEducationUseCase getEducationUseCase(EducationRepositoryPort repo) {
return new GetEducationUseCase(repo);
}
@Override
public void install(@Nonnull Jooby app) {
EducationJpaMapper mapper = Mappers.getMapper(EducationJpaMapper.class);
app.getServices().put(EducationJpaMapper.class, mapper);
@Bean
public CreateEducationUseCase createEducationUseCase(EducationRepositoryPort repo) {
return new CreateEducationUseCase(repo);
EducationRepositoryAdapter adapter = new EducationRepositoryAdapter(mapper);
// 2. Mapeamos la INTERFAZ (Puerto) a esa instancia concreta
app.getServices().put(EducationRepositoryPort.class, adapter);
// 3. Registramos los Casos de Uso (Aplicación)
// Usamos app.require() para que Jooby inyecte el EducationRepositoryPort
// en el constructor de los Use Cases.
app.getServices().put(GetEducationUseCase.class, new GetEducationUseCase(adapter));
app.getServices().put(CreateEducationUseCase.class, new CreateEducationUseCase(adapter));
}
}

33
bootstrap/src/main/java/com/pablotj/portfolio/bootstrap/experience/ExperienceApplicationConfig.java
View File

@@ -3,19 +3,30 @@ package com.pablotj.portfolio.bootstrap.experience;
import com.pablotj.portfolio.application.experience.CreateExperienceUseCase;
import com.pablotj.portfolio.application.experience.GetExperienceUseCase;
import com.pablotj.portfolio.domain.experience.port.ExperienceRepositoryPort;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import com.pablotj.portfolio.infrastructure.persistence.education.adapter.EducationRepositoryAdapter;
import com.pablotj.portfolio.infrastructure.persistence.education.mapper.EducationJpaMapper;
import com.pablotj.portfolio.infrastructure.persistence.experience.adapter.ExperienceRepositoryAdapter;
import com.pablotj.portfolio.infrastructure.persistence.experience.mapper.ExperienceJpaMapper;
import io.jooby.Extension;
import io.jooby.Jooby;
import io.jooby.ServiceRegistry;
import jakarta.annotation.Nonnull;
import org.mapstruct.factory.Mappers;
@Configuration
public class ExperienceApplicationConfig {
public class ExperienceApplicationConfig implements Extension {
@Override
public void install(@Nonnull Jooby app) {
// 1. Instanciar y registrar el adaptador
ExperienceJpaMapper mapper = Mappers.getMapper(ExperienceJpaMapper.class);
app.getServices().put(ExperienceJpaMapper.class, mapper);
@Bean
public GetExperienceUseCase getExperienceUseCase(ExperienceRepositoryPort repo) {
return new GetExperienceUseCase(repo);
}
ExperienceRepositoryAdapter adapter = new ExperienceRepositoryAdapter(mapper);
@Bean
public CreateExperienceUseCase createExperienceUseCase(ExperienceRepositoryPort repo) {
return new CreateExperienceUseCase(repo);
app.getServices().put(ExperienceRepositoryPort.class, adapter);
// 2. Registrar casos de uso usando app.require para inyectar el puerto
app.getServices().put(GetExperienceUseCase.class, new GetExperienceUseCase(adapter));
app.getServices().put(CreateExperienceUseCase.class, new CreateExperienceUseCase(adapter));
}
}

32
bootstrap/src/main/java/com/pablotj/portfolio/bootstrap/profile/ProfileApplicationConfig.java
View File

@@ -3,19 +3,29 @@ package com.pablotj.portfolio.bootstrap.profile;
import com.pablotj.portfolio.application.profile.CreateProfileUseCase;
import com.pablotj.portfolio.application.profile.GetProfileUseCase;
import com.pablotj.portfolio.domain.profile.port.ProfileRepositoryPort;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import com.pablotj.portfolio.infrastructure.persistence.profile.adapter.ProfileRepositoryAdapter;
import com.pablotj.portfolio.infrastructure.persistence.profile.mapper.ProfileJpaMapper;
import io.jooby.Extension;
import io.jooby.Jooby;
import jakarta.annotation.Nonnull;
import org.mapstruct.factory.Mappers;
@Configuration
public class ProfileApplicationConfig {
public class ProfileApplicationConfig implements Extension {
@Override
public void install(@Nonnull Jooby app) {
// 1. Registramos el Mapper primero (para que esté disponible)
ProfileJpaMapper mapper = Mappers.getMapper(ProfileJpaMapper.class);
app.getServices().put(ProfileJpaMapper.class, mapper);
@Bean
public GetProfileUseCase getHomeUseCase(ProfileRepositoryPort repo) {
return new GetProfileUseCase(repo);
}
// 2. Instanciamos el Adaptador MANUALMENTE
// Jooby NO puede hacer "app.require" de una clase con constructor si no hay un DI Module (Guice)
ProfileRepositoryAdapter adapter = new ProfileRepositoryAdapter(mapper);
@Bean
public CreateProfileUseCase createHomeUseCase(ProfileRepositoryPort repo) {
return new CreateProfileUseCase(repo);
// 3. Registramos el adaptador bajo su Interfaz (Port)
app.getServices().put(ProfileRepositoryPort.class, adapter);
// 4. Registramos casos de uso instanciándolos con sus dependencias
app.getServices().put(GetProfileUseCase.class, new GetProfileUseCase(adapter));
app.getServices().put(CreateProfileUseCase.class, new CreateProfileUseCase(adapter));
}
}

32
bootstrap/src/main/java/com/pablotj/portfolio/bootstrap/project/ProjectApplicationConfig.java
View File

@@ -3,19 +3,29 @@ package com.pablotj.portfolio.bootstrap.project;
import com.pablotj.portfolio.application.project.CreateProjectUseCase;
import com.pablotj.portfolio.application.project.GetProjectUseCase;
import com.pablotj.portfolio.domain.project.port.ProjectRepositoryPort;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import com.pablotj.portfolio.infrastructure.persistence.experience.adapter.ExperienceRepositoryAdapter;
import com.pablotj.portfolio.infrastructure.persistence.experience.mapper.ExperienceJpaMapper;
import com.pablotj.portfolio.infrastructure.persistence.project.adapter.ProjectRepositoryAdapter;
import com.pablotj.portfolio.infrastructure.persistence.project.mapper.ProjectJpaMapper;
import io.jooby.Extension;
import io.jooby.Jooby;
import io.jooby.ServiceRegistry;
import jakarta.annotation.Nonnull;
import org.mapstruct.factory.Mappers;
@Configuration
public class ProjectApplicationConfig {
public class ProjectApplicationConfig implements Extension {
@Override
public void install(@Nonnull Jooby app) {
@Bean
public CreateProjectUseCase createProjectUseCase(ProjectRepositoryPort repo) {
return new CreateProjectUseCase(repo);
}
ProjectJpaMapper mapper = Mappers.getMapper(ProjectJpaMapper.class);
app.getServices().put(ProjectJpaMapper.class, mapper);
@Bean
public GetProjectUseCase getProjectUseCase(ProjectRepositoryPort repo) {
return new GetProjectUseCase(repo);
ProjectRepositoryAdapter adapter = new ProjectRepositoryAdapter(mapper);
app.getServices().put(ProjectRepositoryPort.class, adapter);
// 2. Registrar casos de uso
app.getServices().put(CreateProjectUseCase.class, new CreateProjectUseCase(adapter));
app.getServices().put(GetProjectUseCase.class, new GetProjectUseCase(adapter));
}
}

34
bootstrap/src/main/java/com/pablotj/portfolio/bootstrap/skill/SkillApplicationConfig.java
View File

@@ -3,19 +3,31 @@ package com.pablotj.portfolio.bootstrap.skill;
import com.pablotj.portfolio.application.skill.CreateSkillUseCase;
import com.pablotj.portfolio.application.skill.GetSkillUseCase;
import com.pablotj.portfolio.domain.skill.port.SkillRepositoryPort;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import com.pablotj.portfolio.infrastructure.persistence.project.adapter.ProjectRepositoryAdapter;
import com.pablotj.portfolio.infrastructure.persistence.project.mapper.ProjectJpaMapper;
import com.pablotj.portfolio.infrastructure.persistence.skill.adapter.SkillRepositoryAdapter;
import com.pablotj.portfolio.infrastructure.persistence.skill.mapper.SkillJpaMapper;
import io.jooby.Extension;
import io.jooby.Jooby;
import io.jooby.ServiceRegistry;
import jakarta.annotation.Nonnull;
import org.mapstruct.factory.Mappers;
@Configuration
public class SkillApplicationConfig {
public class SkillApplicationConfig implements Extension {
@Override
public void install(@Nonnull Jooby app) {
@Bean
public GetSkillUseCase getSkillUseCase(SkillRepositoryPort repo) {
return new GetSkillUseCase(repo);
}
SkillJpaMapper mapper = Mappers.getMapper(SkillJpaMapper.class);
app.getServices().put(SkillJpaMapper.class, mapper);
@Bean
public CreateSkillUseCase createSkillUseCase(SkillRepositoryPort repo) {
return new CreateSkillUseCase(repo);
SkillRepositoryAdapter adapter = new SkillRepositoryAdapter(mapper);
// 1. Instanciar y registrar el adaptador
app.getServices().put(SkillRepositoryPort.class, adapter);
// 2. Registrar casos de uso
app.getServices().put(GetSkillUseCase.class, new GetSkillUseCase(adapter));
app.getServices().put(CreateSkillUseCase.class, new CreateSkillUseCase(adapter));
}
}

67
bootstrap/src/main/resources/application.conf Normal file
View File

@@ -0,0 +1,67 @@
# Configuración de la App (Sustituye a info y app)
info {
app {
version = "0.0.1-SNAPSHOT" # Maven no rellena esto automáticamente en Jooby sin plugins extra, mejor ponlo fijo
}
}
app {
cors {
allowed-origins = ${?APP_ALLOWED_ORIGINS}
allowed-origins = "http://localhost:8080" # Valor por defecto
}
}
# Configuración del Servidor
server {
port = 8080
# En Jooby, el context-path se define habitualmente en la clase App,
# pero puedes usar esta propiedad si la gestionas manualmente.
}
# Base de Datos (Ebean usa estas propiedades automáticamente)
db {
url = "jdbc:postgresql://"${?DB_HOST}":"${?DB_PORT}"/"${?DB_NAME}
user = ${?DB_USER}
password = ${?DB_PASSWORD}
driverClassName = org.postgresql.Driver
# HikariCP (Configuración de Pool)
hikari {
maximumPoolSize = 3
minimumIdle = 1
idleTimeout = 30000
connectionTimeout = 10000
}
}
flyway {
# Ubicación de tus scripts .sql
locations = ["classpath:db/migration"]
cleanDisabled = true
baselineOnMigrate = true
baselineVersion = ${?FLYWAY_BASELINE_VERSION}
# Si quieres que se ejecute siempre al arrancar
run = [migrate]
}
# Ebean (Sustituye a jpa/hibernate)
ebean {
ddl {
generate = false
run = false
}
# Mostrar SQL en consola
debug = true
}
# Jackson
jackson {
indent_output = true
}
# Swagger/OpenAPI (Jooby OpenAPI usa estas rutas por defecto o configurables)
swagger {
path = "/swagger-ui"
}

54
bootstrap/src/main/resources/application.yml
View File

@@ -1,54 +0,0 @@
info:
app:
version: @project.version@
app:
cors:
allowed-origins: ${APP_ALLOWED_ORIGINS:http://localhost:8080}
spring:
application:
name: portfolio-api
web:
resources:
add-mappings: false
datasource:
url: jdbc:postgresql://${DB_HOST:localhost}:${DB_PORT:5432}/${DB_NAME:portfolio}
username: ${DB_USER:postgres}
password: ${DB_PASSWORD:postgres}
driver-class-name: org.postgresql.Driver
hikari:
maximum-pool-size: 3
minimum-idle: 1
idle-timeout: 30000
connection-timeout: 10000
leak-detection-threshold: 10000
jpa:
hibernate:
ddl-auto: validate
properties:
hibernate.transaction.jta.platform: org.hibernate.engine.transaction.jta.platform.internal.NoJtaPlatform
hibernate:
format_sql: true
dialect: org.hibernate.dialect.PostgreSQLDialect
show-sql: true
jackson:
serialization:
INDENT_OUTPUT: true
springdoc:
api-docs:
path: /v3/api-docs
swagger-ui:
path: /swagger-ui
server:
port: 8080
servlet:
context-path: /api
forward-headers-strategy: framework