El enlace del correo y la contraseña nueva

pokedex://auth/callback#access_token=eyJhbGci.abc&expires_in=3600&refresh_token=v1kqNrTz&type=recovery

fun main() {
    val texto = "sabor=fresa&bolas=2&=sin-clave&cono"
    val campos = texto.split('&')                          // ["sabor=fresa", "bolas=2", "=sin-clave", "cono"]
        .mapNotNull { trozo ->                              // como map, pero tira los null
            val clave = trozo.substringBefore('=')          // lo de antes del =
            val valor = trozo.substringAfter('=', missingDelimiterValue = "") // lo de después; "" si no hay =
            if (clave.isBlank() || valor.isBlank()) null else clave to valor
        }
        .toMap()                                            // lista de parejas -> mapa
    println(campos)
    println(campos["bolas"])
    println(campos["sirope"])
}

package com.sebastiannarvaez.pokedex.feature.auth
 
// El enlace que llega por correo para recuperar la contraseña.
// NO es un destino de la app y por eso no está en `Destination`: aquel mapa son
// pantallas que el usuario puede pedir; esto es un suceso de sesión que además
// trae credenciales.
data class EnlaceDeRecuperacion(
    val accessToken: String,
    val refreshToken: String,
    val expiresIn: Long,
) {
    companion object {
        // La ruta a la que Supabase redirige. Va en `redirect_to`.
        const val RUTA = "auth/callback"
 
        // Devuelve el enlace, o null si la URL no es de recuperación.
        fun parse(url: String): EnlaceDeRecuperacion? {
            // Una URL de otro sitio de la app (pokedex://pokemon/25) no es esto.
            if (!url.contains(RUTA)) return null
            // Los tokens vienen detrás del `#` (el fragmento), no del `?`.
            val fragmento = url.substringAfter('#', missingDelimiterValue = "")
            if (fragmento.isBlank()) return null
 
            // «a=1&b=2» -> mapa {a: 1, b: 2}, como en el ejemplo. Los trozos
            // sin clave o sin valor se descartan.
            val campos = fragmento.split('&')
                .mapNotNull { trozo ->
                    val clave = trozo.substringBefore('=')
                    val valor = trozo.substringAfter('=', missingDelimiterValue = "")
                    if (clave.isBlank() || valor.isBlank()) null else clave to valor
                }
                .toMap()
 
            // `type=recovery` distingue este correo del de confirmación de
            // cuenta, que llega al mismo sitio con la misma forma.
            if (campos["type"] != "recovery") return null
 
            // Si falta cualquiera de los dos tokens, el enlace se descarta
            // entero: media sesión no sirve de nada.
            val acceso = campos["access_token"] ?: return null
            val refresco = campos["refresh_token"] ?: return null
            return EnlaceDeRecuperacion(
                accessToken = acceso,
                refreshToken = refresco,
                // Si no dice cuánto dura, se asume una hora.
                expiresIn = campos["expires_in"]?.toLongOrNull() ?: 3600,
            )
        }
    }
}

// Antes:
    private companion object {
        val REDIRECCION = "${Destination.ESQUEMA}://auth/callback"
    }
 
// Después:
    private companion object {
        val REDIRECCION = "${Destination.ESQUEMA}://${EnlaceDeRecuperacion.RUTA}"
    }

// Import nuevo, arriba del fichero:
import com.sebastiannarvaez.pokedex.feature.auth.EnlaceDeRecuperacion
 
// Dentro de la clase, debajo de `recuperar`:
 
    // Adopta la sesión que trae el enlace del correo. El enlace de recuperación
    // YA viene con sesión iniciada: Supabase da acceso temporal para que el
    // usuario pueda cambiar la contraseña sin saberse la vieja. Por eso esto
    // entra por la misma puerta que un login: guarda y publica.
    // `: Unit` dice que no devuelve nada: la función vale lo que vale el bloque
    // de `withContext`, y su última línea (una asignación) no es un valor.
    suspend fun adoptar(enlace: EnlaceDeRecuperacion): Unit = withContext(dispatchers.io) {
        val session = Session(
            accessToken = enlace.accessToken,
            refreshToken = enlace.refreshToken,
            // El instante de caducidad, no la duración (como en publicar).
            expiresAtEpochSeconds = ahoraEnSegundos() + enlace.expiresIn,
            // El enlace no trae datos del usuario, así que el identificador y
            // el correo se quedan vacíos: bastan para cambiar la contraseña, y
            // las pantallas de cuenta enseñan un texto genérico en vez del
            // correo hasta que el usuario vuelve a entrar.
            userId = "",
            email = null,
        )
        store.guardar(session)
        _state.value = AuthState(comprobando = false, session = session)
    }

    // El enlace del correo trae sesión temporal: se adopta y se entra.
    fun abrirRecuperacion(enlace: EnlaceDeRecuperacion) {
        viewModelScope.launch { repository.adoptar(enlace) }
    }

