build.gradle

plugins {
    id "org.jetbrains.kotlin.jvm" version "${kotlinVersion}"
    id "org.jetbrains.kotlin.kapt" version "${kotlinVersion}"
    id "org.jetbrains.kotlin.plugin.allopen" version "${kotlinVersion}"
    id "application"
    id "com.google.cloud.tools.jib" version "${jibVersion}"
    id "com.github.johnrengelman.shadow" version "${shadowVersion}"
    id "io.gitlab.arturbosch.detekt" version "${detektVersion}"
    id "jacoco"
    id "nu.studer.jooq" version "${jooqPluginVersion}"
    id "com.palantir.git-version" version "${palantirGitVersion}"
    id "name.remal.check-updates" version "${checkUpdatesVersion}"
    id "io.micronaut.application" version "${micronautPluginVersion}"
}

version gitVersion()
group "com.kuvaszuptime.kuvasz"

repositories {
    mavenCentral()
    jcenter()
}

micronaut {
    version micronautVersion
    runtime "netty"
    testRuntime "kotest"
    processing {
        incremental true
        annotations "com.kuvaszuptime.kuvasz.*"
    }
}

configurations {
    // for dependencies that are needed for development only
    developmentOnly
}

dependencies {
    kapt("io.micronaut:micronaut-graal")
    kapt("io.micronaut.configuration:micronaut-openapi")
    kapt("io.micronaut.security:micronaut-security-annotations")
    compileOnly("org.graalvm.nativeimage:svm")
    implementation("io.micronaut:micronaut-validation")
    implementation("io.arrow-kt:arrow-core-data:${arrowDataVersion}")
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:${kotlinCoroutinesVersion}")
    implementation("io.micronaut:micronaut-validation")
    implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8:${kotlinVersion}")
    implementation("org.jetbrains.kotlin:kotlin-reflect:${kotlinVersion}")
    implementation("io.micronaut.kotlin:micronaut-kotlin-runtime")
    implementation("io.micronaut:micronaut-runtime")
    implementation("javax.annotation:javax.annotation-api")
    implementation("io.micronaut:micronaut-http-client")
    implementation("io.swagger.core.v3:swagger-annotations")
    implementation("io.micronaut.flyway:micronaut-flyway")
    implementation("io.micronaut.sql:micronaut-jdbc-hikari")
    implementation("io.micronaut.sql:micronaut-jooq")
    implementation("io.micronaut.security:micronaut-security-jwt")
    implementation("io.micronaut.kotlin:micronaut-kotlin-extension-functions")
    implementation "nu.studer:gradle-jooq-plugin:$jooqPluginVersion"
    implementation("org.postgresql:postgresql:${postgresVersion}")
    implementation("org.simplejavamail:simple-java-mail:${simpleJavaMailVersion}")
    implementation("org.simplejavamail:batch-module:${simpleJavaMailVersion}")
    implementation("ch.qos.logback:logback-classic")
    implementation("org.zalando:logbook-core:$logbookVersion")
    implementation("org.zalando:logbook-netty:$logbookVersion")
    implementation("org.zalando:logbook-json:$logbookVersion")
    runtimeOnly("com.fasterxml.jackson.module:jackson-module-kotlin")
    detektPlugins "io.gitlab.arturbosch.detekt:detekt-formatting:$detektVersion"
    testImplementation("io.mockk:mockk:${mockkVersion}")
    testImplementation("org.testcontainers:postgresql:${postgresTestContainersVersion}")
    jooqGenerator("org.postgresql:postgresql:${postgresVersion}")
}

test.classpath += configurations.developmentOnly

mainClassName = "com.kuvaszuptime.kuvasz.Application"

shadowJar {
    mergeServiceFiles()
}

jacoco {
    toolVersion = "0.8.5"
}

jacocoTestReport {
    reports {
        xml.enabled true
        xml.destination file("${buildDir}/reports/jacoco/report.xml")
        html.enabled true
        csv.enabled false
    }
    classDirectories.setFrom(
            fileTree("build/classes/kotlin/main") {
                exclude("com/kuvaszuptime/kuvasz/Application.class")
            }
    )
}

