fix(modelql): unresolvable node reference in ModelQL should result in a 404

Author: slisson

model-api/src/commonMain/kotlin/org/modelix/model/api/INodeReference.kt

@@ -73,3 +73,5 @@ class NodeReferenceKSerializer : KSerializer<INodeReference> {
         encoder.encodeString(value.serialize())
     }
 }
+
+class UnresolvableNodeReferenceException(val reference: INodeReference) : IllegalArgumentException("Node not found: $reference")

model-server-openapi/specifications/model-server-v2.yaml

@@ -322,6 +322,8 @@ paths:
       responses:
         "200":
           $ref: '#/components/responses/200json'
+        "404":
+          $ref: '#/components/responses/modelql-404'
         default:
           $ref: '#/components/responses/GeneralError'
   /repositories/{repository}/init:
@@ -427,6 +429,8 @@ paths:
       responses:
         "200":
           $ref: '#/components/responses/200json'
+        "404":
+          $ref: '#/components/responses/modelql-404'
         default:
           $ref: '#/components/responses/GeneralError'
 
@@ -499,6 +503,8 @@ components:
         application/problem+json:
           schema:
             $ref: 'problem.yaml#/Problem'
+    "modelql-404":
+      description: "A IProducingStep<INodeReference>.resolve() call failed to find the node."
     GeneralError:
       description: Unexpected error
       content:

modelql-client/src/commonMain/kotlin/org/modelix/modelql/client/ModelQLClient.kt

@@ -16,6 +16,7 @@ package org.modelix.modelql.client
 import io.ktor.client.HttpClient
 import io.ktor.client.request.post
 import io.ktor.client.request.setBody
+import io.ktor.client.statement.HttpResponse
 import io.ktor.client.statement.bodyAsText
 import io.ktor.http.HttpStatusCode
 import kotlinx.serialization.encodeToString
@@ -82,7 +83,7 @@ class ModelQLClient(val url: String, val client: HttpClient, includedSerializers
                 LOG.debug { "result: $text" }
                 return text
             }
-            else -> throw RuntimeException("Query failed : $query \nclient version: $MODELIX_VERSION\n${response.status}\n${response.bodyAsText()}")
+            else -> throw ModelQueryRequestException(query, response, response.bodyAsText())
         }
     }
 
@@ -93,3 +94,9 @@ class ModelQLClient(val url: String, val client: HttpClient, includedSerializers
 }
 
 expect fun <ResultT> ModelQLClient.blockingQuery(body: (IMonoStep<INode>) -> IMonoStep<ResultT>): ResultT
+
+class ModelQueryRequestException(
+    val query: UnboundQuery<INode, *, *>,
+    val httpResponse: HttpResponse,
+    val responseBody: String,
+) : RuntimeException("Query failed : $query \nclient version: $MODELIX_VERSION\n${httpResponse.status}\n$responseBody")

modelql-client/src/jvmTest/kotlin/org/modelix/modelql/client/ModelQLClientTest.kt

@@ -14,12 +14,15 @@
 package org.modelix.modelql.client
 
 import io.ktor.client.HttpClient
+import io.ktor.http.HttpStatusCode
 import io.ktor.server.routing.routing
 import io.ktor.server.testing.testApplication
 import kotlinx.coroutines.withTimeout
+import org.junit.jupiter.api.assertThrows
 import org.modelix.model.api.ConceptReference
 import org.modelix.model.api.IConceptReference
 import org.modelix.model.api.INode
+import org.modelix.model.api.NodeReference
 import org.modelix.model.api.PBranch
 import org.modelix.model.api.getRootNode
 import org.modelix.model.client.IdGenerator
@@ -53,6 +56,7 @@ import org.modelix.modelql.untyped.descendants
 import org.modelix.modelql.untyped.nodeReference
 import org.modelix.modelql.untyped.property
 import org.modelix.modelql.untyped.remove
+import org.modelix.modelql.untyped.resolve
 import org.modelix.modelql.untyped.setProperty
 import org.modelix.modelql.untyped.setReference
 import kotlin.test.Test
@@ -279,4 +283,15 @@ class ModelQLClientTest {
         }
         assertEquals(3, result)
     }
+
+    @Test
+    fun `resolving a non-existing node reference returns 404`() = runTest { httpClient ->
+        val client = ModelQLClient("http://localhost/query", httpClient)
+        val ex = assertThrows<ModelQueryRequestException> {
+            client.query<INode> {
+                NodeReference("doesnotexist").asMono().resolve()
+            }
+        }
+        assertEquals(HttpStatusCode.NotFound, ex.httpResponse.status)
+    }
 }

modelql-server/src/main/kotlin/org/modelix/modelql/server/ModelQLServer.kt

@@ -24,6 +24,7 @@ import io.ktor.server.routing.post
 import kotlinx.coroutines.runBlocking
 import kotlinx.serialization.KSerializer
 import org.modelix.model.api.INode
+import org.modelix.model.api.UnresolvableNodeReferenceException
 import org.modelix.model.area.IArea
 import org.modelix.modelql.core.IMonoUnboundQuery
 import org.modelix.modelql.core.IStepOutput
@@ -113,6 +114,12 @@ class ModelQLServer private constructor(val rootNodeProvider: () -> INode?, val
                 val serializedResult = json.encodeToString(VersionAndData.serializer(serializer), versionAndResult)
                 afterQueryExecution()
                 call.respondText(text = serializedResult, contentType = ContentType.Application.Json)
+            } catch (ex: UnresolvableNodeReferenceException) {
+                afterQueryExecution()
+                call.respondText(
+                    text = "server version: $MODELIX_VERSION\n" + ex.stackTraceToString(),
+                    status = HttpStatusCode.NotFound,
+                )
             } catch (ex: Throwable) {
                 afterQueryExecution()
                 call.respondText(

modelql-untyped/src/commonMain/kotlin/org/modelix/modelql/untyped/ResolveNodeStep.kt

@@ -19,6 +19,7 @@ import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
 import org.modelix.model.api.INode
 import org.modelix.model.api.INodeReference
+import org.modelix.model.api.UnresolvableNodeReferenceException
 import org.modelix.model.api.resolveInCurrentContext
 import org.modelix.modelql.core.IFlowInstantiationContext
 import org.modelix.modelql.core.IFluxStep
@@ -34,12 +35,11 @@ import org.modelix.modelql.core.StepDescriptor
 import org.modelix.modelql.core.StepFlow
 import org.modelix.modelql.core.asStepFlow
 import org.modelix.modelql.core.stepOutputSerializer
-import org.modelix.modelql.untyped.AllReferencesTraversalStep.Descriptor
 
 class ResolveNodeStep() : MonoTransformingStep<INodeReference, INode>() {
     override fun createFlow(input: StepFlow<INodeReference>, context: IFlowInstantiationContext): StepFlow<INode> {
         return input.map {
-            it.value.resolveInCurrentContext() ?: throw IllegalArgumentException("Node not found: ${it.value}")
+            it.value.resolveInCurrentContext() ?: throw UnresolvableNodeReferenceException(it.value)
         }.asStepFlow(this)
     }