build.gradle

import org.openapitools.generator.gradle.plugin.tasks.GenerateTask

import java.nio.file.Paths

plugins {
    id "java"
    id "java-library"

    // Adapted JSONSchema2POJO plugin
    id "jsonschema2pojo-adapted"

    // OpenAPI Generator
    id "org.openapi.generator" version "7.3.0"

    // Gradle versions plugin
    id "com.github.ben-manes.versions" version "0.51.0"

    // For Maven Central publishing
    id "maven-publish"
    id "signing"
}

final def projectGroup = "net.jacobpeterson.alpaca"
final def projectArtifactID = "alpaca-java"
final def projectVersion = "10.0.1-SNAPSHOT"

group = projectGroup
version = projectVersion

repositories {
    mavenCentral()
}

dependencies {
    // Logging framework
    implementation group: "org.slf4j", name: "slf4j-api", version: "2.1.0-alpha1"
    // Require dependencies that use the Apache Jakarta Commons Logging library to use SLF4j instead
    implementation group: "org.slf4j", name: "jcl-over-slf4j", version: "2.1.0-alpha1"

    // Google Guava
    implementation group: "com.google.guava", name: "guava", version: "33.0.0-jre"

    // GSON
    implementation group: "com.google.code.gson", name: "gson", version: "2.10.1"

    // Jetbrains Annotations
    implementation group: "org.jetbrains", name: "annotations", version: "24.1.0"

    // OkHttp
    implementation group: "com.squareup.okhttp3", name: "okhttp", version: "5.0.0-alpha.12"
    implementation group: "com.squareup.okhttp3", name: "okhttp-sse", version: "5.0.0-alpha.12"
    implementation group: "com.squareup.okhttp3", name: "logging-interceptor", version: "5.0.0-alpha.12"

    // Libraries used by the OpenAPI generated client libraries
    implementation group: "jakarta.annotation", name: "jakarta.annotation-api", version: "1.3.5"
    implementation group: "org.openapitools", name: "jackson-databind-nullable", version: "0.2.6"
    implementation group: "io.gsonfire", name: "gson-fire", version: "1.9.0"
}

// Exclude any SLF4j-implementation transitive dependencies so users can use a logging framework of their choice
configurations.implementation {
    exclude group: "commons-logging", module: "commons-logging"
}

java {
    sourceCompatibility = JavaVersion.VERSION_17
    targetCompatibility = JavaVersion.VERSION_17
    withJavadocJar()
    withSourcesJar()
}
javadocJar.dependsOn generatePOJOs
sourcesJar.dependsOn generatePOJOs
jar.dependsOn compileJava
javadocJar.dependsOn compileJava
sourcesJar.dependsOn compileJava

[compileJava, compileTestJava]*.options*.encoding = "UTF-8"

javadoc {
    options.addStringOption("source", "17")
    options.addStringOption("charset", "UTF-8")
    options.addStringOption("Xdoclint:none", "-quiet") // Suppress Javadoc linting warnings
    options.addStringOption("link", "https://docs.oracle.com/en/java/javase/17/docs/api/")
}

//
// BEGIN Alpaca OpenAPI Specification (OAS) client generation
//

// These IDs come from the URLs on this page: https://docs.alpaca.markets/openapi
final def specIDsOfFileNames = Map.of(
        "trader.json", "657760422129f9005cf4bd58",
        "broker.json", "657771fc2471d20070183049",
        "market-data.json", "6577704d1fb6b9007032bf39")
final File specDownloadPath = new File(project.layout.buildDirectory.get().getAsFile(),
        "/download/openapi/")
final File generatedClientLibrariesPath = new File(project.layout.buildDirectory.get().getAsFile(),
        "/generated/openapi/")

def downloadOpenAPISpecFilesTask = tasks.register("downloadOpenAPISpecFiles") {
    configure {
        outputs.dir(specDownloadPath)
        outputs.cacheIf { true }
    }

    doLast {
        // Download spec files
        specIDsOfFileNames.forEach { fileName, alpacaSpecID ->
            final def outputFile = new File(specDownloadPath, fileName)
            final def specURL = "https://docs.alpaca.markets/openapi/${alpacaSpecID}"
            outputFile.getParentFile().mkdirs()
            try {
                logger.info("Downloading OpenAPI spec file from: {}", specURL)
                new URL(specURL).withInputStream { inputStream -> outputFile.withOutputStream { it << inputStream } }
                logger.info("Successfully downloaded OpenAPI spec file to: {}", outputFile.getPath())
            } catch (IOException ioException) {
                throw new RuntimeException("Could not download OpenAPI spec file!", ioException)
            }
        }

        // Fix an issue in the Broker spec file that uses an empty string as an object key for some reason
        // TODO remove this when issue is fixed by Alpaca
        final def brokerSpecFile = new File(specDownloadPath, "broker.json")
        brokerSpecFile.text = brokerSpecFile.text
                .replace(",\"\":{\"type\":\"string\",\"x-stoplight\":{\"id\":\"1zg5jnb6rzdoo\"}}", "")
    }
}
compileJava.dependsOn downloadOpenAPISpecFilesTask