detekt {
    input = files(
            "src/main/kotlin",
            "src/test/kotlin"
    )
}

build {
    dependsOn("detekt")
}

// use JUnit 5 platform
test {
    useJUnitPlatform {
        systemProperties("micronaut.environments": "test")
    }
    finalizedBy("jacocoTestReport")
}

java {
    sourceCompatibility = JavaVersion.toVersion('11')
}

allOpen {
    annotation("io.micronaut.aop.Around")
}
compileKotlin {
    kotlinOptions {
        jvmTarget = '11'
        //Will retain parameter names for Java reflection
        javaParameters = true
        freeCompilerArgs += "-Xuse-experimental=kotlin.time.ExperimentalTime"
    }
    finalizedBy("updateApiDoc")
}
compileTestKotlin {
    kotlinOptions {
        jvmTarget = '11'
        javaParameters = true
        freeCompilerArgs += "-Xuse-experimental=kotlin.time.ExperimentalTime"
    }
}

tasks.withType(JavaExec) {
    classpath += configurations.developmentOnly
    jvmArgs(
            "-XX:TieredStopAtLevel=1",
            "-Dcom.sun.management.jmxremote",
            "-Xms64M",
            "-Xmx128M",
            "-Dlogback.configurationFile=logback-dev.xml"
//            "-agentlib:native-image-agent=experimental-class-loader-support,config-output-dir=./tmp",
//            "-Dorg.graalvm.nativeimage.imagecode=agent"
    )
    systemProperty("micronaut.environments", "dev")
    if (gradle.startParameter.continuous) {
        systemProperties(
                "micronaut.io.watch.restart": "true",
                "micronaut.io.watch.enabled": "true",
                "micronaut.io.watch.paths": "src/main"
        )
    }
}

jib {
    to {
        image = "kuvaszmonitoring/kuvasz:${version}"
        tags = ["latest"]
    }
    container {
        environment = ["JAVA_TOOL_OPTIONS": "-Xms64M -Xmx128M"]
    }
}

task buildNativeImage(type: Exec) {
    dependsOn("shadowJar")
    workingDir projectDir
    commandLine "sh", "./docker-build-native.sh", "-v${version}"
}

task pushNativeImage(type: Exec) {
    workingDir projectDir
    commandLine "sh", "./docker-push-native.sh", "-t${version}-native"
}

task releaseDockerImages() {
    dependsOn("jib")
    dependsOn("buildNativeImage")
    dependsOn("pushNativeImage")
    tasks.findByName("buildNativeImage").mustRunAfter "jib"
    tasks.findByName("pushNativeImage").mustRunAfter "buildNativeImage"
}

task updateApiDoc(type: Copy) {
    dependsOn("kaptKotlin")
    from "$buildDir/tmp/kapt3/classes/main/META-INF/swagger/kuvasz-latest.yml"
    into "$projectDir/docs/api-doc"
}

jooq {
    version = jooqVersion
    configurations {
        main {
            generateSchemaSourceOnCompilation = false
            generationTool {
                jdbc {
                    url = "jdbc:postgresql://localhost:5432/postgres"
                    user = "postgres"
                    password = "pass"
                    driver = "org.postgresql.Driver"
                }
                generator {
                    name = "org.jooq.codegen.DefaultGenerator"
                    target {
                        directory = "src/jooq/java"
                        packageName = "com.kuvaszuptime.kuvasz"
                    }
                    generate {
                        validationAnnotations = true
                        jpaAnnotations = true
                        daos = true
                        pojosEqualsAndHashCode = true
                        fluentSetters = true
                    }
                    database {
                        inputSchema = "kuvasz"
                        outputSchemaToDefault = true
                        excludes = "flyway_schema_history"
                    }
                    strategy {
                        name = null
                        matchers {
                            tables {
                                table {
                                    pojoClass {
                                        transform = "PASCAL"
                                        expression = "\$0_Pojo"
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}