flow-io
v0.1.0
Published
Flow compatible runtime type system for IO validation
Downloads
5
Maintainers
Readme
The idea
A value of type Type<T>
(called "runtime type") is a representation of the type T
:
class Type<T> {
name: string;
validate: (value: mixed, context: Context) => Validation<T>;
}
where Context
and Validation<T>
are defined as
type ContextEntry = { key: string, name: string };
type Context = Array<ContextEntry>;
type ValidationError = { value: mixed, context: Context, description: string };
type Validation<T> = Either<Array<ValidationError>, T>;
Example: a runtime type representing the type string
is
import * as t from 'flow-io'
export const string: Type<string> = new Type(
'string',
(v, c) => typeof v === 'string' ? t.success(v) : t.failure(v, c)
)
A runtime type can be used to validate an object in memory (for example an API payload)
import * as t from 'flow-io'
const Person = t.object({
name: t.string,
age: t.number
})
// ok
t.fromValidation(JSON.parse('{"name":"Giulio","age":43}'), Person) // => {name: "Giulio", age: 43}
// throws Invalid value undefined supplied to : { name: string, age: number }/age: number
t.fromValidation(JSON.parse('{"name":"Giulio"}'), Person)
// doesn't throw, returns an Either
const validation = t.validate(JSON.parse('{"name":"Giulio"}'), Person)
t.map(person => console.log(person), validation)
Runtime type introspection
Runtime types can be inspected
const Name: Type<string> = Person.props.name
const Age: Type<number> = Person.props.age
Error reporters
A reporter implements the following interface
export interface Reporter<A> {
report: (validation: Validation<*>) => A;
}
This package exports two default reporters
PathReporter: Reporter<Array<string>>
ThrowReporter: Reporter<void>
Example
import * as t from 'flow-io'
import { PathReporter, ThrowReporter } from 'flow-io/lib/reporters/default'
const validation = t.validate('a', t.number)
console.log(PathReporter.report(validation)) // => ["Invalid value "a" supplied to : number"]
ThrowReporter.report(validation) // => throws Invalid value "a" supplied to : number
Implemented types / combinators
| Type | Flow syntax | Runtime type / combinator |
|------|-------|-------------|
| string | string
| string
|
| number | number
| number
|
| boolean | boolean
| boolean
|
| generic object | Object
| Object
|
| generic function | Function
| Function
|
| instance of C
| C
| instanceOf(C)
|
| class of C
| Class<C>
| classOf(C)
|
| array | Array<A>
| array(A)
|
| intersection | A & B
| intersection([A, B])
|
| literal | 's'
| literal('s')
|
| maybe | ?A
| maybe(A)
|
| map | { [key: A]: B }
| mapping(A, B)
|
| refinement | ✘ | refinement(A, predicate)
|
| object | { name: string }
| object({ name: string })
|
| tuple | [A, B]
| tuple([A, B])
|
| union | A | B
| union([A, B])
|
| $Exact | {| name: string |}
| $exact({ name: string })
|
| function | (a: A) => B
| ✘ |