build.gradle.kts

import net.researchgate.release.ReleaseExtension

plugins {
    `maven-publish`
    signing
    id("io.github.gradle-nexus.publish-plugin") version "2.0.0" // nexus publish/close/release
    id("net.researchgate.release") version "3.1.0"

}

allprojects {
    group = "org.openprojectx.bigdata.test.core"
}


subprojects {
    tasks.register<DependencyReportTask>("allDependencies") {}

    val testcontainersBomConfigurations = setOf(
        "api",
        "implementation",
        "testImplementation",
        "kapt",
        "kaptTest",
    )
    configurations.matching { it.name in testcontainersBomConfigurations }.all {
        project.dependencies.add(name, project.dependencies.platform(libs.testcontainersBom))
    }

    if (path.startsWith(":example:")) {
        return@subprojects
    }

    // Apply to every module (safe even if a module doesn't publish)
    apply(plugin = "maven-publish")
    apply(plugin = "signing")

    // Configure publishing only when the project has a Java component (Kotlin/JVM typically applies java too)
    plugins.withId("java") {

        // ✅ Ensure required artifacts exist for Maven Central
        extensions.configure<JavaPluginExtension>("java") {
            withSourcesJar()
            withJavadocJar()
        }

        // Kotlin-only modules can produce "empty-ish" Javadoc; don't fail the build on doclint/errors
        tasks.withType(Javadoc::class.java).configureEach {
            isFailOnError = false
        }


        extensions.configure<PublishingExtension>("publishing") {
            publications {
                // Create once per project
                if (project.path != ":gradle-plugin" && findByName("mavenJava") == null) {
                    create<MavenPublication>("mavenJava") {
                        from(components["java"])

                        // Prefer explicit artifactId; by default it's project.name
                        artifactId = project.name

                        pom {
                            // Module-specific name/description; override per-module if you want
                            name.set(project.name)
                            description.set("BIGDATA-TEST Spring Boot starter")
                            url.set("https://github.com/OpenProjectX/bigdata-test")

                            licenses {
                                license {
                                    name.set("Apache License 2.0")
                                    url.set("https://www.apache.org/licenses/LICENSE-2.0")
                                }
                            }

                            developers {
                                developer {
                                    id.set("OpenProjectX")
                                    name.set("OpenProjectX")
                                    email.set("admin@openprojectx.org")
                                }
                            }

                            scm {
                                url.set("https://github.com/OpenProjectX/bigdata-test")
                                connection.set("scm:git:https://github.com/OpenProjectX/bigdata-test.git")
                                developerConnection.set("scm:git:ssh://git@github.com:OpenProjectX/bigdata-test.git")
                            }
                        }
                    }
                }
            }

            repositories {
                maven {
                    name = "GitHubPackages"
                    url = uri("https://maven.pkg.github.com/OpenProjectX/bigdata-test")
                    credentials {
                        username = System.getenv("GITHUB_PACKAGES_USERNAME")
                            ?: System.getenv("GITHUB_ACTOR")
                        password = System.getenv("GITHUB_PACKAGES_TOKEN")
                            ?: System.getenv("GITHUB_TOKEN")
                    }
                }
            }
        }
    }

    // Signing: only configure keys if provided (keeps local dev painless)
    extensions.configure<SigningExtension>("signing") {
        val keyFile = System.getenv("SIGNING_KEY_FILE")
        val keyPass = System.getenv("SIGNING_KEY_PASSWORD")

        if (!keyFile.isNullOrBlank()) {
            val keyText = file(keyFile).readText()
            useInMemoryPgpKeys(keyText, keyPass)

            // Sign all publications created in this subproject
            val publishing = extensions.findByType(PublishingExtension::class.java)
            if (publishing != null) {
                sign(publishing.publications)
            }
        }
    }
}


nexusPublishing {

    repositories {
        sonatype {
            nexusUrl.set(uri("https://ossrh-staging-api.central.sonatype.com/service/local/"))
            snapshotRepositoryUrl.set(uri("https://central.sonatype.com/repository/maven-snapshots/"))
            username.set(System.getenv("OSSRH_USERNAME"))
            password.set(System.getenv("OSSRH_PASSWORD"))

        }
    }
}

configure<ReleaseExtension> {
    val publishGitHubPackages =
        providers.gradleProperty("publishGitHubPackages")
            .orElse(providers.environmentVariable("PUBLISH_GITHUB_PACKAGES"))
            .map { it.equals("true", ignoreCase = true) }
            .getOrElse(false)

    val releaseBuildTasks = mutableListOf("publishToSonatype")
    if (publishGitHubPackages) {
        releaseBuildTasks.add("publishAllPublicationsToGitHubPackagesRepository")
    }
    releaseBuildTasks.add("closeAndReleaseSonatypeStagingRepository")

    buildTasks.set(
        releaseBuildTasks
    )
    versionPropertyFile.set("gradle.properties")
    tagTemplate.set("\$name-\$version")

    with(git) {
        requireBranch.set("master")
    }
}