feat: allow combining multiple validators

Author: andy.patterson

src/index.ts

@@ -2,9 +2,11 @@ import { Schema, SchemaMetaData } from 'type-level-schema/schema';
 import { objectKeys, Nominal, AnyFunc, AllRequired, Optional, Unknown } from 'simplytyped';
 import * as Ajv from 'ajv';
 
-type ObjectValidator<O extends Record<string, Validator<any>>, OptionalKeys extends keyof O> = Optional<{
+type ObjectValidator<O extends Record<string, Validator<any>>> = {
     [S in keyof O]: ValidType<O[S]>;
-}, OptionalKeys>;
+};
+
+type OptionalObjectValidator<O extends Record<string, Validator<any>>, OptionalKeys extends keyof O> = Optional<ObjectValidator<O>, OptionalKeys>;
 
 export type ObjectOptions<OptionalKeys> = Partial<{
     optional: OptionalKeys[];
@@ -50,10 +52,16 @@ export default class Validator<T> {
         return new Validator({ type: 'boolean' });
     }
 
+    static any(): Validator<any> {
+        return new Validator({});
+    }
+
     static nominal<T, S extends string>(v: Validator<T>, s: S): Validator<Nominal<T, S>> {
         return new Validator(v.getSchema());
     }
 
+    static object<O extends Record<string, Validator<any>>>(o: O): Validator<ObjectValidator<O>>;
+    static object<O extends Record<string, Validator<any>>, OptionalKeys extends keyof O = never>(o: O, opts?: ObjectOptions<OptionalKeys>): Validator<OptionalObjectValidator<O, OptionalKeys>>;
     static object<O extends Record<string, Validator<any>>, OptionalKeys extends keyof O = never>(o: O, opts?: ObjectOptions<OptionalKeys>) {
         const options: AllRequired<ObjectOptions<OptionalKeys>> = {
             optional: [] as OptionalKeys[],
@@ -68,7 +76,7 @@ export default class Validator<T> {
 
         const required = Object.keys(o).filter(key => !options.optional.includes(key as OptionalKeys));
 
-        return new Validator<ObjectValidator<O, OptionalKeys>>({
+        return new Validator({
             type: 'object',
             properties,
             required,
@@ -82,6 +90,16 @@ export default class Validator<T> {
         });
     }
 
+    static partial<T extends Record<string, any>>(v: Validator<T>): Validator<Partial<T>> {
+        const schema = v.getSchema();
+        if (!('type' in schema)) throw new Error('Must apply partial only to a type definition');
+        if (schema.type !== 'object') throw new Error('Must only apply partial to an object schema');
+        return new Validator({
+            ...schema,
+            required: [],
+        });
+    }
+
     static array<V extends Validator<any>>(v: V[]) {
         return new Validator<Array<ValidType<V>>>({
             type: 'array',
@@ -96,6 +114,10 @@ export default class Validator<T> {
         });
     }
 
+    static intersect<T1, T2>(v1: Validator<T1>, v2: Validator<T2>) {
+        return new Validator<T1 & T2>({ allOf: [v1.getSchema(), v2.getSchema()] });
+    }
+
     private constructor(private schema: Schema) {}
 
     private getAjv = once(() => new Ajv());
@@ -131,6 +153,14 @@ export default class Validator<T> {
         };
         return this;
     }
+
+    or<V extends Validator<any>>(v: V): Validator<T | ValidType<V>> {
+        return Validator.union([this, v]);
+    }
+
+    and<V extends Validator<any>>(v: V): Validator<T & ValidType<V>> {
+        return Validator.intersect(this, v);
+    }
 }
 
 export type ValidType<V extends Validator<any>> = V extends Validator<infer T> ? T : never;

tests/unit/and.test.ts

@@ -0,0 +1,22 @@
+import v from 'index';
+import { fail, pass, assertTypesEqual } from '../helpers/assert';
+
+test('Can combine two schema', () => {
+    const x: any = { a: '', b: 22 };
+
+    const validator = v.object({
+        a: v.string(),
+    }).and(v.object({
+        b: v.number(),
+    }));
+
+    if (validator.isValid(x)) {
+        type got = typeof x;
+        type expected = { a: string, b: number };
+        assertTypesEqual<got, expected>();
+        assertTypesEqual<expected, got>();
+        pass();
+    } else {
+        fail();
+    }
+});

tests/unit/any.test.ts

@@ -0,0 +1,22 @@
+import v from 'index';
+import { pass } from '../helpers/assert';
+
+test('Can validate an any type', () => {
+    const things: any[] = [
+        22,
+        'yellow',
+        false,
+        {},
+        undefined,
+        null,
+        () => ({}),
+    ];
+
+    const validator = v.any();
+
+    things.forEach(thing => {
+        if (validator.isValid(thing)) pass();
+        else fail();
+    });
+
+});

tests/unit/intersect.test.ts

@@ -0,0 +1,21 @@
+import v from 'index';
+import { fail, pass, assertTypesEqual } from '../helpers/assert';
+
+test('Can validate an intersection of objects', () => {
+    const x: any = { a: '', b: 22 };
+
+    const v1 = v.object({ a: v.string() });
+    const v2 = v.object({ b: v.number() });
+
+    const validator = v.intersect(v1, v2);
+
+    if (validator.isValid(x)) {
+        type got = typeof x;
+        type expected = { a: string, b: number };
+        assertTypesEqual<got, expected>();
+        assertTypesEqual<expected, got>();
+        pass();
+    } else {
+        fail();
+    }
+});

tests/unit/or.test.ts

@@ -0,0 +1,18 @@
+import v from 'index';
+import { fail, pass, assertTypesEqual } from '../helpers/assert';
+
+test('Can combine two schema', () => {
+    const x: any = 'hi';
+
+    const validator = v.string().or(v.number());
+
+    if (validator.isValid(x)) {
+        type got = typeof x;
+        type expected = string | number;
+        assertTypesEqual<got, expected>();
+        assertTypesEqual<expected, got>();
+        pass();
+    } else {
+        fail();
+    }
+});

tests/unit/partial.test.ts

@@ -0,0 +1,21 @@
+import v from 'index';
+import { fail, pass, assertTypesEqual } from '../helpers/assert';
+
+test('Can validate a partial object', () => {
+    const x: any = { a: '' };
+
+    const validator = v.partial(v.object({
+        a: v.string(),
+        b: v.number(),
+    }));
+
+    if (validator.isValid(x)) {
+        type got = typeof x;
+        type expected = { a?: string, b?: number };
+        assertTypesEqual<got, expected>();
+        assertTypesEqual<expected, got>();
+        pass();
+    } else {
+        fail();
+    }
+});