FIX: DB Schema generator (#388)

* Update CodeGenApi.kt

* Update Schema.kt

* Update Schema.kt

* fix: postgres data type for double to float8

* fix: Support a tags field on the entity column

* fix: Entities - auto-load of required w/ override

* fix: tests to ensure double type

Author: kishorereddy

src/data/data/src/main/kotlin/kiit/data/sql/vendors/Postgres.kt

@@ -66,6 +66,8 @@ object PostgresTypes : DbTypes() {
     override val localDateTimeType = DataTypeMap(DataType.DTLocalDateTime, "TIMESTAMP", Types.JLocalDateTimeClass)
     override val zonedDateTimeType = DataTypeMap(DataType.DTZonedDateTime, "TIMESTAMPTZ", Types.JZonedDateTimeClass)
     override val dateTimeType = DataTypeMap(DataType.DTDateTime, "TIMESTAMPTZ", Types.JDateTimeClass)
+    override val doubleType = DataTypeMap(DataType.DTDouble, "FLOAT8", Types.JDoubleClass)
+
 
 
     override val lookup:Map<DataType, DataTypeMap> = mapOf(

src/data/entities/src/main/kotlin/kiit/entities/EntityRepo.kt

@@ -34,7 +34,7 @@ open class EntityRepo<TId, T>(
     : SqlRepo<TId, T>(db, meta, mapper, syntax, hooks, mode) where TId : Comparable<TId>, T : Any {
 
     private val lookup:Map<String, String> = if(mapper is EntityMapper<*, *>) {
-        mapper.model.fields.map { it.name to it.storedName }.toMap()
+        mapper.model.fields.associate { it.name to it.storedName }
     }
     else {
         mapOf()

src/data/entities/src/main/kotlin/kiit/entities/Id.kt

@@ -31,12 +31,13 @@ annotation class Id(
 annotation class Column(
     val name: String = "",
     val desc: String = "",
-    val required: Boolean = true,
+    val required: Boolean = false,
     val unique: Boolean = false,
     val updatable: Boolean = true,
     val indexed: Boolean = false,
     val length: Int = 0,
     val defaultVal: String = "",
     val encrypt: Boolean = false,
-    val example: String = ""
+    val example: String = "",
+    val tags: Array<String> = [],
 )

src/data/entities/src/main/kotlin/kiit/entities/Schema.kt

@@ -51,15 +51,20 @@ object Schema {
 
     @JvmStatic
     fun column(prop: KProperty<*>, anno: Column, namer: Namer?, checkForId:Boolean, idFieldName:String?):ModelField {
-        val name = if (anno.name.isNullOrEmpty()) prop.name else anno.name
+        val name = anno.name.ifEmpty { prop.name }
         val cat = idFieldName?.let {
             if(it == name)
                 FieldCategory.Id
             else
                 FieldCategory.Data
         } ?: FieldCategory.Data
 
-        val required = anno.required
+        // Get whether its required based on nullable property.
+        val required = when {
+            !prop.returnType.isMarkedNullable -> true
+            anno.required -> true
+            else -> false
+        }
         val length = anno.length
         val encrypt = anno.encrypt
         val fieldKType = prop.returnType
@@ -76,7 +81,8 @@ object Schema {
             maxLength = length,
             encrypt = encrypt,
             cat = cat,
-            namer = namer
+            namer = namer,
+            tags = anno.tags.toList()
         )
         return field
     }

src/lib/kotlin/slatekit-tests/src/test/kotlin/test/data/repo/Repo_Postgres_Tests.kt

@@ -1,9 +1,11 @@
 package test.data.repo
 
 import kiit.common.data.Vendor
+import kiit.data.sql.vendors.PostgresTypes
 import kiit.entities.Entities
 import kiit.entities.EntityLongId
 import kiit.entities.EntityRepo
+import kiit.entities.mapper.EntityMapper
 import kotlinx.coroutines.runBlocking
 import org.junit.Assert
 import org.junit.Test
@@ -38,5 +40,8 @@ open class Repo_Postgres_Tests : Repo_Common_Tests() {
         val repo = entities.repo(EntityLongId(), Long::class, User5::class, Vendor.Postgres)
         Assert.assertEquals("user", repo.meta.table.name)
         Assert.assertEquals("unit_tests", repo.meta.table.schema)
+        val mapper = repo.mapper as EntityMapper<Long, User5>
+        val field = mapper.model.fields.first { it.name ==  "salary" }
+        Assert.assertEquals(PostgresTypes.doubleType.metaType, field.dataTpe)
     }
 }

src/lib/kotlin/slatekit-tests/src/test/kotlin/test/entities/Entity_Service_Registry_Tests.kt

@@ -17,6 +17,7 @@ import org.junit.Test
 import kiit.common.data.*
 import kiit.entities.*
 import test.setup.User5
+import test.setup.UserTypes
 
 class Entity_Service_Registry_Tests {
 
@@ -29,6 +30,24 @@ class Entity_Service_Registry_Tests {
     }
 
 
+    @Test
+    fun can_load_model_field_required_from_type() {
+        val model = Schema.load(UserTypes::class, UserTypes::id.name)
+
+        // Case 1: Type is required
+        val email = model.fields.first { it.name == "email" }
+        Assert.assertEquals(true, email.isRequired)
+
+        // Case 2: Type is nullable ( Optional )
+        val website = model.fields.first { it.name == "website" }
+        Assert.assertEquals(false, website.isRequired)
+
+        // Case 3: Type is nullable ( Optional ), but annotation marked as required
+        val link = model.fields.first { it.name == "link" }
+        Assert.assertEquals(true, link.isRequired)
+    }
+
+
     @Test
     fun can_register(){
         val info = entities.getInfo<User5>()

src/lib/kotlin/slatekit-tests/src/test/kotlin/test/setup/UserNormal.kt

@@ -171,6 +171,56 @@ data class User5(
 }
 
 
+@Table("user", schema = "unit_tests")
+data class UserTypes(
+    @Id()
+    override val id: Long = 0,
+
+    @Column(length = 50)
+    val userId: String = Random.uuid(),
+
+    @Column(length = 100)
+    val email: String = "",
+
+    @Column(length = 100)
+    val website: String? = null,
+
+    @Column(length = 100, required = true)
+    val link: String? = null,
+
+    @Column()
+    val isActive: Boolean = false,
+
+    @Column()
+    val level: Int = 35,
+
+    @Column()
+    val salary: Double = 20.5,
+
+    @Column(name = "createdat", required = true)
+    val createdAt: DateTime = DateTime.now(),
+
+    @Column(name = "createdby", required = true)
+    val createdBy: Long = 0,
+
+    @Column(name = "updatedat")
+    val updatedAt: DateTime? = null,
+
+    @Column(name = "updatedby")
+    val updatedBy: Long? = null
+) : EntityWithId<Long>, EntityUpdatable<Long, UserTypes> {
+
+    override fun isPersisted(): Boolean = id > 0
+
+    /**
+     * sets the id on the entity and returns the entity with updated id.
+     * @param id
+     * @return
+     */
+    override fun withId(id: Long): UserTypes {
+        return this.copy(id = id)
+    }
+}
 
 data class UserNullable(
     @Id()

src/services/apis/src/main/kotlin/kiit/apis/tools/code/CodeGenApi.kt

@@ -16,7 +16,7 @@ import kiit.results.Notice
  * slatekit.codegen.toJava   -templatesFolder="user://git/slatekit/scripts/templates/codegen/java"       -outputFolder="user://dev/temp/codegen/java"  -packageName="myapp" -classFile="" -methodFile="" -modelFile=""
  * slatekit.codegen.toKotlin -templatesFolder="usr://dev/tmp/slatekit/slatekit/scripts/templates/codegen/kotlin" -outputFolder="usr://dev/tmp/codegen/kotlin" -packageName="myapp"
  */
-@Api(area = "slatekit", name = "codegen", desc = "client code generator", verb = Verbs.AUTO, sources = [Sources.CLI])
+@Api(area = "kiit", name = "codegen", desc = "client code generator", verb = Verbs.AUTO, sources = [Sources.CLI])
 class CodeGenApi : HostAware {
 
     private var host: ApiServer? = null