it's not very pretty, but i don't really feel comfortable opening that whole can of worms

What’s the main difference from SparkJava now getting Kotlin API?

spark's kotlin-api is a wrapper-class on top of the java-api, which adds implicit request/response variables

i'm trying to do the opposite, i'm going back to basics and implementing everything in kotlin (i'm also a spark co-maintainer)

javalin is my way of learning kotlin

I see. So from end user perspective the difference is small?

yes, the main difference would be that you're supposed to mutate the response (no return value for handlers), and that the classes you interact with (request/response) are kotlin

@jrp if you're looking for something like rails check out spring boot. it has a thing called spring data that generates queries for you based on method names, a la rails

what would people here prefer

app.get("/") { req, res-> res.body("Hello World") }

or

app.get("/") { ctx -> ctx.body("Hello World") }

where ctx contains both request and response

call.respond

;)

you're biased 😄

Everyone is!

i suppose that's true, but if you had to chose between these two inferior versions

Well, the second example is ambiguous because both the request and response could have a body (depending on the method, in the case of get it won’t, but then you’d need to create different kinds of contexts depending on the request type).

The thing is, request and response in http are so interconnected, you will have to pass both anyway, so context (or

call

) is preferred. It's easier to pass single object around

my thinking was to provide assumption-methods:

ctx.body() -> get request body
ctx.body(arg) -> set response body

then let people use `ctx.response`/`ctx.request` if they want to be more explicit

Yep, pretty much same to #ktor :)

alright, i'll try it out

if anyone is feeling very nice, i'd appreciate a review: https://github.com/tipsy/javalin/pull/19/files

just on the overall structure, if i should bother wrapping anything inside the

Context

, i just kinda dumped everything there

i just released javalin 0.3.0: https://javalin.io/news#major-api-changes feedback (both general and on the change) would be welcome

Well a request can also have a body, not just the response, therefore I would not endorse

ctx.body

(and calling it sans-argument to get the req. body and with-argument to set the response body doesn't feel right, either)

@gregopet currently it works like this -

ctx.body()

returns servlet-request body (

ctx.body(arg)

does not exist anymore) -

ctx.result(arg)

sets what will eventually become the response body

What are peoples opinions about backend framework? Ktor, Spring?

@thisen what's your use-case? I'm personally pretty biased towards http://www.http4k.org (not sure why.. :), but there's a further list of options on awesome-kotlin. https://kotlin.link/

My usecase is a web application using GraphQL

So http4k is probably not my thing 😉

@thisen fair play 😉 Not sure if there is a particularly mature graphql kotlin implementation, so maybe fallback to the spring-graphql options? - there's details in https://github.com/chentsulin/awesome-graphql . And in that case you might as well just use spring boot in kotlin TBH.