Autenticación en el núcleo: la API

src/commonMain/kotlin/com/sebastiannarvaez/pokedex/data/network/dto/AuthDto.kt

// Un formulario de reclamaciones: la queja puede llegar en tres sitios.
data class Reclamacion(val queja: String? = null, val nota: String? = null, val margen: String? = null) {
    // `?:` («si es null, lo de la derecha»): el primero que venga relleno.
    val texto: String? get() = queja ?: nota ?: margen
}
 
fun main() {
    println(Reclamacion(queja = "Llegó frío").texto)
    println(Reclamacion(margen = "Faltaba el postre").texto)
    println(Reclamacion().texto)
}

Llegó frío
Faltaba el postre
null

package com.sebastiannarvaez.pokedex.data.network.dto
 
import kotlinx.serialization.SerialName
import kotlinx.serialization.Serializable
 
// La sesión tal y como la devuelve Supabase. `@SerialName` liga el nombre del
// JSON (con guion bajo) con el de la propiedad (en camelCase).
@Serializable
internal data class SessionDto(
    @SerialName("access_token") val accessToken: String,
    @SerialName("refresh_token") val refreshToken: String,
    // Con valor por defecto: si el servidor no lo manda, se asume una hora.
    @SerialName("expires_in") val expiresIn: Long = 3600,
    @SerialName("token_type") val tokenType: String = "bearer",
    val user: UserDto? = null,
)
 
@Serializable
internal data class UserDto(
    val id: String,
    val email: String? = null,
)
 
// El error de Supabase, con TODOS los campos opcionales: según el endpoint
// llega uno u otro, y un campo ausente no debe romper el parseo.
@Serializable
internal data class AuthErrorDto(
    val error: String? = null,
    @SerialName("error_description") val errorDescription: String? = null,
    val msg: String? = null,
    val message: String? = null,
    @SerialName("error_code") val errorCode: String? = null,
) {
    // El primero que venga relleno, que es lo único que se puede enseñar. `?:`
    // devuelve lo de la derecha si lo de la izquierda es `null`.
    val mensaje: String?
        get() = errorDescription ?: msg ?: message ?: error
}

// Un cupón de descuento que vale una hora desde que llega.
data class Cupon(val caducaEn: Long) {
    // Con un margen de 60 s: un cupón al que le quedan 50 ya no sirve para pagar.
    fun caducado(ahora: Long, margen: Long = 60): Boolean = ahora + margen >= caducaEn
}
 
fun main() {
    val recibidoA = 1_000L          // el reloj cuando llega el cupón, en segundos
    val duracion = 3_600L           // lo que dice el cupón: «vale una hora»
    val cupon = Cupon(caducaEn = recibidoA + duracion)
    println(cupon.caducaEn)
    println(cupon.caducado(ahora = 2_000))
    println(cupon.caducado(ahora = 4_550))
}

4600
false
true

package com.sebastiannarvaez.pokedex.domain
 
// Modelo de dominio: lo que la app entiende. No lleva anotaciones de
// serialización porque no viaja por la red.
data class Session(
    val accessToken: String,
    val refreshToken: String,
    // El instante de caducidad, en segundos desde 1970 («época Unix»).
    val expiresAtEpochSeconds: Long,
    val userId: String,
    val email: String?,
) {
    // Si conviene refrescar ya. Con un margen: un token que caduca dentro de
    // treinta segundos ya no sirve para una petición que tarda dos.
    fun caducaAntesDe(ahoraEpochSeconds: Long, margenSegundos: Long = 60): Boolean =
        ahoraEpochSeconds + margenSegundos >= expiresAtEpochSeconds
}

src/commonMain/kotlin/com/sebastiannarvaez/pokedex/data/network/SupabaseAuthApi.kt

// Lo que se envía: un pedido a una pizzería, como JSON.
@Serializable
data class Pedido(val pizza: String, val unidades: Int)
 
// Un servidor de mentira que enseña lo que le llega y contesta «ok».
val motor = MockEngine { peticion ->
    println("método: ${peticion.method.value}")
    println("dirección: ${peticion.url}")
    println("cabecera tienda: ${peticion.headers["tienda"]}")
    // `as TextContent`: «trata este cuerpo como un texto», para poder leer su `text`.
    println("cuerpo: ${(peticion.body as TextContent).text}")
    respond("ok")
}
val cliente = HttpClient(motor) { install(ContentNegotiation) { json() } }
 
