feat: in-browser graphical interface using GraphQL APIs

alchemist-graphql/build.gradle.kts

@@ -11,15 +11,12 @@ import Libs.alchemist
 import Libs.incarnation
 import com.apollographql.apollo3.gradle.internal.ApolloGenerateSourcesTask
 import com.expediagroup.graphql.plugin.gradle.tasks.AbstractGenerateClientTask
-import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
 import io.gitlab.arturbosch.detekt.Detekt
 import java.io.File.separator
 
 plugins {
-    application
     alias(libs.plugins.kotest.multiplatform)
     alias(libs.plugins.kotlin.serialization)
-    alias(libs.plugins.ktor)
     alias(libs.plugins.graphql.server)
     alias(libs.plugins.graphql.client)
 }
@@ -70,10 +67,6 @@ kotlin {
     }
 }
 
-application {
-    mainClass.set("it.unibo.alchemist.Alchemist")
-}
-
 graphql {
     schema {
         packages = listOf(
@@ -127,30 +120,18 @@ tasks.withType<ApolloGenerateSourcesTask>().configureEach {
  */
 val webpackTask = tasks.named("jsBrowserProductionWebpack")
 
-tasks.named("run", JavaExec::class).configure {
-    classpath(
-        tasks.named("compileKotlinJvm"),
-        configurations.named("jvmRuntimeClasspath"),
-        webpackTask.map { task ->
-            task.outputs.files.map { file ->
-                file.parent
-            }
-        },
-    )
-}
-
 /**
- * Configure the [ShadowJar] task to work exactly like the "jvmJar" task of Kotlin Multiplatform, but also
+ * Configure the shadowJar task to work exactly like the "jvmJar" task of Kotlin Multiplatform, but also
  * include the JS artifacts by depending on the "jsBrowserProductionWebpack" task.
  */
-tasks.withType<ShadowJar>().configureEach {
-    val jvmJarTask = tasks.named("jvmJar")
-    from(webpackTask)
-    from(jvmJarTask)
-    from(tasks.named("jsBrowserDistribution"))
-    mustRunAfter(tasks.distTar, tasks.distZip)
-    archiveClassifier.set("all")
-}
+// tasks.withType<ShadowJar>().configureEach {
+//    val jvmJarTask = tasks.named("jvmJar")
+//    from(webpackTask)
+//    from(jvmJarTask)
+//    from(tasks.named("jsBrowserDistribution"))
+//    mustRunAfter(tasks.distTar, tasks.distZip)
+//    archiveClassifier.set("all")
+// }
 
 fun PatternFilterable.excludeGenerated() = exclude { "build${separator}generated" in it.file.absolutePath }
 tasks.withType<Detekt>().configureEach { excludeGenerated() }

alchemist-graphql/src/commonMain/resources/graphql/EnvironmentQuery.graphql

@@ -0,0 +1,12 @@
+query EnvironmentQuery {
+    environment{
+        nodeToPos{
+            entries{
+                id
+                position{
+                    coordinates
+                }
+            }
+        }
+    }
+}

alchemist-graphql/src/commonMain/resources/graphql/EnvironmentSub.graphql

@@ -0,0 +1,12 @@
+subscription Environment {
+    environment{
+        nodeToPos{
+            entries{
+                id
+                position{
+                    coordinates
+                }
+            }
+        }
+    }
+}

alchemist-graphql/src/commonMain/resources/graphql/NodeQuery.graphql

@@ -0,0 +1,30 @@
+query Node($id: Int! = 0){
+
+    environment{
+        nodeById(id: $id){
+            id
+            moleculeCount
+            contents{
+                size
+                entries{
+                    molecule{
+                        name
+                    }
+                    concentration
+                }
+            }
+            properties
+            reactions{
+                inputContext
+                outputContext
+                node{
+                    id
+                }
+            }
+        }
+    }
+
+    nodePosition(nodeId: $id) {
+        coordinates
+    }
+}

alchemist-graphql/src/jvmMain/kotlin/it/unibo/alchemist/boundary/launchers/GraphQLServer.kt

@@ -11,7 +11,6 @@ package it.unibo.alchemist.boundary.launchers
 
 import io.ktor.server.engine.ApplicationEngine
 import io.ktor.server.engine.embeddedServer
-import io.ktor.server.engine.stop
 import io.ktor.server.netty.Netty
 import it.unibo.alchemist.boundary.OutputMonitor
 import it.unibo.alchemist.boundary.graphql.monitor.EnvironmentSubscriptionMonitor
@@ -25,15 +24,14 @@ import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.runBlocking
-import kotlinx.coroutines.sync.Semaphore
 
 /**
  * An [OutputMonitor] observing the [environment] through a GraphQL server listening on [host]:[port].
  * The server is started in a new coroutine on the [serverDispatcher] dispatcher.
  * By default, the server is stopped after the simulation terminates.
  * This behavior can be changed by setting [teardownOnSimulationTermination] to false.
  */
-class GraphQLServer<T, P : Position<out P>> @JvmOverloads constructor(
+open class GraphQLServer<T, P : Position<out P>> @JvmOverloads constructor(
     val environment: Environment<T, P>,
     val host: String = DefaultGraphQLSettings.DEFAULT_HOST,
     val port: Int = DefaultGraphQLSettings.DEFAULT_PORT,

alchemist-web-renderer/build.gradle.kts

@@ -11,7 +11,6 @@ import Libs.alchemist
 import Libs.incarnation
 
 plugins {
-    application
     alias(libs.plugins.kotlin.serialization)
     alias(libs.plugins.kotest.multiplatform)
 }
@@ -23,6 +22,11 @@ kotlin {
     js(IR) {
         browser {
             binaries.executable()
+            testTask {
+                useKarma {
+                    useChromeHeadless()
+                }
+            }
         }
     }
     sourceSets {
@@ -86,27 +90,11 @@ kotlin {
     }
 }
 
-application {
-    mainClass.set("it.unibo.alchemist.Alchemist")
-}
-
 /**
  * Webpack task that generates the JS artifacts.
  */
 val webpackTask = tasks.named("jsBrowserProductionWebpack")
 
-tasks.named("run", JavaExec::class).configure {
-    classpath(
-        tasks.named("compileKotlinJvm"),
-        configurations.named("jvmRuntimeClasspath"),
-        webpackTask.map { task ->
-            task.outputs.files.map { file ->
-                file.parent
-            }
-        },
-    )
-}
-
 /*
  * Configure the shadowJar task to work exactly like the "jvmJar" task of Kotlin Multiplatform, but also
  * include the JS artifacts by depending on the "jsBrowserProductionWebpack" task.