build.gradle

// Spotless requires JVM 11+; NMCP requires JVM 17+
// Only add classpath entries when building with a compatible JVM so older JDK builds succeed
buildscript {
    repositories { gradlePluginPortal() }
    dependencies {
        if (JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_11)) {
            classpath 'com.diffplug.spotless:spotless-plugin-gradle:6.25.0'
        }
        if (JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_17)) {
            classpath 'com.gradleup.nmcp:nmcp:1.4.4'
        }
    }
}

plugins {
    id 'java'
    id 'jacoco'
    id 'java-library'
    id 'maven-publish'
    id 'signing'
}

if (JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_17)) {
    apply plugin: 'com.gradleup.nmcp'
    apply plugin: 'com.gradleup.nmcp.aggregation'
}

if (JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_11)) {
    apply plugin: 'com.diffplug.spotless'
    spotless {
        java {
            eclipse()
            removeUnusedImports()
            trimTrailingWhitespace()
            endWithNewline()
        }
    }
}

group 'com.surrealdb'
version '2.1.2'

repositories {
    mavenCentral()
}

java {
    sourceCompatibility = JavaVersion.VERSION_1_8
    targetCompatibility = JavaVersion.VERSION_1_8
    withJavadocJar()
    withSourcesJar()
}

// Use --release to enforce both bytecode version and API surface at compile time.
// This prevents accidental use of APIs introduced after Java 8 (e.g. String.isBlank()),
// which would compile fine on a modern JDK but fail at runtime on Java 8.
// Note: --release flag is only supported on JDK 9+.
if (JavaVersion.current() > JavaVersion.VERSION_1_8) {
    tasks.withType(JavaCompile).configureEach {
        options.release = 8
    }
}

sourceSets {
    integrationTest {
        java
    }
    // Java-record-using tests live in their own source set so the main library
    // and the standard test suite remain compilable with --release 8.
    // The set is always created (so configuration-time references resolve);
    // compilation and execution are conditional on JDK 16+ below.
    recordTest {
        java {
            srcDirs 'src/recordTest/java'
        }
        compileClasspath += sourceSets.main.output + sourceSets.test.output
        runtimeClasspath += sourceSets.main.output + sourceSets.test.output
    }
}

configurations {
    integrationTestImplementation.extendsFrom testImplementation
    integrationTestRuntimeOnly.extendsFrom testRuntimeOnly
    recordTestImplementation.extendsFrom testImplementation
    recordTestRuntimeOnly.extendsFrom testRuntimeOnly
}

ext.nativeJar = file("native/surrealdb-${version}.jar")

// Fail fast, but only when the task graph contains a task that needs the file
gradle.taskGraph.whenReady { graph ->
    boolean needsNativeJar = graph.allTasks.any { t ->
                t.name in ['publish', 'publishToMavenLocal'] ||
                      (t.name.startsWith('generate') && t.name.endsWith('Publication'))
    }



    if (needsNativeJar && !nativeJar.exists()) {
               throw new GradleException(
                            "Native JAR not found at '${nativeJar}'. " +
                                    "Build/copy it to native/ before running publishing tasks."
               )
    }
}



// ---------------------------------------------------------------------------
// 2. Task that stages (copies) the external JAR into build/libs
// ---------------------------------------------------------------------------
tasks.register('stageNativeJar', Copy) {
    description = 'Copies the externally built JAR (with native libs) into build/libs.'
    group       = 'build'

    from nativeJar
    into "$buildDir/libs"
    rename { "surrealdb-${version}.jar" }     // the file name expected by publish/sign
}

// ---------------------------------------------------------------------------
// 3. Make sure every task that cares about the JAR sees the staged version.
//    • jar is still executed (keeps components.java happy), but the copy task
//      will overwrite its output afterwards.
// ---------------------------------------------------------------------------
tasks.named('jar') {
    finalizedBy 'stageNativeJar'            // run jar first, then overwrite
}

// All publish-to-Maven tasks must wait for the staged JAR
tasks.withType(PublishToMavenRepository).configureEach {
    dependsOn 'stageNativeJar'
}

// Metadata / POM generation tasks must wait as well
tasks.matching { it.name.startsWith('generate') && it.name.endsWith('Publication') }
      .configureEach { dependsOn 'stageNativeJar' }

// The generated signing task is created after evaluation; use task rules
tasks.matching { it.name == 'signMavenJavaPublication' }.configureEach {
    dependsOn 'stageNativeJar'
}


