wip: react ssr support

Signed-off-by: Dario Valdespino <dvaldespino00@gmail.com>

Author: darvld

packages/graalvm-py/src/main/resources/META-INF/elide/embedded/runtime/python/init.py

@@ -33,6 +33,7 @@ def __init__interop():
   FLASK_URL_FOR = "url_for"
   FLASK_MAKE_RESPONSE = "make_response"
   FLASK_REDIRECT = "redirect"
+  FLASK_REACT = "react"
 
   MODULE_NAME = "elide"
 
@@ -60,6 +61,15 @@ def polyglot_decorator(name = None):
   def flask_binding():
     return polyglot.import_value(_private_symbol_name(FLASK_ENTRY))
 
+  def react(source_path: str):
+    flask = flask_binding()
+    entrypoint = flask.react_template(source_path)
+
+    def render(**params):
+      return entrypoint(params)
+
+    return render
+
   def redirect(target):
     response = flask_binding().make_response()
     response.status = 302
@@ -154,6 +164,8 @@ def __getattr__(self, name):
         return flask_binding().make_response
       if name == FLASK_REDIRECT:
         return redirect
+      if name == FLASK_REACT:
+        return react
       raise AttributeError(f"module '{MODULE_NAME}' has no attribute '{name}'")
 
     def __dir__(self):

packages/graalvm/src/main/kotlin/elide/runtime/intrinsics/server/http/v2/flask/FlaskHttpIntrinsic.kt

@@ -181,6 +181,16 @@ private const val BIND_METHOD = "bind"
   @Deprecated("Use symbolicName instead")
   override fun displayName(): String = FlaskAPI.FLASK_INTRINSIC
   override fun getMember(key: String?): Any? = when (key) {
+    "react_template" -> ProxyExecutable { args ->
+      val relativePath = args.firstOrNull()?.takeIf { it.isString }?.asString()
+        ?: error("Expected a string argument for `react`")
+
+      val scriptPath = applicationRoot?.resolve(relativePath)
+        ?: error("No location info available for the current application")
+
+      FlaskReactTemplate(scriptPath)
+    }
+
     "request" -> requestAccessor
     "abort" -> ProxyExecutable { args ->
       val code = args.firstOrNull()?.takeIf { it.isNumber }?.asInt()
@@ -379,6 +389,17 @@ private const val BIND_METHOD = "bind"
         httpContext.responseBody.source(DefaultLastHttpContent(content))
       }
 
+      returnValue.isHostObject -> {
+        // it could be a content producer
+        val producer = runCatching { returnValue.asHostObject<HttpContentSink.Producer>() }
+          .getOrNull()
+          ?: error("Invalid Flask response object provided: $returnValue")
+
+        if (overrideStatus) httpContext.response.status = HttpResponseStatus.OK
+        httpContext.response.headers().set(HttpHeaderNames.TRANSFER_ENCODING, "chunked")
+        httpContext.responseBody.source(producer)
+      }
+
       returnValue.isProxyObject -> {
         // assume it is a Flask response object
         val response = runCatching { returnValue.asProxyObject<FlaskResponseObject>() }
@@ -412,6 +433,7 @@ private const val BIND_METHOD = "bind"
       "abort",
       "url_for",
       "make_response",
+      "react_template",
     )
   }
 }

packages/graalvm/src/main/kotlin/elide/runtime/intrinsics/server/http/v2/flask/FlaskReactTemplate.kt

@@ -0,0 +1,80 @@
+/*
+ *  Copyright (c) 2024-2025 Elide Technologies, Inc.
+ *
+ *  Licensed under the MIT license (the "License"); you may not use this file except in compliance
+ *  with the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/license/mit/
+ *
+ *  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ *  an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ *  License for the specific language governing permissions and limitations under the License.
+ */
+
+package elide.runtime.intrinsics.server.http.v2.flask
+
+import io.netty.buffer.Unpooled
+import io.netty.handler.codec.http.DefaultLastHttpContent
+import org.graalvm.polyglot.Context
+import org.graalvm.polyglot.Source
+import org.graalvm.polyglot.Value
+import org.graalvm.polyglot.proxy.ProxyExecutable
+import java.nio.file.Path
+import java.util.concurrent.atomic.AtomicReference
+import kotlin.concurrent.getOrSet
+import elide.runtime.Logging
+import elide.runtime.intrinsics.js.JsPromise
+import elide.runtime.intrinsics.server.http.v2.HttpContentSink
+
+internal class FlaskReactTemplate(private val source: Path) : ProxyExecutable {
+  private val sourceScript by lazy {
+    Source.newBuilder("ts", source.toFile())
+      .build()
+  }
+
+  private val template = ThreadLocal<Value>()
+
+  override fun execute(vararg arguments: Value?): Any {
+    val parsedTemplate = template.getOrSet {
+      Context.getCurrent().eval(sourceScript).getMember("default")
+    }
+
+    val result = parsedTemplate.execute(arguments.firstOrNull())
+    val promise = JsPromise.wrapOrNull(
+      value = result,
+      unwrapFulfilled = { it!!.asString() },
+      unwrapRejected = { it },
+    )
+
+    if (promise == null) {
+      if (!result.isString) error("React template did not render to a string and did not return a promise")
+      else return result.asString()
+    }
+
+    return object : HttpContentSink.Producer {
+      private val pulled = AtomicReference<HttpContentSink.Handle>()
+
+      override fun pull(handle: HttpContentSink.Handle) {
+        if (!promise.isDone) pulled.set(handle)
+        promise.then(
+          onFulfilled = { rendered ->
+            pulled.get()?.push(DefaultLastHttpContent(Unpooled.copiedBuffer(rendered, Charsets.UTF_8)))
+            handle.release(close = true)
+          },
+          onCatch = {
+            logging.error("Failed to render React template: $it")
+            handle.release(close = true)
+          },
+        )
+      }
+
+      override fun released() {
+        pulled.set(null)
+      }
+    }
+  }
+
+  private companion object {
+    private val logging by lazy { Logging.of(FlaskReactTemplate::class) }
+  }
+}