import com.sebastiannarvaez.pokedex.data.network.dto.AuthErrorDto
import io.ktor.client.request.put
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 kotlinx.serialization.Serializable

// En la interfaz SupabaseAccountApi, debajo de `perfil`:
    suspend fun cambiarPassword(nueva: String)
 
// Encima de la clase KtorSupabaseAccountApi:
 
// El cuerpo de «cambiar contraseña»: solo la nueva.
@Serializable
private data class PasswordDto(val password: String)
 
// Dentro de KtorSupabaseAccountApi, debajo de `perfil`:
 
    // PUT /auth/v1/user con la contraseña nueva. El cliente ya pone la cabecera
    // Authorization con el token del usuario.
    override suspend fun cambiarPassword(nueva: String) {
        client.put("user") {
            contentType(ContentType.Application.Json)
            setBody(PasswordDto(nueva))
        }.exigirExito()
    }
 
    // Si el servidor no responde con éxito, lanza AuthException con su mensaje.
    // Es la tercera copia de «lee AuthErrorDto si no es éxito» (ver el paso 1
    // de la lección anterior); aquí va en una función porque la lección
    // siguiente la usa otra vez.
    private suspend fun HttpResponse.exigirExito() {
        if (status.isSuccess()) return
        val error = runCatching { body<AuthErrorDto>() }.getOrNull()
        throw AuthException(status.value, error?.mensaje)
    }

package com.sebastiannarvaez.pokedex.data
 
import com.sebastiannarvaez.pokedex.core.AppDispatchers
import com.sebastiannarvaez.pokedex.data.network.SupabaseAccountApi
import kotlinx.coroutines.withContext
 
// Lo que se hace CON la cuenta, ya dentro.
internal class AccountRepository(
    private val api: SupabaseAccountApi,
    private val dispatchers: AppDispatchers,
) {
 
    // `withContext(dispatchers.io)`: la petición va al hilo de entrada y salida.
    suspend fun cambiarPassword(nueva: String) = withContext(dispatchers.io) {
        api.cambiarPassword(nueva)
    }
}

package com.sebastiannarvaez.pokedex.feature.auth
 
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.sebastiannarvaez.pokedex.core.UiError
import com.sebastiannarvaez.pokedex.data.AccountRepository
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.launch
 
// Lo que pasa DENTRO de la cuenta (por ahora, cambiar la contraseña).
data class AccountState(
    // true mientras hay una petición en vuelo.
    val trabajando: Boolean = false,
    val error: UiError? = null,
    // true cuando la contraseña se ha cambiado: la pantalla enseña «Listo».
    val passwordCambiada: Boolean = false,
)
 
class AccountViewModel internal constructor(
    private val repository: AccountRepository,
) : ViewModel() {
 
    private val _state = MutableStateFlow(AccountState())
    val state: StateFlow<AccountState> = _state.asStateFlow()
 
    fun cambiarPassword(nueva: String) {
        // Mismas guardas que el formulario: mínimo de caracteres y una sola
        // petición a la vez.
        if (nueva.length < AuthFormState.MINIMO_PASSWORD || _state.value.trabajando) return
        _state.value = AccountState(trabajando = true)
        viewModelScope.launch {
            // Otro `try` como expresión, igual que en `recuperar()`: su valor
            // es el nuevo estado.
            _state.value = try {
                repository.cambiarPassword(nueva)
                AccountState(passwordCambiada = true)
            } catch (e: Throwable) {
                AccountState(error = e.aUiErrorDeAuth())
            }
        }
    }
 
    fun descartarError() {
        _state.value = _state.value.copy(error = null)
    }
 
    // Vuelve al estado del principio: lo llama el diálogo de contraseña nueva
    // al cerrarse. El ViewModel vive lo que la actividad, y sin esto el
    // «Contraseña cambiada» de ahora seguiría puesto la próxima vez.
    fun reiniciar() {
        _state.value = AccountState()
    }
}

// Imports nuevos, arriba:
import com.sebastiannarvaez.pokedex.data.AccountRepository
import com.sebastiannarvaez.pokedex.feature.auth.AccountViewModel
 
// Dentro del módulo:
    single { AccountRepository(get(), get()) }
    viewModelOf(::AccountViewModel)

package com.sebastiannarvaez.pokedex.android.auth
 
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.material3.AlertDialog
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.text.input.PasswordVisualTransformation
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import com.sebastiannarvaez.pokedex.feature.auth.AccountViewModel
import com.sebastiannarvaez.pokedex.feature.auth.AuthFormState
import org.koin.compose.viewmodel.koinViewModel
 
