@react-native/gradle-plugin 0.75.2 → 0.75.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@react-native/gradle-plugin",
-  "version": "0.75.2",
+  "version": "0.75.4",
   "description": "Gradle Plugin for React Native",
   "license": "MIT",
   "repository": {

package/react-native-gradle-plugin/build.gradle.kts

@@ -7,7 +7,6 @@
 
 import org.gradle.api.internal.classpath.ModuleRegistry
 import org.gradle.api.tasks.testing.logging.TestExceptionFormat
-import org.gradle.configurationcache.extensions.serviceOf
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
@@ -52,14 +51,6 @@ dependencies {
   testImplementation(libs.junit)
   testImplementation(libs.assertj)
   testImplementation(project(":shared-testutil"))
-
-  testRuntimeOnly(
-      files(
-          serviceOf<ModuleRegistry>()
-              .getModule("gradle-tooling-api-builders")
-              .classpath
-              .asFiles
-              .first()))
 }
 
 // We intentionally don't build for Java 17 as users will see a cryptic bytecode version
@@ -74,7 +65,8 @@ tasks.withType<KotlinCompile>().configureEach {
     apiVersion = "1.6"
     // See comment above on JDK 11 support
     jvmTarget = "11"
-    allWarningsAsErrors = true
+    allWarningsAsErrors =
+        project.properties["enableWarningsAsErrors"]?.toString()?.toBoolean() ?: false
   }
 }
 

package/react-native-gradle-plugin/src/main/kotlin/com/facebook/react/ReactExtension.kt

