[WIP] JS Scripting Support

.github/workflows/ci.yml

@@ -131,7 +131,7 @@ jobs:
         with:
           version: '22.3.1'
           java-version: '17'
-          components: 'native-image'
+          components: 'native-image,js'
           github-token: ${{ secrets.GITHUB_TOKEN }}
           native-image-job-reports: 'true'
 

backend/build.sbt

@@ -76,6 +76,7 @@ val mockingbird = (project in file("mockingbird"))
       "com.github.geirolz"            %% "advxml-core"         % "2.5.1",
       "com.github.geirolz"            %% "advxml-xpath"        % "2.5.1",
       "io.estatico"                   %% "newtype"             % "0.4.4",
+      "org.graalvm.js"                 % "js"                            % "22.3.0",
       "org.slf4j"                      % "slf4j-api"           % "1.7.30" % Provided
     ),
     Compile / unmanagedResourceDirectories += file("../frontend/dist")

backend/mockingbird-api/src/main/scala/ru/tinkoff/tcb/mockingbird/Mockingbird.scala

@@ -51,6 +51,8 @@ import ru.tinkoff.tcb.mockingbird.stream.EphemeralCleaner
 import ru.tinkoff.tcb.mockingbird.stream.EventSpawner
 import ru.tinkoff.tcb.mockingbird.stream.SDFetcher
 import ru.tinkoff.tcb.utils.metrics.makeRegistry
+import ru.tinkoff.tcb.utils.resource.readStr
+import ru.tinkoff.tcb.utils.sandboxing.GraalJsSandbox
 
 object Mockingbird extends scala.App {
   type FL = WLD & ServerConfig & PublicHttp & EventSpawner & ResourceManager & EphemeralCleaner & GrpcRequestHandler
@@ -142,6 +144,9 @@ object Mockingbird extends scala.App {
             scopedBackend <- ArmeriaZioBackend.scopedUsingClient(webClient)
           } yield scopedBackend
         },
+        (ZLayer.service[ServerConfig].project(_.sandbox) ++ ZLayer.fromZIO(
+          ZIO.attempt(readStr("prelude.js")).map(Option(_))
+        )) >>> GraalJsSandbox.live,
         mongoLayer,
         aesEncoder,
         collection(_.stub) >>> HttpStubDAOImpl.live,
@@ -186,10 +191,13 @@ object Mockingbird extends scala.App {
           .exec(bytes)
           .provideSome[RequestContext](
             Tracing.live,
+            MockingbirdConfiguration.server,
             MockingbirdConfiguration.mongo,
             mongoLayer,
             collection(_.state) >>> PersistentStateDAOImpl.live,
             collection(_.grpcStub) >>> GrpcStubDAOImpl.live,
+            (ZLayer.service[ServerConfig].project(_.sandbox) ++ ZLayer
+              .fromZIO(ZIO.attempt(readStr("prelude.js")).map(Option(_)))) >>> GraalJsSandbox.live,
             GrpcStubResolverImpl.live,
             GrpcRequestHandlerImpl.live
           )

backend/mockingbird-native/src/main/resources/META-INF/native-image/ru.tinkoff.tcb/mockingbird/native-image.properties

@@ -1,5 +1,6 @@
 Args = -H:+AddAllCharsets \
 --no-fallback \
+--language:js \
 --initialize-at-run-time=io.netty.bootstrap.Bootstrap,\
 io.netty.bootstrap.ServerBootstrap,\
 io.netty.buffer,\

backend/mockingbird/src/main/resources/application.conf

@@ -19,7 +19,8 @@ ru.tinkoff.tcb {
     port = 8228
     allowedOrigins = [
       "http://localhost",
-      "http://localhost:3000"
+      "http://localhost:3000",
+      "http://localhost:8228"
     ]
   }
 

backend/mockingbird/src/main/resources/prelude.js

@@ -0,0 +1,61 @@
+function randomInt(lbound, rbound) {
+    if (typeof rbound === "undefined")
+        return Math.floor(Math.random() * lbound);
+    var min = Math.ceil(lbound);
+    var max = Math.floor(rbound);
+    return Math.floor(Math.random() * (max - min) + min);
+}
+
+function randomLong(lbound, rbound) {
+    return randomInt(lbound, rbound);
+}
+
+function randomString(param1, param2, param3) {
+    if (typeof param2 === "undefined" || typeof param3 === "undefined") {
+        var result           = '';
+        var characters       = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+        var charactersLength = characters.length;
+        for ( var i = 0; i < param1; i++ ) {
+            result += characters.charAt(Math.floor(Math.random() * charactersLength));
+        }
+        return result;
+    }
+
+    var result           = '';
+    var charactersLength = param1.length;
+    for ( var i = 0; i < randomInt(param2, param3); i++ ) {
+        result += param1.charAt(Math.floor(Math.random() * charactersLength));
+    }
+    return result;
+}
+
+function randomNumericString(length) {
+    return randomString('0123456789', length, length + 1);
+}
+
+// https://stackoverflow.com/a/8809472/3819595
+function UUID() { // Public Domain/MIT
+    var d = new Date().getTime();//Timestamp
+    var d2 = ((typeof performance !== 'undefined') && performance.now && (performance.now()*1000)) || 0;//Time in microseconds since page-load or 0 if unsupported
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
+        var r = Math.random() * 16;//random number between 0 and 16
+        if(d > 0){//Use timestamp until depleted
+            r = (d + r)%16 | 0;
+            d = Math.floor(d/16);
+        } else {//Use microseconds since page-load if supported
+            r = (d2 + r)%16 | 0;
+            d2 = Math.floor(d2/16);
+        }
+        return (c === 'x' ? r : (r & 0x3 | 0x8)).toString(16);
+    });
+}
+
+function now(pattern) {
+    var format = java.time.format.DateTimeFormatter.ofPattern(pattern);
+    return java.time.LocalDateTime.now().format(format);
+}
+
+function today(pattern) {
+    var format = java.time.format.DateTimeFormatter.ofPattern(pattern);
+    return java.time.LocalDate.now().format(format);
+}

