change the signature of methods to accept class object

[lambdaR]

@cyb3rko hi ... can we do this in kotlin? I have changed the signature of call method to accept HelloworldCallRequest instead of String

package com.m3o.m3okotlin.services

import com.m3o.m3okotlin.M3O.getUrl
import com.m3o.m3okotlin.M3O.ktorHttpClient
import com.m3o.m3okotlin.WebSocket

import io.ktor.client.request.*
import kotlinx.serialization.decodeFromString
import kotlinx.serialization.encodeToString
import kotlinx.serialization.json.Json
import kotlinx.serialization.Serializable

private const val SERVICE = "helloworld"

object HelloworldService {
    suspend fun call(req: HelloworldCallRequest): HelloworldCallResponse {
        return ktorHttpClient.post(getUrl(SERVICE, "Call")) {
          body = req
        }
    }
    fun stream(req: HelloworldStreamRequest, action: (Exception?, HelloworldStreamResponse?) -> Unit) {
        val url = getUrl(SERVICE, "Stream", true)
        WebSocket(url, Json.encodeToString(req)) { e, response ->
            action(e, if (response != null) Json.decodeFromString(response) else null)
        }.connect()
    }
}
@Serializable
internal data class HelloworldCallRequest(val name: String)
@Serializable
data class HelloworldCallResponse(val message: String)
@Serializable
internal data class HelloworldStreamRequest(val messages: Long, val name: String)
@Serializable
data class HelloworldStreamResponse(val message: String)

and then use it like this

package examples.helloworld.call

import com.m3o.m3okotlin.M3O
import com.m3o.m3okotlin.services.HelloWorldService

suspend fun main() {
    M3O.initialize("M3O_API_TOKEN")

    req = HelloWorldServiceRequest(name = "Jone")
    
    try {
        val response = HelloWorldService.call(req)
        println(response)
    } catch (e: Exception) {
        println(e)
    }
}

[cyb3rko]

That's an idea, it should work.
You are only missing the imports and the val in the main method when initializing the req.

[cyb3rko]

And how do you implement e.g. the stream request to follow the code scheme we use here?
Because I have some improvement, where can I at some point contribute it?

[lambdaR]

Because I have some improvement, where can I at some point contribute it?

You can contribute here (this org is basically a lab) until you PR kotlin project to m3o/m3o and m3o/m3o-kotlin.

And how do you implement e.g. the stream request to follow the code scheme we use here?

package examples.helloworld.stream

import com.cyb3rko.m3okotlin.M3O
import com.cyb3rko.m3okotlin.services.HelloWorldService

fun main() {
    M3O.initialize("NjJhODlhMmMtOGQ3Ni00YzljLWJhMzAtNGFkYzBhZTc5Yzcz")

    val req = HelloworldStreamRequest(messages = 2, name = "John")
    
    try {
        val socket = HelloWorldService.stream(req) { socketError, response ->
            if (socketError == null) {
                println(response)
            } else {
                println(socketError)
            }
        }
    } catch (e: Exception) {
        println(e)
    }
}

[lambdaR]

@cyb3rko I believe Asim wants all clients to look like below when you use it.

package examples.helloworld.call

import com.m3o.m3okotlin.M3O
import com.m3o.m3okotlin.services.HelloWorldService

suspend fun main() {
    val client = M3O.new("M3O_API_TOKEN")
    
    try {
        val response = client.HelloWorldService.call(
          req = HelloWorldServiceRequest(name = "Jone")
        )
        println(response)
    } catch (e: Exception) {
        println(e)
    }
}

see the equivalent go example https://github.com/m3o/m3o-go/blob/main/examples/helloworld/call/callHelloworld/main.go

[cyb3rko]

I think the solution I use in my handcrafted client is more convenient, but if Asim says he wants it like that, I can build new examples for that.

[lambdaR]

@cyb3rko Hi ... back to this .... i have applied the changes that we have discussed above ... can you make some random tests of these newly generated clients, lets see if they work properly.

[cyb3rko]

Hi, sorry for the delay. I was on holidays after finishing school.

I will take a look at it today.

[lambdaR]

Congrats... and don't worry

[cyb3rko]

Okay.
Some other things we have to change:

1. Every data class has to be public now (so the Request data classes are not allowed anymore to be "internal", just remove the keyword).

2. The first line of every file currently is "package com.m3o.m3okotlin.services".
   But it has to end with the according name of the service. E.g. "package com.m3o.m3okotlin.services.helloworld".

3. Furthermore we just need to fix a broken import line, I can open a pull request.

[lambdaR]

Cool... I will fix the generator... Then we can work on generating examples for each endpoint based on the examples.json

[lambdaR]

One thing that we can do to improve the visibility (it is quite verbose right now) is to create an index file where we list all repetitive imports in one file and then use that file instead, so for example at the top code there are 7 repeated import statements that we could replace with only one import.

[cyb3rko]

If I understand right you want to remove the following lines of the example above:

import com.m3o.m3okotlin.M3O.getUrl
import com.m3o.m3okotlin.M3O.ktorHttpClient
import com.m3o.m3okotlin.WebSocket

import io.ktor.client.request.*
import kotlinx.serialization.decodeFromString
import kotlinx.serialization.encodeToString
import kotlinx.serialization.json.Json
import kotlinx.serialization.Serializable

Unfortunately that's not a thing you can do in Kotlin.
And honestly I don't see a reason why we should do changes about the imports. Additionally they are just necessary for the code to work xD
We could just lower the number of imports with wildcarding.

You can even see this in code of Google Apps like here:

https://github.com/material-components/material-components-android/blob/master/catalog/java/io/material/catalog/main/MainActivity.java#L21-L38

Even though you could use more wildcard imports here for imports but they don't even use them here.
What we can improve though is to use better formatting:

• remove blank lines between imports
• sorting the imports alphabetically (here they seem to be sorted, I don't know about the other files)

[lambdaR]

I see... One more thing that we need to know for sure is the process of publishing a library to the kotlin libraries/packages manager... What are the steps we need to do? Is there any community github action that do all/parts of the process?

[cyb3rko]

For sure. I will look it up and tell you when I've found something.