What is the idiomatic way to succinctly tell Flow that nullable properties will not be null in a chain of property accesses?

Question

Say you have a couple of simple Flow types with optional properties:

type A = { b?: B };
type B = { action?: () => void };

And you want to access the properties in a chain and know they are defined:

a.b.action()

What's the idiomatic way to tell Flow that a.b and b.action are safe?

Answer 1

There isn't a simple answer. You basically have three options.

• Circumvent the typechecker, giving up type safety.
• To maintain type safety do a runtime check. Flow understands many runtime checks and will refine types based on them.
• Restructure your program so that these properties are not optional.

To circumvent the typechecker entirely and give up safety, you could do something like (a: any).b.action(). I don't recommend this.

Obviously there is not enough information in this question to determine if it's feasible or even desirable to restructure your program to avoid having optional properties.

So, to maintain type safety you need to have a runtime check. You could do something like:

if (a.b != null && a.b.action != null) {
  a.b.action();
} else {
  // throw error or something
}

Or, if you simply want to assert that they are non-null, Flow has special-cased functions named invariant for that purpose (of course, you need to figure out how to get it at runtime. In Node, you can do import invariant from 'assert'. It's pretty simple to write yourself if you want, though).

invariant(a.b != null && a.b.action != null);
a.b.action();

The one caveat with this sort of thing is that Flow aggressively invalidates type refinements if it believes that something could have been changed. So, if there are any intervening function calls between the tests and the use, it could start erroring again. In that case, you'll have to pull each bit out into a separate variable, something like:

const b = a.b;
invariant(b != null);
const action = b.action;
invariant(action != null);
// other stuff that would have invalidated the type refinement
action();

Answer 2

You can test that they exist, like a.b && a.b.action && a.b.action()

https://flowtype.org/try/#0PQKgBAAgZgNg9gdzCYAoVAXAngBwKZgCCYAvGAN5gBGA-AFxgBCYAvgNya4HNmUCGAYwwBLOADt6YABQBKUgD4wANzjCAJqw6ooAVzFDRYsFCl8GhOeVRgwfAHRU7gkeNkcW6XfpdGA5qfNLa1sHMAAyMJDHZ0NwyPtog1cZdyA