backend/mockingbird/src/main/scala/ru/tinkoff/tcb/mockingbird/api/PublicApiHandler.scala

@@ -41,6 +41,7 @@ import ru.tinkoff.tcb.mockingbird.scenario.CallbackEngine
 import ru.tinkoff.tcb.mockingbird.scenario.ScenarioEngine
 import ru.tinkoff.tcb.utils.circe.optics.JsonOptic
 import ru.tinkoff.tcb.utils.regex.*
+import ru.tinkoff.tcb.utils.sandboxing.GraalJsSandbox
 import ru.tinkoff.tcb.utils.transformation.json.*
 import ru.tinkoff.tcb.utils.transformation.string.*
 import ru.tinkoff.tcb.utils.transformation.xml.*
@@ -54,6 +55,7 @@ final class PublicApiHandler(
     stateDAO: PersistentStateDAO[Task],
     resolver: StubResolver,
     engine: CallbackEngine,
+    implicit val jsSandbox: GraalJsSandbox,
     private val httpBackend: SttpBackend[Task, ?],
     proxyConfig: ProxyConfig
 ) {
@@ -304,8 +306,9 @@ object PublicApiHandler {
       ssd        <- ZIO.service[PersistentStateDAO[Task]]
       resolver   <- ZIO.service[StubResolver]
       engine     <- ZIO.service[ScenarioEngine]
+      jsSandbox  <- ZIO.service[GraalJsSandbox]
       sttpClient <- ZIO.service[SttpBackend[Task, Any]]
       proxyCfg   <- ZIO.service[ProxyConfig]
-    } yield new PublicApiHandler(hsd, ssd, resolver, engine, sttpClient, proxyCfg)
+    } yield new PublicApiHandler(hsd, ssd, resolver, engine, jsSandbox, sttpClient, proxyCfg)
   }
 }

backend/mockingbird/src/main/scala/ru/tinkoff/tcb/mockingbird/config/Configuration.scala

@@ -8,7 +8,15 @@ import net.ceedubs.ficus.Ficus.*
 import net.ceedubs.ficus.readers.ArbitraryTypeReader.*
 import net.ceedubs.ficus.readers.EnumerationReader.*
 
-case class ServerConfig(interface: String, port: Int, allowedOrigins: Seq[String], healthCheckRoute: Option[String])
+case class JsSandboxConfig(allowedClasses: Set[String] = Set())
+
+case class ServerConfig(
+    interface: String,
+    port: Int,
+    allowedOrigins: Seq[String],
+    healthCheckRoute: Option[String],
+    sandbox: JsSandboxConfig
+)
 
 case class SecurityConfig(secret: String)
 

backend/mockingbird/src/main/scala/ru/tinkoff/tcb/mockingbird/grpc/GrpcRequestHandler.scala

@@ -18,13 +18,15 @@ import ru.tinkoff.tcb.mockingbird.model.FillResponse
 import ru.tinkoff.tcb.mockingbird.model.GProxyResponse
 import ru.tinkoff.tcb.mockingbird.model.PersistentState
 import ru.tinkoff.tcb.mockingbird.model.Scope
+import ru.tinkoff.tcb.utils.sandboxing.GraalJsSandbox
 import ru.tinkoff.tcb.utils.transformation.json.*
 
 trait GrpcRequestHandler {
   def exec(bytes: Array[Byte]): RIO[WLD & RequestContext, Array[Byte]]
 }
 
