Easier way to enforce typed immutable data structures? - immutable.js

Question

Enforcing a data structure with vanilla JS objects and flow is easy:
type ExampleObjType = {
key1: number,
key2: string
};
const obj: ExampleObjType = {
key1: 123,
key2: '123'
};
It seems like this requires an unnecessarily large amount of boilerplate to enforce a similar structure in Immutable:
type TestSpec = {
key1: number,
key2: string,
};
const TestRecord = Record({
key1: 0,
key2: '',
});
const record: TestSpec & Record<TestSpec> = new TestRecord({
key1: 123,
key2: '123',
});
Further, the above structure has some major drawbacks:
Forced default values
No enforcement on invalid keys on initialization, only on access
Ideally I would be able to use Immutable.Map, something like this:
type TestSpec = Map<{key1: number, key2: number}>;
const testMap: TestSpec = Map({
key1: 123,
key2: '123',
});
However, the current implementation only allows typing of key and value type. I could constrain the key type using something hokey like type Key = 'key1' | 'key2', but that still wouldn't me to explicitly type the values per key.
Is there a way to accomplish what I'm looking for with Immutable? It seems like a very foundational requirement to true type safety, particularly when used for, say, Redux action payloads.

Answer 1

immutable.Record() is difficult to type. In fact, it's currently typed to return any. On one hand, this is inconvenient, since you'll need to describe the type of TestRecord from scratch. On the other hand, it lets you type it however you like!
Here's one option:
interface TestSpec {
constructor(defaults: $Shape<TestSpec>): void,
key1: number,
key2: string,
};
const TestRecord: Class<TestSpec> = Record({
key1: 0,
key2: '',
});
The Class<TestSpec> type is the type of a class who's instances have the type TestSpec. You don't have to define the constructor in TestSpec, but by doing so, Flow will make sure obj has the right time when it sees new TestRecord(obj).
(Note: $Shape<TestSpec> is the type of an object which may or may not have. So in this case it basically means {key1?: number, key2?: string})
new TestRecord({key1: 123, key2: '123'}); // OK
new TestRecord({key1: 123}); // OK
new TestRecord({key2: '123'}); // OK
new TestRecord({key2: 123}); // Error number -> string
new TestRecord({key1: '123'}); // Error string -> number
new TestRecord({key1: 123, key2: '123', key3: 'blah'}); // Error unknown property key3
And Flow will check that instance properties have the right type
const record = new TestRecord({key1: 123, key2: '123'});
(record.key1: string); // Error number -> string
(record.key2: number); // Error string -> number
Try this code on flowtype.org/try