Merge pull request #8 from andnp/ValidationErrors

feat: make validation errors available

Author: andnp

src/index.ts

@@ -1,5 +1,5 @@
-import { Schema } from 'type-level-schema/schema';
-import { objectKeys, Nominal, AnyFunc, AllRequired, Optional } from 'simplytyped';
+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<{
@@ -10,6 +10,16 @@ export type ObjectOptions<OptionalKeys> = Partial<{
     optional: OptionalKeys[];
 }>;
 
+export interface ValidResult<T> {
+    data: T;
+    valid: true;
+}
+
+export interface InvalidResult {
+    errors: Ajv.ErrorObject[];
+    valid: false;
+}
+
 const once = <F extends AnyFunc>(f: F): F => {
     let ret: any;
     let called = false;
@@ -89,16 +99,37 @@ export default class Validator<T> {
     private constructor(private schema: Schema) {}
 
     private getAjv = once(() => new Ajv());
+    private getCompiledSchema = once(() => {
+        const ajv = this.getAjv();
+        const schema = this.getSchema();
+        return ajv.compile(schema);
+    });
 
     getSchema(): Schema {
         return this.schema;
     }
 
-    isValid(thing: any): thing is T {
-        const schema = this.getSchema();
-        const ajv = this.getAjv();
+    isValid(thing: Unknown): thing is T {
+        const ajvValidator = this.getCompiledSchema();
 
-        return ajv.validate(schema, thing) as boolean;
+        return ajvValidator(thing) as boolean;
+    }
+
+    validate(data: Unknown): ValidResult<T> | InvalidResult {
+        if (this.isValid(data)) {
+            return { data, valid: true };
+        }
+
+        const ajvValidator = this.getCompiledSchema();
+        return { errors: ajvValidator.errors || [], valid: false };
+    }
+
+    setSchemaMetaData(meta: Partial<SchemaMetaData>): this {
+        this.schema = {
+            ...this.schema,
+            ...meta,
+        };
+        return this;
     }
 }
 

tests/integration/api.test.ts

@@ -95,3 +95,26 @@ test('Validates a deep object', () => {
         fail();
     }
 });
+
+test('Can add json schema metadata', () => {
+    const validator = v.object({
+        thing: v.string(),
+    }).setSchemaMetaData({
+        title: 'ThingSchema',
+        description: 'This is a thing schema',
+    });
+
+    const obj: any = { thing: 'hi' };
+    const result = validator.validate(obj);
+    if (result.valid) {
+        expect(result.data).toEqual({ thing: 'hi' });
+    } else {
+        type Got = typeof result;
+        interface Expected {
+            valid: false;
+            errors: Ajv.ErrorObject[];
+        }
+        assertTypesEqual<Got, Expected>();
+        fail();
+    }
+});

tests/integration/errors.test.ts

@@ -0,0 +1,15 @@
+import v from 'index';
+
+test('Will get back array of errors on invalid data', () => {
+    const validator = v.object({
+        thing: v.string(),
+    });
+
+    const obj: any = { thing: 22 };
+
+    const result = validator.validate(obj);
+    if (result.valid) fail();
+    else {
+        expect(result.errors.length).toBe(1);
+    }
+});

tests/integration/scale.test.ts

@@ -0,0 +1,26 @@
+import v from 'index';
+import { pass } from '../helpers/assert';
+
+test('Ajv compiles only one instance of schema', () => {
+    const validator = v.object({
+        a: v.string([ 'a', 'b', 'c' ]),
+        b: v.number(),
+        c: v.boolean(),
+    });
+
+    const t = Date.now();
+    for (let i = 0; i < 2e4; ++i) {
+        const o = {
+            a: 'a',
+            b: Math.random(),
+            c: false,
+        };
+
+        if (validator.isValid(o)) pass();
+        else fail();
+    }
+
+    const took = Date.now() - t;
+
+    expect(took).toBeLessThan(2000);
+});