Removing credentials from source package

build.sbt

@@ -24,7 +24,7 @@ ThisBuild / credentials += Credentials(
   "raw-labs",
   sys.env.getOrElse("GITHUB_TOKEN", "")
 )
-ThisBuild/ resolvers += "Github RAW main repo" at "https://maven.pkg.github.com/raw-labs/raw"
+ThisBuild / resolvers += "Github RAW main repo" at "https://maven.pkg.github.com/raw-labs/raw"
 
 ThisBuild / javaHome := {
   val javaHomePath = sys.env.getOrElse("JAVA_HOME", sys.props("java.home"))
@@ -83,20 +83,9 @@ lazy val utils = (project in file("utils"))
       jacksonDeps
   )
 
-lazy val client = (project in file("client"))
-  .dependsOn(
-    utils % "compile->compile;test->test"
-  )
-  .settings(
-    commonSettings,
-    scalaCompileSettings,
-    testSettings,
-    libraryDependencies += trufflePolyglot
-  )
-
 lazy val sources = (project in file("sources"))
   .dependsOn(
-    client % "compile->compile;test->test"
+    utils % "compile->compile;test->test"
   )
   .settings(
     commonSettings,
@@ -119,23 +108,36 @@ lazy val sources = (project in file("sources"))
     )
   )
 
+lazy val client = (project in file("client"))
+  .dependsOn(
+    utils % "compile->compile;test->test"
+  )
+  .settings(
+    commonSettings,
+    scalaCompileSettings,
+    testSettings,
+    libraryDependencies += trufflePolyglot
+  )
+
 lazy val snapiParser = (project in file("snapi-parser"))
   .enablePlugins(GenParserPlugin)
   .settings(
     commonSettings,
     commonCompileSettings,
     javaSrcBasePath := s"${baseDirectory.value}/src/main/java",
     parserDefinitions := List(
-      (s"${javaSrcBasePath.value}/raw/compiler/rql2/generated",
+      (
+        s"${javaSrcBasePath.value}/raw/compiler/rql2/generated",
         "raw.compiler.rql2.generated",
         s"${javaSrcBasePath.value}/raw/snapi/grammar",
-        "Snapi")
+        "Snapi"
+      )
     ),
     Compile / doc := { file("/dev/null") },
     compileOrder := CompileOrder.JavaThenScala,
     libraryDependencies ++= Seq(
       antlr4Runtime
-    ),
+    )
   )
 
 lazy val snapiFrontend = (project in file("snapi-frontend"))
@@ -249,30 +251,31 @@ lazy val snapiClient = (project in file("snapi-client"))
     testSettings
   )
 
