Add fastNpmInstall which output only tracks lock-files

Author: deepy

src/main/kotlin/com/github/gradle/node/NodeExtension.kt

@@ -108,6 +108,31 @@ open class NodeExtension(project: Project) {
      */
     val nodeProxySettings = project.objects.property<ProxySettings>().convention(ProxySettings.SMART)
 
+    /**
+     * Use fast NpmInstall logic, excluding node_modules for output tracking resulting in a significantly faster
+     * npm install/ci configuration at the cost of slightly decreased correctness in certain circumstances.
+     *
+     * In practice this means that if you change node_modules through other means than npm install/ci
+     * NpmInstall tasks will continue being up-to-date, but if you're modifying node_modules through
+     * other tools you may have other correctness problems and surfacing them here may be preferred.
+     *
+     * https://docs.npmjs.com/cli/v8/configuring-npm/package-lock-json#hidden-lockfiles
+     *
+     * Requires npm 7 or later
+     * This will become the default in 4.x
+     */
+    val fastNpmInstall = project.objects.property<Boolean>().convention(false)
+
+    /**
+     * Disable functionality that requires newer versions of npm
+     *
+     * If you're not downloading Node.js and using old version of Node or npm
+     * set this to true to disable functionality that makes use of newer functionality.
+     *
+     * This will be removed in 4.x
+     */
+    val oldNpm = project.objects.property<Boolean>().convention(false)
+
     @Suppress("unused")
     @Deprecated("Deprecated in version 3.0, please use nodeProjectDir now")
     val nodeModulesDir = nodeProjectDir

src/main/kotlin/com/github/gradle/node/npm/task/NpmInstallTask.kt

@@ -20,11 +20,15 @@ abstract class NpmInstallTask : NpmTask() {
     val nodeModulesOutputFilter =
             objects.property<Action<ConfigurableFileTree>>()
 
+    @get:Internal
+    val fastInstall = objects.property<Boolean>()
+
     init {
         group = NodePlugin.NPM_GROUP
         description = "Install node packages from package.json."
         dependsOn(NpmSetupTask.NAME)
         npmCommand.set(nodeExtension.npmInstallCommand.map { listOf(it) })
+        fastInstall.set(nodeExtension.fastNpmInstall)
     }
 
     @PathSensitive(RELATIVE)
@@ -75,23 +79,56 @@ abstract class NpmInstallTask : NpmTask() {
     @Suppress("unused")
     protected fun getNodeModulesDirectory(): Provider<Directory> {
         val filter = nodeModulesOutputFilter.orNull
-        return if (filter == null) nodeExtension.nodeProjectDir.dir("node_modules")
+        return if (filter == null && !fastInstall.get()) nodeExtension.nodeProjectDir.dir("node_modules")
         else providers.provider { null }
     }
 
     @Optional
     @OutputFiles
     @Suppress("unused")
     protected fun getNodeModulesFiles(): Provider<FileTree> {
-        val nodeModulesDirectoryProvider = nodeExtension.nodeProjectDir.dir("node_modules")
-        return zip(nodeModulesDirectoryProvider, nodeModulesOutputFilter)
-                .flatMap { (nodeModulesDirectory, nodeModulesOutputFilter) ->
-                    if (nodeModulesOutputFilter != null) {
-                        val fileTree = projectHelper.fileTree(nodeModulesDirectory)
-                        nodeModulesOutputFilter.execute(fileTree)
-                        providers.provider { fileTree }
-                    } else providers.provider { null }
-                }
+        return if (fastInstall.get()) {
+            providers.provider { null }
+        } else {
+            val nodeModulesDirectoryProvider = nodeExtension.nodeProjectDir.dir("node_modules")
+            zip(nodeModulesDirectoryProvider, nodeModulesOutputFilter)
+                    .flatMap { (nodeModulesDirectory, nodeModulesOutputFilter) ->
+                        if (nodeModulesOutputFilter != null) {
+                            val fileTree = projectHelper.fileTree(nodeModulesDirectory)
+                            nodeModulesOutputFilter.execute(fileTree)
+                            providers.provider { fileTree }
+                        } else providers.provider { null }
+                    }
+        }
+    }
+
+    @Optional
+    @OutputFile
+    protected fun getNodeModulesPackageLock(): Provider<File> {
+        if (isLegacyNpm()) {
+            return providers.provider { null }
+        }
+
+        return projectFileIfExists("node_modules/.package-lock.json")
+    }
+
+    /**
+     * Is our npm likely to be lower than 7?
+     */
+    private fun isLegacyNpm(): Boolean {
+        if (nodeExtension.oldNpm.get()) {
+            return true
+        }
+
+        val npmVersion = nodeExtension.npmVersion.get()
+        if (npmVersion.isBlank()) {
+            if (nodeExtension.version.get().split('.').first().toInt() <= 14)
+                return true
+        } else if (npmVersion.split('.').first().toInt() < 7 ) {
+            return true
+        }
+
+        return false
     }
 
     // For DSL

src/test/groovy/com/github/gradle/node/npm/task/NpmInstall_integTest.groovy

@@ -49,6 +49,51 @@ class NpmInstall_integTest extends AbstractIntegTest {
         gv << GRADLE_VERSIONS_UNDER_TEST
     }
 
+    def 'install packages with fast npm install (#gv.version)'() {
+        given:
+        gradleVersion = gv
+
+        writeBuild('''
+            plugins {
+                id 'com.github.node-gradle.node'
+            }
+            
+            node {
+                fastNpmInstall = true
+            }
+        ''')
+        writePackageJson '''
+{
+  "name": "fastinstall",
+  "dependencies": {
+    "@isaacs/string-locale-compare": "1.1.0"
+  }
+}
+'''
+
+        when:
+        def result = build('npmInstall')
+
+        then:
+        result.task(":npmInstall").outcome == TaskOutcome.SUCCESS
+
+        when:
+        result = build('npmInstall')
+
+        then:
+        // because of package-lock.json that was generated during the previous npm install execution
+        result.task(":npmInstall").outcome == TaskOutcome.SUCCESS
+
+        when:
+        result = build('npmInstall')
+
+        then:
+        result.task(":npmInstall").outcome == TaskOutcome.UP_TO_DATE
+
+        where:
+        gv << GRADLE_VERSIONS_UNDER_TEST
+    }
+
     def 'install packages with npm >= 7 (#gv.version)'() {
         given:
         gradleVersion = gv