Recuperar la contraseña

// 1. Dentro de la interfaz SupabaseAuthApi, debajo de `salir`:
 
    // Manda el correo con el enlace para poner una contraseña nueva.
    suspend fun recuperar(email: String, redirectTo: String)
 
// 2. Debajo de `RefrescoDto`, junto a los otros cuerpos de petición:
 
// El cuerpo de la petición de recuperación: solo el correo.
@Serializable
private data class EmailDto(val email: String)
 
// 3. Dentro de KtorSupabaseAuthApi, encima de `sesionOError`:
 
    override suspend fun recuperar(email: String, redirectTo: String) {
        val respuesta = client.post("recover") {
            // `redirect_to` decide a dónde vuelve el usuario tras pulsar el
            // enlace. Sin él, Supabase usa el «Site URL» del panel, que por
            // defecto es localhost y en un móvil no abre nada.
            parameter("redirect_to", redirectTo)
            contentType(ContentType.Application.Json)
            setBody(EmailDto(email))
        }
        // Mismo patrón que el resto: un error del servidor se convierte en
        // AuthException con el mensaje que mandó Supabase.
        if (!respuesta.status.isSuccess()) {
            val error = runCatching { respuesta.body<AuthErrorDto>() }.getOrNull()
            throw AuthException(respuesta.status.value, error?.mensaje)
        }
    }

    // Cuántas veces se pidió el correo y a qué dirección: lo que los tests miran.
    var recuperaciones = 0
        private set
    var ultimaRedireccion: String? = null
        private set
 
    override suspend fun recuperar(email: String, redirectTo: String) {
        recuperaciones++
        ultimaRedireccion = redirectTo
    }

    // Pide el correo con el enlace para poner una contraseña nueva.
    suspend fun recuperar(email: String, redirectTo: String) = withContext(dispatchers.io) {
        api.recuperar(email.trim(), redirectTo)
    }

    // true cuando el correo de recuperación ya salió: la pantalla enseña el aviso.
    val correoEnviado: Boolean = false,

// Import nuevo, arriba del fichero:
import com.sebastiannarvaez.pokedex.navigation.Destination
 
// `descartarError` pasa a ser (se cambia):
 
    // Cierra el error o el aviso de «revisa tu correo». Apagar `correoEnviado`
    // es lo que cierra el aviso: si se quedara en `true`, el diálogo de
    // Android reaparecería al instante y la alerta de iOS no volvería a salir
    // la próxima vez (el valor no cambiaría, y nada se enteraría).
    fun descartarError() {
        _form.value = _form.value.copy(error = null, correoEnviado = false)
    }
 
// Nuevo, encima de `private fun enviar`:
 
    // Pide el correo de recuperación.
    // `correoEnviado` se pone pase lo que pase con la respuesta, salvo error
    // de red. Es deliberado: decir «ese correo no existe» le cuenta a cualquiera
    // quién tiene cuenta aquí. Supabase también responde igual en los dos casos.
    fun recuperar() {
        val actual = _form.value
        // Sin correo válido o con una petición en vuelo, no se hace nada.
        if (!actual.emailValido || actual.enviando) return
        _form.value = actual.copy(enviando = true, error = null)
        viewModelScope.launch {
            // `try` es una expresión: vale lo que valga la última línea del
            // bloque que se ejecute, y ese valor se asigna directamente.
            _form.value = try {
                repository.recuperar(actual.email, REDIRECCION)
                actual.copy(enviando = false, correoEnviado = true)
            } catch (e: Throwable) {
                actual.copy(enviando = false, error = e.aUiErrorDeAuth())
            }
        }
    }
 
    // La dirección a la que vuelve el enlace: `pokedex://auth/callback`.
    // `private companion object`: un sitio para constantes de la clase que
    // nadie de fuera puede ver. La ruta se repite aquí a mano; la lección
    // siguiente le da nombre. Es `val` y no `const val` porque se arma con una
    // plantilla de texto: se calcula una sola vez, y da igual.
    private companion object {
        val REDIRECCION = "${Destination.ESQUEMA}://auth/callback"
    }

// Un pedido de helado con tres datos y valores por defecto.
data class Pedido(
    val sabor: String,
    val bolas: Int = 1,
    val cucurucho: Boolean = true,
) {
    // Constructor secundario: otra forma de crear el pedido. No lleva datos y
    // delega (`: this(...)`) en el principal con el sabor "vainilla".
    constructor() : this(sabor = "vainilla")
}
 
fun main() {
    println(Pedido("fresa"))          // el principal; usa los valores por defecto
    println(Pedido("limón", 3))       // el principal, con dos datos
    println(Pedido())                 // el secundario, sin ningún dato
}

./gradlew :shared:linkDebugFrameworkIosSimulatorArm64

