Add validation handling

Author: Lee Richmond

src/model.ts

@@ -10,6 +10,7 @@ import { camelize } from './util/string';
 import WritePayload from './util/write-payload';
 import IncludeDirective from './util/include-directive';
 import DirtyChecker from './util/dirty-check';
+import ValidationErrors from './util/validation-errors';
 import relationshipIdentifiersFor from './util/relationship-identifiers';
 import Request from './request';
 import * as _cloneDeep from './util/clonedeep';
@@ -33,6 +34,7 @@ export default class Model {
   _originalAttributes: Object = {};
   _originalRelationships: Object = {};
   relationships: Object = {};
+  errors: Object = {};
   __meta__: Object | void = null;
   _persisted: boolean = false;
   _markedForDestruction: boolean = false;
@@ -149,6 +151,10 @@ export default class Model {
     this._originalRelationships = this.relationshipResourceIdentifiers(Object.keys(this.relationships));
   }
 
+  clearErrors() {
+    this.errors = {};
+  }
+
   // Todo:
   // * needs to recurse the directive
   // * remove the corresponding code from isPersisted and handle here (likely
@@ -207,6 +213,10 @@ export default class Model {
     return deserializeInstance(this, resource, payload);
   }
 
+  get hasError() {
+    return Object.keys(this.errors).length > 1;
+  }
+
   isDirty(relationships?: Object | Array<any> | string) : boolean {
     let dc = new DirtyChecker(this);
     return dc.check(relationships);
@@ -243,14 +253,17 @@ export default class Model {
 
     let json = payload.asJSON();
     let requestPromise = request[verb](url, json, { jwt });
+    console.log('b4 req')
     return this._writeRequest(requestPromise, () => {
+      console.log('HERE PRERS')
       this.isPersisted(true);
       payload.postProcess();
     });
   }
 
   private _writeRequest(requestPromise : Promise<any>, callback: Function) : Promise<any> {
     return new Promise((resolve, reject) => {
+      requestPromise.catch((e) => { throw(e) });
       return requestPromise.then((response) => {
         this._handleResponse(response, resolve, reject, callback);
       });
@@ -259,6 +272,7 @@ export default class Model {
 
   private _handleResponse(response: any, resolve: Function, reject: Function, callback: Function) : void {
     if (response.status == 422) {
+      ValidationErrors.apply(this, response['jsonPayload']);
       resolve(false);
     } else if (response.status >= 500) {
       reject('Server Error');

src/request.ts

@@ -55,7 +55,7 @@ export default class Request {
         response.json().then((json) => {
           response['jsonPayload'] = json;
           resolve(response);
-        });
+        }).catch((e) => { throw(e); });
       });
       fetchPromise.catch(reject);
     });

src/util/validation-errors.ts

@@ -0,0 +1,47 @@
+import Model from '../model';
+
+export default class ValidationErrors {
+  model: Model;
+  payload: Array<Object> = [];
+
+  constructor(model: Model, payload: Array<Object>) {
+    this.model = model;
+    this.payload = payload;
+  }
+
+  static apply(model: Model, payload: Array<Object>) {
+    let instance = new ValidationErrors(model, payload);
+    instance.apply();
+  }
+
+  apply() {
+    this.payload['errors'].forEach((err) => {
+      let meta = err['meta'];
+      let metaRelationship = meta['relationship'];
+
+      if (metaRelationship) {
+        this._processRelationship(this.model, metaRelationship);
+      } else {
+        this._processResource(this.model, meta);
+      }
+    });
+  }
+
+  private _processResource(model: Model, meta: Object) {
+    model.errors[meta['attribute']] = meta['message'];
+  }
+
+  private _processRelationship(model: Model, meta: Object) {
+    let relatedObject = model[meta['name']];
+    if (Array.isArray(relatedObject)) {
+      relatedObject = relatedObject.find((r) => {
+        return (r.id === meta['id'] || r.temp_id === meta['temp-id']);
+      });
+    }
+    if (meta['relationship']) {
+      this._processRelationship(relatedObject, meta['relationship']);
+    } else {
+      this._processResource(relatedObject, meta);
+    }
+  }
+}

src/util/write-payload.ts

@@ -95,6 +95,8 @@ export default class WritePayload {
   asJSON() : Object {
     let data = {}
 
+    this.model.clearErrors();
+
     if (this.model.id) {
       data['id'] = this.model.id;
     }
@@ -120,12 +122,15 @@ export default class WritePayload {
       json['included'] = this.included
     }
 
+    console.log(json)
     return json;
   }
 
   // private
 
   private _processRelatedModel(model: Model, nested: Object) {
+    model.clearErrors();
+
     if (!model.isPersisted()) {
       model.temp_id = uuid.generate();
     }

test/integration/authorization-test.ts

@@ -59,7 +59,6 @@ describe('authorization headers', function() {
   describe('when header is returned in response', function() {
     beforeEach(function() {
       fetchMock.mock({
-        name: 'route',
         matcher: '*',
         response: {
           status: 200,

test/integration/validations-test.ts

@@ -0,0 +1,135 @@
+import { expect, sinon, fetchMock } from '../test-helper';
+import { Author, Book, Genre } from '../fixtures';
+import uuid from '../../src/util/uuid';
+
+let serverResponse;
+
+const resetMocks = function() {
+  fetchMock.restore();
+
+  fetchMock.mock({
+    matcher: '*',
+    response: {
+      status: 422,
+      body: {
+        errors: [
+          {
+            code: 'unprocessable_entity',
+            status: '422',
+            title: 'Validation Error',
+            detail: 'First Name cannot be blank',
+            meta: { attribute: 'first_name', message: 'cannot be blank' }
+          },
+          {
+            code: 'unprocessable_entity',
+            status: '422',
+            title: 'Validation Error',
+            detail: 'Last Name cannot be blank',
+            meta: { attribute: 'last_name', message: 'cannot be blank' }
+          },
+          {
+            code: 'unprocessable_entity',
+            status: '422',
+            title: 'Validation Error',
+            detail: 'Title cannot be blank',
+            meta: {
+              relationship: {
+                name: 'books',
+                type: 'books',
+                ['temp-id']: 'abc1',
+                attribute: 'title',
+                message: 'cannot be blank'
+              }
+            }
+          },
+          {
+            code: 'unprocessable_entity',
+            status: '422',
+            title: 'Validation Error',
+            detail: 'Name cannot be blank',
+            meta: {
+              relationship: {
+                name: 'books',
+                type: 'books',
+                ['temp-id']: 'abc1',
+                relationship: {
+                  name: 'genre',
+                  type: 'genres',
+                  id: '1',
+                  attribute: 'name',
+                  message: 'cannot be blank'
+                }
+              }
+            }
+          }
+        ]
+      }
+    }
+  });
+
+  fetchMock.post('http://example.com/api/v1/people', function(url, payload) {
+    return serverResponse;
+  });
+}
+
+let instance;
+let tempIdIndex = 0;
+describe('validations', function() {
+  beforeEach(function () {
+    resetMocks();
+  });
+
+  beforeEach(function() {
+    sinon.stub(uuid, 'generate').callsFake(function() {
+      tempIdIndex++
+      return `abc${tempIdIndex}`;
+    });
+
+    instance = new Author({ lastName: 'King' });
+    let genre = new Genre({ id: '1' });
+    genre.isPersisted(true);
+    let book = new Book({ title: 'blah', genre });
+    instance.books = [book]
+  });
+
+  afterEach(function() {
+    tempIdIndex = 0;
+    uuid.generate['restore']();
+  });
+
+  // todo on next save, remove errs
+  it('applies errors to the instance', function(done) {
+    instance.save({ with: { books: 'genre' }}).then((success) => {
+      expect(instance.isPersisted()).to.eq(false);
+      expect(success).to.eq(false);
+      expect(instance.errors).to.deep.equal({
+        first_name: 'cannot be blank',
+        last_name: 'cannot be blank'
+      });
+      done();
+    });
+  });
+
+  it('applies errors to nested hasMany relationships', function(done) {
+    instance.save({ with: { books: 'genre' }}).then((success) => {
+      expect(instance.isPersisted()).to.eq(false);
+      expect(success).to.eq(false);
+      expect(instance.books[0].errors).to.deep.equal({
+        title: 'cannot be blank',
+      });
+      done();
+    });
+  });
+
+  it('applies errors to nested belongsTo relationships', function(done) {
+    instance.save({ with: { books: 'genre' }}).then((success) => {
+      expect(instance.isPersisted()).to.eq(false);
+      expect(success).to.eq(false);
+      console.log(instance.books[0].genre.errors)
+      expect(instance.books[0].genre.errors).to.deep.equal({
+        name: 'cannot be blank',
+      });
+      done();
+    });
+  });
+});