// post: un POST (enviar datos). Dentro del bloque se arma la petición.
val respuesta = cliente.post("https://pizzeria.test/pedidos") {
    parameter("urgente", "si")                   // ?urgente=si al final de la dirección
    header("tienda", "centro")                   // una cabecera: un dato que viaja aparte del cuerpo
    contentType(ContentType.Application.Json)    // avisa de que el cuerpo es JSON
    setBody(Pedido("margarita", 2))              // el objeto, que Ktor convierte en JSON
}
println("respuesta: ${respuesta.bodyAsText()}")

método: POST
dirección: https://pizzeria.test/pedidos?urgente=si
cabecera tienda: centro
cuerpo: {"pizza":"margarita","unidades":2}
respuesta: ok

package com.sebastiannarvaez.pokedex.data.network
 
import com.sebastiannarvaez.pokedex.core.AppConfig
import com.sebastiannarvaez.pokedex.core.Log
import com.sebastiannarvaez.pokedex.data.network.dto.AuthErrorDto
import com.sebastiannarvaez.pokedex.data.network.dto.SessionDto
import io.ktor.client.HttpClient
import io.ktor.client.HttpClientConfig
import io.ktor.client.call.body
import io.ktor.client.engine.HttpClientEngine
import io.ktor.client.plugins.HttpTimeout
import io.ktor.client.plugins.contentnegotiation.ContentNegotiation
import io.ktor.client.plugins.defaultRequest
import io.ktor.client.request.header
import io.ktor.client.request.parameter
import io.ktor.client.request.post
import io.ktor.client.request.setBody
import io.ktor.client.statement.HttpResponse
import io.ktor.http.ContentType
import io.ktor.http.contentType
import io.ktor.http.isSuccess
import io.ktor.serialization.kotlinx.json.json
import kotlinx.serialization.SerialName
import kotlinx.serialization.Serializable
import kotlinx.serialization.json.Json
 
// Lo que la app le pide a Supabase: la lista de operaciones, sin cómo se hacen.
// Una interfaz permite que el repositorio use un doble en los tests.
internal interface SupabaseAuthApi {
    suspend fun registrar(email: String, password: String): SessionDto
    suspend fun entrar(email: String, password: String): SessionDto
    suspend fun refrescar(refreshToken: String): SessionDto
    suspend fun salir(accessToken: String)
}
 
// Los cuerpos JSON que se envían. `private`: solo los usa este fichero.
@Serializable
private data class CredencialesDto(val email: String, val password: String)
 
@Serializable
private data class RefrescoDto(@SerialName("refresh_token") val refreshToken: String)
 
// Un error de autenticación, con el mensaje que devolvió el servidor. Se lanza
// en vez de devolver un resultado: el mapeo a `UiError` (el error ya traducido
// para enseñarlo, de «Errores que se pueden contar») ya trata cualquier `Throwable`, y un tipo de resultado nuevo
// duplicaría el camino de los errores.
// `val codigo` guarda el código como propiedad de la clase; `mensaje` no lleva
// `val` porque solo se pasa a `Exception`, no se guarda aparte.
internal class AuthException(val codigo: Int, mensaje: String?) :
    Exception(mensaje ?: "error de autenticación ($codigo)")

// La implementación con Ktor. Las rutas son relativas: la base
// (`…/auth/v1/`) la pone el cliente del último trozo.
internal class KtorSupabaseAuthApi(private val client: HttpClient) : SupabaseAuthApi {
 
    override suspend fun registrar(email: String, password: String): SessionDto =
        client.post("signup") {
            contentType(ContentType.Application.Json)
            setBody(CredencialesDto(email, password))
        }.sesionOError()
 
    // Entrar y refrescar: la misma ruta `token`, distinto `grant_type`.
    override suspend fun entrar(email: String, password: String): SessionDto =
        client.post("token") {
            parameter("grant_type", "password")
            contentType(ContentType.Application.Json)
            setBody(CredencialesDto(email, password))
        }.sesionOError()
 
