Add response models

Author: abnegate

build.gradle

@@ -1,9 +1,8 @@
 plugins {
-    id 'org.jetbrains.kotlin.jvm' version '1.4.32'
+    id 'org.jetbrains.kotlin.jvm' version '1.5.31'
     id 'java-library'
 }
 
-
 ext {
     PUBLISH_GROUP_ID = 'io.appwrite'
     PUBLISH_ARTIFACT_ID = 'sdk-for-kotlin'
@@ -27,12 +26,12 @@ repositories {
 }
 
 dependencies {
-    api("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.4.3")
+    api("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.5.2")
     api(platform("com.squareup.okhttp3:okhttp-bom:4.9.0"))
     api("com.squareup.okhttp3:okhttp")
     implementation("com.squareup.okhttp3:okhttp-urlconnection")
     implementation("com.squareup.okhttp3:logging-interceptor")
-    implementation("com.google.code.gson:gson:2.8.5")
+    implementation("com.google.code.gson:gson:2.8.7")
 
     testImplementation 'org.jetbrains.kotlin:kotlin-test-junit'
 }

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.8-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.0.2-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

settings.gradle

@@ -1,3 +1,2 @@
-
 rootProject.name = 'sdk-for-kotlin'
 

src/main/kotlin/io/appwrite/Client.kt

@@ -1,9 +1,10 @@
 package io.appwrite
 
-import com.google.gson.Gson
+import com.google.gson.GsonBuilder
+import com.google.gson.reflect.TypeToken
 import io.appwrite.exceptions.AppwriteException
-import io.appwrite.extensions.JsonExtensions.fromJson
-import io.appwrite.models.Error
+import io.appwrite.extensions.fromJson
+import io.appwrite.json.PreciseNumberAdapter
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
@@ -15,6 +16,7 @@ import okhttp3.MediaType.Companion.toMediaType
 import okhttp3.RequestBody.Companion.asRequestBody
 import okhttp3.RequestBody.Companion.toRequestBody
 import okhttp3.logging.HttpLoggingInterceptor
+import java.io.BufferedInputStream
 import java.io.BufferedReader
 import java.io.File
 import java.io.IOException
@@ -38,20 +40,26 @@ class Client @JvmOverloads constructor(
 
     private val job = Job()
 
-    private lateinit var http: OkHttpClient
+    private val gson = GsonBuilder().registerTypeAdapter(
+        object : TypeToken<Map<String, Any>>(){}.type,
+        PreciseNumberAdapter()
+    ).create()
+
+    lateinit var http: OkHttpClient
 
     private val headers: MutableMap<String, String>
-    
+
     val config: MutableMap<String, String>
 
+
     init {
         headers = mutableMapOf(
             "content-type" to "application/json",
             "x-sdk-version" to "appwrite:kotlin:0.1.1",            
             "x-appwrite-response-format" to "0.11.0"
         )
         config = mutableMapOf()
-        
+
         setSelfSigned(selfSigned)
     }
 
@@ -115,10 +123,10 @@ class Client @JvmOverloads constructor(
 
     /**
      * Set self Signed
-     * 
+     *
      * @param status
      *
-     * @return this     
+     * @return this
      */
     fun setSelfSigned(status: Boolean): Client {
         selfSigned = status
@@ -134,9 +142,12 @@ class Client @JvmOverloads constructor(
         try {
             // Create a trust manager that does not validate certificate chains
             val trustAllCerts = arrayOf<TrustManager>(
+                @Suppress("CustomX509TrustManager")
                 object : X509TrustManager {
+                    @Suppress("TrustAllX509TrustManager")
                     override fun checkClientTrusted(chain: Array<X509Certificate>, authType: String) {
                     }
+                    @Suppress("TrustAllX509TrustManager")
                     override fun checkServerTrusted(chain: Array<X509Certificate>, authType: String) {
                     }
                     override fun getAcceptedIssuers(): Array<X509Certificate> {
@@ -175,11 +186,11 @@ class Client @JvmOverloads constructor(
 
     /**
      * Add Header
-     * 
+     *
      * @param key
      * @param value
      *
-     * @return this     
+     * @return this
      */
     fun addHeader(key: String, value: String): Client {
         headers[key] = value
@@ -188,22 +199,23 @@ class Client @JvmOverloads constructor(
 
     /**
      * Send the HTTP request
-     * 
+     *
      * @param method
      * @param path
      * @param headers
      * @param params
      *
-     * @return [Response]    
+     * @return [Response]
      */
     @Throws(AppwriteException::class)
-    suspend fun call(
-        method: String, 
-        path: String, 
-        headers:  Map<String, String> = mapOf(), 
-        params: Map<String, Any?> = mapOf()
-    ): Response {
-
+    suspend fun <T> call(
+        method: String,
+        path: String,
+        headers:  Map<String, String> = mapOf(),
+        params: Map<String, Any?> = mapOf(),
+        responseType: Class<T>,
+        convert: ((Map<String, Any,>) -> T)? = null
+    ): T {
         val filteredParams = params.filterValues { it != null }
 
         val requestHeaders = this.headers.toHeaders().newBuilder()
@@ -238,7 +250,7 @@ class Client @JvmOverloads constructor(
                 .get()
                 .build()
 
-            return awaitResponse(request)
+            return awaitResponse(request, responseType, convert)
         }
 
         val body = if (MultipartBody.FORM.toString() == headers["content-type"]) {
@@ -266,7 +278,7 @@ class Client @JvmOverloads constructor(
             }
             builder.build()
         } else {
-            Gson().toJson(filteredParams)
+            gson.toJson(filteredParams)
                 .toRequestBody("application/json".toMediaType())
         }
 
@@ -276,21 +288,24 @@ class Client @JvmOverloads constructor(
             .method(method, body)
             .build()
 
-        return awaitResponse(request)
+        return awaitResponse(request, responseType, convert)
     }
 
     /**
      * Await Response
-     * 
-     * @param method
-     * @param path
-     * @param headers
-     * @param params
      *
-     * @return [Response]    
+     * @param request
+     * @param responseType
+     * @param convert
+     *
+     * @return [T]
      */
     @Throws(AppwriteException::class)
-    private suspend fun awaitResponse(request: Request) = suspendCancellableCoroutine<Response> {
+    private suspend fun <T> awaitResponse(
+        request: Request,
+        responseType: Class<T>,
+        convert: ((Map<String, Any,>) -> T)? = null
+    ) = suspendCancellableCoroutine<T> {
         http.newCall(request).enqueue(object : Callback {
             override fun onFailure(call: Call, e: IOException) {
                 if (it.isCancelled) {
@@ -299,27 +314,54 @@ class Client @JvmOverloads constructor(
                 it.cancel(e)
             }
 
+            @Suppress("UNCHECKED_CAST")
             override fun onResponse(call: Call, response: Response) {
-                if (response.code >= 400) {
-                    val bodyString = response.body
-                        ?.charStream()
-                        ?.buffered()
-                        ?.use(BufferedReader::readText) ?: ""
-
-                    val contentType: String = response.headers["content-type"] ?: ""
-                    val error = if (contentType.contains("application/json", ignoreCase = true)) {
-                        bodyString.fromJson(Error::class.java)
+                if (!response.isSuccessful) {
+                    val body = response.body!!
+                        .charStream()
+                        .buffered()
+                        .use(BufferedReader::readText)
+                    val error = if (response.headers["content-type"]?.contains("application/json") == true) {
+                        body.fromJson()
                     } else {
-                        Error(bodyString, response.code)
+                        AppwriteException(body, response.code)
                     }
-
-                    it.cancel(AppwriteException(
-                        error.message,
-                        error.code,
-                        bodyString
-                    ))
+                    it.cancel(error)
+                    return
+                }
+                when {
+                    responseType == Boolean::class.java -> {
+                        it.resume(true as T)
+                        return
+                    }
+                    responseType == ByteArray::class.java -> {
+                        it.resume(response.body!!
+                            .byteStream()
+                            .buffered()
+                            .use(BufferedInputStream::readBytes) as T
+                        )
+                        return
+                    }
+                    response.body == null -> {
+                        it.resume(true as T)
+                        return
+                    }
+                }
+                val body = response.body!!
+                    .charStream()
+                    .buffered()
+                    .use(BufferedReader::readText)
+                if (body.isEmpty()) {
+                    it.resume(true as T)
+                    return
                 }
-                it.resume(response)
+                val map = gson.fromJson<Map<String, Any>>(
+                    body,
+                    object : TypeToken<Map<String, Any>>(){}.type
+                )
+                it.resume(
+                    convert?.invoke(map) ?: map as T
+                )
             }
         })
     }

src/main/kotlin/io/appwrite/exceptions/AppwriteException.kt

@@ -3,7 +3,7 @@ package io.appwrite.exceptions
 import java.lang.Exception
 
 class AppwriteException(
-    message: String? = null,
+    override val message: String? = null,
     val code: Int? = null,
     val response: String? = null
 ) : Exception(message)

src/main/kotlin/io/appwrite/extensions/JsonExtensions.kt

@@ -2,11 +2,33 @@ package io.appwrite.extensions
 
 import com.google.gson.Gson
 
-object JsonExtensions {
+val gson = Gson()
 
-    fun Any.toJson(): String =
-        Gson().toJson(this)
+fun Any.toJson(): String =
+    gson.toJson(this)
 
-    fun <T> String.fromJson(clazz: Class<T>): T =
-        Gson().fromJson(this, clazz)
-}
+fun <T> String.fromJson(clazz: Class<T>): T =
+    gson.fromJson(this, clazz)
+
+inline fun <reified T> String.fromJson(): T =
+    gson.fromJson(this, T::class.java)
+
+fun <T> Any.jsonCast(to: Class<T>): T =
+    toJson().fromJson(to)
+
+inline fun <reified T> Any.jsonCast(): T =
+    toJson().fromJson(T::class.java)
+
+fun <T> Any.tryJsonCast(to: Class<T>): T? = try {
+    toJson().fromJson(to)
+} catch (ex: Exception) {
+    ex.printStackTrace()
+    null
+}
+
+inline fun <reified T> Any.tryJsonCast(): T? = try {
+    toJson().fromJson(T::class.java)
+} catch (ex: Exception) {
+    ex.printStackTrace()
+    null
+}