// La contraseña nueva, tras abrir el enlace del correo.
@Composable
fun NuevaPasswordDialog(
    alTerminar: () -> Unit,
    viewModel: AccountViewModel = koinViewModel(),
) {
    // El texto se queda en `remember`: perder una contraseña a medio escribir al
    // girar es aceptable, y así no se guarda en el estado de la actividad.
    var password by remember { mutableStateOf("") }
    val estado by viewModel.state.collectAsStateWithLifecycle()
 
    // Las tres salidas hacen lo mismo: olvidar el estado y avisar a quien
    // abrió el diálogo.
    val cerrar = {
        viewModel.reiniciar()
        alTerminar()
    }
 
    if (estado.passwordCambiada) {
        AlertDialog(
            onDismissRequest = cerrar,
            confirmButton = { TextButton(onClick = cerrar) { Text("Listo") } },
            title = { Text("Contraseña cambiada") },
            text = { Text("Ya puedes seguir usando la app con la contraseña nueva.") },
        )
        return
    }
 
    AlertDialog(
        onDismissRequest = cerrar,
        title = { Text("Nueva contraseña") },
        text = {
            Column {
                OutlinedTextField(
                    value = password,
                    onValueChange = { password = it },
                    label = { Text("Contraseña") },
                    singleLine = true,
                    visualTransformation = PasswordVisualTransformation(),
                    supportingText = { Text("Al menos ${AuthFormState.MINIMO_PASSWORD} caracteres") },
                    isError = estado.error != null,
                    modifier = Modifier.fillMaxWidth(),
                )
                estado.error?.let {
                    Text(
                        it.detalle,
                        style = MaterialTheme.typography.bodySmall,
                        color = MaterialTheme.colorScheme.error,
                    )
                }
            }
        },
        confirmButton = {
            TextButton(
                onClick = { viewModel.cambiarPassword(password) },
                enabled = password.length >= AuthFormState.MINIMO_PASSWORD && !estado.trabajando,
            ) { Text("Guardar") }
        },
        dismissButton = { TextButton(onClick = cerrar) { Text("Ahora no") } },
    )
}

// 1. Imports nuevos, arriba:
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import com.sebastiannarvaez.pokedex.feature.auth.EnlaceDeRecuperacion
 
