Micronaut - No bean of type [io.micronaut.transaction.SynchronousTransactionManager] exists

Question

I'm migrating one of my Microservices from Spring to Micronaut and this is a problem I'm facing while calling a controller to load one entity. The error I get is:

{
    "message": "Internal Server Error: No bean of type [io.micronaut.transaction.SynchronousTransactionManager] exists. Make sure the bean is not disabled by bean requirements (enable trace logging for 'io.micronaut.context.condition' to check) and if the bean is enabled then ensure the class is declared a bean and annotation processing is enabled (for Java and Kotlin the 'micronaut-inject-java' dependency should be configured as an annotation processor)."
}

I already enabled the io.micronaut.context.condition logger, setting it to TRACE level, but I see no reference of the class SynchronousTransactionManager in the logs.

This is my build.gradle:

buildscript {
    repositories {
        jcenter()
        mavenCentral()
        maven {
            url "https://plugins.gradle.org/m2/"
        }
        maven {
            url 'https://jitpack.io'
        }
    }
    dependencies {
        classpath "org.hibernate:hibernate-gradle-plugin:5.4.12.Final"
    }
}

plugins {
    id("com.github.johnrengelman.shadow") version "6.1.0"
    id("io.micronaut.application") version "1.3.3"
    id('com.google.protobuf') version '0.8.11'
    id('java')
    id('idea')
}

apply plugin: 'org.hibernate.orm'
hibernate {
    enhance {
        enableLazyInitialization = true
        enableDirtyTracking = true
        enableAssociationManagement = true
    }
}

version = "0.1"
group = "com.elevenstars.service"

repositories {
    mavenCentral()
    jcenter()
}

micronaut {
    runtime("netty")
    testRuntime("junit5")
    processing {
        incremental(true)
        annotations("com.elevenstars.service.*")
    }
}

dependencies {
    // Annotation processors - Order does matter!!
    annotationProcessor("org.mapstruct:mapstruct-processor:1.4.1.Final")
    annotationProcessor("org.projectlombok:lombok")
    annotationProcessor("io.micronaut.data:micronaut-data-processor")
    annotationProcessor('io.micronaut:micronaut-inject-java')
    annotationProcessor("io.micronaut:micronaut-graal")
    annotationProcessor("io.micronaut.security:micronaut-security-annotations")

    // Micronaut libs
    implementation("io.micronaut:micronaut-validation")
    implementation("io.micronaut:micronaut-runtime")
    implementation("io.micronaut:micronaut-inject")
    implementation("io.micronaut.xml:micronaut-jackson-xml")
    implementation("javax.annotation:javax.annotation-api")
    compileOnly("org.graalvm.nativeimage:svm")

    // Kafka
    implementation("io.micronaut.kafka:micronaut-kafka")

    // Consul
    implementation("io.micronaut:micronaut-discovery-client")

    // Security
    implementation("io.micronaut.security:micronaut-security-annotations")
    implementation("io.micronaut.security:micronaut-security-jwt")

    // Database access
    implementation("io.micronaut.data:micronaut-data-hibernate-jpa")
    implementation("io.micronaut.beanvalidation:micronaut-hibernate-validator")
    implementation('com.vladmihalcea:hibernate-types-52:2.9.7')
    implementation "org.hibernate:hibernate-graalvm:5.4.12.Final"
    runtimeOnly('org.postgresql:postgresql')

    //Mapping
    implementation 'org.mapstruct:mapstruct:1.4.1.Final'

    // gRPC
    implementation 'io.grpc:grpc-protobuf:1.33.0'
    implementation 'io.grpc:grpc-stub:1.33.0'
    implementation 'io.grpc:grpc-netty:1.33.0'
    implementation 'io.grpc:grpc-core:1.33.0'
    implementation('io.grpc:grpc-netty-shaded:1.33.0') {
        version {
            strictly "1.33.0"
        }
        because "fails to run"
    }

    // Protobuf
    implementation 'com.google.protobuf:protobuf-java-util:3.11.4'

    // Dev tools
    compileOnly 'org.projectlombok:lombok'

    // Other stuff
    implementation("io.micronaut:micronaut-http-client")
    runtimeOnly("ch.qos.logback:logback-classic")
}


