Eliminar la cuenta

-- Crea la función `delete_user` (o la sustituye si ya existía) en el esquema
-- `public`, el que expone la API REST del proyecto. No recibe nada: quién eres
-- lo saca de tu token, no lo manda la app.
create or replace function public.delete_user()
-- `returns void`: no devuelve ningún valor. `language plpgsql`: el lenguaje en
-- que está escrito el cuerpo (el de SQL con `if`, `begin` y `end`).
returns void
language plpgsql
-- `security definer`: la función se ejecuta con los permisos de quien la crea
-- (el administrador), no con los de quien la llama. Es lo que le permite
-- tocar `auth.users`.
security definer
-- `set search_path = ''`: sin esto, una función `security definer` puede ser
-- engañada para ejecutar código de otro esquema con permisos elevados. Es la
-- línea que no se quita.
set search_path = ''
-- Lo que va entre los dos `$$` es el cuerpo de la función, como las llaves de
-- Kotlin.
as $$
begin
  -- `auth.uid()` es el identificador de quien llama, sacado del token. Si no
  -- hay token, es nulo y se corta aquí.
  if auth.uid() is null then
    raise exception 'no hay sesión';
  end if;
  -- Borra solo la fila de quien llama. Nadie puede borrar a otro.
  delete from auth.users where id = auth.uid();
end;
$$;
 
-- Quién puede llamarla. Aquí `public` es el rol que agrupa a todo el mundo
-- (no el esquema `public` de arriba, aunque se llamen igual) y `anon` es quien
-- solo trae la clave pública, sin sesión. Se les quita el permiso a los dos y
-- se da solo a quien ha iniciado sesión (`authenticated`): sin esto,
-- cualquiera con la clave pública de la app podría ejecutarla.
revoke all on function public.delete_user() from public, anon;
grant execute on function public.delete_user() to authenticated;

// 1. Import nuevo, arriba (Option+Enter sobre `post` en rojo lo añade; si
//    pregunta de cuál, el de `io.ktor.client.request`).
//    `AppConfig` ya está importado desde `createSupabaseAccountClient`:
import io.ktor.client.request.post
 
// 2. En la interfaz, debajo de `cambiarPassword`:
    suspend fun borrarCuenta()
 
// 3. La cabecera de la clase pasa a recibir el AppConfig (los dos parámetros):
internal class KtorSupabaseAccountApi(
    private val client: HttpClient,
    // Hace falta para construir la dirección de borrar la cuenta.
    private val config: AppConfig,
) : SupabaseAccountApi {
 
// 4. Dentro de la clase, debajo de `cambiarPassword`:
 
    // Borra la cuenta de quien tiene la sesión. La dirección es absoluta porque
    // el cliente apunta a `/auth/v1/` y esto vive en `/rest/v1/`, otra API del
    // mismo proyecto. `exigirExito()` es la función privada que escribiste
    // en esta misma clase, junto a `cambiarPassword`: aquí se reutiliza.
    // `trimEnd('/')` quita la barra final de la URL, si la tiene, para no
    // escribir dos seguidas.
    override suspend fun borrarCuenta() {
        client.post(config.supabaseUrl.trimEnd('/') + "/rest/v1/rpc/delete_user")
            .exigirExito()
    }

    single<SupabaseAccountApi> { KtorSupabaseAccountApi(get(SUPABASE_CUENTA), get()) }

// Antes:
        KtorSupabaseAccountApi(
            createSupabaseAccountClient(ConfigDePrueba(), proveedor(repo), motor),
        )
 
// Después:
        KtorSupabaseAccountApi(
            createSupabaseAccountClient(ConfigDePrueba(), proveedor(repo), motor),
            ConfigDePrueba(),
        )

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,
    // Nuevo: hace falta para cerrar la sesión tras borrar la cuenta. Puede
    // depender de la sesión porque nadie depende de este repositorio.
    private val session: SessionRepository,
    private val dispatchers: AppDispatchers,
) {
 
    suspend fun cambiarPassword(nueva: String) = withContext(dispatchers.io) {
        api.cambiarPassword(nueva)
    }
 
    // Nuevo.
    suspend fun borrarCuenta() = withContext(dispatchers.io) {
        api.borrarCuenta()
        // Se cierra la sesión DESPUÉS de borrar, no antes: si el borrado
        // falla, el usuario sigue dentro y puede reintentar. Al revés quedaría
        // fuera de una cuenta que aún existe, sin token para volver a probar.
        session.salir()
    }
}

    single { AccountRepository(get(), get(), get()) }

    fun borrarCuenta() {
        // Una sola petición a la vez: dos toques seguidos no borran dos veces.
        if (_state.value.trabajando) return
        _state.value = AccountState(trabajando = true)
        viewModelScope.launch {
            _state.value = try {
                repository.borrarCuenta()
                // No se pone ningún estado de éxito: al borrar la cuenta se
                // cierra la sesión, y la app vuelve sola a la pantalla de
                // entrada. Anunciarlo sería un mensaje que nadie llega a leer.
                AccountState()
            } catch (e: Throwable) {
                // Si falla, el error queda en el estado: las dos pantallas lo
                // enseñan, y la sesión sigue abierta.
                AccountState(error = e.aUiErrorDeAuth())
            }
        }
    }

@Composable
fun CuentaHoja(session: Session, alCerrar: () -> Unit, alSalir: () -> Unit) {   // cambios 1 y 2
    ModalBottomSheet(onDismissRequest = alCerrar, sheetState = rememberModalBottomSheetState()) {   // cambio 3
        Column(…) {
            Row { … el círculo con el icono y el correo … }
            Text("Tus favoritos se guardan…")
            OutlinedButton(onClick = alSalir, …) { Text("Cerrar sesión") }
            // aquí, cambio 4
        }
    }
    // aquí, cambio 5
}

