Manejo de flatMap y catch: Operadores Esenciales en Combine

Hoy en SwiftBeta vamos a explicar el operador flatMap en Combine. Este operador tiene un potencial tremendo y es muy versátil, en el video de hoy vamos a aprender a cómo concatenar el resultado de varios Publishers. Imagina que quieres registrar un usuario en tu servidor, y justo a continuación, después de hacer la petición HTTP,  si el user se ha registrado correctamente guardamos el usuario en la base de datos del iPhone, pues bien, podemos concatenar estas dos llamadas, estos dos métodos y suscribirnos al Publisher, como resultado el código que nos queda es muy fácil de interpretar y leer.

Vas a ver que el uso de flatMap es muy sencillo pero potente, vamos a crear 2 métodos. Uno que nos permita simular que hemos realizado el registro en nuestro servidor correctamente, y el otro método va a ser para simular que almacenamos el user que hemos registrado en una base de datos del iPhone.

Creamos nuevas Page de Xcode

Lo primero de todo que vamos hacer es continuar con la serie de Combine, y como es un nuevo operador, vamos a crear una nueva page llamada "Operador FlatMap".

Lo siguiente que vamos hacer es crear 2 nuevos tipos, primero un tipo User que será el tipo Output de nuestro Publisher:

struct User {
    let email: String
    let name: String
}

Ya que estamos creamos una instancia de User:

let user: User = .init(email: "swiftbeta.blog@gmail.com", name: "SwiftBeta")

Y ahora creamos el otro tipo, va a ser un Enum que será el tipo Failure de nuestro Publisher:

enum RegisterFormError: String, Error {
    case userExists = "User already exists"
    case wrongEmail = "Wrong Email"
    case wrongPassword = "Wrong Password"
    case unknown = "Unknown Error"
}

A continuación creamos el método que va a simular que registramos un user. Es decir, si el correo electrónico del user es swiftbeta.blog@gmail.com todo irá bien pero si el correo electrónico es otro publicamos un error. Vamos a usar el mismo método que vimos en el anterior video, así que puedes ir a su Page del Playground y copiarlo directamente.

Fíjate que para crear la implementación usamos Just y Fail que lo vimos en el anterior video.

func register(user: User) -> AnyPublisher<User, RegisterFormError> {
    // Petición HTTP al backend para guardar el user en Base de Datos
    if user.email == "swiftbeta.blog@gmail.com" {
        return Just(user)
        .setFailureType(to: RegisterFormError.self)
        .eraseToAnyPublisher()
    } else {
        return Fail(error: RegisterFormError.wrongEmail)
    }
}

Lo siguiente que vamos hacer es crear el método para almacenar en la base de datos. La única validación que vamos a tener, es que si el user tiene de nombre SwiftBeta, lo podremos almacenar en la base de datos, y sino retornaremos un error:

func save(user: User) -> AnyPublisher<Bool, RegisterFormError> {
    // Guardamos al user en la base de datos
    if user.name == "SwiftBeta" {
        return Just(true)
            .setFailureType(to: RegisterFormError.self)
            .eraseToAnyPublisher()
    } else {
        return Fail(error: RegisterFormError.userExists)
            .eraseToAnyPublisher()
    }
}

En este caso, si el user se llama SwiftBeta simulamos que hemos almacenado correctamente al User en la base de datos, y sino Publicamos un error de que el usuario ya existe.

Ya tenemos los dos métodos, ahora ya podemos concatenar nuestros 2 métodos para que si funciona correctamente el primero se llame al segundo. Escribimos el siguiente código:

register(user: user).flatMap { user in
    return save(user: user)
}

Añadimos el método register y a continuación utilizamos el operador flatMap. El operador flatMap tiene como parámetro de entrada la salida del método register, es decir un tipo User. Este valor que recibimos, lo inyectamos al segundo método llamado save, que simula que lo almacena en la base de datos. Y una vez tenemos esta parte, ya nos podemos suscribir al publisher utilizando el método sink:

register(user: user).flatMap { user in
    return save(user: user)
}
.sink(receiveCompletion: { hasFinished in
    switch hasFinished {
    case .finished:
        print("Registro completado")
    case .failure(let error):
        print(error.localizedDescription)
    }
}, receiveValue: { value in
    print("Usuario Registrado y almacenado en la base de datos registered -> \(value)")
})

En este caso hemos usado flatMap para concatenar 2 métodos pero podríamos concatenar más lógica. Fíjate que si todo va bien recibimos el valor dentro del closure receiveValue, y si obtenemos un error, tanto del método register como del método save, se ejecuta el closure receiveCompletion.

Antes de acabar, como curiosidad y para enseñarte otro operador. Si queremos que nuestro suscriber no reciba errores, podemos utilizar el operador catch. Este operador es muy útil para capturar cualquier error que viaje en nuestro Publisher y así retornar otro Publisher con el valor, con el output que queramos, es decir:

register(user: user).flatMap { user in
    return save(user: user)
}
.catch({ error in
    Just(false)
})
.sink(receiveCompletion: { hasFinished in
    switch hasFinished {
    case .finished:
        print("Registro completado")
    case .failure(let error):
        print(error.localizedDescription)
    }
}, receiveValue: { value in
    print("Usuario Registrado y almacenado en la base de datos registered -> \(value)")
})

En este caso si recibimos un error, lo que hacemos es retornar un false, indicando que algo no ha ido bien.

Conclusión

Hoy hemos aprendido a cómo usar flatMap desde 0 usando Combine. Antes de usarlo, hemos aprendido 2 tipos de Publishers que no habíamos visto hasta ahora, uno de ellos es Just y el otro Fail. El primero publica valores dentro del Publisher y el segundo Publica errores dentro del Publisher. Una vez hemos entendido estos conceptos hemos usado AnyPublisher como valor de retorno de 2 métodos y hemos usado flatMap para concatenar el Output de un método con el Input del otro.

Y hasta aquí el video de hoy!