-class GrpcRequestHandlerImpl(stubResolver: GrpcStubResolver) extends GrpcRequestHandler {
+class GrpcRequestHandlerImpl(stubResolver: GrpcStubResolver, implicit val jsSandbox: GraalJsSandbox)
+    extends GrpcRequestHandler {
   override def exec(bytes: Array[Byte]): RIO[WLD & RequestContext, Array[Byte]] =
     for {
       context <- ZIO.service[RequestContext]
@@ -86,7 +88,8 @@ class GrpcRequestHandlerImpl(stubResolver: GrpcStubResolver) extends GrpcRequest
 }
 
 object GrpcRequestHandlerImpl {
-  val live: URLayer[GrpcStubResolver, GrpcRequestHandler] = ZLayer.fromFunction(new GrpcRequestHandlerImpl(_))
+  val live: URLayer[GrpcStubResolver & GraalJsSandbox, GrpcRequestHandlerImpl] =
+    ZLayer.fromFunction(new GrpcRequestHandlerImpl(_, _))
 }
 
 object GrpcRequestHandler {

backend/mockingbird/src/main/scala/ru/tinkoff/tcb/mockingbird/scenario/ScenarioEngine.scala

@@ -42,6 +42,7 @@ import ru.tinkoff.tcb.mockingbird.model.XMLCallbackRequest
 import ru.tinkoff.tcb.mockingbird.model.XmlOutput
 import ru.tinkoff.tcb.mockingbird.stream.SDFetcher
 import ru.tinkoff.tcb.utils.id.SID
+import ru.tinkoff.tcb.utils.sandboxing.GraalJsSandbox
 import ru.tinkoff.tcb.utils.transformation.json.*
 import ru.tinkoff.tcb.utils.transformation.string.*
 import ru.tinkoff.tcb.utils.transformation.xml.*
@@ -62,6 +63,7 @@ final class ScenarioEngine(
     stateDAO: PersistentStateDAO[Task],
     resolver: ScenarioResolver,
     fetcher: SDFetcher,
+    implicit val jsSandbox: GraalJsSandbox,
     private val httpBackend: SttpBackend[Task, ?]
 ) extends CallbackEngine {
   private val log = MDCLogging.`for`[WLD](this)
@@ -222,7 +224,8 @@ object ScenarioEngine {
       psd        <- ZIO.service[PersistentStateDAO[Task]]
       resolver   <- ZIO.service[ScenarioResolver]
       fetcher    <- ZIO.service[SDFetcher]
+      jsSandbox  <- ZIO.service[GraalJsSandbox]
       sttpClient <- ZIO.service[SttpBackend[Task, Any]]
-    } yield new ScenarioEngine(sd, psd, resolver, fetcher, sttpClient)
+    } yield new ScenarioEngine(sd, psd, resolver, fetcher, jsSandbox, sttpClient)
   }
 }

backend/mockingbird/src/main/scala/ru/tinkoff/tcb/utils/sandboxing/GraalJsSandbox.scala

@@ -0,0 +1,65 @@
+package ru.tinkoff.tcb.utils.sandboxing
+
+import scala.reflect.ClassTag
+import scala.reflect.classTag
+import scala.util.Try
+import scala.util.Using
+
+import org.graalvm.polyglot.*
+
+import ru.tinkoff.tcb.mockingbird.config.JsSandboxConfig
+
+class GraalJsSandbox(
+    jsSandboxConfig: JsSandboxConfig,
+    prelude: Option[String] = None
+) {
+  private val allowedClasses = GraalJsSandbox.DefaultAccess ++ jsSandboxConfig.allowedClasses
+  private val preludeSource  = prelude.map(Source.create("js", _))
+
+  def eval[T: ClassTag](code: String, environment: Map[String, Any] = Map.empty): Try[T] =
+    Using(
+      Context
+        .newBuilder("js")
+        .allowHostAccess(HostAccess.ALL)
+        .allowHostClassLookup((t: String) => allowedClasses(t))
+        .option("engine.WarnInterpreterOnly", "false")
+        .build()
+    ) { context =>
+      context.getBindings("js").pipe { bindings =>
+        for ((key, value) <- environment)
+          bindings.putMember(key, value)
+      }
+      preludeSource.foreach(context.eval)
+      context.eval("js", code).as(classTag[T].runtimeClass.asInstanceOf[Class[T]])
+    }
+}
+
+object GraalJsSandbox {
+  val live: URLayer[Option[String] & JsSandboxConfig, GraalJsSandbox] = ZLayer {
+    for {
+      sandboxConfig <- ZIO.service[JsSandboxConfig]
+      prelude       <- ZIO.service[Option[String]]
+    } yield new GraalJsSandbox(sandboxConfig, prelude)
+  }
+
+  val DefaultAccess: Set[String] = Set(
+    "java.lang.Byte",
+    "java.lang.Boolean",
+    "java.lang.Double",
+    "java.lang.Float",
+    "java.lang.Integer",
+    "java.lang.Long",
+    "java.lang.Math",
+    "java.lang.Short",
+    "java.lang.String",
+    "java.math.BigDecimal",
+    "java.math.BigInteger",
+    "java.time.LocalDate",
+    "java.time.LocalDateTime",
+    "java.time.format.DateTimeFormatter",
+    "java.util.List",
+    "java.util.Map",
+    "java.util.Random",
+    "java.util.Set"
+  )
+}

backend/mockingbird/src/main/scala/ru/tinkoff/tcb/utils/transformation/json/js_eval/package.scala

@@ -0,0 +1,37 @@
+package ru.tinkoff.tcb.utils.transformation.json
+
+import java.lang as jl
+import java.math as jm
+import scala.jdk.CollectionConverters.*
+
+import io.circe.Json
+import io.circe.JsonNumber
+import io.circe.JsonObject
+
+package object js_eval {
+  val circe2js: Json.Folder[AnyRef] = new Json.Folder[AnyRef] {
+    override def onNull: AnyRef = null
+
+    override def onBoolean(value: Boolean): AnyRef = jl.Boolean.valueOf(value)
+
+    override def onNumber(value: JsonNumber): AnyRef = value.toBigDecimal.map(_.bigDecimal).orNull
+
+    override def onString(value: String): AnyRef = value
+
+    override def onArray(value: Vector[Json]): AnyRef = value.map(_.foldWith[AnyRef](this)).asJava
+
+    override def onObject(value: JsonObject): AnyRef =
+      value.toMap.view
+        .mapValues(_.foldWith[AnyRef](this))
+        .toMap
+        .asJava
+  }
+
+  val fold2Json: PartialFunction[AnyRef, Json] = {
+    case b: jl.Boolean     => Json.fromBoolean(b)
+    case s: String         => Json.fromString(s)
+    case bd: jm.BigDecimal => Json.fromBigDecimal(bd)
+    case i: jl.Integer     => Json.fromInt(i.intValue())
+    case l: jl.Long        => Json.fromLong(l.longValue())
+  }
+}

backend/mockingbird/src/main/scala/ru/tinkoff/tcb/utils/transformation/json/package.scala

@@ -1,17 +1,20 @@
 package ru.tinkoff.tcb.utils.transformation
 
+import scala.util.Failure
+import scala.util.Success
 import scala.util.control.TailCalls
 import scala.util.control.TailCalls.TailRec
 
 import io.circe.Json
 import io.circe.JsonNumber as JNumber
 import kantan.xpath.*
-import mouse.boolean.*
 
 import ru.tinkoff.tcb.utils.circe.*
 import ru.tinkoff.tcb.utils.circe.optics.JsonOptic
 import ru.tinkoff.tcb.utils.json.json2StringFolder
 import ru.tinkoff.tcb.utils.regex.OneOrMore
+import ru.tinkoff.tcb.utils.sandboxing.GraalJsSandbox
+import ru.tinkoff.tcb.utils.transformation.json.js_eval.fold2Json
 import ru.tinkoff.tcb.utils.transformation.xml.nodeTemplater
 
 package object json {
@@ -86,25 +89,13 @@ package object json {
         }.result
       }
 
-    def eval: Json =
-      transformValues { case js @ JsonString(str) =>
-        str
-          .foldTemplate(
-            Json.fromString,
-            Json.fromInt,
-            Json.fromLong
-          )
-          .orElse {
-            FunRx
-              .findFirstIn(str)
-              .isDefined
-              .option(
-                FunRx
-                  .replaceSomeIn(str, m => m.matched.foldTemplate(identity, _.toString(), _.toString()))
-              )
-              .map(Json.fromString)
-          }
-          .getOrElse(js)
+    def eval(implicit sandbox: GraalJsSandbox): Json =
+      transformValues { case js @ JsonString(CodeRx(code)) =>
+        (sandbox.eval[AnyRef](code) match {
+          case Success(value) if fold2Json.isDefinedAt(value) => Option(fold2Json(value))
+          case Success(other)     => throw new Exception(s"${other.getClass.getCanonicalName}: $other")
+          case Failure(exception) => throw exception
+        }).getOrElse(js)
       }.result
 
     def patch(values: Json, schema: Map[JsonOptic, String]): Json =