// 1. Imports nuevos, arriba (Option+Enter sobre cada nombre en rojo los añade;
//    añade los que falten, algunos pueden estar ya):
import androidx.compose.material3.AlertDialog
import androidx.compose.material3.TextButton
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import com.sebastiannarvaez.pokedex.feature.auth.AccountViewModel
import org.koin.compose.viewmodel.koinViewModel
 
// 2. La firma recibe el ViewModel de la cuenta, y dos líneas nuevas encima del
//    `ModalBottomSheet`. `koinViewModel()` lo pide al grafo de Koin, como en
//    `Raiz.kt`; como tiene valor por defecto, quien llama a `CuentaHoja` no cambia.
@Composable
fun CuentaHoja(
    session: Session,
    alCerrar: () -> Unit,
    alSalir: () -> Unit,
    cuenta: AccountViewModel = koinViewModel(),
) {
    // Si el diálogo de confirmación está abierto.
    var confirmandoBorrado by remember { mutableStateOf(false) }
    // Lo que le pasa a la cuenta: trabajando, error...
    val estado by cuenta.state.collectAsStateWithLifecycle()
 
// 3. El `onDismissRequest` de la hoja. Al cerrar la hoja se olvida el error:
//    el ViewModel vive lo que la actividad, y si no, reaparecería al volver
//    a abrirla. Antes era `onDismissRequest = alCerrar`.
    ModalBottomSheet(
        onDismissRequest = {
            cuenta.descartarError()
            alCerrar()
        },
        sheetState = rememberModalBottomSheetState(),
    ) {
 
// 4. Dentro de la `Column`, debajo del `OutlinedButton` de «Cerrar sesión»:
 
            // Eliminar la cuenta es obligatorio en las dos tiendas si la app
            // deja crearla. No es una cortesía: sin esta opción, la revisión la
            // rechaza.
            TextButton(
                onClick = { confirmandoBorrado = true },
                enabled = !estado.trabajando,
                modifier = Modifier.fillMaxWidth(),
            ) {
                Text("Eliminar mi cuenta", color = MaterialTheme.colorScheme.error)
            }
 
            // Si el borrado falla, la hoja lo dice y la sesión sigue abierta.
            estado.error?.let {
                Text(
                    it.detalle,
                    style = MaterialTheme.typography.bodySmall,
                    color = MaterialTheme.colorScheme.error,
                )
            }
 
// 5. Después de la llave que cierra el `ModalBottomSheet`, antes de la llave
//    que cierra `CuentaHoja`:
 
    if (confirmandoBorrado) {
        AlertDialog(
            onDismissRequest = { confirmandoBorrado = false },
            title = { Text("¿Eliminar tu cuenta?") },
            text = {
                Text(
                    "Se borra tu usuario en el servidor y no se puede deshacer. " +
                        "Tus favoritos, que están en este teléfono, no se tocan.",
                )
            },
            confirmButton = {
                TextButton(
                    onClick = {
                        // Primero se cierra el diálogo, luego se lanza el
                        // borrado: solo tras confirmar.
                        confirmandoBorrado = false
                        cuenta.borrarCuenta()
                    },
                ) {
                    Text("Eliminar", color = MaterialTheme.colorScheme.error)
                }
            },
            dismissButton = {
                TextButton(onClick = { confirmandoBorrado = false }) { Text("Cancelar") }
            },
        )
    }

// 1. Estado nuevo, debajo de `@State private var confirmandoSalida = false`:
    // Lo mismo para borrar la cuenta, con su propio ViewModel (el de la cuenta,
    // que ya existe en el núcleo desde la lección anterior) y el texto del
    // error, si el borrado falla.
    @State private var confirmandoBorrado = false
    @State private var cuenta: AccountViewModel?
    @State private var errorDeBorrado: String?
 
// 2. En la sección Cuenta, debajo del botón «Cerrar sesión»:
                        Button("Eliminar mi cuenta", role: .destructive) {
                            confirmandoBorrado = true
                        }
 
// 3. Debajo del `.confirmationDialog` de «¿Cerrar la sesión?», dos modificadores:
            .confirmationDialog(
                "¿Eliminar tu cuenta?",
                isPresented: $confirmandoBorrado,
                titleVisibility: .visible
            ) {
                Button("Eliminar", role: .destructive) { cuenta?.borrarCuenta() }
                Button("Cancelar", role: .cancel) { }
            } message: {
                Text("Se borra tu usuario en el servidor y no se puede deshacer. Tus favoritos, que están en este iPhone, no se tocan.")
            }
            // La alerta está abierta mientras haya un error. Al cerrarla se
            // le dice al ViewModel que lo olvide, y eso la apaga.
            .alert(
                "No se pudo eliminar la cuenta",
                isPresented: Binding(
                    get: { errorDeBorrado != nil },
                    set: { if !$0 { cuenta?.descartarError() } }
                )
            ) {
                Button("Entendido", role: .cancel) { }
            } message: {
                Text(errorDeBorrado ?? "")
            }
 
// 4. Una `.task` nueva. Va junto a las otras `.task` de la pantalla, justo
//    antes de la de `RecordatorioDiario` (la de `permiso = await …`) y, por
//    tanto, después de la que escucha la sesión:
        .task {
            guard AuthIosKt.hayCuentas() else { return }
            // El ViewModel de la cuenta, creado una sola vez.
            let vm = cuenta ?? AuthIosKt.accountViewModel(owner: owner)
            cuenta = vm
            do {
                // Cada cambio del estado de la cuenta: si trae error, se enseña.
                for try await nuevo in asyncSequence(for: vm.accountStateForIosFlow) {
                    errorDeBorrado = nuevo.error?.detalle
                }
            } catch { }
        }