error: missing argument for parameter 'correoEnviado' in call

    // El constructor vacío, para Swift. Los argumentos por defecto de Kotlin
    // no cruzan a Objective-C: allí solo llega el constructor con todos los
    // parámetros. Esta segunda forma de crear la clase delega en la principal.
    constructor() : this(email = "")

    // `AuthFormState()` y no la lista entera de campos: los argumentos por
    // defecto de Kotlin no cruzan, así que el núcleo declara un constructor
    // vacío a propósito. Sin él, cada campo nuevo rompería este fichero.
    @State private var formulario = AuthFormState()

// Una pantalla de sala de chat. El diálogo vive mientras `saliendo` sea true.
@Composable
fun SalaDeChat() {
    var saliendo by remember { mutableStateOf(false) }
 
    Button(onClick = { saliendo = true }) { Text("Salir de la sala") }
 
    if (saliendo) {                                    // el diálogo existe solo con este if
        AlertDialog(
            onDismissRequest = { saliendo = false },   // tocar fuera o pulsar «atrás»
            title = { Text("¿Salir de la sala?") },    // el título, arriba
            text = { Text("Dejarás de ver los mensajes nuevos.") },
            confirmButton = {                          // el botón principal
                TextButton(onClick = { saliendo = false }) { Text("Salir") }
            },
            dismissButton = {                          // el botón secundario (opcional)
                TextButton(onClick = { saliendo = false }) { Text("Quedarme") }
            },
        )
    }
}

import androidx.compose.material3.AlertDialog

            // Recuperar solo tiene sentido al entrar: quien se está
            // registrando no tiene contraseña que olvidar.
            if (!registrando) {
                TextButton(
                    onClick = {
                        teclado?.hide()                // `teclado` es el que ya usas en `enviar`
                        viewModel.recuperar()
                    },
                    // Sin un correo válido no hay a dónde mandar nada.
                    enabled = formulario.emailValido && !formulario.enviando,
                    modifier = Modifier.padding(top = 8.dp),
                ) {
                    Text("¿Olvidaste tu contraseña?")
                }
                // La pista solo sale mientras el botón está apagado.
                if (!formulario.emailValido) {
                    Text(
                        "Escribe tu correo arriba y te mandamos un enlace.",
                        style = MaterialTheme.typography.bodySmall,
                        color = MaterialTheme.colorScheme.onSurfaceVariant,
                        textAlign = TextAlign.Center,
                    )
                }
            }

    // El aviso no dice si el correo existe. Decirlo le contaría a cualquiera
    // quién tiene cuenta aquí, y Supabase responde igual en los dos casos.
    if (formulario.correoEnviado) {
        AlertDialog(
            // Tocar fuera y «Entendido» hacen lo mismo: apagar `correoEnviado`
            // en el núcleo, y con eso el `if` deja de cumplirse.
            onDismissRequest = viewModel::descartarError,
            confirmButton = {
                TextButton(onClick = viewModel::descartarError) { Text("Entendido") }
            },
            title = { Text("Revisa tu correo") },
            text = {
                Text(
                    "Si hay una cuenta con ese correo, le hemos mandado un enlace " +
                        "para poner una contraseña nueva.",
                )
            },
        )
    }

// 1. Estado nuevo, debajo de `@State private var mostrandoError = false`:
    @State private var mostrandoCorreoEnviado = false
 
// 2. El botón, debajo del `Button` de enviar: detrás de su último modificador,
//    `.disabled(!formulario.sePuedeEnviar)`, y dentro de la misma pila:
 
            // Recuperar solo tiene sentido al entrar: quien se registra no
            // tiene contraseña que olvidar.
            if !registrando {
                Button("¿Olvidaste tu contraseña?") {
                    campo = nil                  // baja el teclado
                    viewModel.recuperar()
                }
                .font(.footnote)
                // Sin un correo válido no hay a dónde mandar nada.
                .disabled(!formulario.emailValido || formulario.enviando)
            }
 
// 3. La alerta, debajo de la `.alert` de los errores:
 
        // El aviso no dice si el correo existe. Decirlo le contaría a cualquiera
        // quién tiene cuenta aquí, y Supabase responde igual en los dos casos.
        .alert("Revisa tu correo", isPresented: $mostrandoCorreoEnviado) {
            // Apaga `correoEnviado` en el núcleo: si se quedara en verdadero, la
            // segunda petición no lo cambiaría y la alerta no volvería a salir.
            Button("Entendido", role: .cancel) { viewModel.descartarError() }
        } message: {
            Text("Si hay una cuenta con ese correo, le hemos mandado un enlace para poner una contraseña nueva.")
        }
 
// 4. Debajo del `.onChange(of: formulario.error)`:
 
        // Abre la alerta cuando `correoEnviado` pasa a verdadero.
        .onChange(of: formulario.correoEnviado) { _, enviado in
            mostrandoCorreoEnviado = enviado
        }