// 2. La firma, con los parámetros nuevos antes de `contenido`:
@Composable
fun RaizConSesion(
    // El enlace del correo, si llegó uno. Lo guarda la actividad.
    recuperacion: EnlaceDeRecuperacion? = null,
    // Lo que se llama al usarlo, para que la actividad lo ponga a null.
    alConsumirRecuperacion: () -> Unit = {},
    contenido: @Composable () -> Unit,
) {
 
// 3. Debajo de `val estado by viewModel.state.collectAsStateWithLifecycle()`:
    // Si el diálogo de contraseña nueva está abierto. `rememberSaveable` y no
    // `remember`: al girar el móvil Android rehace la actividad, el enlace ya
    // se consumió y no vuelve a llegar, y con `remember` el diálogo se
    // cerraría dejando al usuario dentro con la sesión temporal.
    var cambiandoPassword by rememberSaveable { mutableStateOf(false) }
 
    // `LaunchedEffect(recuperacion)` se ejecuta cada vez que llega un enlace
    // distinto. El enlace trae una sesión temporal: se adopta, el usuario entra
    // y el diálogo de contraseña nueva queda encima de la app.
    LaunchedEffect(recuperacion) {
        val enlace = recuperacion ?: return@LaunchedEffect
        viewModel.abrirRecuperacion(enlace)
        cambiandoPassword = true
        alConsumirRecuperacion()
    }
 
// 4. Debajo del `when`, antes de la llave que cierra la función:
    // El diálogo solo se enseña con sesión: la que acaba de traer el enlace.
    if (cambiandoPassword && estado.haySesion) {
        NuevaPasswordDialog(alTerminar = { cambiandoPassword = false })
    }

// 1. Import nuevo, arriba:
import com.sebastiannarvaez.pokedex.feature.auth.EnlaceDeRecuperacion
 
// 2. Estado nuevo, debajo de `destinoEntrante`:
    // El enlace del correo de recuperación. Va aparte del destino porque no es
    // una pantalla: trae una sesión y abre un diálogo encima de la app.
    private val recuperacionEntrante = mutableStateOf<EnlaceDeRecuperacion?>(null)
 
// 3. En onCreate, dentro del `if (savedInstanceState == null) { … }`.
//    Antes:
        // `dataString` es la URL; `parse` la traduce o devuelve null.
        destinoEntrante.value = intent?.dataString?.let(Destination::parse)
//    Después (el `if` se queda como está):
        // `dataString` es la URL; `recibir` decide qué es.
        recibir(intent?.dataString)
 
// 4. En onNewIntent.
//    Antes:
        destinoEntrante.value = intent.dataString?.let(Destination::parse)
//    Después:
        recibir(intent.dataString)
 
// 5. La llamada al guardián (`RaizConSesion`, dentro de `PokedexTheme`):
//    antes era `RaizConSesion { PokedexApp(…) }`. Ahora recibe el enlace, y lo
//    de dentro no cambia:
                RaizConSesion(
                    recuperacion = recuperacionEntrante.value,
                    alConsumirRecuperacion = { recuperacionEntrante.value = null },
                ) {
                    PokedexApp(
                        destinoEntrante = destinoEntrante.value,
                        alConsumirDestino = { destinoEntrante.value = null },
                    )
                }
 
// 6. La función nueva, al final de la clase:
    // Un enlace entrante es una de dos cosas, y el orden importa: el de
    // recuperación TAMBIÉN encaja en el esquema de la app (pokedex://), así que
    // hay que descartarlo antes de intentar leerlo como pantalla.
    private fun recibir(url: String?) {
        val enlace = url ?: return
        val recuperacion = EnlaceDeRecuperacion.parse(enlace)
        if (recuperacion != null) {
            recuperacionEntrante.value = recuperacion
        } else {
            destinoEntrante.value = Destination.parse(enlace)
        }
    }

// Lo mismo para el ViewModel de la cuenta (por ahora, cambiar la contraseña).
fun accountViewModel(owner: ViewModelStoreOwner): AccountViewModel {
    val koin = KoinPlatform.getKoin()
    return ViewModelProvider.create(
        owner = owner,
        factory = viewModelFactory { initializer { koin.get<AccountViewModel>() } },
    )[AccountViewModel::class]
}
 
@NativeCoroutinesState
val AccountViewModel.accountStateForIos: StateFlow<AccountState>
    get() = state

struct NuevaPasswordView: View {
    let alTerminar: () -> Void                 // lo que llama al cerrarse: la raíz apaga la hoja
 
    @StateObject private var owner = IosViewModelStoreOwner()   // el almacén de su ViewModel
    @State private var viewModel: AccountViewModel?
    @State private var estado = AccountState(…)                 // lo último que dijo el núcleo
    @State private var password = ""
 
    var body: some View {
        NavigationStack {
            Form { … SecureField + pie con el error o el mínimo … }
                .toolbar { … «Ahora no» y «Guardar» (apagado si es corta o hay petición) … }
        }
        .onChange(of: estado.passwordCambiada) { … si cambió, alTerminar() … }
        .task { … crea el ViewModel y escucha su estado … }
    }
}

// 1. Debajo de `@State private var estado`:
    // Si la hoja de contraseña nueva está abierta.
    @State private var cambiandoPassword = false
    // El enlace que llegó antes de que exista el ViewModel (arranque en frío).
    @State private var enlacePendiente: EnlaceDeRecuperacion?
 
// 2. Debajo de `.animation(.default, value: estado.haySesion)`:
        // El enlace de recuperación TAMBIÉN encaja en el esquema de la app, así
        // que hay que mirarlo antes de que nadie lo lea como pantalla.
        .onOpenURL { url in
            guard let enlace = EnlaceDeRecuperacion.companion.parse(url: url.absoluteString) else { return }
            // Arranque en frío: el ViewModel aún no existe. Se guarda y la
            // `.task` lo atiende. (En el simulador la `.task` suele llegar
            // antes, pero SwiftUI no promete el orden.)
            guard let viewModel else {
                enlacePendiente = enlace
                return
            }
            // Adopta la sesión temporal del enlace y abre la hoja.
            viewModel.abrirRecuperacion(enlace: enlace)
            cambiandoPassword = true
        }
        .sheet(isPresented: $cambiandoPassword) {
            NuevaPasswordView { cambiandoPassword = false }
        }
 
// 3. En la `.task` que ya tienes, justo debajo de `estado = vm.authStateForIos`:
            // Si llegó un enlace antes de que existiera el ViewModel, se atiende ahora.
            if let enlace = enlacePendiente {
                enlacePendiente = nil
                vm.abrirRecuperacion(enlace: enlace)
                cambiandoPassword = true
            }

adb shell "am start -a android.intent.action.VIEW -d 'pokedex://auth/callback#access_token=eyJhbGci.abc&expires_in=3600&refresh_token=v1kqNrTz&token_type=bearer&type=recovery'"

xcrun simctl openurl booted 'pokedex://auth/callback#access_token=eyJhbGci.abc&expires_in=3600&refresh_token=v1kqNrTz&token_type=bearer&type=recovery'