build.gradle

def moduleVersion = "1.0.0"

def requiredVersionTerraform = "^1.1.9"
def requiredVersionNodeJS = "^18.0.0"
def requiredVersionTsc = "^5.0.0"

allprojects {
    ext {
        if (org.gradle.internal.os.OperatingSystem.current().isWindows()) {
            nodeExecutable = ["node"]
            ngExecutable = ["cmd", "/c", "ng"]
            npmExecutable = ["cmd", "/c", "npm"]
            terraformExecutable = ["cmd", "/c", "terraform"]
            tscExecutable = ["cmd", "/c", "tsc"]
            gitExecutable = ["git"]
        } else {
            nodeExecutable = ["node"]
            ngExecutable = ["ng"]
            npmExecutable = ["npm"]
            terraformExecutable = ["terraform"]
            tscExecutable = ["tsc"]
            gitExecutable = ["git"]
        }
    }
}

static def isSemVerMatching(String actual, String expected) {
    def beginIndex
    def equalParts

    if (expected.startsWith("^")) {
        beginIndex = 1
        equalParts = 1
    } else if (expected.startsWith("~")) {
        beginIndex = 1
        equalParts = 2
    } else {
        beginIndex = 0
        equalParts = 3
    }

    def expectedParts = expected.substring(beginIndex).split(/\./).collect { it as int }
    def actualParts = actual.split(/\./).collect { it as int }

    for (def i = 0; i < expectedParts.size(); i++) {

        if (i < equalParts) {
            if (actualParts[i] != expectedParts[i]) {
                return false
            }
        } else {
            if (actualParts[i] > expectedParts[i]) {
                return true
            }
            if (actualParts[i] < expectedParts[i]) {
                return false
            }
        }
    }

    return true
}

def getVersionNodeJS() {
    def stdout = new ByteArrayOutputStream()
    def stderr = new ByteArrayOutputStream()
    try {
        exec {
            commandLine nodeExecutable
            args "--version"
            standardOutput stdout
            errorOutput stderr
        }
    } catch (Exception ignored) {
    }

    return stdout.toString().trim().replace("v", "")
}

def getVersionTerraform() {
    def stdout = new ByteArrayOutputStream()
    def stderr = new ByteArrayOutputStream()
    try {
        exec {
            commandLine terraformExecutable
            args "--version"
            standardOutput stdout
            errorOutput stderr
        }
    } catch (Exception ignored) {
    }

    return stdout.toString().split("\n")[0].trim().replace("Terraform v", "")
}

def getVersionTsc() {
    def stdout = new ByteArrayOutputStream()
    def stderr = new ByteArrayOutputStream()
    try {
        exec {
            commandLine tscExecutable
            args "--v"
            standardOutput stdout
            errorOutput stderr
        }
    } catch (Exception ignored) {
    }

    return stdout.toString().trim().replace("Version ", "")
}

task verifyNodeJS {
    def actualVersion = getVersionNodeJS()

    inputs.property("VERSION_NODE_JS", requiredVersionNodeJS)
    outputs.upToDateWhen { isSemVerMatching(actualVersion, requiredVersionNodeJS) }
    doLast {
        if (!isSemVerMatching(actualVersion, requiredVersionNodeJS)) {
            throw new Exception("Required Node version " + requiredVersionNodeJS + " not found. Detected version " + actualVersion)
        }
    }
}

task verifyTerraform {
    def actualVersion = getVersionTerraform()

    inputs.property("VERSION_TERRAFORM", requiredVersionTerraform)
    outputs.upToDateWhen { isSemVerMatching(actualVersion, requiredVersionTerraform) }
    doLast {
        if (!isSemVerMatching(actualVersion, requiredVersionTerraform)) {
            throw new Exception("Required Terraform version " + requiredVersionTerraform + " not found. Detected version " + actualVersion)
        }
    }
}

task verifyTsc {
    def actualVersion = getVersionTsc()

    inputs.property("VERSION_TSC", requiredVersionTsc)
    outputs.upToDateWhen { isSemVerMatching(actualVersion, requiredVersionTsc) }
    doLast {
        if (!isSemVerMatching(actualVersion, requiredVersionTsc)) {
            throw new Exception("Required tsc version " + requiredVersionTsc + " not found. Detected version " + actualVersion)
        }
    }
}

task build {
    dependsOn "aws:build"
    dependsOn "azure:build"
}

task clean {}

task publish(type: Exec) {
    doFirst {
        def stdout = new ByteArrayOutputStream()
        def stderr = new ByteArrayOutputStream()
        try {
            exec {
                commandLine gitExecutable
                args "status", "--porcelain"
                standardOutput stdout
                errorOutput stderr
            }
        } catch (Exception ignored) {
        }

        if (stdout.toString().trim().length() > 0) {
            throw new Exception("Local changes detected. Version tag not added")
        }
    }
    commandLine gitExecutable
    args "tag", "-a", "v${moduleVersion}", "-m", "Released version ${moduleVersion}"

    doLast {
        exec {
            commandLine gitExecutable
            args "push", "origin", "tag", "v${moduleVersion}"
        }
    }
}

afterEvaluate {
    // avoiding simultaneous connections to npmjs.com
    def prevTask = null
    project.subprojects.each {
        def task = it.tasks.find { task -> task.name.contains('npmUpdate') }
        if (task != null) {
            if (prevTask != null) {
                task.mustRunAfter(prevTask)
            }
            prevTask = task
        }
    }

    prevTask = null
    project.subprojects.each {
        def task = it.tasks.find { task -> task.name.contains('npmInstall') }
        if (task != null) {
            if (prevTask != null) {
                task.mustRunAfter(prevTask)
            }
            prevTask = task
        }
    }
}