Implement type safe usage of uris

* Fixed some serialization errors caused by non transient fields
* Added SpotifyTrackUri
* Removed SpotifyUri#UriType and reimplemented SpotifyUri#isUriType
* Marked the typealiases *URI to *Uri as deprecated
* Added some Uri tests

Author: molikuner

src/commonMain/kotlin/com.adamratzman.spotify/models/Albums.kt

@@ -48,6 +48,8 @@ data class SimpleAlbum(
     @SerialName("total_tracks") val totalTracks: Int? = null,
     @SerialName("album_group") private val albumGroupString: String? = null
 ) : CoreObject(href, id, AlbumUri(uriString), externalUrlsString) {
+    override val uri: AlbumUri get() = super.uri as AlbumUri
+
     @Transient
     val availableMarkets = availableMarketsString.map { CountryCode.valueOf(it) }
 
@@ -135,6 +137,8 @@ data class Album(
     @SerialName("total_tracks") val totalTracks: Int,
     val restrictions: Restrictions? = null
 ) : CoreObject(href, id, AlbumUri(uriString), externalUrlsString) {
+    override val uri: AlbumUri get() = super.uri as AlbumUri
+
     @Transient
     val availableMarkets = availableMarketsString.map { CountryCode.valueOf(it) }
 

src/commonMain/kotlin/com.adamratzman.spotify/models/Artists.kt

@@ -22,6 +22,8 @@ data class SimpleArtist(
     val name: String,
     val type: String
 ) : CoreObject(href, id, ArtistUri(uriString), externalUrlsString) {
+    override val uri: ArtistUri get() = super.uri as ArtistUri
+
     /**
      * Converts this [SimpleArtist] into a full [Artist] object
      */
@@ -55,7 +57,9 @@ data class Artist(
     val name: String,
     val popularity: Int,
     val type: String
-) : CoreObject(href, id, ArtistUri(uriString), externalUrlsString)
+) : CoreObject(href, id, ArtistUri(uriString), externalUrlsString) {
+    override val uri: ArtistUri get() = super.uri as ArtistUri
+}
 
 @Serializable
 internal data class ArtistList(val artists: List<Artist?>)

src/commonMain/kotlin/com.adamratzman.spotify/models/PagingObjects.kt

@@ -207,7 +207,7 @@ abstract class AbstractPagingObject<T : Any>(
     @Transient open val previous: String? = null,
     @Transient open val total: Int = -1
 ) : List<T> {
-    override val size: Int = items.size
+    override val size: Int get() = items.size
 
     override fun contains(element: T) = items.contains(element)
 

src/commonMain/kotlin/com.adamratzman.spotify/models/Player.kt

@@ -19,7 +19,9 @@ data class PlayHistoryContext(
     @SerialName("uri") private val uriString: String,
 
     val type: String
-) : CoreObject(href, href, TrackUri(uriString), externalUrlsString)
+) : CoreObject(href, href, TrackUri(uriString), externalUrlsString) {
+    override val uri: TrackUri get() = super.uri as TrackUri
+}
 
 /**
  * Information about a previously-played track

src/commonMain/kotlin/com.adamratzman.spotify/models/Playlist.kt

@@ -45,6 +45,8 @@ data class SimplePlaylist(
     val tracks: PlaylistTrackInfo,
     val type: String
 ) : CoreObject(href, id, PlaylistUri(uriString), externalUrlsString) {
+    override val uri: PlaylistUri get() = super.uri as PlaylistUri
+
     @Transient
     val snapshot: PlaylistSnapshot = PlaylistSnapshot(snapshotIdString)
 
@@ -118,6 +120,8 @@ data class Playlist(
     val tracks: PagingObject<PlaylistTrack>,
     val type: String
 ) : CoreObject(href, id, PlaylistUri(uriString), externalUrlsString) {
+    override val uri: PlaylistUri get() = super.uri as PlaylistUri
+
     @Transient
     val snapshot: PlaylistSnapshot = PlaylistSnapshot(snapshotIdString)
 }

src/commonMain/kotlin/com.adamratzman.spotify/models/SpotifyUris.kt

@@ -42,14 +42,14 @@ private class SimpleUriSerializer<T : SpotifyUri>(val ctor: (String) -> T) : KSe
  * @property id representation of this uri as an id
  */
 @Serializable
-sealed class SpotifyUri(input: String, type: UriType) {
+sealed class SpotifyUri(val input: String, type: String) {
     val uri: String
     val id: String
 
     init {
         input.replace(" ", "").let {
-            this.uri = it.add(type.toString())
-            this.id = it.remove(type.toString())
+            this.uri = it.add(type)
+            this.id = it.remove(type)
         }
     }
 
@@ -68,100 +68,156 @@ sealed class SpotifyUri(input: String, type: UriType) {
         return "SpotifyUri($uri)"
     }
 
-    enum class UriType(private val typeStr: String) {
-        ALBUM("album"),
-        ARTIST("artist"),
-        TRACK("track"),
-        USER("user"),
-        PLAYLIST("playlist"),
-        LOCAL_TRACK("local");
-
-        override fun toString() = typeStr
-    }
-
     @Serializer(forClass = SpotifyUri::class)
     companion object : KSerializer<SpotifyUri> {
-        fun isUriType(uri: String, type: UriType) = uri.matchType(type.toString()) != null
-
         override val descriptor: SerialDescriptor = StringDescriptor
         override fun deserialize(decoder: Decoder): SpotifyUri = SpotifyUri(decoder.decodeString())
         override fun serialize(encoder: Encoder, obj: SpotifyUri) = encoder.encodeString(obj.uri)
 
-        private inline fun <T : SpotifyUri> safeInitiate(uri: String, ctor: (String) -> T): T? {
+        /**
+         * This function safely instantiates a SpotifyUri from given constructor.
+         * */
+        inline fun <T : SpotifyUri> safeInitiate(uri: String, ctor: (String) -> T): T? {
             return try {
-                ctor(uri).takeIf { it.uri == uri }
+                ctor(uri)
             } catch (e: SpotifyUriException) {
                 null
             }
         }
 
+        /**
+         * Creates a abstract SpotifyUri of given input. Doesn't allow ambiguity by disallowing creation by id.
+         * */
         operator fun invoke(input: String): SpotifyUri {
-            val constructors = listOf(::AlbumUri, ::ArtistUri, ::TrackUri, ::UserUri, ::PlaylistUri)
+            val constructors = listOf(::AlbumUri, ::ArtistUri, TrackUri.Companion::invoke, ::UserUri, ::PlaylistUri)
             for (ctor in constructors) {
-                safeInitiate(input, ctor)?.also { return it }
+                safeInitiate(input, ctor)?.takeIf { it.uri == input }?.also { return it }
             }
 
             throw SpotifyUriException("Illegal Spotify ID/URI: '$input' isn't convertible to any arbitrary id")
         }
+
+        /**
+         * This function returns whether or not the given input IS a given type.
+         *
+         * @example ```Kotlin
+         *     SpotifyUri.isType<UserUri>("abc") // returns: false
+         *     SpotifyUri.isType<UserUri>("spotify:user:abc") // returns: true
+         *     SpotifyUri.isType<UserUri>("spotify:track:abc") // returns: false
+         * ```
+         * */
+        inline fun <reified T: SpotifyUri> isType(input: String): Boolean {
+            return safeInitiate(input, ::invoke)?.let { it is T } ?: false
+        }
+
+        /**
+         * This function returns whether ot not the given input CAN be a given type.
+         *
+         * @example ```Kotlin
+         *     SpotifyUri.canBeType<UserUri>("abc") // returns: true
+         *     SpotifyUri.canBeType<UserUri>("spotify:user:abc") // returns: true
+         *     SpotifyUri.canBeType<UserUri>("spotify:track:abc") // returns: false
+         * ```
+         * */
+        inline fun <reified T: SpotifyUri> canBeType(input: String): Boolean {
+            return isType<T>(input) || !input.contains(':')
+        }
     }
 }
 
 /**
  * Represents a Spotify **Album** URI, parsed from either a Spotify ID or taken from an endpoint.
  */
 @Serializable
-class AlbumUri(val input: String) : SpotifyUri(input, UriType.ALBUM) {
+class AlbumUri(input: String) : SpotifyUri(input, "album") {
     @Serializer(forClass = AlbumUri::class)
     companion object : KSerializer<AlbumUri> by SimpleUriSerializer(::AlbumUri)
 }
+
+@Deprecated("renamed", ReplaceWith("AlbumUri", "com.adamratzman.spotify.models.AlbumUri"))
 typealias AlbumURI = AlbumUri
 
 /**
  * Represents a Spotify **Artist** URI, parsed from either a Spotify ID or taken from an endpoint.
  */
 @Serializable
-class ArtistUri(val input: String) : SpotifyUri(input, UriType.ARTIST) {
+class ArtistUri(input: String) : SpotifyUri(input, "artist") {
     @Serializer(forClass = ArtistUri::class)
     companion object : KSerializer<ArtistUri> by SimpleUriSerializer(::ArtistUri)
 }
-typealias ArtistURI = ArtistUri
 
-/**
- * Represents a Spotify **Track** URI, parsed from either a Spotify ID or taken from an endpoint.
- */
-@Serializable
-class TrackUri(val input: String) : SpotifyUri(input, UriType.TRACK) {
-    @Serializer(forClass = TrackUri::class)
-    companion object : KSerializer<TrackUri> by SimpleUriSerializer(::TrackUri)
-}
-typealias TrackURI = TrackUri
+@Deprecated("renamed", ReplaceWith("ArtistUri", "com.adamratzman.spotify.models.ArtistUri"))
+typealias ArtistURI = ArtistUri
 
 /**
  * Represents a Spotify **User** URI, parsed from either a Spotify ID or taken from an endpoint.
  */
 @Serializable
-class UserUri(val input: String) : SpotifyUri(input, UriType.USER) {
+class UserUri(input: String) : SpotifyUri(input, "user") {
     @Serializer(forClass = UserUri::class)
     companion object : KSerializer<UserUri> by SimpleUriSerializer(::UserUri)
 }
+
+@Deprecated("renamed", ReplaceWith("UserUri", "com.adamratzman.spotify.models.UserUri"))
 typealias UserURI = UserUri
 
 /**
  * Represents a Spotify **Playlist** URI, parsed from either a Spotify ID or taken from an endpoint.
  */
 @Serializable
-class PlaylistUri(val input: String) : SpotifyUri(input, UriType.PLAYLIST) {
+class PlaylistUri(input: String) : SpotifyUri(input, "playlist") {
     @Serializer(forClass = PlaylistUri::class)
     companion object : KSerializer<PlaylistUri> by SimpleUriSerializer(::PlaylistUri)
 }
+
+@Deprecated("renamed", ReplaceWith("PlaylistUri", "com.adamratzman.spotify.models.PlaylistUri"))
 typealias PlaylistURI = PlaylistUri
 
+/**
+ * Represents a Spotify **Track** URI, ether LocalTrack or SpotifyTrack, parsed from either a Spotify ID or taken
+ * from an endpoint
+ * */
+@Serializable
+sealed class TrackUri(input: String, type: String) : SpotifyUri(input, type) {
+    @Serializer(forClass = TrackUri::class)
+    companion object : KSerializer<TrackUri> {
+        override val descriptor: SerialDescriptor = StringDescriptor
+        override fun deserialize(decoder: Decoder): TrackUri = TrackUri(decoder.decodeString())
+        override fun serialize(encoder: Encoder, obj: TrackUri) = encoder.encodeString(obj.uri)
+
+        /**
+         * Creates a abstract TrackURI of given input. Prefers SpotifyTrackUri if the input is ambiguous.
+         * */
+        operator fun invoke(input: String): TrackUri {
+            val constructors = listOf(::SpotifyTrackUri, ::LocalTrackUri)
+            for (ctor in constructors) {
+                safeInitiate(input, ctor)?.also { return it }
+            }
+            throw SpotifyUriException("Illegal Spotify ID/URI: '$input' isn't convertible to 'track' or 'local' id")
+        }
+    }
+}
+
+@Deprecated("renamed", ReplaceWith("TrackUri", "com.adamratzman.spotify.models.TrackUri"))
+typealias TrackURI = TrackUri
+
+/**
+ * Represents a Spotify **Track** URI, parsed from either a Spotify ID or taken from an endpoint.
+ */
+@Serializable
+class SpotifyTrackUri(input: String) : TrackUri(input, "track") {
+    @Serializer(forClass = SpotifyTrackUri::class)
+    companion object : KSerializer<SpotifyTrackUri> by SimpleUriSerializer(::SpotifyTrackUri)
+}
+
 /**
  * Represents a Spotify **local track** URI
  */
 @Serializable
-class LocalTrackUri(val input: String) : SpotifyUri(input, UriType.LOCAL_TRACK) {
+class LocalTrackUri(input: String) : TrackUri(input, "local") {
     @Serializer(forClass = LocalTrackUri::class)
     companion object : KSerializer<LocalTrackUri> by SimpleUriSerializer(::LocalTrackUri)
 }
+
+@Deprecated("renamed", ReplaceWith("LocalTrackUri", "com.adamratzman.spotify.models.LocalTrackUri"))
 typealias LocalTrackURI = LocalTrackUri

src/commonMain/kotlin/com.adamratzman.spotify/models/Track.kt

@@ -58,6 +58,8 @@ data class SimpleTrack(
     val popularity: Int? = null,
     val restrictions: Restrictions? = null
 ) : RelinkingAvailableResponse(linkedFrom, href, id, TrackUri(uriString), externalUrlsString) {
+    override val uri: TrackUri get() = super.uri as TrackUri
+
     @Transient
     val availableMarkets = availableMarketsString.map { CountryCode.valueOf(it) }
 
@@ -142,6 +144,8 @@ data class Track(
     if (uriString.contains("local:")) LocalTrackUri(uriString) else TrackUri(uriString),
     externalUrlsString
 ) {
+    override val uri: TrackUri get() = super.uri as TrackUri
+
     @Transient
     val availableMarkets = availableMarketsString.map { CountryCode.valueOf(it) }
 
@@ -166,6 +170,7 @@ data class LinkedTrack(
 
     val type: String
 ) : CoreObject(href, id, TrackUri(uriString), externalUrlsString) {
+    override val uri: TrackUri get() = super.uri as TrackUri
 
     /**
      * Retrieves the full [Track] object associated with this [LinkedTrack] with the given market

src/commonMain/kotlin/com.adamratzman.spotify/models/Users.kt

@@ -40,7 +40,9 @@ data class SpotifyUserInformation(
     val product: String?,
     @SerialName("explicit_content") val explicitContentSettings: ExplicitContentSettings?,
     val type: String
-) : CoreObject(href, id, UserUri(uriString), externalUrlsString)
+) : CoreObject(href, id, UserUri(uriString), externalUrlsString) {
+    override val uri: UserUri get() = super.uri as UserUri
+}
 
 /**
  * Public information about a Spotify user
@@ -63,7 +65,9 @@ data class SpotifyPublicUser(
     val followers: Followers = Followers(null, -1),
     val images: List<SpotifyImage> = listOf(),
     val type: String
-) : CoreObject(href, id, UserUri(uriString), externalUrlsString)
+) : CoreObject(href, id, UserUri(uriString), externalUrlsString) {
+    override val uri: UserUri get() = super.uri as UserUri
+}
 
 /**
  * Information about a Spotify user's followers