feat(@angular-devkit/core): support schema custom formats

Author: filipesilva

packages/angular_devkit/core/README.md

@@ -23,17 +23,34 @@ export interface SchemaValidator {
 }
 ```
 
+### SchemaFormatter
+
+```
+export interface SchemaFormatter {
+  readonly async: boolean;
+  validate(data: any): boolean | Observable<boolean>;
+}
+```
+
 ### SchemaRegistry
 
 ```
 export interface SchemaRegistry {
   compile(schema: Object): Observable<SchemaValidator>;
+  addFormat(name: string, formatter: SchemaFormatter): void;
 }
 ```
 
 ### CoreSchemaRegistry
 
 `SchemaRegistry` implementation using https://github.com/epoberezkin/ajv.
+Constructor accepts object containing `SchemaFormatter` that will be added automatically.
+
+```
+export class CoreSchemaRegistry implements SchemaRegistry {
+  constructor(formats: { [name: string]: SchemaFormatter} = {}) {}
+}
+```
 
 # Logger
 

packages/angular_devkit/core/src/json/schema/interface.ts

@@ -13,13 +13,23 @@ export interface SchemaValidatorResult {
   errors?: string[];
 }
 
-
 export interface SchemaValidator {
   // tslint:disable-next-line:no-any
   (data: any): Observable<SchemaValidatorResult>;
 }
 
+export interface SchemaFormatter {
+  readonly async: boolean;
+  // tslint:disable-next-line:no-any
+  validate(data: any): boolean | Observable<boolean>;
+}
+
+export interface SchemaFormat {
+  name: string;
+  formatter: SchemaFormatter;
+}
 
 export interface SchemaRegistry {
   compile(schema: Object): Observable<SchemaValidator>;
+  addFormat(format: SchemaFormat): void;
 }

packages/angular_devkit/core/src/json/schema/registry.ts

@@ -12,7 +12,13 @@ import 'rxjs/add/observable/of';
 import { fromPromise } from 'rxjs/observable/fromPromise';
 import { map } from 'rxjs/operators/map';
 import { JsonArray, JsonObject } from '../interface';
-import { SchemaRegistry, SchemaValidator, SchemaValidatorResult } from './interface';
+import {
+  SchemaFormat,
+  SchemaFormatter,
+  SchemaRegistry,
+  SchemaValidator,
+  SchemaValidatorResult,
+} from './interface';
 
 
 function _parseJsonPointer(pointer: string): string[] {
@@ -101,13 +107,21 @@ export class CoreSchemaRegistry implements SchemaRegistry {
   private _ajv: ajv.Ajv;
   private _uriCache = new Map<string, JsonObject>();
 
-  constructor() {
+  constructor(formats: SchemaFormat[] = []) {
     /**
      * Build an AJV instance that will be used to validate schemas.
      */
+
+    const formatsObj: { [name: string]: SchemaFormatter } = {};
+
+    for (const format of formats) {
+      formatsObj[format.name] = format.formatter;
+    }
+
     this._ajv = ajv({
       removeAdditional: 'all',
       useDefaults: true,
+      formats: formatsObj,
       loadSchema: (uri: string) => this._fetch(uri) as ajv.Thenable<object>,
     });
 
@@ -265,11 +279,28 @@ export class CoreSchemaRegistry implements SchemaRegistry {
 
                 return {
                   success: false,
-                  errors: (validate.errors || []).map((err: ajv.ErrorObject) => err.message),
+                  errors: (validate.errors || [])
+                    .map((err: ajv.ErrorObject) => `${err.dataPath} ${err.message}`),
                 } as SchemaValidatorResult;
               }),
             );
         }),
       );
   }
+
+  addFormat(format: SchemaFormat): void {
+    // tslint:disable-next-line:no-any
+    const validate = (data: any) => {
+      const result = format.formatter.validate(data);
+
+      return result instanceof Observable ? result.toPromise() : result;
+    };
+
+    this._ajv.addFormat(format.name, {
+      async: format.formatter.async,
+      validate,
+    // AJV typings list `compare` as required, but it is optional.
+    // tslint:disable-next-line:no-any
+    } as any);
+  }
 }

packages/angular_devkit/core/src/json/schema/registry_spec.ts

@@ -5,15 +5,15 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-// tslint:disable:no-any
+import { Observable } from 'rxjs/Observable';
 import 'rxjs/add/operator/mergeMap';
 import { CoreSchemaRegistry } from './registry';
 
 
 describe('CoreSchemaRegistry', () => {
   it('works asynchronously', done => {
-    const registry  = new CoreSchemaRegistry();
-    const data: any = {};  // tslint:disable:no-any
+    const registry = new CoreSchemaRegistry();
+    const data: any = {};  // tslint:disable-line:no-any
 
     registry
       .compile({
@@ -38,14 +38,14 @@ describe('CoreSchemaRegistry', () => {
         expect(data.tslint).not.toBeUndefined();
       })
       .subscribe(done, done.fail);
-    });
+  });
 
   // Synchronous failure is only used internally.
   // If it's meant to be used externally then this test should change to truly be synchronous
   // (i.e. not relyign on the observable).
   it('works synchronously', done => {
-    const registry  = new CoreSchemaRegistry();
-    const data: any = {};  // tslint:disable:no-any
+    const registry = new CoreSchemaRegistry();
+    const data: any = {};  // tslint:disable-line:no-any
     let isDone = false;
 
     registry
@@ -73,4 +73,85 @@ describe('CoreSchemaRegistry', () => {
     expect(isDone).toBe(true);
     done();
   });
+
+  it('supports sync format', done => {
+    const registry = new CoreSchemaRegistry();
+    const data = { str: 'hotdog' };
+    const format = {
+      name: 'is-hotdog',
+      formatter: {
+        async: false,
+        validate: (str: string) => str === 'hotdog',
+      },
+    };
+
+    registry.addFormat(format);
+
+    registry
+      .compile({
+        properties: {
+          str: { type: 'string', format: 'is-hotdog' },
+        },
+      })
+      .mergeMap(validator => validator(data))
+      .map(result => {
+        expect(result.success).toBe(true);
+      })
+      .subscribe(done, done.fail);
+  });
+
+  it('supports async format', done => {
+    const registry = new CoreSchemaRegistry();
+    const data = { str: 'hotdog' };
+    const format = {
+      name: 'is-hotdog',
+      formatter: {
+        async: true,
+        validate: (str: string) => Observable.of(str === 'hotdog'),
+      },
+    };
+
+    registry.addFormat(format);
+
+    registry
+      .compile({
+        $async: true,
+        properties: {
+          str: { type: 'string', format: 'is-hotdog' },
+        },
+      })
+      .mergeMap(validator => validator(data))
+      .map(result => {
+        expect(result.success).toBe(true);
+      })
+      .subscribe(done, done.fail);
+  });
+
+  it('shows dataPath and message on error', done => {
+    const registry = new CoreSchemaRegistry();
+    const data = { hotdot: 'hotdog', banana: 'banana' };
+    const format = {
+      name: 'is-hotdog',
+      formatter: {
+        async: false,
+        validate: (str: string) => str === 'hotdog',
+      },
+    };
+
+    registry.addFormat(format);
+
+    registry
+      .compile({
+        properties: {
+          hotdot: { type: 'string', format: 'is-hotdog' },
+          banana: { type: 'string', format: 'is-hotdog' },
+        },
+      })
+      .mergeMap(validator => validator(data))
+      .map(result => {
+        expect(result.success).toBe(false);
+        expect(result.errors && result.errors[0]).toBe('.banana should match format "is-hotdog"');
+      })
+      .subscribe(done, done.fail);
+  });
 });