fun add(value1: Int, value2: Int): HttpHandler = {
        Response(OK).with(
            Body.string(TEXT_PLAIN).toLens() of (value1 + value2).toString()
        )}

    val contract = contract(OpenApi(ApiInfo("my great api", "v1.0"), Argo),
        "/add" / <http://Path.int|Path.int>().of("value1") / Path.fixed("hello") / <http://Path.int|Path.int>().of("value2") meta {
            summary = "add"
            description = "Adds 2 numbers together"
            returning("The result" to OK)
        } bindContract GET
            to { a, _, c -> add(a, c) }
    )

    contract.asServer(Jetty(8000)).start()

class SimpleObject(val id: String, val attrs: Map<String, Any?>,
                        val created: ZonedDateTime,
                        val updated: ZonedDateTime
)

with( Header.zonedDateTime().required("last-modified") of obj.created)

"created":{"dateTime":{"date":{"year":2018,"month":3,...

this.map(ZonedDateTime::parse, DateTimeFormatter.ISO_ZONED_DATE_TIME::format)

"object-1161328054": {
			"type": "object",
			"properties": {}
		},
		"object158819726": {
			"type": "object",
			"properties": {
				"id": {
					"type": "string"
				},
				"attrs": {
					"$ref": "#/definitions/object-1161328054"
				},
				"created": {
					"type": "string"
				},
				"updated": {
					"type": "string"
				}
			}
		},
		"object-1161328054": {
			"type": "object",
			"properties": {}
		},

HTTP/1.1 400 body 'body' must be object

routes(
"/sgzr/api/v1" bind Api.router(productService, orderService)
).let {
DebuggingFilters.PrintRequestAndResponse()
                .then(ServerFilters.Cors(CorsPolicy.UnsafeGlobalPermissive))
                .then(ServerFilters.CatchAll())
                .then(ServerFilters.CatchLensFailure)
                .then(it)
}

CatchLensFailure

ServerFilters.CatchLensFailure { lensFailure -> Response(OK).body(lensFailure.localizedMessage) }

import org.http4k.contract.*
import org.http4k.core.*
import org.http4k.format.Jackson
import org.http4k.format.Jackson.auto
import org.http4k.routing.bind
import org.http4k.routing.routes
import org.http4k.server.Jetty
import org.http4k.server.asServer

data class MyDataClass(val something: String)
val requestBody = Body.auto<MyDataClass>().toLens()

fun main(args: Array<String>) {
    routes(
        "/api" bind contract(OpenApi(ApiInfo("My great API", "v1.0"), Jackson),"/route" meta {
            body = requestBody
        } bindContract Method.GET to ::handler)
    ).asServer(Jetty(5000)).start()
}

fun handler(request: Request): Response {
    return Response(Status.OK)
}

{
  “swagger” : “2.0",
  “info” : {
    “title” : “My great API”,
    “version” : “v1.0”,
    “description” : “”
  },
  “basePath” : “/”,
  “tags” : [ ],
  “paths” : {
    “/api/route” : {
      “get” : {
        “tags” : [ “/api” ],
        “summary” : “<unknown>“,
        “description” : null,
        “produces” : [ ],
        “consumes” : [ “application/json” ],
        “parameters” : [ {
          “in” : “body”,
          “name” : “body”,
          “description” : null,
          “required” : true,
          “type” : “object”
        } ],
        “responses” : { },
        “supportedContentTypes” : [ ],
        “security” : [ ]
      }
    }
  },
  “securityDefinitions” : { },
  “definitions” : { }
}

/foo/{bar:.*}

.