deserialized mixed data (#36)

#34

Author: danivek

README.md

@@ -378,9 +378,11 @@ relationships: {
 }
 ```
 
-## Serialize mixed data (dynamic type)
+## Mixed data (dynamic type)
 
-If your data contains one or multiple objects of varying types, it's possible to define a configuration object instead of the type-string as the first argument of ```serialize``` and ```serializeAsync``` with these options:
+### Serialize
+
+If your data contains one or multiple objects of different types, it's possible to define a configuration object instead of the type-string as the first argument of ```serialize``` and ```serializeAsync``` with these options:
 
 - **type** (required): A *string* for the path to the key to use to determine type or a *function* deriving a type-string from each data-item.
 - **topLevelMeta** (optional): Describes the top-level meta. It can be:
@@ -403,6 +405,22 @@ Serializer.serializeAsync(typeConfig, data, {count: 2})
   });
 ```
 
+### Deserialize
+
+If your data contains one or multiple objects of different types, it's possible to define a configuration object instead of the type-string as the first argument of ```deserialize``` with these options:
+
+- **type** (required): A *string* for the path to the key to use to determine type or a *function* deriving a type-string from each data-item.
+
+Example :
+```javascript
+const typeConfig = {
+  // Same as type: 'type'
+  type: (data) => data.type, // Can be very complex to determine different types of items.
+};
+
+const deserialized = Serializer.deserialize(typeConfig, data);
+```
+
 ## Requirements
 
 json-api-serializer only use ECMAScript 2015 (ES6) features supported natively by Node.js 4 and above ([ECMAScript 2015 (ES6) | Node.js](https://nodejs.org/en/docs/es6/)). Make sure that you have Node.js 4+ or above.

lib/JSONAPISerializer.js

@@ -268,20 +268,24 @@ module.exports = class JSONAPISerializer {
    * Input data can be a simple object or an array of objects.
    *
    * @method JSONAPISerializer#deserialize
-   * @param {string} type resource's type.
+   * @param {string|Object} type resource's type as string or an object with a dynamic type resolved from data.
    * @param {Object} data JSON API input data.
    * @param {string} [schema=default] resource's schema name.
    * @return {Object} deserialized data.
    */
   deserialize(type, data, schema) {
     schema = schema || 'default';
 
-    if (!this.schemas[type]) {
-      throw new Error(`No type registered for ${type}`);
-    }
+    if (!_.isPlainObject(type)) {
+      if (!this.schemas[type]) {
+        throw new Error(`No type registered for ${type}`);
+      }
 
-    if (schema && !this.schemas[type][schema]) {
-      throw new Error(`No schema ${schema} registered for ${type}`);
+      if (schema && !this.schemas[type][schema]) {
+        throw new Error(`No schema ${schema} registered for ${type}`);
+      }
+    } else {
+      type = this.validateDynamicTypeOptions(type);
     }
 
     let deserializedData = {};
@@ -302,12 +306,26 @@ module.exports = class JSONAPISerializer {
    * Input data must be a simple object.
    *
    * @method JSONAPISerializer#deserializeResource
-   * @param {string} type resource's type.
+   * @param {string|Object} type resource's type as string or an object with a dynamic type resolved from data.
    * @param {Object} data JSON API resource data.
    * @param {string} [schema=default] resource's schema name.
    * @return {Object} deserialized data.
    */
   deserializeResource(type, data, schema, included) {
+    if (_.isPlainObject(type)) {
+      type = (typeof type.type === 'function') ? type.type(data) : _.get(data, type.type);
+
+      if (!type) {
+        throw new Error(`No type can be resolved from data: ${JSON.stringify(data)}`);
+      }
+
+      if (!this.schemas[type]) {
+        throw new Error(`No type registered for ${type}`);
+      }
+
+      schema = 'default';
+    }
+
     const resourceOpts = this.schemas[type][schema];
 
     let deserializedData = {};

test/unit/JSONAPISerializer.test.js

@@ -1496,4 +1496,99 @@ describe('JSONAPISerializer', function() {
       done();
     });
   });
+
+  describe('deserializeMixedData', function() {
+    const Serializer = new JSONAPISerializer();
+    Serializer.register('article');
+    Serializer.register('people');
+    const typeOption = {type: 'type'};
+
+    it('should return error if no type can be resolved from data', function(done) {
+      const singleData = {
+        data: {
+          id: '1'
+        }
+      };
+
+      expect(function() {
+        Serializer.deserialize(typeOption, singleData);
+      }).to.throw(Error, 'No type can be resolved from data: {"id":"1"}');
+      done();
+    });
+
+    it('should return error if type has not been registered', function(done) {
+      const singleData = {
+        data: {
+          id: '1',
+          type: 'book'
+        }
+      };
+
+      expect(function() {
+        Serializer.deserialize(typeOption, singleData);
+      }).to.throw(Error, 'No type registered for book');
+      done();
+    });
+
+    it('should return deserialized data for a single data', function(done) {
+      const singleData = {
+        data: {
+          id: '1',
+          type: 'article',
+          attributes: {
+            title: 'JSON API paints my bikeshed!',
+          }
+        }
+      };
+      const deserializedData = Serializer.deserialize(typeOption, singleData);
+
+      expect(deserializedData).to.have.property('id').to.eql('1');
+      expect(deserializedData).to.have.property('title').to.eql('JSON API paints my bikeshed!');
+      done();
+    });
+
+    it('should return deserialized data for an array with mixed data', function(done) {
+      const arrayData = {
+        data: [{
+          id: '1',
+          type: 'article',
+          attributes: {
+            title: 'JSON API paints my bikeshed!',
+          }
+        }, {
+          id: '1',
+          type: 'people',
+          attributes: {
+            firstName: 'Kaley',
+          }
+        }]
+      };
+      const deserializedData = Serializer.deserialize(typeOption, arrayData);
+      expect(deserializedData).to.be.instanceof(Array).to.have.lengthOf(2);
+      expect(deserializedData[0]).to.have.property('id').to.eql('1');
+      expect(deserializedData[0]).to.have.property('title').to.eql('JSON API paints my bikeshed!');
+      expect(deserializedData[1]).to.have.property('id').to.eql('1');
+      expect(deserializedData[1]).to.have.property('firstName').to.eql('Kaley');
+      done();
+    });
+
+    it('should return deserialized data with a type resolved from a function deriving a type-string from data', function(done) {
+      const data = {
+        data: {
+          id: '1',
+          type: 'article',
+          attributes: {
+            title: 'JSON API paints my bikeshed!',
+          }
+        }
+      };
+      const typeFuncOption = {type: (data) => data.type ? 'article' : ''};
+      const deserializedData = Serializer.deserialize(typeOption, data);
+
+      expect(deserializedData).to.have.property('id').to.eql('1');
+      expect(deserializedData).to.have.property('title').to.eql('JSON API paints my bikeshed!');
+
+      done();
+    });
+  });
 });