kotlin 1.4, ktor, kotlinx.serialization updates

adamint · adamint · commit ad36734cadae · 2020-10-21T14:04:08.000-04:00
Signed-off-by: Adam Ratzman &lt;adam@adamratzman.com&gt;
diff --git a/build.gradle.kts b/build.gradle.kts
@@ -31,7 +31,7 @@ buildscript {
 }
 
 group = "com.adamratzman"
-version = "3.2.13"
+version = "3.2.14"
 
 tasks.withType<Test> {
     this.testLogging {
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.1.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.7-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
diff --git a/src/commonMain/kotlin/com.adamratzman.spotify/SpotifyExceptions.kt b/src/commonMain/kotlin/com.adamratzman.spotify/SpotifyExceptions.kt
@@ -31,7 +31,7 @@ sealed class SpotifyException(message: String, cause: Throwable? = null) : Excep
         constructor(responseException: ResponseException) :
                 this(
                         responseException.message ?: "Bad Request",
-                        responseException.response.status.value,
+                        responseException.response?.status?.value,
                         null,
                         responseException
                 )
diff --git a/src/commonMain/kotlin/com.adamratzman.spotify/endpoints/client/ClientFollowingApi.kt b/src/commonMain/kotlin/com.adamratzman.spotify/endpoints/client/ClientFollowingApi.kt
@@ -17,6 +17,7 @@ import com.adamratzman.spotify.models.PlaylistUri
 import com.adamratzman.spotify.models.UserUri
 import com.adamratzman.spotify.models.serialization.toCursorBasedPagingObject
 import com.adamratzman.spotify.models.serialization.toList
+import kotlinx.serialization.builtins.ListSerializer
 import kotlinx.serialization.builtins.list
 import kotlinx.serialization.builtins.serializer
 
@@ -90,7 +91,7 @@ class ClientFollowingApi(api: GenericSpotifyApi) : FollowingApi(api) {
                 get(
                         EndpointBuilder("/me/following/contains").with("type", "user")
                                 .with("ids", chunk.joinToString(",") { UserUri(it).id.encodeUrl() }).toString()
-                ).toList(Boolean.serializer().list, api, json)
+                ).toList(ListSerializer(Boolean.serializer()), api, json)
             }.flatten()
         }
     }
@@ -132,7 +133,7 @@ class ClientFollowingApi(api: GenericSpotifyApi) : FollowingApi(api) {
                 get(
                         EndpointBuilder("/me/following/contains").with("type", "artist")
                                 .with("ids", chunk.joinToString(",") { ArtistUri(it).id.encodeUrl() }).toString()
-                ).toList(Boolean.serializer().list, api, json)
+                ).toList(ListSerializer(Boolean.serializer()), api, json)
             }.flatten()
         }
     }
diff --git a/src/commonMain/kotlin/com.adamratzman.spotify/endpoints/client/ClientLibraryApi.kt b/src/commonMain/kotlin/com.adamratzman.spotify/endpoints/client/ClientLibraryApi.kt
@@ -17,6 +17,7 @@ import com.adamratzman.spotify.models.SavedTrack
 import com.adamratzman.spotify.models.serialization.toList
 import com.adamratzman.spotify.models.serialization.toPagingObject
 import com.adamratzman.spotify.utils.Market
+import kotlinx.serialization.builtins.ListSerializer
 import kotlinx.serialization.builtins.list
 import kotlinx.serialization.builtins.serializer
 
@@ -120,7 +121,7 @@ class ClientLibraryApi(api: GenericSpotifyApi) : SpotifyEndpoint(api) {
                 get(
                         EndpointBuilder("/me/$type/contains").with("ids", list.joinToString(",") { type.id(it).encodeUrl() })
                                 .toString()
-                ).toList(Boolean.serializer().list, api, json)
+                ).toList(ListSerializer(Boolean.serializer()), api, json)
             }.flatten()
         }
     }
