Best Practices for State Management
LobeHub differs from traditional CRUD web applications in that it involves a large amount of rich interactive capabilities. Therefore, it is crucial to design a data flow architecture that is easy to develop and maintain. This document will introduce the best practices for data flow management in LobeHub.
Key Concepts
| Concept | Explanation |
|---|---|
| store | The store contains the application's state and actions. It allows access to and modification of the state during application rendering. |
| state | State refers to the data of the application, storing the current state of the application. Any change in the state will trigger a re-rendering to reflect the new state. |
| action | An action is an operation function that describes the interactive events occurring in the application. Actions are typically triggered by user interactions, network requests, or timers. Actions can be synchronous or asynchronous. |
| reducer | A reducer is a pure function that takes the current state and action as parameters and returns a new state. It is used to update the application's state based on the action type. A reducer is a pure function with no side effects, therefore it is always a synchronous function. |
| selector | A selector is a function used to retrieve specific data from the application's state. It takes the application's state as a parameter and returns computed or transformed data. Selectors can combine parts of the state or multiple states to generate derived data. Selectors are commonly used to map the application's state to a component's props for the component's use. |
| slice | A slice is a concept used to express a part of the data model state. It specifies a state slice and its related state, action, reducer, and selector. Using slices, a large store can be divided into smaller, maintainable subtypes. |
Hierarchical Structure
The structure of the Store can vary greatly depending on the complexity:
- Low Complexity: Generally includes 2 to 5 states and 3 to 4 actions. In this case, the structure usually consists of a
store.tsand aninitialState.ts.
- Moderate Complexity: Typically involves 5 to 15 states and 5 to 10 actions, with the possibility of selectors for derived states and reducers to simplify data changes. The structure usually includes a
store.ts, aninitialState.ts, and aselectors.ts/reducer.ts.
- Medium Complexity: Involves 15 to 30 states and 10 to 20 actions, often requiring the use of multiple slices to manage different actions. The following code represents the internal data flow of the
SortableTreecomponent:
- High Complexity: Involves over 30 states and 20 actions, requiring modular cohesion using slices. Each slice declares its own initState, actions, reducers, and selectors.
The directory structure of the previous version of SessionStore for LobeHub, with high complexity, implements a large amount of business logic. However, with the modularization of slices and the fractal architecture, it is easy to find the corresponding modules, making it easy to maintain and iterate on new features.
Based on the provided directory structure of LobeHub SessionStore, we can update the previous document and convert the examples to the implementation of LobeHub's SessionStore. The following is a portion of the updated document:
Best Practices for LobeHub SessionStore Directory Structure
In the LobeHub application, session management is a complex functional module, so we use the Slice pattern to organize the data flow. Below is the directory structure of LobeHub SessionStore, where each directory and file has its specific purpose:
Implementation of SessionStore
The legacy SessionStore retains selection/UI state and compatibility actions. Its slices group related behavior. The following simplified example shows how action classes are composed into the store:
store.ts
In this store.ts file, we create a useSessionStore hook that uses the zustand library to create a global state manager. We merge the initialState with the actions from each Slice — via the shared flattenActions helper — to create a complete SessionStore. The legacy SessionStore manages session selection and UI state. Agent/sidebar lists are loaded and cached by HomeStore’s replica-backed Agent list.
slices/session/action.ts
The action slice below shows the existing switchSession action. It checks the active Agent ID and updates activeAgentId through a labeled state write.
createSessionSlice returns an action-class instance. flattenActions exposes its public methods on the legacy store, and SessionAction is inferred from those methods. List loading and persistence belong to the owning list resource; this selection action only changes UI state.