refactor: simplify Project and LspProject logic

Now client's requests are modelled as `CompletionRequest` which will not
include args or conftype. This simplifies the logic of `LspProject` and
the translation between the two.

Author: S-furi

completions/src/main/kotlin/completions/controllers/rest/CompletionsRestController.kt

@@ -1,6 +1,6 @@
 package completions.controllers.rest
 
-import completions.model.Project
+import completions.dto.api.CompletionRequest
 import completions.service.lsp.LspCompletionProvider
 import model.Completion
 import org.springframework.web.bind.annotation.PostMapping
@@ -16,8 +16,8 @@ class CompletionsRestController(
 ) {
     @PostMapping("/lsp")
     suspend fun complete(
-        @RequestBody project: Project,
+        @RequestBody completionRequest: CompletionRequest,
         @RequestParam line: Int,
         @RequestParam ch: Int,
-    ): List<Completion> = lspCompletionProvider.complete(project, line, ch)
+    ): List<Completion> = lspCompletionProvider.complete(completionRequest, line, ch)
 }

completions/src/main/kotlin/completions/controllers/ws/LspCompletionWebSocketHandler.kt

@@ -2,9 +2,9 @@
 
 package completions.controllers.ws
 
-import completions.model.Project
 import com.fasterxml.jackson.databind.ObjectMapper
 import com.fasterxml.jackson.module.kotlin.readValue
+import completions.dto.api.CompletionRequest
 import completions.lsp.KotlinLspProxy
 import completions.lsp.StatefulKotlinLspProxy.onClientConnected
 import completions.lsp.StatefulKotlinLspProxy.onClientDisconnected
@@ -28,7 +28,7 @@ import reactor.core.scheduler.Schedulers
  * - **Connection**: Server sends `Init{ sessionId }` immediately after the WebSocket is established. The client could persist
  *   this identifier for the lifetime of the connection and treat it as the LSP client id.
  *
- * - **Requests**: Client sends `CompletionRequest{ requestId, project, line, ch }` for each caret position to be completed.
+ * - **Requests**: Client sends `CompletionRequest{ requestId, completionRequest, line, ch }` for each caret position to be completed.
  *   `requestId` must be unique per client session and is used exclusively for correlation.
  *
  * - **Responses**: For a successfully processed request: `Completions{ completions, requestId }` where `completions` are
