Fix SQL parsing when creating and tests (#20)

KapStorm · web-flow · commit ce07a04865a7 · 2023-09-26T21:10:37.000-07:00
* Fix UUID field references

* Tests

* Address reviewer changes

* Fix create for all types

* Fix QueryBuild tests
diff --git a/build.sbt b/build.sbt
@@ -27,7 +27,7 @@ inThisBuild(
 resolvers += Resolver.sonatypeRepo("releases")
 
 val play = "2.9.0-M6"
-val playJson = "2.10.0-RC9"
+val playJson = "2.10.1"
 val sttp = "3.5.0"
 val anorm = "2.7.0"
 val scalaTestPlusPlay = "6.0.0-M6"
diff --git a/spra-api/shared/src/main/scala/net/wiringbits/spra/api/AdminDataExplorerApiClient.scala b/spra-api/shared/src/main/scala/net/wiringbits/spra/api/AdminDataExplorerApiClient.scala
@@ -142,7 +142,8 @@ object AdminDataExplorerApiClient {
 
       prepareRequest[AdminCreateTable.Response]
         .post(uri)
-        .body(Json.toJson(request).toString())
+        // TODO: check the AdminCreateTable.Request model, it isn't parsing correctly to json
+        .body(Json.toJson(request.data).toString())
         .send(backend)
         .map(_.body)
         .flatMap(Future.fromTry)
diff --git a/spra-api/shared/src/main/scala/net/wiringbits/spra/api/models/AdminCreateTable.scala b/spra-api/shared/src/main/scala/net/wiringbits/spra/api/models/AdminCreateTable.scala
@@ -5,7 +5,7 @@ import play.api.libs.json.{Format, Json}
 object AdminCreateTable {
   case class Request(data: Map[String, String])
 
-  case class Response(noData: String = "")
+  case class Response(id: String)
 
   implicit val adminCreateTableRequestFormat: Format[Request] =
     Json.format[Request]
diff --git a/spra-play-server/src/main/resources/application.conf b/spra-play-server/src/main/resources/application.conf
@@ -15,7 +15,18 @@ dataExplorer {
       filterableColumns = ["name", "last_name"]
       createFilter {
         requiredColumns = ["name", "email", "password"]
-        nonRequiredColumns = ["last_name", "discord_webhook_url"]
+        nonRequiredColumns = ["last_name"]
+      }
+    }
+
+    userLogs {
+      tableName = "user_logs"
+      primaryKeyField = "user_log_id"
+      nonEditableColumns = ["user_log_id", "user_id", "created_at"]
+      canBeDeleted = true
+      filterableColumns = ["user_id"]
+      createFilter {
+        requiredColumns = ["user_id", "message"]
       }
     }
   }
diff --git a/spra-play-server/src/main/scala/net/wiringbits/spra/admin/controllers/AdminController.scala b/spra-play-server/src/main/scala/net/wiringbits/spra/admin/controllers/AdminController.scala
@@ -60,7 +60,7 @@ class AdminController @Inject() (
       _ <- adminUser(request)
       _ = logger.info(s"Create row in $tableName: ${body.data}")
       id <- adminService.create(tableName, body)
-    } yield Ok(Json.toJson(Map("id" -> id)))
+    } yield Ok(Json.toJson(AdminCreateTable.Response(id)))
   }
 
   def update(tableName: String, primaryKeyValue: String) = handleJsonBody[Map[String, String]] { request =>
diff --git a/spra-play-server/src/main/scala/net/wiringbits/spra/admin/repositories/DatabaseTablesRepository.scala b/spra-play-server/src/main/scala/net/wiringbits/spra/admin/repositories/DatabaseTablesRepository.scala
@@ -71,9 +71,15 @@ class DatabaseTablesRepository @Inject() (database: Database)(implicit
     database.withConnection { implicit conn =>
       val primaryKeyField = dataExplorerConfig.unsafeFindByName(tableName).primaryKeyField
       val primaryKeyType = dataExplorerConfig.unsafeFindByName(tableName).primaryKeyDataType
+      val columns = DatabaseTablesDAO.getTableColumns(tableName)
+      val fieldsAndValues = body.map { case (key, value) =>
+        val field =
+          columns.find(_.name == key).getOrElse(throw new RuntimeException(s"Invalid property in body request: $key"))
+        (field, value)
+      }
       DatabaseTablesDAO.create(
         tableName = tableName,
-        body = body,
+        fieldsAndValues = fieldsAndValues,
         primaryKeyField = primaryKeyField,
         primaryKeyType = primaryKeyType
       )
diff --git a/spra-play-server/src/main/scala/net/wiringbits/spra/admin/repositories/daos/DatabaseTablesDAO.scala b/spra-play-server/src/main/scala/net/wiringbits/spra/admin/repositories/daos/DatabaseTablesDAO.scala
@@ -230,13 +230,13 @@ object DatabaseTablesDAO {
   }
   def create(
       tableName: String,
-      body: Map[String, String],
+      fieldsAndValues: Map[TableColumn, String],
       primaryKeyField: String,
       primaryKeyType: PrimaryKeyDataType = PrimaryKeyDataType.UUID
   )(implicit
       conn: Connection
   ): String = {
-    val sql = QueryBuilder.create(tableName, body, primaryKeyField, primaryKeyType)
+    val sql = QueryBuilder.create(tableName, fieldsAndValues, primaryKeyField, primaryKeyType)
     val preparedStatement = conn.prepareStatement(sql)
 
     var i = 0
@@ -249,8 +249,8 @@ object DatabaseTablesDAO {
     // eg. NULL can be used in MySQL to generate default value in an autoincrement column, but not Postgres unfortunately
     // Postgres: INSERT INTO test_serial (id) VALUES(DEFAULT); MySQL: INSERT INTO table (id) VALUES(NULL)
 
-    for (j <- i + 1 to body.size + i) {
-      val value = body(body.keys.toList(j - i - 1))
+    for (j <- i + 1 to fieldsAndValues.size + i) {
+      val value = fieldsAndValues(fieldsAndValues.keys.toList(j - i - 1))
       preparedStatement.setObject(j, value)
     }
     val result = preparedStatement.executeQuery()
diff --git a/spra-play-server/src/main/scala/net/wiringbits/spra/admin/utils/QueryBuilder.scala b/spra-play-server/src/main/scala/net/wiringbits/spra/admin/utils/QueryBuilder.scala
@@ -8,7 +8,7 @@ import scala.collection.mutable
 object QueryBuilder {
   def create(
       tableName: String,
-      body: Map[String, String],
+      fieldsAndValues: Map[TableColumn, String],
       primaryKeyField: String,
       primaryKeyType: PrimaryKeyDataType = PrimaryKeyDataType.UUID
   ): String = {
@@ -18,9 +18,9 @@ object QueryBuilder {
       case PrimaryKeyDataType.Serial => new mutable.StringBuilder("DEFAULT")
       case PrimaryKeyDataType.BigSerial => new mutable.StringBuilder("DEFAULT")
     }
-    for ((key, _) <- body) {
-      sqlFields.append(s", $key")
-      sqlValues.append(s", ?")
+    for ((tableColumn, _) <- fieldsAndValues) {
+      sqlFields.append(s", ${tableColumn.name}")
+      sqlValues.append(s", ?::${tableColumn.`type`}")
     }
 
     s"""
diff --git a/spra-play-server/src/test/scala/controllers/AdminControllerSpec.scala b/spra-play-server/src/test/scala/controllers/AdminControllerSpec.scala
@@ -9,14 +9,16 @@ import net.wiringbits.spra.api.models.AdminCreateTable
 import org.apache.commons.lang3.StringUtils
 import play.api.inject
 import play.api.inject.guice.GuiceApplicationBuilder
+import utils.AdminUtils
 
 import java.util.UUID
 import java.util.regex.Pattern
 import scala.util.Random
 
-class AdminControllerSpec extends PlayPostgresSpec {
+class AdminControllerSpec extends PlayPostgresSpec with AdminUtils {
   val dataExplorerConfigTables: List[TableSettings] = List(
     TableSettings("users", "user_id"), // "UUID" default
+    TableSettings("user_logs", "user_log_id", Some("users")), // "UUID" default
     TableSettings(
       tableName = "uuid_table",
       primaryKeyField = "id",
@@ -42,11 +44,12 @@ class AdminControllerSpec extends PlayPostgresSpec {
   val dataExplorerConfig: DataExplorerConfig = DataExplorerConfig("http://localhost:9000", dataExplorerConfigTables)
   def usersSettings: TableSettings = dataExplorerConfig.tablesSettings.headOption.value
   // TODO: loop through dataExplorerSettings for each table instead of defining usersSettings, uuidSettings
-  def uuidSettings: TableSettings = dataExplorerConfig.tablesSettings(1)
-  def serialSettings: TableSettings = dataExplorerConfig.tablesSettings(2)
-  def bigSerialSettings: TableSettings = dataExplorerConfig.tablesSettings(3)
-  def serialOverflowSettings: TableSettings = dataExplorerConfig.tablesSettings(4)
-  def bigSerialOverflowSettings: TableSettings = dataExplorerConfig.tablesSettings(5)
+  def userLogsSettings: TableSettings = dataExplorerConfig.tablesSettings(1)
+  def uuidSettings: TableSettings = dataExplorerConfig.tablesSettings(2)
+  def serialSettings: TableSettings = dataExplorerConfig.tablesSettings(3)
+  def bigSerialSettings: TableSettings = dataExplorerConfig.tablesSettings(4)
+  def serialOverflowSettings: TableSettings = dataExplorerConfig.tablesSettings(5)
+  def bigSerialOverflowSettings: TableSettings = dataExplorerConfig.tablesSettings(6)
 
   def isValidUUID(str: String): Boolean = {
     if (str == null) return false
@@ -66,14 +69,14 @@ class AdminControllerSpec extends PlayPostgresSpec {
   "GET /admin/tables" should {
     "return tables from modules" in withApiClient { client =>
       val response = client.getTables.futureValue
-      val tableName = response.data.map(_.name).headOption.value // users
-      tableName must be(usersSettings.tableName)
-      val uuidTable = response.data.map(_.name)(1) // table 2
-      uuidTable must be(uuidSettings.tableName)
-      val serialTable = response.data.map(_.name)(2) // table 3
-      serialTable must be(serialSettings.tableName)
-      val bigSerialTable = response.data.map(_.name)(3) // table 4
-      bigSerialTable must be(bigSerialSettings.tableName)
+      response.data.map(_.name) match
+        case List(users, userLogs, uuidTable, serialTable, bigSerialTable, _, _) =>
+          users must be(usersSettings.tableName)
+          userLogs must be(userLogsSettings.tableName)
+          uuidTable must be(uuidSettings.tableName)
+          serialTable must be(serialSettings.tableName)
+          bigSerialTable must be(bigSerialSettings.tableName)
+        case list => fail(s"Unexpected response: ${list.mkString(", ")}")
     }
 
     "return extra config from module" in withApiClient { client =>
@@ -83,24 +86,55 @@ class AdminControllerSpec extends PlayPostgresSpec {
       usersSettings.referenceField must be(None)
       usersSettings.hiddenColumns must be(List.empty)
       usersSettings.nonEditableColumns must be(List.empty)
+      usersSettings.canBeDeleted must be(true)
+      usersSettings.columnTypeOverrides must be(Map.empty)
+      usersSettings.filterableColumns must be(List.empty)
+      usersSettings.createSettings.nonRequiredColumns must be(List.empty)
+      usersSettings.createSettings.requiredColumns must be(List.empty)
 
       val head2 = response.data(1)
-      head2.primaryKeyName must be(uuidSettings.primaryKeyField)
+      head2.primaryKeyName must be(userLogsSettings.primaryKeyField)
+      userLogsSettings.referenceField must be(Some("users"))
+      userLogsSettings.hiddenColumns must be(List.empty)
+      userLogsSettings.nonEditableColumns must be(List.empty)
+      userLogsSettings.canBeDeleted must be(true)
+      userLogsSettings.columnTypeOverrides must be(Map.empty)
+      userLogsSettings.filterableColumns must be(List.empty)
+      userLogsSettings.createSettings.nonRequiredColumns must be(List.empty)
+      userLogsSettings.createSettings.requiredColumns must be(List.empty)
+
+      val head3 = response.data(2)
+      head3.primaryKeyName must be(uuidSettings.primaryKeyField)
       uuidSettings.referenceField must be(None)
       uuidSettings.hiddenColumns must be(List.empty)
       uuidSettings.nonEditableColumns must be(List.empty)
+      uuidSettings.canBeDeleted must be(true)
+      uuidSettings.columnTypeOverrides must be(Map.empty)
+      uuidSettings.filterableColumns must be(List.empty)
+      uuidSettings.createSettings.nonRequiredColumns must be(List.empty)
+      uuidSettings.createSettings.requiredColumns must be(List.empty)
 
-      val head3 = response.data(2)
-      head3.primaryKeyName must be(serialSettings.primaryKeyField)
+      val head4 = response.data(3)
+      head4.primaryKeyName must be(serialSettings.primaryKeyField)
       serialSettings.referenceField must be(None)
       serialSettings.hiddenColumns must be(List.empty)
       serialSettings.nonEditableColumns must be(List.empty)
-
-      val head4 = response.data(3)
-      head4.primaryKeyName must be(bigSerialSettings.primaryKeyField)
+      serialSettings.canBeDeleted must be(true)
+      serialSettings.columnTypeOverrides must be(Map.empty)
+      serialSettings.filterableColumns must be(List.empty)
+      serialSettings.createSettings.nonRequiredColumns must be(List.empty)
+      serialSettings.createSettings.requiredColumns must be(List.empty)
+
+      val head5 = response.data(4)
+      head5.primaryKeyName must be(bigSerialSettings.primaryKeyField)
       bigSerialSettings.referenceField must be(None)
       bigSerialSettings.hiddenColumns must be(List.empty)
       bigSerialSettings.nonEditableColumns must be(List.empty)
+      bigSerialSettings.canBeDeleted must be(true)
+      bigSerialSettings.columnTypeOverrides must be(Map.empty)
+      bigSerialSettings.filterableColumns must be(List.empty)
+      bigSerialSettings.createSettings.nonRequiredColumns must be(List.empty)
+      bigSerialSettings.createSettings.requiredColumns must be(List.empty)
     }
   }
 
@@ -123,6 +157,17 @@ class AdminControllerSpec extends PlayPostgresSpec {
       email must be(emailValue)
     }
 
+    "return data from user logs table" in withApiClient { implicit client =>
+      val user = createUser.futureValue
+      val userLog = createUserLog(user.userId).futureValue
+
+      val response =
+        client.getTableMetadata(userLogsSettings.tableName, List("message", "ASC"), List(0, 9), "{}").futureValue.head
+      response("message") mustBe userLog.message
+      response("user_id") mustBe user.userId
+      response("id") mustBe userLog.userLogId
+    }
+
     "return data from uuid table" in withApiClient { client =>
       val name = "wiringbits"
       // val uuid_id =  UUID.randomUUID().toString
@@ -610,7 +655,7 @@ class AdminControllerSpec extends PlayPostgresSpec {
       val password = "wiringbits"
       val request = AdminCreateTable.Request(Map("name" -> name, "email" -> email, "password" -> password))
       val response = client.createItem("users", request).futureValue
-      response.noData must be(empty)
+      response.id.nonEmpty mustBe true
     }
 
     "create a new row for all tables" in withApiClient { client =>
@@ -620,10 +665,26 @@ class AdminControllerSpec extends PlayPostgresSpec {
       for (table <- tables) {
         val request = AdminCreateTable.Request(Map("name" -> name))
         val response = client.createItem(table.tableName, request).futureValue
-        response.noData must be(empty)
+        response.id.nonEmpty mustBe true
       }
     }
 
+    "return new user id" in withApiClient { implicit client =>
+      val user = createUser.futureValue
+      val response = client.getTableMetadata(usersSettings.tableName, List("name", "ASC"), List(0, 9), "{}").futureValue
+      val userId = response.head("id")
+
+      userId mustBe user.userId
+    }
+
+    "create a new user log" in withApiClient { implicit client =>
+      val user = createUser.futureValue
+      val request = AdminCreateTable.Request(Map("user_id" -> user.userId, "message" -> "Wiringbits"))
+
+      val response = client.createItem("user_logs", request).futureValue
+      response.id.nonEmpty mustBe true
+    }
+
     "fail when a mandatory field is not sent" in withApiClient { client =>
       val name = "wiringbits"
       val request = AdminCreateTable.Request(Map("name" -> name))
@@ -647,7 +708,7 @@ class AdminControllerSpec extends PlayPostgresSpec {
       val table = serialOverflowSettings
       val request = AdminCreateTable.Request(Map("name" -> name))
       val ignore = client.createItem(table.tableName, request).futureValue
-      ignore.noData must be(empty)
+      ignore.id.nonEmpty mustBe true
       val request2 = AdminCreateTable.Request(Map("name" -> s"asdf"))
       val error = client.createItem(table.tableName, request2).expectError
       error must be(s"ERROR: integer out of range")
@@ -657,7 +718,7 @@ class AdminControllerSpec extends PlayPostgresSpec {
       val table = bigSerialOverflowSettings
       val request = AdminCreateTable.Request(Map("name" -> name))
       val ignore = client.createItem(table.tableName, request).futureValue
-      ignore.noData must be(empty)
+      ignore.id.nonEmpty mustBe true
       val request2 = AdminCreateTable.Request(Map("name" -> s"asdf"))
       val error = client.createItem(table.tableName, request2).expectError
       error must be(
diff --git a/spra-play-server/src/test/scala/net/wiringbits/spra/admin/QueryBuilderSpec.scala b/spra-play-server/src/test/scala/net/wiringbits/spra/admin/QueryBuilderSpec.scala
@@ -14,14 +14,18 @@ class QueryBuilderSpec extends AnyWordSpec {
           |INSERT INTO users
           |  (user_id, email, name)
           |VALUES (
-          |  ?, ?, ?
+          |  ?, ?::citext, ?::text
           |)
+          |RETURNING user_id::TEXT
           |""".stripMargin
       val tableName = "users"
-      val body = Map("email" -> "wiringbits@wiringbits.net", "name" -> "wiringbits")
+      val body =
+        Map(TableColumn("email", "citext") -> "wiringbits@wiringbits.net", TableColumn("name", "text") -> "wiringbits")
       val primaryKeyField = "user_id"
 
       val response = QueryBuilder.create(tableName, body, primaryKeyField)
+      println(response)
+      println(expected)
       response must be(expected)
     }
 
@@ -33,9 +37,10 @@ class QueryBuilderSpec extends AnyWordSpec {
           |VALUES (
           |  ?
           |)
+          |RETURNING user_id::TEXT
           |""".stripMargin
       val tableName = "users"
-      val body = Map.empty[String, String]
+      val body = Map.empty[TableColumn, String]
       val primaryKeyField = "user_id"
 
       val response = QueryBuilder.create(tableName, body, primaryKeyField)
diff --git a/spra-play-server/src/test/scala/utils/AdminUtils.scala b/spra-play-server/src/test/scala/utils/AdminUtils.scala
@@ -0,0 +1,26 @@
+package utils
+
+import net.wiringbits.spra.api.AdminDataExplorerApiClient
+import net.wiringbits.spra.api.models.AdminCreateTable
+
+import scala.concurrent.{ExecutionContext, Future}
+
+trait AdminUtils {
+  case class User(userId: String, name: String, email: String)
+
+  case class UserLog(userLogId: String, userId: String, message: String)
+
+  def createUser(using ec: ExecutionContext, client: AdminDataExplorerApiClient): Future[User] = {
+    val name = "wiringbits"
+    val email = "test@wiringbits.net"
+    val password = "wiringbits"
+    val request = AdminCreateTable.Request(Map("name" -> name, "email" -> email, "password" -> password))
+    client.createItem("users", request).map(response => User(response.id, name, email))
+  }
+
+  def createUserLog(userId: String)(using ec: ExecutionContext, client: AdminDataExplorerApiClient): Future[UserLog] = {
+    val message = "test"
+    val request = AdminCreateTable.Request(Map("user_id" -> userId, "message" -> message))
+    client.createItem("user_logs", request).map(response => UserLog(response.id, userId, message))
+  }
+}
diff --git a/spra-web/src/main/scala/net/wiringbits/spra/ui/web/components/CreateGuesser.scala b/spra-web/src/main/scala/net/wiringbits/spra/ui/web/components/CreateGuesser.scala
@@ -37,7 +37,9 @@ object CreateGuesser {
                 ReferenceInput.Props(
                   source = field.name,
                   reference = reference,
-                  children = Seq(SelectInput(SelectInput.Props(optionText = source, disabled = field.disabled))),
+                  children = Seq(
+                    SelectInput(SelectInput.Props(optionText = source, isRequired = isRequired, validate = required))
+                  ),
                   isRequired = isRequired,
                   validate = required
                 )
diff --git a/spra-web/src/main/scala/net/wiringbits/spra/ui/web/components/EditGuesser.scala b/spra-web/src/main/scala/net/wiringbits/spra/ui/web/components/EditGuesser.scala
@@ -25,7 +25,7 @@ object EditGuesser {
 
   val component: FunctionalComponent[Props] = FunctionalComponent[Props] { props =>
     val fields = ResponseGuesser.getTypesFromResponse(props.response)
-    println(fields)
+
     val inputs: Seq[ReactElement] = fields.map { field =>
       if !field.isVisible then Fragment()
       else
diff --git a/spra-web/src/main/scala/net/wiringbits/spra/ui/web/facades/reactadmin/SelectInput.scala b/spra-web/src/main/scala/net/wiringbits/spra/ui/web/facades/reactadmin/SelectInput.scala

Original file line number	Diff line number	Diff line change
`@@ -60,7 +60,7 @@ class AdminController @Inject() (`
`60`	`60`	`_ <- adminUser(request)`
`61`	`61`	`_ = logger.info(s"Create row in $tableName: ${body.data}")`
`62`	`62`	`id <- adminService.create(tableName, body)`
`63`		`- } yield Ok(Json.toJson(Map("id" -> id)))`
	`63`	`+ } yield Ok(Json.toJson(AdminCreateTable.Response(id)))`
`64`	`64`	`}`
`65`	`65`
`66`	`66`	`def update(tableName: String, primaryKeyValue: String) = handleJsonBody[Map[String, String]] { request =>`