dependencies {
    testImplementation 'org.junit.jupiter:junit-jupiter:5.10.2'
    // classes produced by src/main/java
    integrationTestImplementation sourceSets.main.output
    // the staged, native-enabled JAR
    integrationTestImplementation files("native/surrealdb-${version}.jar")
}

if (JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_17)) {
    dependencies {
        // NMCP aggregation: include this project's publications
        nmcpAggregation project(":")
    }
}

jacoco {
    toolVersion = "0.8.12"
}

// Build Rust native library so tests can load it
def nativeLibName = System.getProperty('os.name').toLowerCase().contains('mac') ? 'libsurrealdb.dylib' : (System.getProperty('os.name').toLowerCase().contains('win') ? 'surrealdb.dll' : 'libsurrealdb.so')
tasks.register('cargoBuild', Exec) {
    description = 'Builds the Rust native library (debug) for tests'
    group = 'build'
    commandLine 'cargo', 'build'
    workingDir projectDir
    // Always build so test JVM loads a lib that matches current Java/Rust code (avoids UnsatisfiedLinkError)
}
tasks.register('cargoBuildRelease', Exec) {
    description = 'Builds the Rust native library (release)'
    group = 'build'
    commandLine 'cargo', 'build', '--release'
    workingDir projectDir
}

test {
    useJUnitPlatform()
    dependsOn cargoBuild
    // Explicit path so tests load the built native lib regardless of java.library.path
    def nativeLibFile = file("target/debug/${nativeLibName}")
    def nativeLibPath = nativeLibFile.absolutePath
    systemProperty 'surrealdb.native.path', nativeLibPath
    jvmArgs "-Dsurrealdb.native.path=${nativeLibPath}"
    // Also set java.library.path for fallback
    def debugDir = new File(projectDir, 'target/debug').absolutePath
    def releaseDir = new File(projectDir, 'target/release').absolutePath
    def libPath = debugDir + File.pathSeparator + releaseDir
    systemProperty 'java.library.path', libPath
    jvmArgs "-Djava.library.path=${libPath}"
    // Per-test timeout so a single test cannot hang the suite (may not interrupt native/JNI blocks)
    systemProperty 'junit.jupiter.execution.timeout.default', '15s'
    maxParallelForks = 1
    // To pinpoint where the run gets stuck, uncomment and run with short timeout (e.g. ./test-with-timeout.sh 25):
    // beforeTest { d -> logger.lifecycle("[{}] START {} > {}", System.currentTimeMillis(), d.className, d.name) }
    // afterTest { d, r -> logger.lifecycle("[{}] END   {} > {} => {}", System.currentTimeMillis(), d.className, d.name, r.resultType) }
    testLogging {
        events "passed", "failed", "skipped"
        // Also emit the events at INFO level, otherwise `gradlew -i` (as used
        // in CI) hides them: Gradle switches to the per-level event set, which
        // is empty by default.
        info {
            events "passed", "failed", "skipped"
        }
        showStackTraces = true
        exceptionFormat = "full"
    }
}

// Records require JDK 16+ at compile time. Only wire up the recordTest task graph
// when the build JDK supports them; on older JDKs the source set is created but
// its compile/test tasks are disabled, so JDK 8/11 builds remain green.
if (JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_16)) {
    tasks.named('compileRecordTestJava') {
        options.release = 16
    }

    tasks.register('recordTest', Test) {
        description = 'Runs the Java-record tests (requires JDK 16+).'
        group = 'verification'
        useJUnitPlatform()
        dependsOn cargoBuild
        testClassesDirs = sourceSets.recordTest.output.classesDirs
        classpath = sourceSets.recordTest.runtimeClasspath
        def nativeLibFile = file("target/debug/${nativeLibName}")
        def nativeLibPath = nativeLibFile.absolutePath
        systemProperty 'surrealdb.native.path', nativeLibPath
        jvmArgs "-Dsurrealdb.native.path=${nativeLibPath}"
        def debugDir = new File(projectDir, 'target/debug').absolutePath
        def releaseDir = new File(projectDir, 'target/release').absolutePath
        def libPath = debugDir + File.pathSeparator + releaseDir
        systemProperty 'java.library.path', libPath
        jvmArgs "-Djava.library.path=${libPath}"
        systemProperty 'junit.jupiter.execution.timeout.default', '15s'
        maxParallelForks = 1
        testLogging {
            events "passed", "failed", "skipped"
            info {
                events "passed", "failed", "skipped"
            }
            showStackTraces = true
            exceptionFormat = "full"
        }
    }

    tasks.named('check') { dependsOn 'recordTest' }
} else {
    // Disable the auto-generated tasks for the recordTest source set on older JDKs.
    tasks.named('compileRecordTestJava') { enabled = false }
    tasks.matching { it.name == 'processRecordTestResources' }.configureEach { enabled = false }

    // Disabled placeholder so `gradlew recordTest` is invocable on every JDK
    // (the CI matrix runs it on all legs); it reports SKIPPED instead of
    // failing with "task not found".
    tasks.register('recordTest') {
        description = 'Runs the Java-record tests (requires JDK 16+; skipped on this JDK).'
        group = 'verification'
        enabled = false
    }
}

