Rename StreamError to Error

Author: JcMinarro

README.md

@@ -52,15 +52,15 @@ dependencies {
 This is a basic model to represent a normalized result from business work. This looks similar to [Kotlin's Result](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-result/), but Stream Result was designed to include more information about success and error and support more convenient functionalities to handle results. Result is basically consist of two detailed types below:
 
 - **Result.Success**: This represents your business's successful result, including a `value` property, a generic type of Result.
-- **Result.Failure**: This represents the failed result of your business result and includes a `value` property, the `StreamError` type.
+- **Result.Failure**: This represents the failed result of your business result and includes a `value` property, the `Error` type.
 
 You can simply create each instance of `Result` like the example below:
 
 ```kotlin
 val result0: Result<String> = Result.Success(value = "result")
 
 val result1: Result<String> = Result.Failure(
-  value = StreamError.GenericError(message = "failure")
+  value = Error.GenericError(message = "failure")
 )
 
 val result = result0 then { result1 }
@@ -71,31 +71,31 @@ result.onSuccess {
 }
 ```
 
-## StreamError
+## Error
 
-`Result.Failure` has `StreamError` as a value property, which contains error details of your business work. Basically, `StreamError` consists of three different types of errors below:
+`Result.Failure` has `Error` as a value property, which contains error details of your business work. Basically, `Error` consists of three different types of errors below:
 
-- **StreamError.GenericError**: Represents a normal type of error and only contains an error message.
-- **StreamError.ThrowableError**: Represents an exceptional type of error and contains a message and cause information.
-- **StreamError.NetworkError**: Represents a network error and contains status code, message, and cause information.
+- **Error.GenericError**: Represents a normal type of error and only contains an error message.
+- **Error.ThrowableError**: Represents an exceptional type of error and contains a message and cause information.
+- **Error.NetworkError**: Represents a network error and contains status code, message, and cause information.
 
 You can create each instance like the example below:
 
 ```kotlin
-val streamError: StreamError = StreamError.GenericError(message = "error")
+val error: Error = Error.GenericError(message = "error")
 
 try {
      .. 
 } catch (e: Exception) {
-  val streamError: StreamError = StreamError.ThrowableError(
+  val error: Error = Error.ThrowableError(
     message = e.localizedMessage ?: e.stackTraceToString(), 
     cause = e
   )
 }
 
-val streamError: StreamError = StreamError.NetworkError(
+val error: Error = Error.NetworkError(
   message = "error",
-  streamCode = code,
+  serverErrorCode = code,
   statusCode = statusCode
 )
 ```
@@ -268,9 +268,9 @@ Retry a network request following your `RetryPolicy`.
 
 ```kotlin
 private val retryPolicy = object : RetryPolicy {
-  override fun shouldRetry(attempt: Int, error: StreamError): Boolean = attempt <= 3
+  override fun shouldRetry(attempt: Int, error: Error): Boolean = attempt <= 3
 
-  override fun retryTimeout(attempt: Int, error: StreamError): Int = 3000
+  override fun retryTimeout(attempt: Int, error: Error): Int = 3000
 }
 
 
@@ -282,7 +282,7 @@ val result = posterService.fetchPosterList()
 
 ### Custom Error Parser
 
-You can customize the creating of `StreamError` from an error response according to your backend service by implementing your `ErrorParser` class. You can provide your custom `ErrorParser` to `RetrofitCallAdapterFactory`. If not, it will use a default `ErrorParser`, which uses [Kotlin Serialization](https://kotlinlang.org/docs/serialization.html) to decode json formats.
+You can customize the creating of `Error` from an error response according to your backend service by implementing your `ErrorParser` class. You can provide your custom `ErrorParser` to `RetrofitCallAdapterFactory`. If not, it will use a default `ErrorParser`, which uses [Kotlin Serialization](https://kotlinlang.org/docs/serialization.html) to decode json formats.
 
 ```kotlin
 internal class MyErrorParser : ErrorParser<DefaultErrorResponse> {
@@ -292,12 +292,12 @@ internal class MyErrorParser : ErrorParser<DefaultErrorResponse> {
     // use moshi or something that you can serialize from json response.
   }
 
-  override fun toError(okHttpResponse: Response): StreamError {
-    // build StreamError with a given okHttpResponse.
+  override fun toError(okHttpResponse: Response): Error {
+    // build Error with a given okHttpResponse.
   }
 
-  override fun toError(errorResponseBody: ResponseBody): StreamError {
-    // build StreamError with a given errorResponseBody.
+  override fun toError(errorResponseBody: ResponseBody): Error {
+    // build Error with a given errorResponseBody.
   }
 }
 

app/src/main/kotlin/io/getstream/resultdemo/MainViewModel.kt

@@ -19,7 +19,7 @@ import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import io.getstream.log.StreamLog
 import io.getstream.log.streamLog
-import io.getstream.result.StreamError
+import io.getstream.result.Error
 import io.getstream.result.call.doOnResult
 import io.getstream.result.call.doOnStart
 import io.getstream.result.call.map
@@ -60,8 +60,8 @@ public class MainViewModel constructor(
   }
 
   private val retryPolicy = object : RetryPolicy {
-    override fun shouldRetry(attempt: Int, error: StreamError): Boolean = attempt <= 3
+    override fun shouldRetry(attempt: Int, error: Error): Boolean = attempt <= 3
 
-    override fun retryTimeout(attempt: Int, error: StreamError): Int = 3000
+    override fun retryTimeout(attempt: Int, error: Error): Int = 3000
   }
 }

stream-result-call-retrofit/api/stream-result-call-retrofit.api

@@ -1,12 +1,12 @@
 public abstract interface class io/getstream/result/call/retrofit/ErrorParser {
 	public abstract fun fromJson (Ljava/lang/String;)Ljava/lang/Object;
-	public abstract fun toError (Lokhttp3/Response;)Lio/getstream/result/StreamError;
-	public abstract fun toError (Lokhttp3/ResponseBody;)Lio/getstream/result/StreamError;
+	public abstract fun toError (Lokhttp3/Response;)Lio/getstream/result/Error;
+	public abstract fun toError (Lokhttp3/ResponseBody;)Lio/getstream/result/Error;
 }
 
 public final class io/getstream/result/call/retrofit/ErrorParser$DefaultImpls {
-	public static fun toError (Lio/getstream/result/call/retrofit/ErrorParser;Lokhttp3/Response;)Lio/getstream/result/StreamError;
-	public static fun toError (Lio/getstream/result/call/retrofit/ErrorParser;Lokhttp3/ResponseBody;)Lio/getstream/result/StreamError;
+	public static fun toError (Lio/getstream/result/call/retrofit/ErrorParser;Lokhttp3/Response;)Lio/getstream/result/Error;
+	public static fun toError (Lio/getstream/result/call/retrofit/ErrorParser;Lokhttp3/ResponseBody;)Lio/getstream/result/Error;
 }
 
 public final class io/getstream/result/call/retrofit/RetrofitCall : io/getstream/result/call/Call {

stream-result-call-retrofit/src/main/kotlin/io/getstream/result/call/retrofit/ErrorParser.kt

@@ -15,54 +15,54 @@
  */
 package io.getstream.result.call.retrofit
 
-import io.getstream.result.StreamError
+import io.getstream.result.Error
 import okhttp3.Response
 import okhttp3.ResponseBody
 
 public interface ErrorParser<T> {
 
   public fun <T : Any> fromJson(raw: String): T
 
-  public fun toError(okHttpResponse: Response): StreamError {
+  public fun toError(okHttpResponse: Response): Error {
     val statusCode: Int = okHttpResponse.code
 
     return try {
       // Try to parse default Stream error body
       val body = okHttpResponse.peekBody(Long.MAX_VALUE).string()
 
       if (body.isEmpty()) {
-        StreamError.NetworkError(
+        Error.NetworkError(
           message = okHttpResponse.message,
-          streamCode = statusCode,
+          serverErrorCode = statusCode,
           statusCode = statusCode
         )
       } else {
-        StreamError.NetworkError(
-          streamCode = statusCode,
+        Error.NetworkError(
           message = okHttpResponse.message,
+          serverErrorCode = statusCode,
           statusCode = statusCode
         )
       }
     } catch (expected: Throwable) {
-      StreamError.ThrowableError(
+      Error.ThrowableError(
         message = expected.message ?: expected.stackTraceToString(),
         cause = expected
       )
     }
   }
 
-  public fun toError(errorResponseBody: ResponseBody): StreamError {
+  public fun toError(errorResponseBody: ResponseBody): Error {
     return try {
       val errorResponse: DefaultErrorResponse = fromJson(errorResponseBody.string())
       val (code, message, statusCode) = errorResponse
 
-      StreamError.NetworkError(
-        streamCode = code,
+      Error.NetworkError(
+        serverErrorCode = code,
         message = message,
         statusCode = statusCode
       )
     } catch (expected: Throwable) {
-      StreamError.ThrowableError(
+      Error.ThrowableError(
         message = expected.message ?: expected.stackTraceToString(),
         cause = expected
       )

stream-result-call-retrofit/src/main/kotlin/io/getstream/result/call/retrofit/RetrofitCall.kt

@@ -15,8 +15,8 @@
  */
 package io.getstream.result.call.retrofit
 
+import io.getstream.result.Error
 import io.getstream.result.Result
-import io.getstream.result.StreamError
 import io.getstream.result.call.Call
 import io.getstream.result.call.dispatcher.CallDispatcherProvider
 import kotlinx.coroutines.CoroutineScope
@@ -65,7 +65,7 @@ public class RetrofitCall<T : Any>(
 
   private fun Throwable.toFailedError(
     message: String
-  ): StreamError = StreamError.ThrowableError(cause = this, message = message)
+  ): Error = Error.ThrowableError(cause = this, message = message)
 
   @Suppress("TooGenericExceptionCaught")
   private suspend fun retrofit2.Call<T>.getResult(): Result<T> =

stream-result-call/api/stream-result-call.api

@@ -88,7 +88,7 @@ public final class io/getstream/result/call/dispatcher/CallDispatcherProvider {
 }
 
 public abstract interface class io/getstream/result/call/retry/RetryPolicy {
-	public abstract fun retryTimeout (ILio/getstream/result/StreamError;)I
-	public abstract fun shouldRetry (ILio/getstream/result/StreamError;)Z
+	public abstract fun retryTimeout (ILio/getstream/result/Error;)I
+	public abstract fun shouldRetry (ILio/getstream/result/Error;)Z
 }
 

stream-result-call/src/main/kotlin/io/getstream/result/call/Call.kt

@@ -15,8 +15,8 @@
  */
 package io.getstream.result.call
 
+import io.getstream.result.Error
 import io.getstream.result.Result
-import io.getstream.result.StreamError
 import io.getstream.result.call.retry.CallRetryService
 import io.getstream.result.call.retry.RetryCall
 import io.getstream.result.call.retry.RetryPolicy
@@ -76,7 +76,7 @@ public interface Call<T : Any> {
 
   public companion object {
     public fun <T : Any> callCanceledError(): Result<T> =
-      Result.Failure(StreamError.GenericError(message = "The call was canceled before complete its execution."))
+      Result.Failure(Error.GenericError(message = "The call was canceled before complete its execution."))
 
     @SuppressWarnings("TooGenericExceptionCaught")
     public suspend fun <T : Any> runCatching(
@@ -90,7 +90,7 @@ public interface Call<T : Any> {
 
     private fun <T : Any> Throwable.toResult(): Result<T> = when (this) {
       is CancellationException -> callCanceledError()
-      else -> Result.Failure(StreamError.ThrowableError(message = "", cause = this))
+      else -> Result.Failure(Error.ThrowableError(message = "", cause = this))
     }
   }
 }
@@ -169,7 +169,7 @@ public fun <T : Any> Call<T>.withPrecondition(
  */
 public fun <T : Any> Call<T>.onErrorReturn(
   scope: CoroutineScope,
-  function: suspend (originalError: StreamError) -> Result<T>
+  function: suspend (originalError: Error) -> Result<T>
 ): ReturnOnErrorCall<T> = ReturnOnErrorCall(this, scope, function)
 
 /**
@@ -186,11 +186,11 @@ public fun <T : Any> Call<T>.share(
 public fun Call<*>.toUnitCall(): Call<Unit> = map {}
 
 private val onSuccessStub: (Any) -> Unit = {}
-private val onErrorStub: (StreamError) -> Unit = {}
+private val onErrorStub: (Error) -> Unit = {}
 
 public fun <T : Any> Call<T>.enqueue(
   onSuccess: (T) -> Unit = onSuccessStub,
-  onError: (StreamError) -> Unit = onErrorStub
+  onError: (Error) -> Unit = onErrorStub
 ) {
   enqueue { result ->
     when (result) {

stream-result-call/src/main/kotlin/io/getstream/result/call/ErrorCall.kt

@@ -15,16 +15,16 @@
  */
 package io.getstream.result.call
 
+import io.getstream.result.Error
 import io.getstream.result.Result
-import io.getstream.result.StreamError
 import io.getstream.result.call.dispatcher.CallDispatcherProvider
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 
 internal class ErrorCall<T : Any>(
   private val scope: CoroutineScope,
-  private val e: StreamError
+  private val e: Error
 ) : Call<T> {
   override fun cancel() {
     // Not supported

stream-result-call/src/main/kotlin/io/getstream/result/call/ReturnOnErrorCall.kt

@@ -15,8 +15,8 @@
  */
 package io.getstream.result.call
 
+import io.getstream.result.Error
 import io.getstream.result.Result
-import io.getstream.result.StreamError
 import io.getstream.result.call.dispatcher.CallDispatcherProvider
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.SupervisorJob
@@ -33,7 +33,7 @@ import kotlinx.coroutines.withContext
 public class ReturnOnErrorCall<T : Any>(
   private val originalCall: Call<T>,
   scope: CoroutineScope,
-  private val onErrorReturn: suspend (originalError: StreamError) -> Result<T>
+  private val onErrorReturn: suspend (originalError: Error) -> Result<T>
 ) : Call<T> {
 
   private val callScope = scope + SupervisorJob(scope.coroutineContext.job)

stream-result-call/src/main/kotlin/io/getstream/result/call/ZipCall.kt

@@ -15,8 +15,8 @@
  */
 package io.getstream.result.call
 
+import io.getstream.result.Error
 import io.getstream.result.Result
-import io.getstream.result.StreamError
 import io.getstream.result.call.dispatcher.CallDispatcherProvider
 import kotlinx.coroutines.async
 import kotlinx.coroutines.runBlocking
@@ -67,7 +67,7 @@ internal class ZipCall<A : Any, B : Any>(
     return if (this is Result.Success && result is Result.Success) {
       Result.Success(Pair(this.value, result.value))
     } else {
-      Result.Failure(StreamError.GenericError("Cannot combine results because one of them failed."))
+      Result.Failure(Error.GenericError("Cannot combine results because one of them failed."))
     }
   }