Clean architecture and user logins in Flutter - how do I store user information?

Question

I've been trying to use Reso Coder's Flutter adaptation of Uncle Bob's Clean Architecture.

My app connects to an API, and most requests (other than logging in) require an authentication token. Furthermore, upon logging in, user profile information (like a name and profile picture) is received.

I need a way to save this data upon login, and use it in both future API requests and my app's UI.

As I'm new to Uncle Bob's Clean Architecture, I'm not quite sure where this data belongs. Here are the ideas I've come up with, all involving storing the data in a User object:

1. Store the User in the repository layer, in an authentication feature directory. Other repository-level methods can pass it to the appropriate datasource methods.

   This seems to make the most sense; other repository-level methods that call other API calls can use the stored User easily, passing it to methods in the data source layer.

   If this is the way to go, I'm not quite sure how other features (that use the API) would access the User - is it okay to have a repository depend on another, and pass the authentication repository to the new feature repository?

2. Store the User in the repository layer, in an authentication feature directory. Other (non-login) usecases can depend on both this repository and on one relevant to their own feature, passing the User to their repository methods.

   This is also breaking the vertical feature barrier, but it may be cleaner then idea 1.

For both these ideas, here's what my repository looks like:

abstract class AuthenticationRepository {
  /// The current user.
  User get currentUser;

  /// True if logged in.
  bool get loggedIn;

  /// Logs in, saving the [User].
  Future<void> login(AuthenticationParams params);

  /// Logs out, disposing of the [User].
  Future<void> logout();

  /// Same as [logout], but logs out of all devices.
  Future<void> logoutAll();

  /// Retrieves stored login credentials.
  Future<AuthenticationParams> retrieveStoredCredentials();
}

Are these ideas "valid", and are there any better ways of doing it?

Answer 1

I see another option to tackle the problem. The solution I want to talk about comes from the domain-driven design and is an event based approach.

In DDD you have the concept of a bounded context. A business object (uncle bob's entity) can have different meanings in different bounded contexts. Take a look at your user business object. The data and methods that some use case uses is often differnt to the data and methods that other use cases use. That's why you have differnt user objects in differnt bounded contexts. They are a kind of perspective that each use case has on the same business object.

If a business object is modified in one bounded context it can emit a business event. Another feature can listen to those events. The event mechanism can either be a simple observer pattern or if you need to distribute your application features via microservices a message queue. In case you use a simple observer patter the event emitter and event handler can run within the same data source transaction. But they can also run in differnt ones. It depends on your needs.

So when the sign-up use case registers a new user it emits a UserSignedUpEvent. Other features can now listen to this event. The event carries the information of the user, like the email, the name, the profile image and other infomration that the user provided during sign-up. Other features can now save the piece of data they need to their own data source. It can be the same as the sign-up use case uses (just other tables or another schema). But it is also possible that is a completely differnt data source, maybe another kind of data source like a nosql db. The part I wrote above about transactions is of course more difficult if you have different data sources.

The main point is that each feature has it's own data and manages it. It might be a copy of the whole user infromation, but in a lot of cases it is only a subset.

The event-based approach can give you perfect modularization. But as it is always when something looks great, it comes at a cost. You have to duplicate some part or even all data. When you think of a microservice architecture and some features are in different microservices it means that the duplication increases the availability of the service. The service can operate even the main service that manages the data is down, because a local copy exists. But now you have to deal with consistency issues - eventual consistency.

At this point I like to stop and guide you to other sources for details:

• Chapter 8: Domain Events, Implementing Domain-Driven Desing, Vaughn Vernon
• The many meanings of event-driven architectures, Martin Fowler