final def generateTasks = []
for (def specFileName : specIDsOfFileNames.keySet()) {
    final def specName = specFileName.replace(".json", "")
    final def inputSpecFile = new File(specDownloadPath, specFileName)
    final def outputDirectory = new File(generatedClientLibrariesPath, specName)

    // Add source set of OpenAPI generated client library
    sourceSets {
        main {
            java {
                srcDir new File(outputDirectory, "src/main/java/").getPath()
            }
        }
    }

    // Register and configure OpenAPI generate task
    final def generateTask = tasks.register("generateOpenAPIClientFor-" + specName, GenerateTask) {
        dependsOn {
            downloadOpenAPISpecFilesTask
        }

        configure {
            inputs.file(inputSpecFile)
            outputs.dir(outputDirectory)
            outputs.cacheIf { true }
        }

        generatorName.set("java")
        inputSpec.set(inputSpecFile.getPath())
        outputDir.set(outputDirectory.getPath())
        final def destinationPackage = projectGroup + ".openapi." + specName.replace("-", "")
        configOptions.set(Map.of(
                "artifactId", specName,
                "artifactVersion", "1.0.0-SNAPSHOT",
                "groupId", destinationPackage,
                "invokerPackage", destinationPackage,
                "apiPackage", destinationPackage + ".api",
                "modelPackage", destinationPackage + ".model",
                "library", "okhttp-gson",
                "documentationProvider", "none",
                "useBeanValidation", "false",
                "performBeanValidation", "false"))
        cleanupOutput.set(true)
        validateSpec.set(false)
        skipValidateSpec.set(true)
        generateModelTests.set(false)
        generateModelDocumentation.set(false)
        generateApiTests.set(false)
        generateApiDocumentation.set(false)
    }
    compileJava.dependsOn generateTask
    generateTasks.add(generateTask)
}