application {
    mainClass.set("com.elevenstars.service.facilities.Application")
}

java {
    sourceCompatibility = JavaVersion.toVersion("11")
    targetCompatibility = JavaVersion.toVersion("11")
}

task mapStruct() {
    sourceSets.main.java.srcDir file("${buildDir}/mappers")
    tasks.withType(JavaCompile) {
        options.setAnnotationProcessorGeneratedSourcesDirectory(file("${buildDir}/mappers"))
        options.compilerArgs << "-Amapstruct.defaultComponentModel=jsr330"
    }
}
compileJava.dependsOn(mapStruct)

This is my application.yml

micronaut:
  application:
    name: facilities
  security:
    authentication: bearer
    token:
      jwt:
        signatures:
          secret:
            generator:
              secret: my-secret
        bearer:
          enabled: true
    enabled: true
    redirect:
      unauthorized:
        enabled: false

  server:
    context-path: /v1/facilities
    port: 8080
    cors:
      enabled: true
kafka:
  bootstrap:
    servers: localhost:9092
  embedded:
    enabled: false

jackson:
  #    time-zone: UTC
  serialization:
    write-dates-as-timestamps: false
  deserialization:
    fail-on-unknown-properties: false
  generator:
    write-numbers-as-strings: false
  time-zone: UTC

consul:
  client:
    registration:
      enabled: true
    defaultZone: "${CONSUL_HOST:localhost}:${CONSUL_PORT:8500}"

jpa:
  default:
    entity-scan:
      packages: 'com.elevenstars.service.facilities.domain.entity'
    properties:
      hibernate:
        dialect: org.hibernate.dialect.PostgreSQLDialect
        format_sql: true
        jdbc:
          time_zone: UTC
      #        ddl-auto: update
      show-sql: false
      open-in-view: false

datasource:
  default:
    url: jdbc:postgresql://localhost:5432/facilities
    username: *hidden*
    password: *hidden*

Controller:

@Controller
@Secured(SecurityRule.IS_AUTHENTICATED)
public class GymController extends BaseController
{
    private final GymReconstructionService gymReconstructionService;
    private final PatrimonyMapper patrimonyMapper;

    @Inject
    public GymController(
        GymReconstructionService gymReconstructionService,
        PatrimonyMapper patrimonyMapper
    ) {
        this.gymReconstructionService = gymReconstructionService;
        this.patrimonyMapper = patrimonyMapper;
    }

    @Get("/gym/upgrade/estimation")
    public HttpResponse<ReconstructionEstimation> getUpgradeReconstructionEstimation() {
        return HttpResponse.ok(gymReconstructionService.getUpgradeEstimations());
    }
}

Application Service

@Singleton
@Transactional
public class GymReconstructionService extends ApplicationService
{
    private final GymRepository gymRepository;
    private final DebitMoneyClient debitMoneyClient;
    private final LoggedUser loggedUser;

    @Inject
    public GymReconstructionService(
        GymRepository gymRepository,
        DebitMoneyClient debitMoneyClient,
        LoggedUser loggedUser
    ) {
        this.loggedUser = loggedUser;
        this.gymRepository = gymRepository;
        this.debitMoneyClient = debitMoneyClient;
    }

    public ReconstructionEstimation getUpgradeEstimations() {
        var gym = getGym(loggedUser.getClubId());

        return gym.getUpgradeReconstructionEstimation();
    }
    private Gym getGym(UUID clubId) throws GymNotFoundException {
        return gymRepository
            .findById(clubId)
            .orElseThrow(GymNotFoundException::new);
    }
}

One thing I've realized was if I remove the @Transactional annotation, this error doesn't happen anymore, but I end up with another error:

{
    "message": "Internal Server Error: No backing RepositoryOperations configured for repository. Check your configuration and try again"
}

Any clue here about what's going on?

Answer 1

I have solved a similar problem.
Try adding the following to your application.yml

jpa.default.properties.hibernate.hbm2ddl.auto: update