diff --git a/src/commonMain/kotlin/com.adamratzman.spotify/endpoints/client/ClientPlayerApi.kt b/src/commonMain/kotlin/com.adamratzman.spotify/endpoints/client/ClientPlayerApi.kt
@@ -22,10 +22,13 @@ import com.adamratzman.spotify.models.serialization.toJson
 import com.adamratzman.spotify.models.serialization.toObject
 import com.adamratzman.spotify.utils.catch
 import com.adamratzman.spotify.utils.jsonMap
+import kotlinx.serialization.builtins.ListSerializer
 import kotlinx.serialization.builtins.list
 import kotlinx.serialization.json.JsonArray
 import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.buildJsonObject
 import kotlinx.serialization.json.json
+import kotlinx.serialization.json.put
 
 @Deprecated("Endpoint name has been updated for kotlin convention consistency", ReplaceWith("ClientPlayerApi"))
 typealias ClientPlayerAPI = ClientPlayerApi
@@ -46,7 +49,7 @@ class ClientPlayerApi(api: GenericSpotifyApi) : SpotifyEndpoint(api) {
      */
     fun getDevices(): SpotifyRestAction<List<Device>> {
         return toAction {
-            get(EndpointBuilder("/me/player/devices").toString()).toInnerObject(Device.serializer().list, "devices", json)
+            get(EndpointBuilder("/me/player/devices").toString()).toInnerObject(ListSerializer(Device.serializer()), "devices", json)
         }
     }
 
@@ -266,17 +269,17 @@ class ClientPlayerApi(api: GenericSpotifyApi) : SpotifyEndpoint(api) {
             val url = EndpointBuilder("/me/player/play").with("device_id", deviceId).toString()
             val body = jsonMap()
             when {
-                collection != null -> body += json { "context_uri" to collection.uri }
-                tracksToPlay.isNotEmpty() -> body += json {
-                    "uris" to JsonArray(
+                collection != null -> body += buildJsonObject { put("context_uri", collection.uri) }
+                tracksToPlay.isNotEmpty() -> body += buildJsonObject {
+                    put("uris", JsonArray(
                             tracksToPlay.map { it.uri }.map(::JsonPrimitive)
-                    )
+                    ))
                 }
             }
             if (body.keys.isNotEmpty()) {
-                if (offsetNum != null) body += json { "offset" to json { "position" to offsetNum } }
-                else if (offsetPlayable != null) body += json {
-                    "offset" to json { "uri" to offsetPlayable.uri }
+                if (offsetNum != null) body += buildJsonObject { put("offset", buildJsonObject { put("position", offsetNum) }) }
+                else if (offsetPlayable != null) body += buildJsonObject {
+                    put("offset", buildJsonObject { put("uri", offsetPlayable.uri) })
                 }
                 put(url, body.toJson())
             } else put(url)
@@ -327,8 +330,8 @@ class ClientPlayerApi(api: GenericSpotifyApi) : SpotifyEndpoint(api) {
         //    require(deviceId.size <= 1) { "Although an array is accepted, only a single device_id is currently supported. Supplying more than one will  400 Bad Request" }
         return toAction {
             val json = jsonMap()
-            play?.let { json += json { "play" to it } }
-            json += json { "device_ids" to JsonArray(listOf(deviceId).map(::JsonPrimitive)) }
+            play?.let { json += buildJsonObject { put("play", it) } }
+            json += buildJsonObject { put("device_ids", JsonArray(listOf(deviceId).map(::JsonPrimitive))) }
             put(EndpointBuilder("/me/player").toString(), json.toJson())
             Unit
         }
diff --git a/src/commonMain/kotlin/com.adamratzman.spotify/endpoints/client/ClientPlaylistApi.kt b/src/commonMain/kotlin/com.adamratzman.spotify/endpoints/client/ClientPlaylistApi.kt
@@ -32,7 +32,9 @@ import kotlinx.serialization.Serializable
 import kotlinx.serialization.json.JsonArray
 import kotlinx.serialization.json.JsonObject
 import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.buildJsonObject
 import kotlinx.serialization.json.json
+import kotlinx.serialization.json.put
 
 @Deprecated("Endpoint name has been updated for kotlin convention consistency", ReplaceWith("ClientPlaylistApi"))
 typealias ClientPlaylistAPI = ClientPlaylistApi
@@ -73,10 +75,10 @@ class ClientPlaylistApi(api: GenericSpotifyApi) : PlaylistApi(api) {
         if (name.isEmpty()) throw BadRequestException(ErrorObject(400, "Name cannot be empty"))
         return toAction {
             val body = jsonMap()
-            body += json { "name" to name }
-            if (description != null) body += json { "description" to description }
-            if (public != null) body += json { "public" to public }
-            if (collaborative != null) body += json { "collaborative" to collaborative }
+            body += buildJsonObject { put("name", name) }
+            if (description != null) body += buildJsonObject { put("description", description) }
+            if (public != null) body += buildJsonObject { put("public", public) }
+            if (collaborative != null) body += buildJsonObject { put("collaborative", collaborative) }
             post(
                     EndpointBuilder("/users/${UserUri(user).id.encodeUrl()}/playlists").toString(),
                     body.toJson()
@@ -125,8 +127,8 @@ class ClientPlaylistApi(api: GenericSpotifyApi) : PlaylistApi(api) {
         return toAction {
             bulkRequest(100, tracks.toList()) { chunk ->
                 val body = jsonMap()
-                body += json { "uris" to JsonArray(chunk.map { PlayableUri(PlayableUri(it).id.encodeUrl()).uri }.map(::JsonPrimitive)) }
-                if (position != null) body += json { "position" to position }
+                body += buildJsonObject { put("uris", JsonArray(chunk.map { PlayableUri(PlayableUri(it).id.encodeUrl()).uri }.map(::JsonPrimitive))) }
+                if (position != null) body += buildJsonObject { put("position", position) }
                 post(
                         EndpointBuilder("/playlists/${PlaylistUri(playlist).id.encodeUrl()}/tracks").toString(),
                         body.toJson()
@@ -161,10 +163,10 @@ class ClientPlaylistApi(api: GenericSpotifyApi) : PlaylistApi(api) {
         description: String? = null
     ): SpotifyRestAction<Unit> {
         val body = jsonMap()
-        if (name != null) body += json { "name" to name }
-        if (public != null) body += json { "public" to public }
-        if (collaborative != null) body += json { "collaborative" to collaborative }
-        if (description != null) body += json { "description" to description }
+        if (name != null) body += buildJsonObject { put("name", name) }
+        if (public != null) body += buildJsonObject { put("public", public) }
+        if (collaborative != null) body += buildJsonObject { put("collaborative", collaborative) }
+        if (description != null) body += buildJsonObject { put("description", description) }
         require(body.isNotEmpty()) { "At least one option must not be null" }
         return toAction {
             put(EndpointBuilder("/playlists/${PlaylistUri(playlist).id.encodeUrl()}").toString(), body.toJson())
@@ -264,10 +266,10 @@ class ClientPlaylistApi(api: GenericSpotifyApi) : PlaylistApi(api) {
     ): SpotifyRestAction<PlaylistSnapshot> {
         return toAction {
             val body = jsonMap()
-            body += json { "range_start" to reorderRangeStart }
-            body += json { "insert_before" to insertionPoint }
-            if (reorderRangeLength != null) body += json { "range_length" to reorderRangeLength }
-            if (snapshotId != null) body += json { "snapshot_id" to snapshotId }
+            body += buildJsonObject { put("range_start", reorderRangeStart) }
+            body += buildJsonObject { put("insert_before", insertionPoint) }
+            if (reorderRangeLength != null) body += buildJsonObject { put("range_length", reorderRangeLength) }
+            if (snapshotId != null) body += buildJsonObject { put("snapshot_id", snapshotId) }
             put(
                     EndpointBuilder("/playlists/${PlaylistUri(playlist).id.encodeUrl()}/tracks").toString(),
                     body.toJson()
@@ -292,7 +294,7 @@ class ClientPlaylistApi(api: GenericSpotifyApi) : PlaylistApi(api) {
     fun setClientPlaylistTracks(playlist: String, vararg tracks: String): SpotifyRestAction<Unit> {
         return toAction {
             val body = jsonMap()
-            body += json { "uris" to JsonArray(tracks.map { PlayableUri(PlayableUri(it).id.encodeUrl()).uri }.map(::JsonPrimitive)) }
+            body += buildJsonObject { put("uris", JsonArray(tracks.map { PlayableUri(PlayableUri(it).id.encodeUrl()).uri }.map(::JsonPrimitive))) }
             put(
                     EndpointBuilder("/playlists/${PlaylistUri(playlist).id.encodeUrl()}/tracks").toString(),
                     body.toJson()
@@ -459,19 +461,19 @@ class ClientPlaylistApi(api: GenericSpotifyApi) : PlaylistApi(api) {
         return toAction {
             bulkRequest(100, tracks.toList()) { chunk ->
                 val body = jsonMap()
-                if (snapshotId != null) body += json { "snapshot_id" to snapshotId }
-                body += json {
-                    "tracks" to JsonArray(
+                if (snapshotId != null) body += buildJsonObject { put("snapshot_id", snapshotId) }
+                body += buildJsonObject {
+                    put("tracks", JsonArray(
                             chunk.map { (track, positions) ->
                                 val json = jsonMap()
-                                json += json { "uri" to PlayableUri(track).uri }
-                                if (positions?.positions?.isNotEmpty() == true) json += json {
-                                    "positions" to JsonArray(
+                                json += buildJsonObject { put("uri", PlayableUri(track).uri) }
+                                if (positions?.positions?.isNotEmpty() == true) json += buildJsonObject {
+                                    put("positions", JsonArray(
                                             positions.positions.map(::JsonPrimitive)
-                                    )
+                                    ))
                                 }
                                 JsonObject(json)
-                            })
+                            }))
                 }
                 delete(
                         EndpointBuilder("/playlists/${PlaylistUri(playlist).id}/tracks").toString(), body = body.toJson()
diff --git a/src/commonMain/kotlin/com.adamratzman.spotify/endpoints/public/ArtistApi.kt b/src/commonMain/kotlin/com.adamratzman.spotify/endpoints/public/ArtistApi.kt
@@ -20,6 +20,7 @@ import com.adamratzman.spotify.models.serialization.toObject
 import com.adamratzman.spotify.models.serialization.toPagingObject
 import com.adamratzman.spotify.utils.Market
 import com.adamratzman.spotify.utils.catch
+import kotlinx.serialization.builtins.ListSerializer
 import kotlinx.serialization.builtins.list
 
 @Deprecated("Endpoint name has been updated for kotlin convention consistency", ReplaceWith("ArtistApi"))
@@ -144,7 +145,7 @@ class ArtistApi(api: GenericSpotifyApi) : SpotifyEndpoint(api) {
                             "country",
                             market.name
                     ).toString()
-            ).toInnerArray(Track.serializer().list, "tracks", json)
+            ).toInnerArray(ListSerializer(Track.serializer()), "tracks", json)
         }
     }
 
diff --git a/src/commonMain/kotlin/com.adamratzman.spotify/endpoints/public/BrowseApi.kt b/src/commonMain/kotlin/com.adamratzman.spotify/endpoints/public/BrowseApi.kt
@@ -25,6 +25,7 @@ import com.adamratzman.spotify.models.serialization.toPagingObject
 import com.adamratzman.spotify.utils.Locale
 import com.adamratzman.spotify.utils.Market
 import com.adamratzman.spotify.utils.formatDate
+import kotlinx.serialization.builtins.ListSerializer
 import kotlin.reflect.KClass
 import kotlinx.serialization.builtins.list
 import kotlinx.serialization.builtins.serializer
@@ -48,7 +49,7 @@ class BrowseApi(api: GenericSpotifyApi) : SpotifyEndpoint(api) {
     fun getAvailableGenreSeeds(): SpotifyRestAction<List<String>> {
         return toAction {
             get(EndpointBuilder("/recommendations/available-genre-seeds").toString()).toInnerArray(
-                    String.serializer().list,
+                    ListSerializer(String.serializer()),
                     "genres",
                     json
             )
diff --git a/src/commonMain/kotlin/com.adamratzman.spotify/endpoints/public/FollowingApi.kt b/src/commonMain/kotlin/com.adamratzman.spotify/endpoints/public/FollowingApi.kt
@@ -10,6 +10,7 @@ import com.adamratzman.spotify.http.encodeUrl
 import com.adamratzman.spotify.models.PlaylistUri
 import com.adamratzman.spotify.models.UserUri
 import com.adamratzman.spotify.models.serialization.toList
+import kotlinx.serialization.builtins.ListSerializer
 import kotlinx.serialization.builtins.list
 import kotlinx.serialization.builtins.serializer
 
@@ -45,7 +46,7 @@ open class FollowingApi(api: GenericSpotifyApi) : SpotifyEndpoint(api) {
                 get(
                         EndpointBuilder("/playlists/${PlaylistUri(playlist).id.encodeUrl()}/followers/contains")
                                 .with("ids", chunk.joinToString(",") { UserUri(it).id.encodeUrl() }).toString()
-                ).toList(Boolean.serializer().list, api, json)
+                ).toList(ListSerializer(Boolean.serializer()), api, json)
             }.flatten()
         }
     }
diff --git a/src/commonMain/kotlin/com.adamratzman.spotify/endpoints/public/PlaylistApi.kt b/src/commonMain/kotlin/com.adamratzman.spotify/endpoints/public/PlaylistApi.kt
@@ -21,6 +21,7 @@ import com.adamratzman.spotify.models.serialization.toObject
 import com.adamratzman.spotify.models.serialization.toPagingObject
 import com.adamratzman.spotify.utils.Market
 import com.adamratzman.spotify.utils.catch
+import kotlinx.serialization.builtins.ListSerializer
 import kotlinx.serialization.builtins.list
 
 @Deprecated("Endpoint name has been updated for kotlin convention consistency", ReplaceWith("PlaylistApi"))
@@ -142,7 +143,7 @@ open class PlaylistApi(api: GenericSpotifyApi) : SpotifyEndpoint(api) {
     fun getPlaylistCovers(playlist: String): SpotifyRestAction<List<SpotifyImage>> {
         return toAction {
             get(EndpointBuilder("/playlists/${PlaylistUri(playlist).id.encodeUrl()}/images").toString())
-                    .toList(SpotifyImage.serializer().list, api, json).toList()
+                    .toList(ListSerializer(SpotifyImage.serializer()), api, json).toList()
         }
     }
 }
diff --git a/src/commonMain/kotlin/com.adamratzman.spotify/endpoints/public/SearchApi.kt b/src/commonMain/kotlin/com.adamratzman.spotify/endpoints/public/SearchApi.kt
@@ -121,7 +121,7 @@ open class SearchApi(api: GenericSpotifyApi) : SpotifyEndpoint(api) {
         require(searchTypes.isNotEmpty()) { "At least one search type must be provided" }
         return toAction {
             val jsonString = get(build(query, market, limit, offset, *searchTypes, includeExternal = includeExternal))
-            val map = json.parse(createMapSerializer(String.serializer(), JsonObject.serializer()), jsonString)
+            val map = json.decodeFromString(createMapSerializer(String.serializer(), JsonObject.serializer()), jsonString)
 
             SpotifySearchResult(
                     map["albums"]?.toString()?.toPagingObject(SimpleAlbum.serializer(), endpoint = this, json = json),
diff --git a/src/commonMain/kotlin/com.adamratzman.spotify/http/HttpConnection.kt b/src/commonMain/kotlin/com.adamratzman.spotify/http/HttpConnection.kt
@@ -145,7 +145,7 @@ class HttpConnection constructor(
         } catch (e: CancellationException) {
             throw e
         } catch (e: ResponseException) {
-            val errorBody = e.response.readText()
+            val errorBody = e.response?.readText() ?: throw BadRequestException("Request $this failed", e)
             try {
                 val error = errorBody.toObject(ErrorResponse.serializer(), api, api?.json ?: nonstrictJson).error
                 throw BadRequestException(error.copy(reason = (error.reason ?: "") + " URL: $url"))
diff --git a/src/commonMain/kotlin/com.adamratzman.spotify/models/Playable.kt b/src/commonMain/kotlin/com.adamratzman.spotify/models/Playable.kt
@@ -1,23 +1,29 @@
 /* Spotify Web API, Kotlin Wrapper; MIT License, 2017-2020; Original author: Adam Ratzman */
 package com.adamratzman.spotify.models
 
+import kotlinx.serialization.DeserializationStrategy
 import kotlinx.serialization.KSerializer
 import kotlinx.serialization.Serializer
+import kotlinx.serialization.json.JsonContentPolymorphicSerializer
 import kotlinx.serialization.json.JsonElement
 import kotlinx.serialization.json.JsonObject
-import kotlinx.serialization.json.JsonParametricSerializer
 import kotlinx.serialization.json.contentOrNull
+import kotlinx.serialization.json.jsonPrimitive
 
 interface Playable {
     val href: String?
     val id: String?
     val uri: PlayableUri
     val type: String
 
+    @Suppress("EXPERIMENTAL_API_USAGE")
     @Serializer(forClass = Playable::class)
-    companion object : KSerializer<Playable> by object : JsonParametricSerializer<Playable>(Playable::class) {
-        override fun selectSerializer(element: JsonElement): KSerializer<out Playable> {
-            val uri: PlayableUri? = (element as? JsonObject)?.get("uri")?.contentOrNull?.let { PlayableUri(it) }
+    companion object : KSerializer<Playable> by object : JsonContentPolymorphicSerializer<Playable>(Playable::class) {
+        override fun selectDeserializer(element: JsonElement): DeserializationStrategy<out Playable> {
+            val uri: PlayableUri? = (element as? JsonObject)?.get("uri")
+                    ?.jsonPrimitive
+                    ?.contentOrNull
+                    ?.let { PlayableUri(it) }
 
             return when (uri) {
                 is LocalTrackUri -> LocalTrack.serializer()
diff --git a/src/commonMain/kotlin/com.adamratzman.spotify/models/SpotifyUris.kt b/src/commonMain/kotlin/com.adamratzman.spotify/models/SpotifyUris.kt
diff --git a/src/commonMain/kotlin/com.adamratzman.spotify/models/serialization/SerializationUtils.kt b/src/commonMain/kotlin/com.adamratzman.spotify/models/serialization/SerializationUtils.kt
diff --git a/src/commonTest/kotlin/com.adamratzman/spotify/utilities/HttpConnectionTests.kt b/src/commonTest/kotlin/com.adamratzman/spotify/utilities/HttpConnectionTests.kt
diff --git a/src/commonTest/kotlin/com.adamratzman/spotify/utilities/JsonTests.kt b/src/commonTest/kotlin/com.adamratzman/spotify/utilities/JsonTests.kt
diff --git a/src/commonTest/kotlin/com.adamratzman/spotify/utilities/UrisTests.kt b/src/commonTest/kotlin/com.adamratzman/spotify/utilities/UrisTests.kt

Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ buildscript {`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`group = "com.adamratzman"`
`34`		`-version = "3.2.13"`
	`34`	`+version = "3.2.14"`
`35`	`35`
`36`	`36`	`tasks.withType<Test> {`
`37`	`37`	`this.testLogging {`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ sealed class SpotifyException(message: String, cause: Throwable? = null) : Excep`
`31`	`31`	`constructor(responseException: ResponseException) :`
`32`	`32`	`this(`
`33`	`33`	`responseException.message ?: "Bad Request",`
`34`		`- responseException.response.status.value,`
	`34`	`+ responseException.response?.status?.value,`
`35`	`35`	`null,`
`36`	`36`	`responseException`
`37`	`37`	`)`
Original file line number	Diff line number	Diff line change
`@@ -17,6 +17,7 @@ import com.adamratzman.spotify.models.PlaylistUri`
`17`	`17`	`import com.adamratzman.spotify.models.UserUri`
`18`	`18`	`import com.adamratzman.spotify.models.serialization.toCursorBasedPagingObject`
`19`	`19`	`import com.adamratzman.spotify.models.serialization.toList`
	`20`	`+import kotlinx.serialization.builtins.ListSerializer`
`20`	`21`	`import kotlinx.serialization.builtins.list`
`21`	`22`	`import kotlinx.serialization.builtins.serializer`
`22`	`23`
`@@ -90,7 +91,7 @@ class ClientFollowingApi(api: GenericSpotifyApi) : FollowingApi(api) {`
`90`	`91`	`get(`
`91`	`92`	`EndpointBuilder("/me/following/contains").with("type", "user")`
`92`	`93`	`.with("ids", chunk.joinToString(",") { UserUri(it).id.encodeUrl() }).toString()`
`93`		`- ).toList(Boolean.serializer().list, api, json)`
	`94`	`+ ).toList(ListSerializer(Boolean.serializer()), api, json)`
`94`	`95`	`}.flatten()`
`95`	`96`	`}`
`96`	`97`	`}`
`@@ -132,7 +133,7 @@ class ClientFollowingApi(api: GenericSpotifyApi) : FollowingApi(api) {`
`132`	`133`	`get(`
`133`	`134`	`EndpointBuilder("/me/following/contains").with("type", "artist")`
`134`	`135`	`.with("ids", chunk.joinToString(",") { ArtistUri(it).id.encodeUrl() }).toString()`
`135`		`- ).toList(Boolean.serializer().list, api, json)`
	`136`	`+ ).toList(ListSerializer(Boolean.serializer()), api, json)`
`136`	`137`	`}.flatten()`
`137`	`138`	`}`
`138`	`139`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,6 +20,7 @@ import com.adamratzman.spotify.models.serialization.toObject`
`20`	`20`	`import com.adamratzman.spotify.models.serialization.toPagingObject`
`21`	`21`	`import com.adamratzman.spotify.utils.Market`
`22`	`22`	`import com.adamratzman.spotify.utils.catch`
	`23`	`+import kotlinx.serialization.builtins.ListSerializer`
`23`	`24`	`import kotlinx.serialization.builtins.list`
`24`	`25`
`25`	`26`	`@Deprecated("Endpoint name has been updated for kotlin convention consistency", ReplaceWith("ArtistApi"))`
`@@ -144,7 +145,7 @@ class ArtistApi(api: GenericSpotifyApi) : SpotifyEndpoint(api) {`
`144`	`145`	`"country",`
`145`	`146`	`market.name`
`146`	`147`	`).toString()`
`147`		`- ).toInnerArray(Track.serializer().list, "tracks", json)`
	`148`	`+ ).toInnerArray(ListSerializer(Track.serializer()), "tracks", json)`
`148`	`149`	`}`
`149`	`150`	`}`
`150`	`151`