Ndtyjky

I'm building an API with Spring Boot and Kotlin. I am trying to generate a structure the following way in MongoDB.

I understand that in MongoDb the concept of relationships between entities does not exist, so I will use the strategy of embedded documents. That is, to embed the Reunión in the Proyecto, and the Participante in the Reunión.

I have a main class called Proyecto and NewProyecto, that contains as property a list of reuniones of type NewReunion. I use two different classes to create and return data.

Proyecto.kt

@Document(collection = "proyectos")

@TypeAlias("proyecto")

data class Proyecto (

        @Id

        val id: String,

        val nombre: String,

        val area: String,

        val fecha:String,

        val reuniones: List<Reunion>?

){}



@Document(collection = "proyectos")

@TypeAlias("newproyecto")

data class NewProyecto (

        @Id

        val id: String?,//Es posiblemente nulo porqué se crea automáticamente

        var nombre: String,

        var area: String,

        var fecha:String,

        var reuniones: List<NewReunion>?

){}

Now, to create 'reuniones' I have two classes, Reunion and NewReunion. The class that corresponds to create a MongoDB embedded document is NewReunion.

NewReunion.kt

@Document

data class Reunion(

        val objetivo: String,

        val fecha: String,

        val participantes: List<Participante>?

) {}



@Document

data class NewReunion(

        var id: String? = ObjectId().toHexString(),

        var fecha: String,

        var participantes: List<NewParticipante>?

) {}

This is where I have the problem. I want to generate an ObjectId for this NewReunion class, so that each object embedded in it has an id. The problem is that ObjectId ().ToHexString() is not generating any value at the time that the object of type NewReunion is built, but the other data that are objetivo and fecha are filled with the data that comes from the request POST.

How I send the information.

The information I send via POST. This request is handled by a Controller named ProyectoController.kt

ProyectoController.kt

@PostMapping("/")

fun createProyecto(@RequestBody newProyecto: NewProyecto): NewProyecto = proyectoService.createProyecto(newProyecto)

ProyectoRepository.kt

interface ProyectoRepository : MongoRepository<Proyecto, String> {

    fun findById(id: ObjectId): Proyecto

    override fun findAll(): List<Proyecto>

    fun insert(proyecto: NewProyecto): NewProyecto

    fun save(proyect: Proyecto): Proyecto

    fun deleteById(id: ObjectId)

}

ProyectoService.kt

@Service("proyectoService")

class ProyectoServiceImpl : ProyectoService {

    @Autowired

    lateinit var proyectoRepository: ProyectoRepository



    //Obtener un proyecto

    override fun findById(id: ObjectId): Proyecto = proyectoRepository.findById(id)



    //Obtener todos los proyectos

    override fun findAll(): List<Proyecto> = proyectoRepository.findAll()



    //Crear un proyecto

    override fun createProyecto(newProyecto: NewProyecto): NewProyecto = proyectoRepository.insert(newProyecto)



    //Actualizar un proyecto

    override fun updateProyecto(proyecto: Proyecto):Proyecto = proyectoRepository.save(proyecto)



    //Eliminar un proyecto

    override fun deleteProyecto(id:ObjectId) = proyectoRepository.deleteById(id)

}

POST using Postman:

To send the information I am using Postman, and I send the request in the following way.

At the time of creating the new Proyecto, I return it to see the result which returns a result with id=null, but all other fields do assign the corresponding value:

Now, I tried initializing all the constructor parameters of the NewReunion class to see what happened.

data class NewReunion(

        @Id

        var id: String? = ObjectId().toHexString(),

        var objetivo: String = "",

        var fecha: String = ""

) {}

the value for the id is generated correctly together with the other values. It is just this behavior that I do not understand why I need to initialize constructor parameters of the NewReunion class.

Result of POST with the parameters initialized.

build.gradle

buildscript {

    ext.kotlin_version = '1.2.71'

    ext {

        kotlinVersion = '1.2.71'

        springBootVersion = '2.0.6.RELEASE'

    }

    repositories {

        mavenCentral()

    }

    dependencies {

        classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")

        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${kotlinVersion}")

        classpath("org.jetbrains.kotlin:kotlin-allopen:${kotlinVersion}")

        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"

    }

}



apply plugin: 'kotlin'

apply plugin: 'kotlin-spring'

apply plugin: 'eclipse-wtp'

apply plugin: 'org.springframework.boot'

apply plugin: 'io.spring.dependency-management'

apply plugin: 'war'



group = 'com.gibranlara'

version = '0.0.1-SNAPSHOT'

sourceCompatibility = 1.8

compileKotlin {

    kotlinOptions {

        freeCompilerArgs = ["-Xjsr305=strict"]

        jvmTarget = "1.8"

    }

}

compileTestKotlin {

    kotlinOptions {

        freeCompilerArgs = ["-Xjsr305=strict"]

        jvmTarget = "1.8"

    }

}



repositories {

    mavenCentral()

}



configurations {

    providedRuntime

}



dependencies {

    compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version" // Required for Kotlin integration

    compile "org.jetbrains.kotlin:kotlin-reflect:$kotlin_version"

    compile "org.springframework.boot:spring-boot-starter-data-mongodb"

    compile 'org.springframework.boot:spring-boot-starter-web'

}

The library you are using is probably not written with Kotlin in mind.

Kotlin generates a synthetic constructor that loads default values prior to calling the actual constructor, e.g.

   // Java 

   public NewReunion(String var1, String var2, String var3, int var4, DefaultConstructorMarker var5) {

      if ((var4 & 1) != 0) {

         var1 = ObjectId().toHexString();

      }

      this(var1, var2, var3);

   }

The library is likely doing one of the following:

• Calling the default constructor, then calling set[Property] matching the annotations/convention.


• Calling the closest match constructor: NewReunion(@Nullable String id, @NotNull String objetivo, @NotNull String fecha) with NewReunion(null, "objetivo", "fecha")
  

If you define your class as such:

data class NewReunion @JvmOverloads constructor(

    var id: String? = "",

    var objetivo: String,

    var fecha: String

)

You will get additional constructors e.g.

// Java

public NewReunion(@NotNull String objetivo, @NotNull String fecha)

If your library is using the first option then you may need to lazy initialize the id field in a getter (also convert data class to normal class).

An Aside

Most of these kind of problems stem from devs using the same object model for communication and business logic. Whenever I see a nullable id on an entity it like a clarion call that bugs are afoot.

Any data you get from an outside source(even if it's from a server you control) should be treated as if it was put there by your most baleful enemy, but many developers just suck it in and use it as it comes.

If you don't have something along the lines of

val cleanData = validate(inputData)

before crossing from an input layer to a business layer then you are setting yourself up for future embarrassment.

Input layers are:

• User interface


• Web services


• Anything coming from outside your immediate domain of control