final def fixOpenAPIGeneratedClientIssuesTask = tasks.register("fixOpenAPIGeneratedClientIssues") {
    configure {
        mustRunAfter(generateTasks)
    }

    it.onlyIf {
        generateTasks.stream().allMatch { generateTask ->
            !generateTask.get().state.upToDate &&
                    generateTask.get().state.failure == null &&
                    !generateTask.get().state.skipped &&
                    generateTask.get().state.executed
        }
    }

    doLast {
        // TODO remove these manual fixes once OpenAPI fixes these issues

        final def sourceFilesPath = "src/main/java/net/jacobpeterson/alpaca/openapi"

        // Fix broker spec generated client issues with discriminators
        // on some enums: https://github.com/OpenAPITools/openapi-generator/issues/806
        final def brokerTransferDataJavaFile = new File(generatedClientLibrariesPath,
                "broker/${sourceFilesPath}/broker/model/TransferData.java")
        brokerTransferDataJavaFile.text = brokerTransferDataJavaFile.text
                .replace("this.transferType = this.getClass().getSimpleName();", "")
        final def brokerTransferResourceJavaFile = new File(generatedClientLibrariesPath,
                "broker/${sourceFilesPath}/broker/model/TransferResource.java")
        brokerTransferResourceJavaFile.text = brokerTransferResourceJavaFile.text
                .replace("this.type = this.getClass().getSimpleName();", "")

        // Remove the JSON validation that the generated client models always run (there isn't an option to
        // disable it for some reason). Also, remove throwing an IllegalArgumentException for a null/empty string
        // given to enum 'fromValue' methods.
        specIDsOfFileNames.keySet().stream().map { it.replace(".json", "") }.forEach {
            for (File modelFile : Paths.get(generatedClientLibrariesPath.getPath(),
                    it, sourceFilesPath, it.replace("-", ""), "model").toFile().listFiles()) {
                modelFile.text = modelFile.text
                        .replaceAll("/\\*\\*\\n {2}\\* Validates the JSON Element and throws an exception if issues " +
                                "found[\\s\\S]*?\\*/", "")
                        .replace("import java.io.IOException;",
                                "import java.io.IOException;\nimport java.util.function.Predicate;")
                        .replace("public static void validateJsonElement(JsonElement jsonElement) throws IOException {",
                                "public static boolean validate = false;\n" +
                                        "    public static Predicate<JsonElement> isValid = jsonElement -> true;\n" +
                                        "    public static void validateJsonElement(JsonElement jsonElement) " +
                                        "throws IOException {\n" +
                                        "      if (!isValid.test(jsonElement)) throw new RuntimeException();\n" +
                                        "      if (!validate) return;\n")
                        .replace("throw new IllegalArgumentException(\"Unexpected value '\" + value + \"'\");",
                                "return null;")
            }
        }

        // Make certain method signatures in the generated client API classes 'protected' instead of 'public'
        specIDsOfFileNames.keySet().stream().map { it.replace(".json", "") }.forEach {
            for (File apiFile : Paths.get(generatedClientLibrariesPath.getPath(),
                    it, sourceFilesPath, it.replace("-", ""), "api").toFile().listFiles()) {
                // Don't make replacements in the broker 'events' API as that class is wrapped
                if (apiFile.name == "EventsApi.java") {
                    continue
                }
                // Make replacements
                apiFile.text = apiFile.text
                        .replace("public okhttp3.Call", "protected okhttp3.Call")
                        .replace("public ApiResponse", "protected ApiResponse")
                        .replaceAll("\\n.*public ApiClient[\\s\\S]*?customBaseUrl;\\n {4}}", "")
            }
        }

        // Remove the necessary authentication header logic from the generate client's ApiClient
        specIDsOfFileNames.keySet().stream().map { it.replace(".json", "") }.forEach {
            final def apiClientFile = Paths.get(generatedClientLibrariesPath.getPath(), it, sourceFilesPath,
                    it.replace("-", ""), "ApiClient.java").toFile()
            apiClientFile.text = apiClientFile.text
                    .replaceAll("// Setup authentications \\(key: authentication name, value: authentication\\)" +
                            "[\\s\\S]*?authentications\\);", "")
                    .replaceAll("for \\(String authName : authNames\\)[\\s\\S]*?uri\\);\\n. {7}}", "")
        }

        // Make the 'JSON' classes of the generate clients have a static Gson initializer. Also fix the OffsetDateTime
        // Gson type adapter to accommodate ISO local dates.
        specIDsOfFileNames.keySet().stream().map { it.replace(".json", "") }.forEach {
            final def jsonClientFile = Paths.get(generatedClientLibrariesPath.getPath(), it, sourceFilesPath,
                    it.replace("-", ""), "JSON.java").toFile()
            jsonClientFile.text = jsonClientFile.text
                    .replaceAll("\\{\\n {8}GsonBuilder", "static {\n        GsonBuilder")
                    .replaceAll("}[\\s\\S].*return OffsetDateTime\\.parse\\(date, formatter\\);",
                            "} else if (!date.contains(\"T\")) {\n" +
                                    "return LocalDate.parse(date, DateTimeFormatter.ISO_LOCAL_DATE)" +
                                    ".atTime(java.time.LocalTime.MIN.atOffset(java.time.ZoneOffset.UTC));\n" +
                                    "}\n" +
                                    "return OffsetDateTime.parse(date, formatter);")
        }
    }
}
compileJava.dependsOn fixOpenAPIGeneratedClientIssuesTask

//
// END Alpaca OpenAPI Specification (OAS) client generation
//

//
// BEGIN Publishing
//

publishing {
    publications {
        mavenJava(MavenPublication) {
            groupId = projectGroup
            artifactId = projectArtifactID
            version = projectVersion
            from(components["java"])

            pom {
                name = projectArtifactID
                description = "A Java API for Alpaca, the commission free, algo friendly, stock trading broker."
                url = "https://github.com/Petersoj/alpaca-java"
                inceptionYear = "2018"

                licenses {
                    license {
                        name = "MIT License"
                        url = "https://opensource.org/licenses/MIT"
                    }
                }

                developers {
                    developer {
                        id = "Petersoj"
                        name = "Jacob Peterson"
                    }
                    developer {
                        id = "mainstringargs"
                        name = "main(String[] args)"
                    }
                }

                scm {
                    url = "https://github.com/Petersoj/alpaca-java.git"
                    connection = "scm:git:https://github.com/Petersoj/alpaca-java.git"
                    developerConnection = "scm:git:git@github.com/Petersoj/alpaca-java.git"
                }
            }
        }
    }

    repositories {
        maven {
            name = "OSSRH"
            url = projectVersion.contains("SNAPSHOT") ? "https://oss.sonatype.org/content/repositories/snapshots/" :
                    "https://oss.sonatype.org/service/local/staging/deploy/maven2/"
            credentials {
                username = project.property("nexus.username")
                password = project.property("nexus.password")
            }
        }
    }
}

signing {
    sign publishing.publications.mavenJava
}

//
// END Publishing
//