MobX Quick Start Guide

Supercharge the client state in your React apps with MobX

Pavan Podila, Michel Weststrate

• Publisher: Packt Publishing
• Year: 2018
• ISBN:
  9781789348972
• Edition: 1
• Topic: Computer Science
• Subtopic: Programming in JavaScript
• Index: Computer Science

Apply functional Reactive programming for simple and scalable state management with MobX

Key Features

• The easiest way to learn MobX to enhance your client-side state-management
• Understand how the concepts and components fit together
• Work through different state management scenarios with MobX

Book Description

MobX is a simple and highly scalable state management library in JavaScript. Its abstractions can help you manage state in small to extremely large applications. However, if you are just starting out, it is essential to have a guide that can help you take the first steps. This book aims to be that guide that will equip you with the skills needed to use MobX and effectively handle the state management aspects of your application.

You will first learn about observables, actions, and reactions: the core concepts of MobX. To see how MobX really shines and simplifies state management, you'll work through some real-world use cases. Building on these core concepts and use cases, you will learn about advanced MobX, its APIs, and libraries that extend MobX.

By the end of this book, you will not only have a solid conceptual understanding of MobX, but also practical experience. You will gain the confidence to tackle many of the common state management problems in your own projects.

What you will learn

• Explore the fundamental concepts of MobX, such as observables, actions, and reactions
• Use observables to track state and react to its changes with validations and visual feedback (via React Components)
• Create a MobX observable from different data types
• Define form data as an observable state and tackle sync and async form validations
• Use the special APIs to directly manipulate observables, tracking its changes, and discovering the reasons behind a change
• Tackle any state management issue you may have in your app by combining mobx-utils and mobx-state-tree
• Explore the internals of the MobX reactive system by diving into its inner workings

Who this book is for

This book is for web developers who want to implement easy and scalable state management for their apps. Knowledge of HTML, CSS, and JavaScript is assumed

Handling Real-World Use Cases

Applying the principles of MobX can seem daunting when you first start using it. To help you with this process, we are gong to tackle two non-trivial examples of using the MobX triad of observables-actions-reactions. We will cover the modeling of the observable state, and then identify the actions and the reactions that track the observables. Once you go through these examples, you should be able to make the mental shift in tackling state management with MobX.

The examples we will cover in this chapter include the following:

• Form validation
• Page routing

Technical requirements

You will be required to have JavaScript programming language. Finally, to use the Git repository of this book, the user needs to install Git.

The code files of this chapter can be found on GitHub:

https://github.com/PacktPublishing/Mobx-Quick-Start-Guide/tree/master/src/Chapter06

Check out the following video to see the code in action:
http://bit.ly/2LDliA9

Form validation

Filling up forms and validating fields is the classic use-case of the web. So, it's fitting we start here and see how MobX can help us simplify it. For our example, we will consider a User Enrollment form that takes in some standard inputs like first name, last name, email, and password.

The various states of enrollment are captured in the following figure:

The interactions

Looking at the preceding screenshot, we can see some standard interactions going on, such as:

• Entering inputs for various fields
• Validation on those fields
• Clicking the Enroll button to perform a network operation

There are few other interactions here that do not meet the eye immediately:

• Network-based validation for the email to ensure that we are not registering with an existing email address
• Showing a progress indicator for the enroll operation

Many of these interactions will be modeled with actions and reactions in MobX. The state will, of course, be modeled with observables. Let's see how the Observables-Actions-Reactions triad comes to life in this example.

Modeling the observable state

The visual design for the example already hints at the core state that we need. This includes the firstName, lastName, email, and password fields. We can model these as observable properties of the UserEnrollmentData class.

Additionally, we also need to track the async validation that will happen with email. We do that with the boolean validating property. Any errors that are found during the validation are tracked with errors. Finally, the enrollmentStatus tracks the network operation around enrollment. It is a string-enum that can have one of four values: none, pending, completed, or failed:

class UserEnrollmentData {
 @observable email = '';
 @observable password = '';
 @observable firstName = '';
 @observable lastName = '';
 @observable validating = false;
 @observable.ref errors = null;
 @observable enrollmentStatus = 'none'; // none | pending | completed | failed
}

You will notice that errors is marked with @observable.ref, as it only needs to track reference changes. This is because the validation output is an opaque object, which does not have anything observable besides a change in reference. Only when errors has a value do we know that there are validation errors.

Onto the actions

The actions here are quite straightforward. We need one to set the field value based on user changes. The other is do enrollment when the Enroll button is clicked. These two can be seen in the following code.

As a general practice,...

Table of contents

• Title Page
• Copyright and Credits
• Dedication
• Packt Upsell
• Foreword
• Contributors
• Preface
• Introduction to State Management
• Observables, Actions, and Reactions
• A React App with MobX
• Crafting the Observable Tree
• Derivations, Actions, and Reactions
• Handling Real-World Use Cases
• Special API for Special Cases
• Exploring mobx-utils and mobx-state-tree
• Mobx Internals
• Other Books You May Enjoy