@@ -105,7 +105,7 @@ class LspCompletionWebSocketHandler(
                     lspProxy.requireAvailable()
                     lspCompletionProvider.complete(
                         clientId = sessionId,
-                        project = request.project,
+                        request = request.completionRequest,
                         line = request.line,
                         ch = request.ch,
                         applyFuzzyRanking = true,
@@ -150,7 +150,7 @@ sealed interface Response {
 
 private data class WebSocketCompletionRequest(
     val requestId: String,
-    val project: Project,
+    val completionRequest: CompletionRequest,
     val line: Int,
     val ch: Int,
 )

completions/src/main/kotlin/completions/dto/api/CompletionRequest.kt

@@ -0,0 +1,11 @@
+package completions.dto.api
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties
+
+@JsonIgnoreProperties(ignoreUnknown = true)
+data class CompletionRequest(
+    val files: List<ProjectFile> = emptyList(),
+)
+
+@JsonIgnoreProperties(ignoreUnknown = true)
+data class ProjectFile(val text: String = "", val name: String = "")

completions/src/main/kotlin/completions/lsp/KotlinLspProxy.kt

@@ -1,11 +1,11 @@
 package completions.lsp
 
+import completions.dto.api.CompletionRequest
+import completions.dto.api.ProjectFile
 import completions.exceptions.LspUnavailableException
 import completions.lsp.client.LspClient
 import completions.lsp.client.ReconnectingLspClient
 import completions.lsp.components.LspProject
-import completions.model.Project
-import completions.model.ProjectFile
 import kotlinx.coroutines.CompletableDeferred
 import kotlinx.coroutines.CoroutineName
 import kotlinx.coroutines.CoroutineScope
@@ -21,14 +21,15 @@ import java.io.IOException
 import java.net.URI
 import java.nio.file.Path
 import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.CopyOnWriteArrayList
 import java.util.concurrent.atomic.AtomicBoolean
 import kotlin.time.Duration.Companion.seconds
 
 @Component
 class KotlinLspProxy {
 
     internal lateinit var lspClient: LspClient
-    internal val lspProjects = ConcurrentHashMap<Project, LspProject>()
+    internal val lspProjects = CopyOnWriteArrayList<LspProject>()
 
     private val available = AtomicBoolean(false)
     private val isInitializing = AtomicBoolean(false)
@@ -51,24 +52,24 @@ class KotlinLspProxy {
      * This modality is aimed for **stateless** scenarios where we don't care about
      * the identity of the client and the project.
      *
-     * @param project the project containing the file
+     * @param request the completion request
      * @param line the line number
      * @param ch the character position
      * @param projectFile the file to be used for completion, defaults to the first file in the project
      * @return a list of [CompletionItem]s
      */
     suspend fun getOneTimeCompletions(
-        project: Project,
+        request: CompletionRequest,
         line: Int,
         ch: Int,
-        projectFile: ProjectFile = project.files.first(),
+        projectFile: ProjectFile = request.files.first(),
     ): List<CompletionItem> {
         ensureLspClientReady() ?: return emptyList()
-        val lspProject = lspProjects.getOrPut(project) { createNewProject(project) }
+        val lspProject = createNewProject(request).also(lspProjects::add)
         val uri = lspProject.getDocumentUri(projectFile.name) ?: return emptyList()
         lspClient.openDocument(uri, projectFile.text, 1)
         return getCompletions(lspProject, line, ch, projectFile.name)
-            .also { closeProject(project) }
+            .also { closeProject(lspProject) }
     }
 
     /**
@@ -149,17 +150,16 @@ class KotlinLspProxy {
             else logger.debug("Lsp client not ready: ${it.message}")
         }.isSuccess.takeIf { it }
 
-    private fun createNewProject(project: Project): LspProject = LspProject.fromProject(project)
+    private fun createNewProject(project: CompletionRequest): LspProject = LspProject.fromCompletionRequest(project)
 
-    internal fun closeProject(project: Project) {
-        val lspProject = lspProjects[project] ?: return
+    internal fun closeProject(lspProject: LspProject) {
         lspProject.getDocumentsUris().forEach { uri -> lspClient.closeDocument(uri) }
         lspProject.tearDown()
-        lspProjects.remove(project)
+        lspProjects.remove(lspProject)
     }
 
     fun closeAllProjects() {
-        lspProjects.keys.forEach { closeProject(it) }
+        lspProjects.forEach { closeProject(it) }
         lspProjects.clear()
     }
 
@@ -184,10 +184,10 @@ class KotlinLspProxy {
                 isInitializing.set(false)
             }
             lspClient.addOnReconnectListener {
-                lspProjects.forEach { (project, lspProject) ->
+                lspProjects.forEach { project ->
                     val file = project.files.first()
-                    val uri = lspProject.getDocumentUri(file.name) ?: return@forEach
-                    lspProject.resetDocumentVersion(file.name)
+                    val uri = project.getDocumentUri(file.name) ?: return@forEach
+                    project.resetDocumentVersion(file.name)
                     client.openDocument(uri, file.text, 1)
                 }
                 lspClientInitializedDeferred.complete(Unit)
@@ -242,7 +242,7 @@ class KotlinLspProxy {
  * Custom WS messages could be designed to handle this.
  */
 object StatefulKotlinLspProxy {
-    private val clientsProjects = ConcurrentHashMap<String, Project>()
+    private val clientsProjects = ConcurrentHashMap<String, LspProject>()
 
     /**
      * Retrieve completions for a given line and character position in a project file.
@@ -254,21 +254,22 @@ object StatefulKotlinLspProxy {
      * the document**.
      *
      * @param clientId the user identifier (or session identifier)
-     * @param newProject the project containing the file
+     * @param completionRequest the request containing the files
      * @param line the line number
      * @param ch the character position
      * @return a list of [CompletionItem]s
      */
     suspend fun KotlinLspProxy.getCompletionsForClient(
         clientId: String,
-        newProject: Project,
+        completionRequest: CompletionRequest,
         line: Int,
         ch: Int,
-        projectFile: ProjectFile = newProject.files.first(),
+        projectFile: ProjectFile = completionRequest.files.first(),
     ): List<CompletionItem> {
-        val project =
-            clientsProjects[clientId]?.let { ensureDocumentPresent(it, projectFile, clientId) } ?: return emptyList()
-        val lspProject = lspProjects[project] ?: return emptyList()
+        val lspProject = clientsProjects[clientId]?.let {
+            ensureDocumentPresent(it, projectFile, clientId)
+        } ?: return emptyList()
+
         val newContent = projectFile.text
         val documentToChange = projectFile.name
         changeDocumentContent(lspProject, documentToChange, newContent)
@@ -282,9 +283,10 @@ object StatefulKotlinLspProxy {
      * @param clientId the unique identifier for the client that has connected
      */
     fun KotlinLspProxy.onClientConnected(clientId: String) {
-        val project = Project()
-            .also { clientsProjects[clientId] = it }
-        val lspProject = LspProject.fromProject(project, ownerId = clientId).also { lspProjects[project] = it }
+        val lspProject = LspProject.empty(clientId).also {
+            lspProjects.add(it)
+            clientsProjects[clientId] = it
+        }
         lspProject.getDocumentsUris().forEach { uri -> lspClient.openDocument(uri, "", 1) }
     }
 
@@ -298,6 +300,7 @@ object StatefulKotlinLspProxy {
         clientsProjects[clientId]?.let {
             closeProject(it)
             clientsProjects.remove(clientId)
+            lspProjects.remove(it)
         }
     }
 
@@ -309,17 +312,21 @@ object StatefulKotlinLspProxy {
      * @param projectFile the file to be opened if not present in the project
      * @return the modified project, with the file added if necessary
      */
-    private fun KotlinLspProxy.ensureDocumentPresent(project: Project, projectFile: ProjectFile, clientId: String): Project {
-        if (project.files.contains(projectFile)) return project
+    private fun KotlinLspProxy.ensureDocumentPresent(
+        project: LspProject,
+        projectFile: ProjectFile,
+        clientId: String
+    ): LspProject {
+        if (project.containsFile(projectFile)) return project
         lspProjects.remove(project)
-        val newProject = project.copy(files = project.files + projectFile)
-        val newLspProject = LspProject.fromProject(newProject, ownerId = clientId)
-        lspProjects[newProject] = newLspProject
-        clientsProjects[clientId] = newProject
+        val newLspProject = project.copy(files = project.files + projectFile).also {
+                lspProjects.add(it)
+                clientsProjects[clientId] = it
+            }
         newLspProject.getDocumentUri(projectFile.name)?.let { uri ->
             lspClient.openDocument(uri, projectFile.text, 1)
         }
-        return newProject
+        return newLspProject
     }
 
     private fun KotlinLspProxy.changeDocumentContent(

completions/src/main/kotlin/completions/lsp/components/LspProject.kt

@@ -1,8 +1,8 @@
 package completions.lsp.components
 
+import completions.dto.api.CompletionRequest
+import completions.dto.api.ProjectFile
 import completions.lsp.KotlinLspProxy
-import completions.model.Project
-import completions.model.ProjectType
 import java.nio.file.Path
 import java.util.UUID
 import java.util.concurrent.ConcurrentHashMap
@@ -13,15 +13,11 @@ import java.util.concurrent.atomic.AtomicInteger
  * and the project's filesystem structure. It facilitates tasks such as creating a project workspace,
  * managing documents within that workspace, and tearing down the workspace when it's no longer needed.
  *
- * @property confType The configuration type of the project, defaulting to `ProjectType.JAVA`.
- * @property files A list of [LspDocument] objects representing project files.
+ * @property files A list of [ProjectFile] objects representing project files.
  */
-class LspProject(
-    confType: ProjectType = ProjectType.JAVA,
-    files: List<LspDocument> = emptyList(),
-    ownerId: String? = null,
-) {
-    private val projectRoot: Path = baseDir.resolve("$confType-${ownerId ?: UUID.randomUUID().toString()}")
+data class LspProject(val files: List<ProjectFile> = emptyList(), val ownerId: String? = null) {
+
+    private val projectRoot: Path = baseDir.resolve("${ownerId?.let { "user-$it" } ?: UUID.randomUUID()}")
     private val documentsToPaths: MutableMap<String, Path> = mutableMapOf()
     private val documentsVersions = ConcurrentHashMap<String, AtomicInteger>()
 
@@ -40,6 +36,8 @@ class LspProject(
         documentsVersions[name]?.incrementAndGet()
     }
 
+    fun containsFile(file: ProjectFile): Boolean = files.any { it.name == file.name && it.text == file.text}
+
     /**
      * Returns the URI of a document in the project compliant with the [completions.lsp.client.LspClient].
      */
@@ -67,39 +65,26 @@ class LspProject(
         private val baseDir = Path.of(KotlinLspProxy.lspLocalWorkspaceRoot()).toAbsolutePath()
 
         /**
-         * Creates a new instance of [LspProject] based on the provided [Project] data.
+         * Creates a new instance of [LspProject] based on the provided [CompletionRequest] data.
          * Please note that currently only JVM-related projects are supported.
          *
-         * @param project the source project containing configuration type and a list of files
+         * @param completionRequest the [CompletionRequest] data to use for project creation
          * @param ownerId optional identifier for the owner of the project
          * @return a new [LspProject] instance with the provided project's configuration type and files
          */
-        fun fromProject(project: Project, ownerId: String? = null): LspProject {
+        fun fromCompletionRequest(completionRequest: CompletionRequest, ownerId: String? = null): LspProject {
             return LspProject(
-                confType = ensureSupportedConfType(project.confType),
-                files = project.files.map { LspDocument(it.text, it.name) },
+                files = completionRequest.files.map { ProjectFile(it.text, it.name) },
                 ownerId = ownerId,
             )
         }
 
         /**
-         * If and when kotlin LSP support other project types, this function can be updated.
+         * Creates a new empty [LspProject] instance, with a single empty file.
          */
-        private fun ensureSupportedConfType(projectType: ProjectType): ProjectType {
-            require(projectType == ProjectType.JAVA) { "Only JVM related projects are supported" }
-            return projectType
-        }
+        fun empty(ownerId: String? = null): LspProject = LspProject(
+            files = listOf(ProjectFile("", "File.kt")),
+            ownerId = ownerId
+        )
     }
-}
-
-data class LspDocument(
-    val text: String = "",
-    val name: String = "File.kt",
-    val publicId: String? = null,
-)
-
-@Suppress("unused")
-enum class LspProjectType(val id: String) {
-    JAVA("java"),
-    // add here support for JS, WASM, ...
 }