@@ -188,6 +188,7 @@ abstract class ReactExtension @Inject constructor(val project: Project) {
           ?.dependencies
           ?.values
           ?.filter { it.platforms?.android !== null }
+          ?.filterNot { it.platforms?.android?.isPureCxxDependency == true }
           ?.forEach { deps ->
             val nameCleansed = deps.nameCleansed
             val dependencyConfiguration = deps.platforms?.android?.dependencyConfiguration

package/react-native-gradle-plugin/src/main/kotlin/com/facebook/react/tasks/GeneratePackageListTask.kt

@@ -30,10 +30,19 @@ abstract class GeneratePackageListTask : DefaultTask() {
 
   @TaskAction
   fun taskAction() {
-    val model = JsonUtils.fromAutolinkingConfigJson(autolinkInputFile.get().asFile)
+    val model =
+        JsonUtils.fromAutolinkingConfigJson(autolinkInputFile.get().asFile)
+            ?: error(
+                """
+        RNGP - Autolinking: Could not parse autolinking config file:
+        ${autolinkInputFile.get().asFile.absolutePath}
+        
+        The file is either missing or not containing valid JSON so the build won't succeed. 
+      """
+                    .trimIndent())
 
     val packageName =
-        model?.project?.android?.packageName
+        model.project?.android?.packageName
             ?: error(
                 "RNGP - Autolinking: Could not find project.android.packageName in react-native config output! Could not autolink packages without this field.")
 

package/react-native-gradle-plugin/src/test/kotlin/com/facebook/react/ReactExtensionTest.kt

@@ -189,6 +189,44 @@ class ReactExtensionTest {
     assertThat(deps).isEmpty()
   }
 
+  @Test
+  fun getGradleDependenciesToApply_withIsPureCxxDeps_filtersCorrectly() {
+    val validJsonFile =
+      createJsonFile(
+        """
+      {
+        "reactNativeVersion": "1000.0.0",
+        "dependencies": {
+          "@react-native/oss-library-example": {
+            "root": "./node_modules/@react-native/android-example",
+            "name": "@react-native/android-example",
+            "platforms": {
+              "android": {
+                "sourceDir": "src/main/java",
+                "packageImportPath": "com.facebook.react"
+              }
+            }
+          },
+          "@react-native/another-library-for-testing": {
+            "root": "./node_modules/@react-native/cxx-testing",
+            "name": "@react-native/cxx-testing",
+            "platforms": {
+              "android": {
+                "sourceDir": "src/main/java",
+                "packageImportPath": "com.facebook.react",
+                "isPureCxxDependency": true
+              }
+            }
+          }
+        }
+      }
+      """
+          .trimIndent())
+
+    val deps = getGradleDependenciesToApply(validJsonFile)
+    assertThat(deps).containsExactly("implementation" to ":react-native_android-example")
+  }
+
   private fun createJsonFile(@Language("JSON") input: String) =
       tempFolder.newFile().apply { writeText(input) }
 }

package/settings-plugin/build.gradle.kts

@@ -7,7 +7,6 @@
 
 import org.gradle.api.internal.classpath.ModuleRegistry
 import org.gradle.api.tasks.testing.logging.TestExceptionFormat
-import org.gradle.configurationcache.extensions.serviceOf
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
@@ -41,14 +40,6 @@ dependencies {
 
   testImplementation(libs.junit)
   testImplementation(project(":shared-testutil"))
-
-  testRuntimeOnly(
-      files(
-          serviceOf<ModuleRegistry>()
-              .getModule("gradle-tooling-api-builders")
-              .classpath
-              .asFiles
-              .first()))
 }
 
 // We intentionally don't build for Java 17 as users will see a cryptic bytecode version
@@ -63,7 +54,8 @@ tasks.withType<KotlinCompile>().configureEach {
     apiVersion = "1.6"
     // See comment above on JDK 11 support
     jvmTarget = "11"
-    allWarningsAsErrors = true
+    allWarningsAsErrors =
+        project.properties["enableWarningsAsErrors"]?.toString()?.toBoolean() ?: false
   }
 }
 

package/settings-plugin/src/main/kotlin/com/facebook/react/ReactSettingsExtension.kt

@@ -7,6 +7,7 @@
 
 package com.facebook.react
 
+import com.facebook.react.model.ModelAutolinkingConfigJson
 import com.facebook.react.utils.JsonUtils
 import com.facebook.react.utils.windowsAwareCommandLine
 import java.io.File
@@ -53,30 +54,22 @@ abstract class ReactSettingsExtension @Inject constructor(val settings: Settings
               .files("yarn.lock", "package-lock.json", "package.json", "react-native.config.js")
   ) {
     outputFile.parentFile.mkdirs()
-    val lockFilesChanged = checkAndUpdateLockfiles(lockFiles, outputFolder)
-    if (lockFilesChanged || outputFile.exists().not() || outputFile.length() != 0L) {
-      val process =
-          ProcessBuilder(command)
-              .directory(workingDirectory)
-              .redirectOutput(ProcessBuilder.Redirect.to(outputFile))
-              .redirectError(ProcessBuilder.Redirect.INHERIT)
-              .start()
-      val finished = process.waitFor(5, TimeUnit.MINUTES)
-      if (!finished || (process.exitValue() != 0)) {
-        val prefixCommand =
-            "ERROR: autolinkLibrariesFromCommand: process ${command.joinToString(" ")}"
-        val message =
-            if (!finished) "${prefixCommand} timed out"
-            else "${prefixCommand} exited with error code: ${process.exitValue()}"
-        val logger = Logging.getLogger("ReactSettingsExtension")
-        logger.error(message)
-        if (outputFile.length() != 0L) {
-          logger.error(outputFile.readText().substring(0, 1024))
+
+    val updateConfig =
+        object : GenerateConfig {
+          private val pb =
+              ProcessBuilder(command)
+                  .directory(workingDirectory)
+                  .redirectOutput(ProcessBuilder.Redirect.to(outputFile))
+                  .redirectError(ProcessBuilder.Redirect.INHERIT)
+
+          override fun command(): List<String> = pb.command()
+
+          override fun start(): Process = pb.start()
         }
-        outputFile.delete()
-        throw GradleException(message)
-      }
-    }
+
+    checkAndUpdateCache(updateConfig, outputFile, outputFolder, lockFiles)
+
     linkLibraries(getLibrariesToAutolink(outputFile))
   }
 
@@ -107,9 +100,73 @@ abstract class ReactSettingsExtension @Inject constructor(val settings: Settings
     }
   }
 
+  internal interface GenerateConfig {
+    fun command(): List<String>
+
+    fun start(): Process
+  }
+
   companion object {
     private val md = MessageDigest.getInstance("SHA-256")
 
+    /**
+     * Determine if our cache is out-of-date
+     *
+     * @param cacheJsonConfig Our current cached autolinking.json config, which may exist
+     * @param cacheFolder The folder we store our cached SHAs and config
+     * @param lockFiles The [FileCollection] of the lockfiles to check.
+     * @return `true` if the cache needs to be rebuilt, `false` otherwise
+     */
+    internal fun isCacheDirty(
+        cacheJsonConfig: File,
+        cacheFolder: File,
+        lockFiles: FileCollection,
+    ): Boolean {
+      if (cacheJsonConfig.exists().not() || cacheJsonConfig.length() == 0L) {
+        return true
+      }
+      val lockFilesChanged = checkAndUpdateLockfiles(lockFiles, cacheFolder)
+      if (lockFilesChanged) {
+        return true
+      }
+      return isConfigModelInvalid(JsonUtils.fromAutolinkingConfigJson(cacheJsonConfig))
+    }
+
+    /**
+     * Utility function to update the settings cache only if it's entries are dirty
+     *
+     * @param updateJsonConfig A [GenerateConfig] to update the project's autolinking config
+     * @param cacheJsonConfig Our current cached autolinking.json config, which may exist
+     * @param cacheFolder The folder we store our cached SHAs and config
+     * @param lockFiles The [FileCollection] of the lockfiles to check.
+     */
+    internal fun checkAndUpdateCache(
+        updateJsonConfig: GenerateConfig,
+        cacheJsonConfig: File,
+        cacheFolder: File,
+        lockFiles: FileCollection,
+    ) {
+      if (isCacheDirty(cacheJsonConfig, cacheFolder, lockFiles)) {
+        val process = updateJsonConfig.start()
+
+        val finished = process.waitFor(5, TimeUnit.MINUTES)
+        if (!finished || (process.exitValue() != 0)) {
+          val command = updateJsonConfig.command().joinToString(" ")
+          val prefixCommand = "ERROR: autolinkLibrariesFromCommand: process $command"
+          val message =
+              if (!finished) "$prefixCommand timed out"
+              else "$prefixCommand exited with error code: ${process.exitValue()}"
+          val logger = Logging.getLogger("ReactSettingsExtension")
+          logger.error(message)
+          if (cacheJsonConfig.length() != 0L) {
+            logger.error(cacheJsonConfig.readText().substring(0, 1024))
+          }
+          cacheJsonConfig.delete()
+          throw GradleException(message)
+        }
+      }
+    }
+
     /**
      * Utility function to check if the provided lockfiles have been updated or not. This function
      * will both check and update the lockfiles hashes if necessary.
@@ -150,5 +207,8 @@ abstract class ReactSettingsExtension @Inject constructor(val settings: Settings
 
     internal fun computeSha256(lockFile: File) =
         String.format("%032x", BigInteger(1, md.digest(lockFile.readBytes())))
+
+    internal fun isConfigModelInvalid(model: ModelAutolinkingConfigJson?) =
+        model?.project?.android?.packageName == null
   }
 }

package/settings-plugin/src/test/kotlin/com/facebook/react/ReactSettingsExtensionTest.kt

@@ -7,10 +7,12 @@
 
 package com.facebook.react
 
+import com.facebook.react.ReactSettingsExtension.Companion.checkAndUpdateCache
 import com.facebook.react.ReactSettingsExtension.Companion.checkAndUpdateLockfiles
 import com.facebook.react.ReactSettingsExtension.Companion.computeSha256
 import com.facebook.react.ReactSettingsExtension.Companion.getLibrariesToAutolink
 import groovy.test.GroovyTestCase.assertEquals
+import com.facebook.react.ReactSettingsExtension.GenerateConfig
 import java.io.File
 import org.gradle.testfixtures.ProjectBuilder
 import org.intellij.lang.annotations.Language
@@ -236,6 +238,241 @@ class ReactSettingsExtensionTest {
         File(buildFolder, "package-lock.json.sha").readText())
   }
 
+  @Test
+  fun skipUpdateIfConfigInCacheIsValid() {
+    val project = ProjectBuilder.builder().withProjectDir(tempFolder.root).build()
+    val buildFolder = tempFolder.newFolder("build")
+    val generatedFolder = tempFolder.newFolder("build", "generated")
+    val outputFile =
+        File(generatedFolder, "autolinking.json").apply {
+          writeText(
+              """
+      {
+        "root": "/",
+        "reactNativePath": "/node_modules/react-native",
+        "reactNativeVersion": "0.75",
+        "dependencies": {},
+        "healthChecks": [],
+        "platforms": {
+          "ios": {},
+          "android": {}
+        },
+        "assets": [],
+        "project": {
+          "ios": {},
+          "android": {
+            "sourceDir": "/",
+            "appName": "app",
+            "packageName": "com.TestApp",
+            "applicationId": "com.TestApp",
+            "mainActivity": ".MainActivity",
+            "assets": []
+          }
+        }
+      }
+    """
+                  .trimIndent())
+        }
+    tempFolder.newFile("yarn.lock").apply { writeText("I'm a lockfile") }
+    val lockfileCollection = project.files("yarn.lock")
+
+    // Prebuild the shas with the invalid empty autolinking.json
+    checkAndUpdateLockfiles(lockfileCollection, buildFolder)
+
+    val monitoredUpdateConfig = createMonitoredUpdateConfig()
+
+    checkAndUpdateCache(monitoredUpdateConfig, outputFile, buildFolder, lockfileCollection)
+
+    // The autolinking.json file is valid, SHA's are untouched therefore config should NOT be
+    // refreshed
+    assertThat(monitoredUpdateConfig.run).isFalse()
+  }
+
+  @Test
+  fun checkAndUpdateConfigIfEmpty() {
+    val project = ProjectBuilder.builder().withProjectDir(tempFolder.root).build()
+    val buildFolder = tempFolder.newFolder("build")
+    val generatedFolder = tempFolder.newFolder("build", "generated")
+    val outputFile = File(generatedFolder, "autolinking.json").apply { writeText("") }
+    tempFolder.newFile("yarn.lock").apply { writeText("I'm a lockfile") }
+    val lockfileCollection = project.files("yarn.lock")
+
+    // Prebuild the shas with the invalid empty autolinking.json
+    checkAndUpdateLockfiles(lockfileCollection, buildFolder)
+
+    val monitoredUpdateConfig = createMonitoredUpdateConfig()
+
+    checkAndUpdateCache(monitoredUpdateConfig, outputFile, buildFolder, lockfileCollection)
+
+    // The autolinking.json file is invalid and should be refreshed
+    assertThat(monitoredUpdateConfig.run).isTrue()
+  }
+
+  @Test
+  fun checkAndUpdateConfigIfCachedConfigInvalid() {
+    val project = ProjectBuilder.builder().withProjectDir(tempFolder.root).build()
+    val buildFolder = tempFolder.newFolder("build")
+    val generatedFolder = tempFolder.newFolder("build", "generated")
+    val outputFile =
+        File(generatedFolder, "autolinking.json").apply {
+          writeText(
+              """
+      {
+        "project": {
+          "ios": {},
+          "android": {}
+        }
+      }
+    """
+                  .trimIndent())
+        }
+    tempFolder.newFile("yarn.lock").apply { writeText("I'm a lockfile") }
+    val lockfileCollection = project.files("yarn.lock")
+
+    // Prebuild the shas with the invalid empty autolinking.json
+    checkAndUpdateLockfiles(lockfileCollection, buildFolder)
+
+    val monitoredUpdateConfig = createMonitoredUpdateConfig()
+
+    checkAndUpdateCache(monitoredUpdateConfig, outputFile, buildFolder, lockfileCollection)
+
+    // The autolinking.json file is invalid and should be refreshed
+    assertThat(monitoredUpdateConfig.run).isTrue()
+  }
+
+  @Test
+  fun isCacheDirty_withMissingAutolinkingFile_returnsTrue() {
+    val project = ProjectBuilder.builder().withProjectDir(tempFolder.root).build()
+    val buildFolder =
+        tempFolder.newFolder("build").apply {
+          File(this, "yarn.lock.sha")
+              .writeText("76046b72442ee7eb130627e56c3db7c9907eef4913b17ad130335edc0eb702a8")
+        }
+    tempFolder.newFile("yarn.lock").apply { writeText("I'm a lockfile") }
+    val lockfiles = project.files("yarn.lock")
+    val emptyConfigFile = File(tempFolder.newFolder("build", "autolinking"), "autolinking.json")
+
+    assertThat(ReactSettingsExtension.isCacheDirty(emptyConfigFile, buildFolder, lockfiles))
+        .isTrue()
+  }
+
+  @Test
+  fun isCacheDirty_withInvalidAutolinkingFile_returnsTrue() {
+    val project = ProjectBuilder.builder().withProjectDir(tempFolder.root).build()
+    val buildFolder =
+        tempFolder.newFolder("build").apply {
+          File(this, "yarn.lock.sha")
+              .writeText("76046b72442ee7eb130627e56c3db7c9907eef4913b17ad130335edc0eb702a8")
+        }
+    tempFolder.newFile("yarn.lock").apply { writeText("I'm a lockfile") }
+    val lockfiles = project.files("yarn.lock")
+    val invalidConfigFile =
+        createJsonFile(
+            """
+      {}
+      """
+                .trimIndent())
+
+    assertThat(ReactSettingsExtension.isCacheDirty(invalidConfigFile, buildFolder, lockfiles))
+        .isTrue()
+  }
+
+  @Test
+  fun isCacheDirty_withMissingDependenciesInJson_returnsFalse() {
+    val project = ProjectBuilder.builder().withProjectDir(tempFolder.root).build()
+    val buildFolder =
+        tempFolder.newFolder("build").apply {
+          File(this, "yarn.lock.sha")
+              .writeText("76046b72442ee7eb130627e56c3db7c9907eef4913b17ad130335edc0eb702a8")
+        }
+    tempFolder.newFile("yarn.lock").apply { writeText("I'm a lockfile") }
+    val lockfiles = project.files("yarn.lock")
+    val invalidConfigFile =
+        createJsonFile(
+            """
+      {
+        "reactNativeVersion": "1000.0.0"
+      }
+      """
+                .trimIndent())
+
+    assertThat(ReactSettingsExtension.isCacheDirty(invalidConfigFile, buildFolder, lockfiles))
+        .isTrue()
+  }
+
+  @Test
+  fun isCacheDirty_withExistingEmptyDependenciesInJson_returnsTrue() {
+    val project = ProjectBuilder.builder().withProjectDir(tempFolder.root).build()
+    val buildFolder =
+        tempFolder.newFolder("build").apply {
+          File(this, "yarn.lock.sha")
+              .writeText("76046b72442ee7eb130627e56c3db7c9907eef4913b17ad130335edc0eb702a8")
+        }
+    tempFolder.newFile("yarn.lock").apply { writeText("I'm a lockfile") }
+    val lockfiles = project.files("yarn.lock")
+    val invalidConfigFile =
+        createJsonFile(
+            """
+      {
+        "reactNativeVersion": "1000.0.0",
+        "dependencies": {}
+      }
+      """
+                .trimIndent())
+
+    assertThat(ReactSettingsExtension.isCacheDirty(invalidConfigFile, buildFolder, lockfiles))
+        .isTrue()
+  }
+
+  @Test
+  fun isCacheDirty_withExistingDependenciesInJson_returnsTrue() {
+    val project = ProjectBuilder.builder().withProjectDir(tempFolder.root).build()
+    val buildFolder =
+        tempFolder.newFolder("build").apply {
+          File(this, "yarn.lock.sha")
+              .writeText("76046b72442ee7eb130627e56c3db7c9907eef4913b17ad130335edc0eb702a8")
+        }
+    tempFolder.newFile("yarn.lock").apply { writeText("I'm a lockfile") }
+    val lockfiles = project.files("yarn.lock")
+    val invalidConfigFile =
+        createJsonFile(
+            """
+      {
+        "reactNativeVersion": "1000.0.0",
+        "dependencies": {
+          "@react-native/oss-library-example": {
+            "root": "./node_modules/@react-native/oss-library-example",
+            "name": "@react-native/oss-library-example",
+            "platforms": {
+              "ios": {
+                "podspecPath": "./node_modules/@react-native/oss-library-example/OSSLibraryExample.podspec",
+                "version": "0.0.1",
+                "configurations": [],
+                "scriptPhases": []
+              }
+            }
+          }
+        }
+      }
+      """
+                .trimIndent())
+
+    assertThat(ReactSettingsExtension.isCacheDirty(invalidConfigFile, buildFolder, lockfiles))
+        .isTrue()
+  }
+
   private fun createJsonFile(@Language("JSON") input: String) =
       tempFolder.newFile().apply { writeText(input) }
+
+  private fun createMonitoredUpdateConfig() =
+      object : GenerateConfig {
+        var run = false
+
+        override fun start(): Process {
+          run = true
+          return ProcessBuilder("true").start()
+        }
+
+        override fun command(): List<String> = listOf("true")
+      }
 }

package/shared/build.gradle.kts

@@ -29,7 +29,8 @@ tasks.withType<KotlinCompile>().configureEach {
   kotlinOptions {
     apiVersion = "1.6"
     jvmTarget = "11"
-    allWarningsAsErrors = true
+    allWarningsAsErrors =
+        project.properties["enableWarningsAsErrors"]?.toString()?.toBoolean() ?: false
   }
 }
 

package/shared/src/main/kotlin/com/facebook/react/utils/JsonUtils.kt

@@ -21,8 +21,23 @@ object JsonUtils {
       }
 
   fun fromAutolinkingConfigJson(input: File): ModelAutolinkingConfigJson? =
-      input.bufferedReader().use {
-        runCatching { gsonConverter.fromJson(it, ModelAutolinkingConfigJson::class.java) }
+      input.bufferedReader().use { reader ->
+        runCatching {
+              // We sanitize the output of the `config` command as it could contain debug logs
+              // such as:
+              //
+              // > AwesomeProject@0.0.1 npx
+              // > rnc-cli config
+              //
+              // which will render the JSON invalid.
+              val content =
+                  reader
+                      .readLines()
+                      .filterNot { line -> line.startsWith(">") }
+                      .joinToString("\n")
+                      .trim()
+              gsonConverter.fromJson(content, ModelAutolinkingConfigJson::class.java)
+            }
             .getOrNull()
       }
 }

package/shared/src/test/kotlin/com/facebook/react/utils/JsonUtilsTest.kt

@@ -185,6 +185,54 @@ class JsonUtilsTest {
     assertEquals("implementation", parsed.project!!.android!!.dependencyConfiguration)
   }
 
+  @Test
+  fun fromAutolinkingConfigJson_withInfoLogs_sanitizeAndParseIt() {
+    @Suppress("JsonStandardCompliance")
+    val validJson =
+        createJsonFile(
+            """
+      
+      > AwesomeProject@0.0.1 npx
+      > rnc-cli config
+      
+       {
+        "reactNativeVersion": "1000.0.0",
+        "project": {
+          "ios": {
+            "sourceDir": "./packages/rn-tester",
+            "xcodeProject": {
+              "name": "RNTesterPods.xcworkspace",
+              "isWorkspace": true
+            },
+            "automaticPodsInstallation": false
+          },
+          "android": {
+            "sourceDir": "./packages/rn-tester",
+            "appName": "RN-Tester",
+            "packageName": "com.facebook.react.uiapp",
+            "applicationId": "com.facebook.react.uiapp",
+            "mainActivity": ".RNTesterActivity",
+            "watchModeCommandParams": [
+              "--mode HermesDebug"
+            ],
+            "dependencyConfiguration": "implementation"
+          }
+        }
+      } 
+      """
+                .trimIndent())
+    val parsed = JsonUtils.fromAutolinkingConfigJson(validJson)!!
+
+    assertThat("./packages/rn-tester").isEqualTo(parsed.project!!.android!!.sourceDir)
+    assertThat("RN-Tester").isEqualTo(parsed.project!!.android!!.appName)
+    assertThat("com.facebook.react.uiapp").isEqualTo(parsed.project!!.android!!.packageName)
+    assertThat("com.facebook.react.uiapp").isEqualTo(parsed.project!!.android!!.applicationId)
+    assertThat(".RNTesterActivity").isEqualTo(parsed.project!!.android!!.mainActivity)
+    assertThat("--mode HermesDebug")
+        .isEqualTo(parsed.project!!.android!!.watchModeCommandParams!![0])
+    assertThat("implementation").isEqualTo(parsed.project!!.android!!.dependencyConfiguration)
+  }
+
   @Test
   fun fromAutolinkingConfigJson_withDependenciesSpecified_canParseIt() {
     val validJson =

package/shared-testutil/build.gradle.kts

@@ -24,7 +24,8 @@ tasks.withType<KotlinCompile>().configureEach {
   kotlinOptions {
     apiVersion = "1.6"
     jvmTarget = "11"
-    allWarningsAsErrors = true
+    allWarningsAsErrors =
+        project.properties["enableWarningsAsErrors"]?.toString()?.toBoolean() ?: false
   }
 }