WD-321 Make default configurations rewritable (#15)

YokiToki · AlexeiiShvedov · web-flow · commit 13f9af7809fd · 2020-05-21T21:38:18.000+07:00
* WD-321 Make default configurations rewritable

* WD-321 Fix sample

* WD-321 Fix filter API configuration

* WD-321 Fix version, small fixes

* WD-321 Fix version, small fixes

* WD-321 change configuration API to apply struct

Co-authored-by: Alex Shvedov &lt;alexeii.shvedov@gmail.com&gt;
diff --git a/README.md b/README.md
@@ -12,7 +12,7 @@ repositories {
 }
 
 // Append dependency
-implementation("com.icerockdev:web-utils:0.3.1")
+implementation("com.icerockdev:web-utils:0.4.0")
 ````
 
 ## Library usage
diff --git a/sample/src/main/kotlin/com/icerockdev/sample/server.kt b/sample/src/main/kotlin/com/icerockdev/sample/server.kt
@@ -4,6 +4,7 @@
 
 package com.icerockdev.sample
 
+import com.fasterxml.jackson.databind.SerializationFeature
 import com.icerockdev.api.AbstractResponse
 import com.icerockdev.api.Request
 import com.icerockdev.exception.ForbiddenException
@@ -12,9 +13,9 @@ import com.icerockdev.exception.ValidationException
 import com.icerockdev.util.QueryParser
 import com.icerockdev.util.receiveQuery
 import com.icerockdev.webserver.*
-import com.icerockdev.webserver.log.LoggingConfiguration
 import com.icerockdev.webserver.log.JsonDataLogger
 import com.icerockdev.webserver.log.JsonSecret
+import com.icerockdev.webserver.log.LoggingConfiguration
 import com.icerockdev.webserver.log.jsonLogger
 import com.icerockdev.webserver.tools.receiveRequest
 import io.ktor.application.Application
@@ -31,26 +32,43 @@ import io.ktor.util.KtorExperimentalAPI
 
 @KtorExperimentalAPI
 fun Application.main() {
-    install(StatusPages, getStatusConfiguration())
+    install(StatusPages) {
+        applyStatusConfiguration()
+    }
+
     install(CORS) {
         applyDefaultCORS()
         anyHost() // @TODO: Don't do this in production if possible. Try to limit it.
     }
     install(DefaultHeaders)
     install(CallLogging) {
         applyDefaultLogging()
+        // Log only /api requests
+        // filter { call -> call.request.path().startsWith("/api") }
     }
     install(JsonDataLogger) {
-        mapperConfiguration = getObjectMapper()
+        mapperConfiguration = {
+            applyObjectMapper()
+        }
         loggingConfiguration =
-            LoggingConfiguration(responseTypes = listOf(AbstractResponse::class, CustomResponse::class))
+            LoggingConfiguration(
+                responseTypes = listOf(AbstractResponse::class, CustomResponse::class),
+                requestTypes = listOf(Request::class)
+            )
+    }
+    install(CallId) {
+        applyCallConfiguration()
     }
-    install(CallId, getCallConfiguration())
     install(ContentNegotiation) {
-        jackson(block = getObjectMapper())
+        jackson() {
+            applyObjectMapper()
+            configure(SerializationFeature.INDENT_OUTPUT, false)
+        }
     }
     install(QueryParser) {
-        mapperConfiguration = getObjectMapper()
+        mapperConfiguration = {
+            applyObjectMapper()
+        }
     }
 
     /**
diff --git a/web-utils/build.gradle.kts b/web-utils/build.gradle.kts
@@ -13,7 +13,7 @@ apply(plugin = "java")
 apply(plugin = "kotlin")
 
 group = "com.icerockdev"
-version = "0.3.1"
+version = "0.4.0"
 
 val sourcesJar by tasks.registering(Jar::class) {
     classifier = "sources"
diff --git a/web-utils/src/main/kotlin/com/icerockdev/webserver/configuration.kt b/web-utils/src/main/kotlin/com/icerockdev/webserver/configuration.kt
@@ -28,50 +28,47 @@ import org.slf4j.LoggerFactory
 import org.slf4j.event.Level
 import java.util.*
 
-fun getStatusConfiguration(): StatusPages.Configuration.() -> Unit {
-
-    return {
-        status(HttpStatusCode.NotFound) { status ->
-            val error = ErrorResponse().also {
-                it.status = status.value
-                it.message = "Route not found"
-            }
-            call.respond(
-                status,
-                error
-            )
+fun StatusPages.Configuration.applyStatusConfiguration() {
+    status(HttpStatusCode.NotFound) { status ->
+        val error = ErrorResponse().also {
+            it.status = status.value
+            it.message = "Route not found"
         }
-        status(HttpStatusCode.Unauthorized) { status ->
-            val error = ErrorResponse().also {
-                it.status = status.value
-                it.message = "Unauthorized"
-                it.success = false
-            }
-            call.respond(
-                status,
-                error
-            )
-        }
-        exception<UserException> { cause ->
-            call.respond(
-                HttpStatusCode(cause.status, cause.message.toString()),
-                cause.getErrorResponse()
-            )
+        call.respond(
+            status,
+            error
+        )
+    }
+    status(HttpStatusCode.Unauthorized) { status ->
+        val error = ErrorResponse().also {
+            it.status = status.value
+            it.message = "Unauthorized"
+            it.success = false
         }
-        exception<Throwable> { cause ->
-            val error = ErrorResponse().also {
-                it.status = HttpStatusCode.InternalServerError.value
-                it.message = cause.message.toString()
-            }
-            call.respond(
-                HttpStatusCode.InternalServerError,
-                error
-            )
+        call.respond(
+            status,
+            error
+        )
+    }
+    exception<UserException> { cause ->
+        call.respond(
+            HttpStatusCode(cause.status, cause.message.toString()),
+            cause.getErrorResponse()
+        )
+    }
+    exception<Throwable> { cause ->
+        val error = ErrorResponse().also {
+            it.status = HttpStatusCode.InternalServerError.value
+            it.message = cause.message.toString()
         }
+        call.respond(
+            HttpStatusCode.InternalServerError,
+            error
+        )
     }
 }
 
-fun CORS.Configuration.applyDefaultCORS(): CORS.Configuration {
+fun CORS.Configuration.applyDefaultCORS() {
     method(HttpMethod.Options)
     method(HttpMethod.Put)
     method(HttpMethod.Delete)
@@ -81,10 +78,9 @@ fun CORS.Configuration.applyDefaultCORS(): CORS.Configuration {
     exposeHeader("X-Total-Count")
     allowCredentials = true
     allowNonSimpleContentTypes = true
-    return this
 }
 
-fun CallLogging.Configuration.applyDefaultLogging(): CallLogging.Configuration {
+fun CallLogging.Configuration.applyDefaultLogging() {
     level = Level.TRACE
     callIdMdc(Constants.LOG_FIELD_TRACE_UUID)
     mdc(Constants.LOG_FIELD_HEADERS) { call: ApplicationCall ->
@@ -99,27 +95,19 @@ fun CallLogging.Configuration.applyDefaultLogging(): CallLogging.Configuration {
     mdc(Constants.LOG_FIELD_REQUEST_PATH) { call: ApplicationCall ->
         call.request.path()
     }
-    return this
-}
-
-fun CallLogging.Configuration.applyApiFilter(): CallLogging.Configuration {
-    filter { call -> call.request.path().startsWith("/api") }
-    return this
 }
 
 private fun entriesToString(entries: Set<Map.Entry<String, List<String>>>): String {
     return entries.joinToString(separator = "\n", transform = { String.format("%s: %s", it.key, it.value.first()) })
 }
 
 
-fun getObjectMapper(): ObjectMapper.() -> Unit {
-    return {
-        configure(SerializationFeature.INDENT_OUTPUT, true)
-        disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS)
-        disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)
-        dateFormat = StdDateFormat()
-        registerKotlinModule()
-    }
+fun ObjectMapper.applyObjectMapper() {
+    configure(SerializationFeature.INDENT_OUTPUT, true)
+    disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS)
+    disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)
+    dateFormat = StdDateFormat()
+    registerKotlinModule()
 }
 
 fun getMonitoringPipeline(): suspend PipelineContext<Unit, ApplicationCall>.(Unit) -> Unit {
@@ -139,21 +127,19 @@ fun getMonitoringPipeline(): suspend PipelineContext<Unit, ApplicationCall>.(Uni
         } catch (e: Throwable) {
             call.respond(
                 HttpStatusCode.InternalServerError,
-                object : Response(
+                Response(
                     status = HttpStatusCode.InternalServerError.value,
                     message = e.message ?: "",
                     isSuccess = false
-                ) {}
+                )
             )
             proceed()
             logger.error(e.localizedMessage, e)
         }
     }
 }
 
-fun getCallConfiguration(): CallId.Configuration.() -> Unit {
-    return {
-        generate { UUID.randomUUID().toString() }
-        header("X-Request-ID")
-    }
-}
+fun CallId.Configuration.applyCallConfiguration() {
+    generate { UUID.randomUUID().toString() }
+    header("X-Request-ID")
+}
diff --git a/web-utils/src/main/kotlin/com/icerockdev/webserver/log/JsonDataLogger.kt b/web-utils/src/main/kotlin/com/icerockdev/webserver/log/JsonDataLogger.kt
@@ -16,6 +16,8 @@ import com.fasterxml.jackson.databind.introspect.JacksonAnnotationIntrospector
 import com.fasterxml.jackson.databind.jsontype.TypeSerializer
 import com.fasterxml.jackson.databind.ser.std.StdScalarSerializer
 import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
+import com.icerockdev.api.AbstractResponse
+import com.icerockdev.api.Request
 import com.icerockdev.webserver.Constants
 import com.icerockdev.webserver.Environment
 import io.ktor.application.*
@@ -45,7 +47,10 @@ class JsonDataLogger(configure: Configuration.() -> Unit) {
         var responseStatusCodeName: String = Constants.LOG_FIELD_STATUS_CODE
         var appEnvName: String = Constants.LOG_FIELD_ENV
         var systemEnvKey: String = "env"
-        var loggingConfiguration: LoggingConfiguration = LoggingConfiguration()
+        var loggingConfiguration: LoggingConfiguration = LoggingConfiguration(
+            requestTypes = listOf(Request::class),
+            responseTypes = listOf(AbstractResponse::class)
+        )
     }
 
     init {
diff --git a/web-utils/src/main/kotlin/com/icerockdev/webserver/log/LoggingConfiguration.kt b/web-utils/src/main/kotlin/com/icerockdev/webserver/log/LoggingConfiguration.kt
@@ -1,10 +1,8 @@
 package com.icerockdev.webserver.log
 
-import com.icerockdev.api.AbstractResponse
-import com.icerockdev.api.Request
 import kotlin.reflect.KClass
 
 class LoggingConfiguration(
-    val requestTypes: List<KClass<*>> = listOf(Request::class),
-    val responseTypes: List<KClass<*>> = listOf(AbstractResponse::class)
+    val requestTypes: List<KClass<*>>,
+    val responseTypes: List<KClass<*>>
 )

Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ repositories {`
`12`	`12`	`}`
`13`	`13`
`14`	`14`	`// Append dependency`
`15`		`-implementation("com.icerockdev:web-utils:0.3.1")`
	`15`	`+implementation("com.icerockdev:web-utils:0.4.0")`
`16`	`16`	````
`17`	`17`
`18`	`18`	`## Library usage`