cleaners
Version:
Cleans & validates untrusted data, with TypeScript & Flow support
243 lines (219 loc) • 6.17 kB
Flow
// @flow
// type names ----------------------------------------------------------------
export type Cleaner<T> = (raw: any) => T
export type Uncleaner<T> = (clean: T) => any
export type ObjectCleaner<T> = Cleaner<T> & {
+shape: $ObjMap<T, <T>(type: T) => Cleaner<T>>,
+withRest: Cleaner<T>
}
type ReturnType = <T>(f: () => T) => T
// simple types --------------------------------------------------------------
declare export var asBoolean: Cleaner<boolean>
declare export var asNone: Cleaner<void>
declare export var asNull: Cleaner<null>
declare export var asNumber: Cleaner<number>
declare export var asString: Cleaner<string>
declare export var asUndefined: Cleaner<void>
declare export var asUnknown: Cleaner<mixed>
declare export function asValue<
T: Array<boolean | number | string | null | void>
>(
...values: T
): Cleaner<$ElementType<T, number>>
// data structures -----------------------------------------------------------
declare export function asArray<T>(cleaner: Cleaner<T>): Cleaner<T[]>
declare export var asObject: {|
<T>(cleaner: Cleaner<T>): Cleaner<{ [keys: string]: T }>,
<Shape>(shape: Shape): ObjectCleaner<$ObjMap<Shape, ReturnType>>
|}
declare export function asTuple<Shape>(
...shape: Shape
): Cleaner<$TupleMap<Shape, ReturnType>>
// branching -----------------------------------------------------------------
declare export var asEither: {|
<A>(a: Cleaner<A>): Cleaner<A>,
<A, B>(a: Cleaner<A>, b: Cleaner<B>): Cleaner<A | B>,
<A, B, C>(a: Cleaner<A>, b: Cleaner<B>, c: Cleaner<C>): Cleaner<A | B | C>,
<A, B, C, D>(
a: Cleaner<A>,
b: Cleaner<B>,
c: Cleaner<C>,
d: Cleaner<D>
): Cleaner<A | B | C | D>,
<A, B, C, D, E>(
a: Cleaner<A>,
b: Cleaner<B>,
c: Cleaner<C>,
d: Cleaner<D>,
e: Cleaner<E>
): Cleaner<A | B | C | D | E>,
<A, B, C, D, E, F>(
a: Cleaner<A>,
b: Cleaner<B>,
c: Cleaner<C>,
d: Cleaner<D>,
e: Cleaner<E>,
f: Cleaner<F>
): Cleaner<A | B | C | D | E | F>,
<A, B, C, D, E, F, G>(
a: Cleaner<A>,
b: Cleaner<B>,
c: Cleaner<C>,
d: Cleaner<D>,
e: Cleaner<E>,
f: Cleaner<F>,
g: Cleaner<G>
): Cleaner<A | B | C | D | E | F | G>,
<A, B, C, D, E, F, G, H>(
a: Cleaner<A>,
b: Cleaner<B>,
c: Cleaner<C>,
d: Cleaner<D>,
e: Cleaner<E>,
f: Cleaner<F>,
g: Cleaner<G>,
h: Cleaner<H>
): Cleaner<A | B | C | D | E | F | G | H>,
<A, B, C, D, E, F, G, H, I>(
a: Cleaner<A>,
b: Cleaner<B>,
c: Cleaner<C>,
d: Cleaner<D>,
e: Cleaner<E>,
f: Cleaner<F>,
g: Cleaner<G>,
h: Cleaner<H>,
i: Cleaner<I>
): Cleaner<A | B | C | D | E | F | G | H | I>,
<A, B, C, D, E, F, G, H, I, J>(
a: Cleaner<A>,
b: Cleaner<B>,
c: Cleaner<C>,
d: Cleaner<D>,
e: Cleaner<E>,
f: Cleaner<F>,
g: Cleaner<G>,
h: Cleaner<H>,
i: Cleaner<I>,
j: Cleaner<J>
): Cleaner<A | B | C | D | E | F | G | H | I | J>,
<A, B, C, D, E, F, G, H, I, J, K>(
a: Cleaner<A>,
b: Cleaner<B>,
c: Cleaner<C>,
d: Cleaner<D>,
e: Cleaner<E>,
f: Cleaner<F>,
g: Cleaner<G>,
h: Cleaner<H>,
i: Cleaner<I>,
j: Cleaner<J>,
k: Cleaner<K>
): Cleaner<A | B | C | D | E | F | G | H | I | J | K>,
<A, B, C, D, E, F, G, H, I, J, K, L>(
a: Cleaner<A>,
b: Cleaner<B>,
c: Cleaner<C>,
d: Cleaner<D>,
e: Cleaner<E>,
f: Cleaner<F>,
g: Cleaner<G>,
h: Cleaner<H>,
i: Cleaner<I>,
j: Cleaner<J>,
k: Cleaner<K>,
l: Cleaner<L>
): Cleaner<A | B | C | D | E | F | G | H | I | J | K | L>,
<A, B, C, D, E, F, G, H, I, J, K, L, M>(
a: Cleaner<A>,
b: Cleaner<B>,
c: Cleaner<C>,
d: Cleaner<D>,
e: Cleaner<E>,
f: Cleaner<F>,
g: Cleaner<G>,
h: Cleaner<H>,
i: Cleaner<I>,
j: Cleaner<J>,
k: Cleaner<K>,
l: Cleaner<L>,
m: Cleaner<M>
): Cleaner<A | B | C | D | E | F | G | H | I | J | K | L | M>,
<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(
a: Cleaner<A>,
b: Cleaner<B>,
c: Cleaner<C>,
d: Cleaner<D>,
e: Cleaner<E>,
f: Cleaner<F>,
g: Cleaner<G>,
h: Cleaner<H>,
i: Cleaner<I>,
j: Cleaner<J>,
k: Cleaner<K>,
l: Cleaner<L>,
m: Cleaner<M>,
n: Cleaner<N>
): Cleaner<A | B | C | D | E | F | G | H | I | J | K | L | M | N>,
<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(
a: Cleaner<A>,
b: Cleaner<B>,
c: Cleaner<C>,
d: Cleaner<D>,
e: Cleaner<E>,
f: Cleaner<F>,
g: Cleaner<G>,
h: Cleaner<H>,
i: Cleaner<I>,
j: Cleaner<J>,
k: Cleaner<K>,
l: Cleaner<L>,
m: Cleaner<M>,
n: Cleaner<N>,
o: Cleaner<O>
): Cleaner<A | B | C | D | E | F | G | H | I | J | K | L | M | N | O>,
<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(
a: Cleaner<A>,
b: Cleaner<B>,
c: Cleaner<C>,
d: Cleaner<D>,
e: Cleaner<E>,
f: Cleaner<F>,
g: Cleaner<G>,
h: Cleaner<H>,
i: Cleaner<I>,
j: Cleaner<J>,
k: Cleaner<K>,
l: Cleaner<L>,
m: Cleaner<M>,
n: Cleaner<N>,
o: Cleaner<O>,
p: Cleaner<P>
): Cleaner<A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P>
|}
declare export var asMaybe: {|
<T>(cleaner: Cleaner<T>): Cleaner<T | void>,
<T>(
cleaner: Cleaner<T>,
// The extra $Call prevents Flow from inferring T from the fallback:
fallback: $Call<Cleaner<T>> | (() => $Call<Cleaner<T>>)
): Cleaner<T>
|}
declare export var asOptional: {|
<T>(cleaner: Cleaner<T>): Cleaner<T | void>,
<T>(
cleaner: Cleaner<T>,
// The extra $Call prevents Flow from inferring T from the fallback:
fallback: $Call<Cleaner<T>> | (() => $Call<Cleaner<T>>)
): Cleaner<T>
|}
// parsing -------------------------------------------------------------------
declare export function asCodec<T>(
cleaner: Cleaner<T>,
uncleaner: Uncleaner<T>
): Cleaner<T>
declare export var asDate: Cleaner<Date>
declare export function asJSON<T>(cleaner: Cleaner<T>): Cleaner<T>
declare export function uncleaner<T>(cleaner: Cleaner<T>): Uncleaner<T>
// deprecated ----------------------------------------------------------------
declare export var asMap: typeof asObject