-
 lazy val sqlParser = (project in file("sql-parser"))
   .enablePlugins(GenParserPlugin)
   .settings(
     commonSettings,
     commonCompileSettings,
     javaSrcBasePath := s"${baseDirectory.value}/src/main/java",
     parserDefinitions := List(
-      (s"${javaSrcBasePath.value}/raw/client/sql/generated",
-      "raw.client.sql.generated",
-      s"${javaSrcBasePath.value}/raw/psql/grammar",
-      "Psql")
+      (
+        s"${javaSrcBasePath.value}/raw/client/sql/generated",
+        "raw.client.sql.generated",
+        s"${javaSrcBasePath.value}/raw/psql/grammar",
+        "Psql"
+      )
     ),
     Compile / doc := { file("/dev/null") },
     compileOrder := CompileOrder.JavaThenScala,
     libraryDependencies ++= Seq(
-      antlr4Runtime,
+      antlr4Runtime
     )
   )
 
 lazy val sqlClient = (project in file("sql-client"))
   .dependsOn(
     client % "compile->compile;test->test",
-    sqlParser % "compile->compile;test->test",
+    sqlParser % "compile->compile;test->test"
   )
   .settings(
     commonSettings,

client/src/main/java/module-info.java

@@ -14,9 +14,12 @@
   requires scala.library;
   requires org.slf4j;
   requires org.graalvm.polyglot;
+  requires com.fasterxml.jackson.core;
   requires com.fasterxml.jackson.databind;
   requires com.fasterxml.jackson.dataformat.csv;
-  requires com.fasterxml.jackson.core;
+  requires com.fasterxml.jackson.scala;
+  requires com.fasterxml.jackson.datatype.jsr310;
+  requires com.fasterxml.jackson.datatype.jdk8;
   requires raw.utils;
 
   exports raw.client.api;

client/src/main/scala/raw/client/api/CompilerService.scala

@@ -81,7 +81,7 @@ object CompilerService {
       "Arguments" -> environment.maybeArguments
         .map(args => args.map { case (k, v) => s"$k -> $v" }.mkString("\n"))
         .getOrElse("<undefined>"),
-      "User" -> environment.user.toString,
+      "Uid" -> environment.uid.toString,
       "Scopes" -> environment.scopes.mkString(","),
       "Options" -> environment.options.map { case (k, v) => s"$k -> $v" }.mkString("\n")
       //"Settings" -> runtimeContext.settings.toString

client/src/main/scala/raw/client/api/ProgramEnvironment.scala

@@ -12,13 +12,110 @@
 
 package raw.client.api
 
-import raw.utils.AuthenticatedUser
+import com.fasterxml.jackson.annotation.JsonSubTypes.{Type => JsonType}
+import com.fasterxml.jackson.annotation.{JsonSubTypes, JsonTypeInfo}
+import com.fasterxml.jackson.databind.ObjectMapper
+import com.fasterxml.jackson.datatype.jdk8.Jdk8Module
+import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule
+import com.fasterxml.jackson.module.scala.{ClassTagExtensions, DefaultScalaModule}
+import raw.utils.RawUid
 
 final case class ProgramEnvironment(
-    user: AuthenticatedUser,
+    uid: RawUid,
     maybeArguments: Option[Array[(String, RawValue)]],
     scopes: Set[String],
+    secrets: Map[String, String],
+    jdbcServers: Map[String, JdbcLocation],
+    httpHeaders: Map[String, Map[String, String]],
+    s3Credentials: Map[String, S3Credential],
     options: Map[String, String],
-    maybeTraceId: Option[String] = None,
-    jdbcUrl: Option[String] = None
+    jdbcUrl: Option[String] = None,
+    maybeTraceId: Option[String] = None
 )
+
+@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.PROPERTY, property = "type")
+@JsonSubTypes(
+  Array(
+    new JsonType(value = classOf[MySqlJdbcLocation], name = "mysql"),
+    new JsonType(value = classOf[OracleJdbcLocation], name = "oracle"),
+    new JsonType(value = classOf[PostgresJdbcLocation], name = "postgres"),
+    new JsonType(value = classOf[SqlServerJdbcLocation], name = "sqlserver"),
+    new JsonType(value = classOf[SnowflakeJdbcLocation], name = "snowflake"),
+    new JsonType(value = classOf[SqliteJdbcLocation], name = "sqlite"),
+    new JsonType(value = classOf[TeradataJdbcLocation], name = "teradata")
+  )
+)
+trait JdbcLocation
+final case class MySqlJdbcLocation(
+    host: String,
+    port: Int,
+    database: String,
+    username: String,
+    password: String
+) extends JdbcLocation
+final case class OracleJdbcLocation(
+    host: String,
+    port: Int,
+    database: String,
+    username: String,
+    password: String
+) extends JdbcLocation
+final case class PostgresJdbcLocation(
+    host: String,
+    port: Int,
+    database: String,
+    username: String,
+    password: String
+) extends JdbcLocation
+final case class SqlServerJdbcLocation(
+    host: String,
+    port: Int,
+    database: String,
+    username: String,
+    password: String
+) extends JdbcLocation
+final case class SnowflakeJdbcLocation(
+    database: String,
+    username: String,
+    password: String,
+    accountIdentifier: String,
+    parameters: Map[String, String]
+) extends JdbcLocation
+final case class SqliteJdbcLocation(
+    path: String
+) extends JdbcLocation
+final case class TeradataJdbcLocation(
+    host: String,
+    port: Int,
+    database: String,
+    username: String,
+    password: String,
+    parameters: Map[String, String]
+) extends JdbcLocation
+
+final case class S3Credential(
+    accessKey: Option[String],
+    secretKey: Option[String],
+    region: Option[String]
+)
+
+object ProgramEnvironment {
+
+  private val jsonMapper = new ObjectMapper with ClassTagExtensions {
+    registerModule(DefaultScalaModule)
+    registerModule(new JavaTimeModule())
+    registerModule(new Jdk8Module())
+  }
+
+  private val reader = jsonMapper.readerFor[ProgramEnvironment]
+  private val writer = jsonMapper.writerFor[ProgramEnvironment]
+
+  def serializeToString(env: ProgramEnvironment): String = {
+    writer.writeValueAsString(env)
+  }
+
+  def deserializeFromString(str: String): ProgramEnvironment = {
+    reader.readValue(str)
+  }
+
+}

launcher/src/main/java/raw/cli/RawLauncher.java

@@ -16,8 +16,7 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import raw.client.api.*;
-import raw.utils.AuthenticatedUser;
-import raw.utils.InteractiveUser;
+import raw.utils.RawUid;
 import raw.utils.RawException;
 import raw.utils.RawSettings;
 import scala.Option;
@@ -44,7 +43,6 @@ public RawLauncher(String language, PrintWriter writer) {
         RawSettings rawSettings = new RawSettings(ConfigFactory.load(), ConfigFactory.empty());
 
         this.compilerService = CompilerServiceProvider.apply(language, rawSettings);
-        AuthenticatedUser user = new InteractiveUser("uid", "name", "email", (Seq<String>) Seq$.MODULE$.empty());
 
         HashMap<String, String> javaOptions = new HashMap<String, String>();
         javaOptions.put("output-format", "json");
@@ -54,7 +52,7 @@ public RawLauncher(String language, PrintWriter writer) {
                         .asScala()
                         .toMap(scala.Predef.<scala.Tuple2<String, String>>conforms());
 
-        this.env = new ProgramEnvironment(user, Option.empty(), (Set<String>) Set$.MODULE$.empty(), scalaOptions, Option.empty());
+        this.env = new ProgramEnvironment(RawUid("uid"), Option.empty(), (Set<String>) Set$.MODULE$.empty(), scalaOptions, Option.empty());
 
     }
 

python-client/src/main/scala/raw/client/python/PythonCompilerService.scala

@@ -270,10 +270,7 @@ class PythonCompilerService(engineDefinition: (Engine, Boolean))(implicit protec
     val ctxBuilder = Context
       .newBuilder("python")
       .engine(engine)
-      .environment("RAW_SETTINGS", settings.renderAsString)
-      .environment("RAW_USER", environment.user.uid.toString)
-      .environment("RAW_TRACE_ID", environment.user.uid.toString)
-      .environment("RAW_SCOPES", environment.scopes.mkString(","))
+      .environment("RAW_PROGRAM_ENVIRONMENT", ProgramEnvironment.serializeToString(environment))
       .allowExperimentalOptions(true)
       .allowPolyglotAccess(PolyglotAccess.ALL)
     maybeOutputStream.foreach(os => ctxBuilder.out(os))