Invoke the Apollo compiler directly, when possible (#62)

* Do not use Gradle continuous mode

* Retrieve configuration via a task rather than via tooling models, and use the Apollo Compiler

* Rename GradleToolingModelService -> ApolloKotlinProjectModelService

* Adapt to renames in the Gradle plugin

* Retrieve Telemetry data from project / service models

* Move ProjectModel, ServiceModel to :apollo-tooling

* Use plugin dependencies

* Add operationManifestFile

* Renames/moves

* Use EntryPoints APIs

* Less verbose log

* Generate data builders

* Cache IDEs

* Use published version of Apollo Kotlin

* Prepare for v5 releace

* Add a note about supported AK versions

* Revert intellij-platform-plugin to 2.8.0

* Changelog tweak

Author: BoD

CHANGELOG.md

@@ -3,4 +3,27 @@
 PUT_CHANGELOG_HERE
 
 # Version 5.0.0
-_2025-07-01_
+
+_2025-09-01_
+
+> [!NOTE]
+> Starting with this release, the plugin no longer depends on the [JetBrains GraphQL plugin](https://plugins.jetbrains.com/plugin/8097-graphql).
+> Instead, it includes a fork of that plugin's code which has been adapted to work better with Apollo Kotlin (#43).
+>
+> If you are upgrading the plugin from 4.x, the IDE will ask you to disable or uninstall the JetBrains GraphQL plugin,
+> as both plugins cannot be used at the same time.
+
+- Overhaul of the code generation mechanism (#62).<br>
+  Code generation is now using the Apollo Compiler directly, instead of
+  invoking the Gradle codegen task, when possible (projects using Apollo Kotlin v5+). This results in faster code generation
+  and lower memory consumption. For projects using Apollo Kotlin < v5, the Gradle task is still invoked, but no longer with
+  the`--continuous` flag, which avoids running a dedicated Gradle daemon (#36).
+- Better `@link` support (#55)
+- Add received date to the cache viewer (#56)
+- Support descriptions on executable definitions (#53)
+- Make the graphql folder stand out (#54)
+- Various crash and bug fixes
+
+#### Compatibility
+
+This version supports projects using Apollo Kotlin v3.x, v4.x and v5.x.

LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2016-present Apollo Graph, Inc. (Formerly Meteor Development Group, Inc.)
+Copyright (c) 2015-present, Jim Kynde Meyer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -10,7 +10,6 @@ This plugin for Android Studio and IntelliJ helps you work with the
 
 ## Features
 - Automatic code generation: models are re-generated whenever GraphQL files change
-- Integration with the [GraphQL IntelliJ Plugin](https://plugins.jetbrains.com/plugin/8097-js-graphql): the structure of the Apollo project is automatically contributed, so there is no need to create a `graphql.config.yml` / `.graphqlconfig` file
 - Navigation Kotlin code ⇄ GraphQL definitions
 - Unused operations and fields highlighting
 - Normalized cache viewer
@@ -52,3 +51,7 @@ Repositories</kbd> > <kbd>+</kbd> > <kbd>https://go.apollo.dev/ij-plugin-snapsho
 <img src="assets/instructions-2-add-repository.png" width="600" />
 
 Then search for "Apollo GraphQL" and install the plugin as usual.
+
+## Acknowledgements
+
+This plugin incorporates code from the [JetBrains GraphQL plugin](https://github.com/JetBrains/js-graphql-intellij-plugin).

gradle.properties

@@ -1,4 +1,4 @@
-VERSION_NAME=4.3.2-SNAPSHOT
+VERSION_NAME=5.0.0-SNAPSHOT
 
 org.gradle.jvmargs=-Xmx8g
 
@@ -11,3 +11,5 @@ org.gradle.parallel=true
 # suppress inspection "UnusedProperty"
 kotlin.stdlib.default.dependency=false
 
+# See https://platform.jetbrains.com/t/new-intellijplatformresolver-helper-to-control-the-intellij-platform-gradle-plugin-dependency-extraction/2024/4
+org.jetbrains.intellij.platform.intellijPlatformIdesCache=~/.intellijPlatform/ides/

gradle/libs.versions.toml

@@ -1,7 +1,7 @@
 [versions]
 kotlin-plugin = "2.1.21"
-intellij-platform-plugin = "2.7.0"
-apollo = "4.3.1"
+intellij-platform-plugin = "2.8.0"
+apollo = "5.0.0-alpha.2"
 grammarkit-plugin = "2022.3.2.2"
 changelog-plugin = "2.2.1"
 sqlite-jdbc = "3.43.2.0"
@@ -32,9 +32,10 @@ changelog = { id = "org.jetbrains.changelog", version.ref = "changelog-plugin" }
 apollo-annotations = { group = "com.apollographql.apollo", name = "apollo-annotations", version.ref = "apollo" }
 apollo-api = { group = "com.apollographql.apollo", name = "apollo-api", version.ref = "apollo" }
 apollo-runtime = { group = "com.apollographql.apollo", name = "apollo-runtime", version.ref = "apollo" }
-apollo-gradle-plugin-external = { group = "com.apollographql.apollo", name = "apollo-gradle-plugin-external", version.ref = "apollo" }
+apollo-gradle-plugin = { group = "com.apollographql.apollo", name = "apollo-gradle-plugin", version.ref = "apollo" }
 apollo-ast = { group = "com.apollographql.apollo", name = "apollo-ast", version.ref = "apollo" }
 apollo-tooling = { group = "com.apollographql.apollo", name = "apollo-tooling", version.ref = "apollo" }
+apollo-compiler = { group = "com.apollographql.apollo", name = "apollo-compiler", version.ref = "apollo" }
 apollo-normalized-cache-sqlite-classic = { group = "com.apollographql.apollo", name = "apollo-normalized-cache-sqlite", version.ref = "apollo" }
 apollo-normalized-cache-sqlite-new = { group = "com.apollographql.cache", name = "normalized-cache-sqlite", version.ref = "apollo-normalizedcache" }
 sqlite-jdbc = { group = "org.xerial", name = "sqlite-jdbc", version.ref = "sqlite-jdbc" }

jsgraphql/build.gradle.kts

@@ -41,7 +41,9 @@ tasks {
 
 dependencies {
   intellijPlatform {
-    intellijIdeaUltimate(libs.versions.intellij.platform.version.get())
+    intellijIdeaUltimate(libs.versions.intellij.platform.version.get()) {
+      useCache = true
+    }
     bundledPlugins(
         listOf(
             "org.jetbrains.kotlin",

plugin/build.gradle.kts

@@ -20,10 +20,10 @@ plugins {
 }
 
 repositories {
-//    mavenLocal()
 //    maven("https://s01.oss.sonatype.org/content/repositories/snapshots/")
 //    maven("https://storage.googleapis.com/apollo-previews/m2/")
   mavenCentral()
+//  mavenLocal()
 
   intellijPlatform {
     defaultRepositories()
@@ -143,7 +143,9 @@ dependencies {
   // IntelliJ Platform dependencies must be declared before the intellijPlatform block
   // See https://github.com/JetBrains/intellij-platform-gradle-plugin/issues/1784
   intellijPlatform {
-    intellijIdeaUltimate(libs.versions.intellij.platform.version.get())
+    intellijIdeaUltimate(libs.versions.intellij.platform.version.get()) {
+      useCache = true
+    }
 
     // Plugin dependencies
     // See https://plugins.jetbrains.com/docs/intellij/plugin-dependencies.html
@@ -178,7 +180,7 @@ dependencies {
 
   // Coroutines must be excluded to avoid a conflict with the version bundled with the IDE
   // See https://plugins.jetbrains.com/docs/intellij/using-kotlin.html#coroutinesLibraries
-  implementation(libs.apollo.gradle.plugin.external) {
+  implementation(libs.apollo.gradle.plugin) {
     exclude(group = "org.jetbrains.kotlinx", module = "kotlinx-coroutines-core")
   }
   implementation(libs.apollo.ast)
@@ -193,7 +195,10 @@ dependencies {
   implementation(libs.apollo.runtime) {
     exclude(group = "org.jetbrains.kotlinx", module = "kotlinx-coroutines-core")
   }
+  implementation(libs.apollo.compiler)
+
   runtimeOnly(libs.slf4j.simple)
+
   testImplementation(libs.google.testparameterinjector)
 
   // Temporary workaround for https://github.com/JetBrains/intellij-platform-gradle-plugin/issues/1663
@@ -230,7 +235,7 @@ intellijPlatform {
         if (isSnapshotBuild()) {
           "Weekly snapshot builds contain the latest changes from the <code>main</code> branch."
         } else {
-          "See the <a href=\"https://github.com/apollographql/apollo-kotlin/releases/tag/v${project.version}\">release notes</a>."
+          "See the <a href=\"https://github.com/apollographql/apollo-intellij-plugin/releases/tag/v${project.version}\">release notes</a>."
         }
     )
   }

plugin/src/main/kotlin/com/apollographql/ijplugin/codegen/ApolloCodegenService.kt

@@ -3,6 +3,7 @@ package com.apollographql.ijplugin.codegen
 import com.apollographql.ijplugin.gradle.CODEGEN_GRADLE_TASK_NAME
 import com.apollographql.ijplugin.gradle.GradleHasSyncedListener
 import com.apollographql.ijplugin.gradle.SimpleProgressListener
+import com.apollographql.ijplugin.gradle.apolloKotlinProjectModelService
 import com.apollographql.ijplugin.gradle.getGradleRootPath
 import com.apollographql.ijplugin.gradle.runGradleBuild
 import com.apollographql.ijplugin.project.ApolloProjectListener
@@ -12,13 +13,15 @@ import com.apollographql.ijplugin.settings.ProjectSettingsListener
 import com.apollographql.ijplugin.settings.ProjectSettingsState
 import com.apollographql.ijplugin.settings.projectSettingsState
 import com.apollographql.ijplugin.util.apolloGeneratedSourcesRoots
+import com.apollographql.ijplugin.util.apolloKotlinService
 import com.apollographql.ijplugin.util.dispose
 import com.apollographql.ijplugin.util.isNotDisposed
 import com.apollographql.ijplugin.util.logd
 import com.apollographql.ijplugin.util.logw
 import com.apollographql.ijplugin.util.newDisposable
 import com.apollographql.ijplugin.util.runWriteActionInEdt
 import com.intellij.lang.jsgraphql.GraphQLFileType
+import com.intellij.lang.jsgraphql.psi.GraphQLFile
 import com.intellij.openapi.Disposable
 import com.intellij.openapi.components.Service
 import com.intellij.openapi.editor.Document
@@ -33,6 +36,7 @@ import com.intellij.openapi.project.Project
 import com.intellij.openapi.roots.ProjectRootManager
 import com.intellij.openapi.util.CheckedDisposable
 import com.intellij.openapi.vfs.VfsUtil
+import com.intellij.psi.PsiDocumentManager
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.launch
 import org.gradle.tooling.CancellationTokenSource
@@ -83,20 +87,19 @@ class ApolloCodegenService(
 
   private fun startOrStopCodegenObservers() {
     if (shouldTriggerCodegenAutomatically()) {
-      // To make the codegen more reactive, any touched GraphQL document will automatically be saved (thus triggering Gradle)
+      // To make the codegen more reactive, any touched GraphQL document will automatically be saved (thus triggering the codegen)
       // as soon as the current editor is changed.
       startObserveDocumentChanges()
       startObserveFileEditorChanges()
 
-      startContinuousGradleCodegen()
+      startCodegen()
 
-      // Since we rely on Gradle's continuous build, which is not re-triggered when Gradle build files change, observe that
-      // ourselves and restart the build when it happens.
+      // A Gradle sync is a good indicator that Gradle files have changed - trigger a codegen build when that happens.
       startObserveGradleHasSynced()
     } else {
       stopObserveDocumentChanges()
       stopObserveFileEditorChanges()
-      stopContinuousGradleCodegen()
+      stopCodegen()
       stopObserveGradleHasSynced()
     }
   }
@@ -144,8 +147,11 @@ class ApolloCodegenService(
     fileEditorChangesDisposable = disposable
     project.messageBus.connect(disposable).subscribe(FileEditorManagerListener.FILE_EDITOR_MANAGER, object : FileEditorManagerListener {
       override fun selectionChanged(event: FileEditorManagerEvent) {
-        logd(event.newFile)
+        logd(event.newFile?.path)
         dirtyGqlDocument?.let {
+          val operationGraphQLFile = PsiDocumentManager.getInstance(project).getPsiFile(dirtyGqlDocument!!) as? GraphQLFile
+          val apolloKotlinService = operationGraphQLFile?.apolloKotlinService()
+          logd("apolloKotlinService=${apolloKotlinService?.id}")
           dirtyGqlDocument = null
           runWriteActionInEdt {
             try {
@@ -156,6 +162,14 @@ class ApolloCodegenService(
               logw(e, "Failed to save document")
             }
           }
+
+          if (apolloKotlinService?.hasCompilerOptions == true) {
+            // We can use the built-in Apollo compiler
+            ApolloCompilerHelper(project).generateSources(apolloKotlinService)
+          } else {
+            // Fall back to the Gradle codegen task
+            startGradleCodegen()
+          }
         }
       }
     })
@@ -167,7 +181,7 @@ class ApolloCodegenService(
     fileEditorChangesDisposable = null
   }
 
-  private fun startContinuousGradleCodegen() {
+  private fun startGradleCodegen() {
     logd()
 
     if (gradleCodegenCancellation != null) {
@@ -178,18 +192,17 @@ class ApolloCodegenService(
     val modules = ModuleManager.getInstance(project).modules
     coroutineScope.launch {
       gradleCodegenCancellation = GradleConnector.newCancellationTokenSource()
-      logd("Start Gradle")
+      logd("Start Gradle codegen build")
       try {
         val cancellationToken = gradleCodegenCancellation!!.token()
         val gradleProjectPath = project.getGradleRootPath()
         if (gradleProjectPath == null) {
           logw("Could not get Gradle root project path")
           return@launch
         }
-        runGradleBuild(project, gradleProjectPath) {
-          it.forTasks(CODEGEN_GRADLE_TASK_NAME)
+        runGradleBuild(project, gradleProjectPath) { buildLauncher ->
+          buildLauncher.forTasks(CODEGEN_GRADLE_TASK_NAME)
               .withCancellationToken(cancellationToken)
-              .addArguments("--continuous")
               .let {
                 if (project.projectSettingsState.automaticCodegenAdditionalGradleJvmArguments.isNotEmpty()) {
                   it.addJvmArguments(project.projectSettingsState.automaticCodegenAdditionalGradleJvmArguments.split(' '))
@@ -199,24 +212,24 @@ class ApolloCodegenService(
               }
               .addProgressListener(object : SimpleProgressListener() {
                 override fun onSuccess() {
-                  logd("Gradle build success, marking generated source roots as dirty")
+                  logd("Gradle codegen build success, marking generated source roots as dirty")
                   // Mark the generated sources dirty so the files are visible to the IDE
                   val generatedSourceRoots = modules.flatMap { it.apolloGeneratedSourcesRoots() }
                   logd("Mark dirty $generatedSourceRoots")
                   VfsUtil.markDirtyAndRefresh(true, true, true, *generatedSourceRoots.toTypedArray())
                 }
               })
         }
-        logd("Gradle execution finished")
+        logd("Gradle codegen build finished")
       } catch (t: Throwable) {
-        logd(t, "Gradle execution failed")
+        logd(t, "Gradle codegen build failed")
       } finally {
         gradleCodegenCancellation = null
       }
     }
   }
 
-  private fun stopContinuousGradleCodegen() {
+  private fun stopCodegen() {
     logd()
     gradleCodegenCancellation?.cancel()
     gradleCodegenCancellation = null
@@ -235,12 +248,22 @@ class ApolloCodegenService(
     project.messageBus.connect(disposable).subscribe(GradleHasSyncedListener.TOPIC, object : GradleHasSyncedListener {
       override fun gradleHasSynced() {
         logd()
-        stopContinuousGradleCodegen()
-        if (shouldTriggerCodegenAutomatically()) startContinuousGradleCodegen()
+        stopCodegen()
+        if (shouldTriggerCodegenAutomatically()) startCodegen()
       }
     })
   }
 
+  private fun startCodegen() {
+    if (project.apolloKotlinProjectModelService.getApolloKotlinServices().any { it.hasCompilerOptions }) {
+      logd("Using Apollo compiler for codegen")
+      ApolloCompilerHelper(project).generateAllSources()
+    } else {
+      logd("Using Gradle codegen task")
+      startGradleCodegen()
+    }
+  }
+
   private fun stopObserveGradleHasSynced() {
     logd()
     dispose(gradleHasSyncedDisposable)
@@ -249,6 +272,6 @@ class ApolloCodegenService(
 
   override fun dispose() {
     logd("project=${project.name}")
-    stopContinuousGradleCodegen()
+    stopCodegen()
   }
 }