    override suspend fun refrescar(refreshToken: String): SessionDto =
        client.post("token") {
            parameter("grant_type", "refresh_token")
            contentType(ContentType.Application.Json)
            setBody(RefrescoDto(refreshToken))
        }.sesionOError()
 
    override suspend fun salir(accessToken: String) {
        // Si falla, da igual: el token local se borra de todos modos. Un cierre
        // de sesión que falla por falta de red no debe dejar al usuario dentro.
        runCatching {
            client.post("logout") { header("Authorization", "Bearer $accessToken") }
        }.onFailure { Log.w("no se pudo cerrar sesion en el servidor", it) }
    }
 
    // Si la respuesta es un éxito (2xx), la convierte en `SessionDto`. Si no,
    // lee el cuerpo como error (`getOrNull` da `null` si no se entiende) y lanza.
    private suspend fun HttpResponse.sesionOError(): SessionDto {
        // `body()` sin más lee la respuesta como el tipo que promete la función
        // (`SessionDto`); `body<AuthErrorDto>()` nombra el tipo a mano.
        if (status.isSuccess()) return body()
        val error = runCatching { body<AuthErrorDto>() }.getOrNull()
        throw AuthException(status.value, error?.mensaje)
    }
}

// Un cliente APARTE para Supabase. No se reutiliza el de PokeAPI: con uno solo
// habría que repetir la dirección en cada petición y, peor, la cabecera
// `apikey` y el token de sesión viajarían también a PokeAPI, que no tiene por
// qué verlos. El parámetro `engine` existe para los tests: en producción es
// `null` y Ktor elige el motor de la plataforma; un test le pasa un MockEngine.
internal fun createSupabaseClient(
    config: AppConfig,
    engine: HttpClientEngine? = null,
): HttpClient {
    val configuracion: HttpClientConfig<*>.() -> Unit = {
        // `ignoreUnknownKeys`: si el JSON trae un campo que la clase no declara,
        // se ignora en vez de fallar.
        install(ContentNegotiation) { json(Json { ignoreUnknownKeys = true }) }
        install(HttpTimeout) {
            requestTimeoutMillis = 15_000
            connectTimeoutMillis = 10_000
        }
        defaultRequest {
            // Todas las rutas relativas cuelgan de aquí.
            url(config.supabaseUrl.trimEnd('/') + "/auth/v1/")
            // `apikey` en todas las peticiones: sin ella, Supabase responde 401
            // aunque el token de sesión sea correcto.
            header("apikey", config.supabaseKey)
        }
    }
 
    // `if` también da un valor: aquí, el cliente que se devuelve.
    return if (engine == null) HttpClient(configuracion) else HttpClient(engine, configuracion)
}

    // `error` + `error_description`: la forma que usan otros endpoints de Supabase.
    @Test
    fun `un error con error_description llega al mensaje`() = runTest {
        val cuerpo = """{"error":"invalid_grant","error_description":"Invalid login credentials"}"""
        val api = KtorSupabaseAuthApi(
            createSupabaseClient(ConfigDePrueba(), json(cuerpo, HttpStatusCode.BadRequest)),
        )
 
        val e = assertFailsWith<AuthException> { api.entrar("ash@pueblo-paleta.test", "malo") }
 
        assertEquals(400, e.codigo)
        assertEquals("Invalid login credentials", e.message)
    }
 
    // `msg`: la forma de `/signup` y de `/token`, la que viste con `curl`.
    @Test
    fun `un error con msg tambien`() = runTest {
        val cuerpo = """{"code":422,"msg":"User already registered"}"""
        val api = KtorSupabaseAuthApi(
            createSupabaseClient(ConfigDePrueba(), json(cuerpo, HttpStatusCode.UnprocessableEntity)),
        )
 
        val e = assertFailsWith<AuthException> { api.registrar("ash@pueblo-paleta.test", "pikachu") }
 
        assertEquals("User already registered", e.message)
    }

./gradlew :shared:jvmTest :shared:testAndroidHostTest :shared:iosSimulatorArm64Test
open shared/build/reports/tests/jvmTest/index.html
open shared/build/reports/tests/testAndroidHostTest/index.html
open shared/build/reports/tests/iosSimulatorArm64Test/index.html