Kea 3.0 – State Management via Logic Builders (opens in new tab)

Just out of curiosity, have you seen our official Redux Toolkit package? We specifically designed it to eliminate the "boilerplate" concerns and work great with TS:

- https://redux.js.org/tutorials/essentials/part-2-app-structu...

- https://redux.js.org/introduction/why-rtk-is-redux-today

- https://redux.js.org/tutorials/typescript-quick-start

I'm also interested in hearing any particular features in Kea you find useful that aren't covered in RTK.

Yes - having an architecture that ensures maintainability is critical. But good architecture needn't require this much boilerplate. There is a lot of non-linear control flow encoded implicitly in calls to `kea`, `actions`, `listeners` in this framework, and for what?

Here's one of the examples from the docs (https://keajs.org/docs/core/listeners/#error-handling)

    kea([
      actions({
        loadUsers: true,
        loadUsersSuccess: (users) => ({ users }),
        loadUsersFailure: (error) => ({ error }),
      }),
    
      reducers({
        users: [
          [],
          {
            loadUsersSuccess: (_, { users }) => users,
          },
        ],
        usersLoading: [
          false,
          {
            loadUsers: () => true,
            loadUsersSuccess: () => false,
            loadUsersFailure: () => false,
          },
        ],
        usersError: [
          null,
          {
            loadUsers: () => null,
            loadUsersFailure: (_, { error }) => error,
          },
        ],
      }),
    
      listeners(({ actions }) => ({
        loadUsers: async () => {
          try {
            const users = await api.get('users')
            actions.loadUsersSuccess(users)
          } catch (error) {
            actions.loadUsersFailure(error.message)
          }
        },
      })),
    ])
    

I argue that an API with a different shape could implement the same behavior in a more direct readable style, without giving up any of the nice debugging, etc that you get with Kea's abstractions.

    class Users extends OtherKeaAPI {
      users = this.state<User[]>([])
      usersLoading = this.state(false)
      usersError = this.state<Error | null>(null)
    
      loadUsers = this.action(action => {
        this.usersLoading = true
        this.usersError = null
     
        action.effect('load em up', async () => {
          try {
            this.loadUsersSuccess(await api.get('users'))
          } catch (error) {
            this.loadUsersFailure(error)
          }
        })
      })
    
      loadUsersSuccess = this.action((users: User[]) => {
        this.usersLoading = false
        this.users = users
      })
    
      loadUsersFailure = this.action((error: Error) => {
        this.usersLoading = false
        this.usersError = error
      })
    }