build.gradle

plugins {
    id 'idea'
    id 'eclipse'
    id 'de.undercouch.download' version '5.5.0'
    id 'java'
    id 'java-library'
    id 'signing'
    id "com.google.protobuf" version "0.9.4"
    id "com.vanniktech.maven.publish" version "0.30.0"
}
import com.vanniktech.maven.publish.SonatypeHost

task sourcesJar(type: Jar) {
    archiveClassifier.set("sources")
    from sourceSets.main.allSource
}

java {
    withSourcesJar()
}

group = "com.devcycle"
archivesBaseName = "java-server-sdk"
version = "2.5.0"

mavenPublishing {
    coordinates("com.devcycle", "java-server-sdk", version)
    publishToMavenCentral(SonatypeHost.CENTRAL_PORTAL, true)
    signAllPublications()
    
    pom {
        name = 'DevCycle Java Server SDK'
        description = 'Server side SDK to interact with DevCycle.'
        url = 'https://devcycle.com'
        
        licenses {
            license {
                name = 'MIT License'
                url = 'https://www.opensource.org/licenses/mit-license.php'
            }
        }
        
        developers {
            developer {
                id = 'devcycle'
                name = 'DevCycle Engineering'
                email = 'support@devcycle.com'
                organization = 'DevCycle'
            }
        }
        
        scm {
            connection = 'scm:git:git://github.com/DevCycleHQ/java-server-sdk.git'
            developerConnection = 'scm:git:ssh://github.com:DevCycleHQ/java-server-sdk.git'
            url = 'https://github.com/DevCycleHQ/java-server-sdk'
        }
    }
}

signing {
    // The signing key needs to be an ascii armored key version of the binary gpg keyfile
    // encoded in base64 to preserver formatting when used in an environment variable
    def signingKey = base64Decode(findProperty("signingKey"))
    def signingKeyId = findProperty("signingKeyId")
    def signingPassword = findProperty("signingPassword")
    useInMemoryPgpKeys(signingKeyId, signingKey, signingPassword)
    sign publishing.publications
}

def base64Decode(encodedString){
    if(encodedString != null) {
        byte[] decoded = encodedString.decodeBase64()
        String decode = new String(decoded)
        return decode
    }
    return null;
}

repositories {
    mavenCentral()
}

sourceCompatibility = JavaVersion.VERSION_11
targetCompatibility = JavaVersion.VERSION_11

def wasmResourcePath = "$projectDir/src/main/resources"
def wasmVersion = "1.25.3"
def wasmUrl = "https://unpkg.com/@devcycle/bucketing-assembly-script@$wasmVersion/build/bucketing-lib.release.wasm"
task downloadDVCBucketingWASM(type: Download) {
    src wasmUrl
    dest wasmResourcePath
    doLast {
        println "Completed DevCycle Bucketing WASM Download to $wasmResourcePath"
    }
}

processResources.dependsOn downloadDVCBucketingWASM
sourcesJar.dependsOn downloadDVCBucketingWASM

protobuf {
    protoc {
        artifact = "com.google.protobuf:protoc:3.24.4"
    }
}

ext {
    retrofit_version = "2.11.0"
    jackson_version = "2.15.3"
    swagger_annotations_version = "2.2.18"
    lombok_version = "1.18.30"
    okhttp_version = "4.12.0"
    wasmtime_version = "0.19.0"
    junit_version = "4.13.2"
    mockito_core_version = "5.6.0"
    protobuf_version = "3.24.4"
    openfeature_version = "1.7.0"
    eventsource_version = "4.1.1"
}

dependencies {
    annotationProcessor("org.projectlombok:lombok:$lombok_version")

    implementation("com.squareup.okhttp3:okhttp:$okhttp_version")

    implementation("com.squareup.retrofit2:retrofit:$retrofit_version") {
        exclude group: "com.squareup.okhttp3", module: "okhttp"
    }
    implementation("com.squareup.retrofit2:converter-jackson:$retrofit_version") {
        exclude group: "com.squareup.okhttp3", module: "okhttp"
    }
    api("com.fasterxml.jackson.core:jackson-databind:$jackson_version")
    implementation("io.swagger.core.v3:swagger-annotations:$swagger_annotations_version")

    implementation("io.github.kawamuray.wasmtime:wasmtime-java:$wasmtime_version")

    implementation("com.google.protobuf:protobuf-java:$protobuf_version")

    implementation("dev.openfeature:sdk:$openfeature_version")
    implementation("com.launchdarkly:okhttp-eventsource:$eventsource_version")

    compileOnly("org.projectlombok:lombok:$lombok_version")

    testAnnotationProcessor("org.projectlombok:lombok:$lombok_version")
    testImplementation("junit:junit:$junit_version")
    testImplementation("org.mockito:mockito-core:$mockito_core_version")
    testImplementation("com.squareup.retrofit2:retrofit-mock:$retrofit_version")
    testCompileOnly("org.projectlombok:lombok:$lombok_version")
}

// Gradle magic for adding a new "examples" source set that's separate from the main source set
sourceSets {
    examples {
        java {
            compileClasspath += sourceSets.main.output
            runtimeClasspath += sourceSets.main.output
        }
    }
}

configurations {
    examplesImplementation.extendsFrom implementation
    examplesRuntimeOnly.extendsFrom runtimeOnly
}

task runLocalExample(type: JavaExec) {
    description = "Run the local bucketing example"
    classpath = sourceSets.examples.runtimeClasspath
    mainClass = 'com.devcycle.examples.LocalExample'
}

task runCloudExample(type: JavaExec) {
    description = "Run the cloud bucketing example"
    classpath = sourceSets.examples.runtimeClasspath
    mainClass = 'com.devcycle.examples.CloudExample'
}

task runOpenFeatureExample(type: JavaExec) {
    description = "Run the OpenFeature example"
    classpath = sourceSets.examples.runtimeClasspath
    mainClass = 'com.devcycle.examples.OpenFeatureExample'
}