Let's say I have a REST API to edit a user profile.
There are two methods concerned here

* a method to update the user profile;
* a method to get the current profile's completion score.

Of course, when the user updates his profile, I want to fetch the completion score.

Here is my (naive ?) way to do this with `redux` and `redux-thunk` action creators

```
function updateProfileAction(userId, profile) {

  return function (dispatch) {
    dispatch("PROFILE_UPDATE", /*...*/)
    api.updateProfile(userId, profile)
      .then(repsonse => dispatch("PROFILE_UPDATE_SUCCESS", /*...*/))
      // ▼ triggers the action that fetch the completion score
      // this is the line that bugs me
      .then(() => fetchProfileCompletionAction(userId))
  }

}

```

What bugs me with this line:

* it **breaks the single responsibility principle** (the `udpateProfileAction` is suddenly responsible for also fetching the completion);
* it is **not fractal** (if I want to add a feature that depends on the profile update, I need to modify, yet again, that piece of code.

For example if, for some reason, I don't want to display the completion anymore (say I remove the component that displays it) and forget to remove this line of code, the `fetchCompletion` will be triggered but will never be used in a graphical component).

I was thinking, maybe in the component that consumes the completion being fetched, I could subscribe to the store and `dispatch` at this moment. This would allow me to code in a **more reactive way**

```
function Completion(props) {

  props.store.subscribe(state => {
    //check if profile has changed
    dispatch(fetchProfileCompletionAction(userId))
  })

  return <div> {props.completion} </div>
}

```

Is this a good idea? Is there a better way to do this? Also I guess checking that the relevant state has changed is not really trivial with this solution.