jacocoTestReport {
    dependsOn test
    finalizedBy jacocoTestCoverageVerification
}

jacocoTestCoverageVerification {
    violationRules {
        rule {
            limit {
                minimum = 0.5
            }
        }
    }
}

tasks.register('createCombinedReport') {
    dependsOn jacocoTestReport
    dependsOn javadoc

    doLast {
        // Copy the javadoc
        def javadocSource = file("build/docs/javadoc")
        def javadocDestination = file("build/reports/javadoc")
        // Ensure destination exists and copy
        delete javadocDestination  // Clean old docs if present
        mkdir javadocDestination
        copy {
            from javadocSource
            into javadocDestination
        }

        def indexFile = file("build/reports/index.html")
        indexFile.text = """
            <!DOCTYPE html>
            <html>
            <head>
                <title>Combined Test, Coverage, and Javadoc Report</title>
            </head>
            <body>
                <h1>Combined Test, Coverage, and Javadoc Report</h1>
                <ul>
                    <li><a href="./tests/test/index.html">Test Report</a></li>
                    <li><a href="./jacoco/test/html/index.html">JaCoCo Coverage Report</a></li>
                    <li><a href="./javadoc/index.html">Javadoc</a></li>
                </ul>
            </body>
            </html>
        """
    }
}


tasks.register('integrationTest', Test) {
    dependsOn 'stageNativeJar'
    useJUnitPlatform()
    testClassesDirs = sourceSets.integrationTest.output.classesDirs
    classpath = sourceSets.integrationTest.runtimeClasspath
    // use target/release for a release build
    testLogging {
        showStandardStreams = true
        events "passed", "skipped", "failed", "standardOut", "standardError"
        exceptionFormat = 'full'
        showCauses = true
        showStackTraces = true
    }
}

project.afterEvaluate {
    def key = System.getenv('SIGNING_KEY')
    def _pass = System.getenv('SIGNING_KEY_PASS')

    signing {
        useInMemoryPgpKeys(key, _pass)
        sign publishing.publications.mavenJava
    }
}

if (JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_17)) {
    nmcpAggregation {
        centralPortal {
            username = System.getenv("MAVEN_USERNAME")
            password = System.getenv("MAVEN_PASSWORD")
            publishingType = "AUTOMATIC"
        }
    }
}

publishing {
    repositories {
        maven {
            name = "GitHubPackages"
            url = uri("https://maven.pkg.github.com/surrealdb/surrealdb.java")
            credentials {
                username = System.getenv("GITHUB_ACTOR")
                password = System.getenv("GITHUB_TOKEN")
            }
        }
    }

    publications {
        mavenJava(MavenPublication) {
            groupId = project.group
            artifactId = project.rootProject.name
            version = project.version

            from components.java

            pom {
                name = 'SurrealDB Driver'
                packaging = 'jar'
                description = 'The driver for accessing a SurrealDB instance.'
                url = 'https://surrealdb.com/docs/integration/libraries/java'

                scm {
                    connection = 'scm:git:git@github.com:surrealdb/surrealdb.java.git'
                    url = 'https://github.com/surrealdb/surrealdb.java'
                }

                licenses {
                    license {
                        name = 'The Apache License, Version 2.0'
                        url = 'http://www.apache.org/licenses/LICENSE-2.0.txt'
                    }
                }
                developers {
                    developer {
                        id = 'tobiemh'
                        name = 'Tobie Morgan Hitchcock'
                        email = 'tobie@surrealdb.com'
                    }
                    developer {
                        id = 'macjuul'
                        name = 'Julian Mills'
                        email = 'julian.mills@surrealdb.com'
                    }
                    developer {
                        id = 'kearfy'
                        name = 'Micha de Vries'
                        email = 'micha.de.vries@surrealdb.com'
                    }
                    developer {
                        id = 'emmanuel-keller'
                        name = 'Emmanuel Keller'
                        email = 'emmanuel.keller@surrealdb.com'
                    }
                }
            }
        }
    }
}