@ember-data/serializer 4.10.0-alpha.2 → 4.10.0-alpha.21

package/addon/json.js

@@ -1,14 +1,13 @@
-/**
- * @module @ember-data/serializer/json
- */
 import { getOwner } from '@ember/application';
 import { assert, warn } from '@ember/debug';
 import { dasherize } from '@ember/string';
-import { isNone, typeOf } from '@ember/utils';
-
-import Serializer from '@ember-data/serializer';
+import { typeOf, isNone } from '@ember/utils';
 import { coerceId } from '@ember-data/store/-private';
+import _class from "./index";
 
+/**
+ * @module @ember-data/serializer/json
+ */
 const SOURCE_POINTER_REGEXP = /^\/?data\/(attributes|relationships)\/(.*)/;
 const SOURCE_POINTER_PRIMARY_REGEXP = /^\/?data/;
 const PRIMARY_ATTRIBUTE_KEY = 'base';
@@ -84,7 +83,7 @@ const PRIMARY_ATTRIBUTE_KEY = 'base';
   @public
   @extends Serializer
 */
-const JSONSerializer = Serializer.extend({
+const JSONSerializer = _class.extend({
   /**
     The `primaryKey` is used when serializing and deserializing
     data. Ember Data always uses the `id` property to store the id of
@@ -92,101 +91,80 @@ const JSONSerializer = Serializer.extend({
     convention. In these cases it is useful to override the
     `primaryKey` property to match the `primaryKey` of your external
     store.
-
-    Example
-
-    ```app/serializers/application.js
+     Example
+     ```app/serializers/application.js
     import JSONSerializer from '@ember-data/serializer/json';
-
-    export default class ApplicationSerializer extends JSONSerializer {
+     export default class ApplicationSerializer extends JSONSerializer {
       primaryKey = '_id'
     }
     ```
-
-    @property primaryKey
+     @property primaryKey
     @type {String}
     @public
     @default 'id'
   */
   primaryKey: 'id',
-
   /**
     The `attrs` object can be used to declare a simple mapping between
     property names on `Model` records and payload keys in the
     serialized JSON object representing the record. An object with the
     property `key` can also be used to designate the attribute's key on
     the response payload.
-
-    Example
-
-    ```app/models/person.js
+     Example
+     ```app/models/person.js
     import Model, { attr } from '@ember-data/model';
-
-    export default class PersonModel extends Model {
+     export default class PersonModel extends Model {
       @attr('string') firstName;
       @attr('string') lastName;
       @attr('string') occupation;
       @attr('boolean') admin;
     }
     ```
-
-    ```app/serializers/person.js
+     ```app/serializers/person.js
     import JSONSerializer from '@ember-data/serializer/json';
-
-    export default class PersonSerializer extends JSONSerializer {
+     export default class PersonSerializer extends JSONSerializer {
       attrs = {
         admin: 'is_admin',
         occupation: { key: 'career' }
       }
     }
     ```
-
-    You can also remove attributes and relationships by setting the `serialize`
+     You can also remove attributes and relationships by setting the `serialize`
     key to `false` in your mapping object.
-
-    Example
-
-    ```app/serializers/person.js
+     Example
+     ```app/serializers/person.js
     import JSONSerializer from '@ember-data/serializer/json';
-
-    export default class PostSerializer extends JSONSerializer {
+     export default class PostSerializer extends JSONSerializer {
       attrs = {
         admin: { serialize: false },
         occupation: { key: 'career' }
       }
     }
     ```
-
-    When serialized:
-
-    ```javascript
+     When serialized:
+     ```javascript
     {
       "firstName": "Harry",
       "lastName": "Houdini",
       "career": "magician"
     }
     ```
-
-    Note that the `admin` is now not included in the payload.
-
-    Setting `serialize` to `true` enforces serialization for hasMany
+     Note that the `admin` is now not included in the payload.
+     Setting `serialize` to `true` enforces serialization for hasMany
     relationships even if it's neither a many-to-many nor many-to-none
     relationship.
-
-    @property attrs
+     @property attrs
     @public
     @type {Object}
   */
   mergedProperties: ['attrs'],
-
   /**
    Given a subclass of `Model` and a JSON object this method will
    iterate through each attribute of the `Model` and invoke the
    `Transform#deserialize` method on the matching property of the
    JSON object.  This method is typically called after the
    serializer's `normalize` method.
-
-   @method applyTransforms
+    @method applyTransforms
    @private
    @param {Model} typeClass
    @param {Object} data The data to transform
@@ -194,47 +172,36 @@ const JSONSerializer = Serializer.extend({
   */
   applyTransforms(typeClass, data) {
     let attributes = typeClass.attributes;
-
     typeClass.eachTransformedAttribute((key, typeClass) => {
       if (data[key] === undefined) {
         return;
       }
-
       let transform = this.transformFor(typeClass);
       let transformMeta = attributes.get(key);
       data[key] = transform.deserialize(data[key], transformMeta.options);
     });
-
     return data;
   },
-
   /**
     The `normalizeResponse` method is used to normalize a payload from the
     server to a JSON-API Document.
-
-    http://jsonapi.org/format/#document-structure
-
-    This method delegates to a more specific normalize method based on
+     http://jsonapi.org/format/#document-structure
+     This method delegates to a more specific normalize method based on
     the `requestType`.
-
-    To override this method with a custom one, make sure to call
+     To override this method with a custom one, make sure to call
     `return super.normalizeResponse(store, primaryModelClass, payload, id, requestType)` with your
     pre-processed data.
-
-    Here's an example of using `normalizeResponse` manually:
-
-    ```javascript
+     Here's an example of using `normalizeResponse` manually:
+     ```javascript
     socket.on('message', function(message) {
       let data = message.data;
       let modelClass = store.modelFor(data.modelName);
       let serializer = store.serializerFor(data.modelName);
       let normalized = serializer.normalizeSingleResponse(store, modelClass, data, data.id);
-
-      store.push(normalized);
+       store.push(normalized);
     });
     ```
-
-    @since 1.13.0
+     @since 1.13.0
     @method normalizeResponse
     @public
     @param {Store} store
@@ -268,12 +235,10 @@ const JSONSerializer = Serializer.extend({
         return this.normalizeUpdateRecordResponse(...arguments);
     }
   },
-
   /**
     Called by the default normalizeResponse implementation when the
     type of request is `findRecord`
-
-    @since 1.13.0
+     @since 1.13.0
     @method normalizeFindRecordResponse
     @public
     @param {Store} store
@@ -286,12 +251,10 @@ const JSONSerializer = Serializer.extend({
   normalizeFindRecordResponse(store, primaryModelClass, payload, id, requestType) {
     return this.normalizeSingleResponse(...arguments);
   },
-
   /**
     Called by the default normalizeResponse implementation when the
     type of request is `queryRecord`
-
-    @since 1.13.0
+     @since 1.13.0
     @method normalizeQueryRecordResponse
     @public
     @param {Store} store
@@ -304,12 +267,10 @@ const JSONSerializer = Serializer.extend({
   normalizeQueryRecordResponse(store, primaryModelClass, payload, id, requestType) {
     return this.normalizeSingleResponse(...arguments);
   },
-
   /**
     Called by the default normalizeResponse implementation when the
     type of request is `findAll`
-
-    @since 1.13.0
+     @since 1.13.0
     @method normalizeFindAllResponse
     @public
     @param {Store} store
@@ -322,12 +283,10 @@ const JSONSerializer = Serializer.extend({
   normalizeFindAllResponse(store, primaryModelClass, payload, id, requestType) {
     return this.normalizeArrayResponse(...arguments);
   },
-
   /**
     Called by the default normalizeResponse implementation when the
     type of request is `findBelongsTo`
-
-    @since 1.13.0
+     @since 1.13.0
     @method normalizeFindBelongsToResponse
     @public
     @param {Store} store
@@ -340,12 +299,10 @@ const JSONSerializer = Serializer.extend({
   normalizeFindBelongsToResponse(store, primaryModelClass, payload, id, requestType) {
     return this.normalizeSingleResponse(...arguments);
   },
-
   /**
     Called by the default normalizeResponse implementation when the
     type of request is `findHasMany`
-
-    @since 1.13.0
+     @since 1.13.0
     @method normalizeFindHasManyResponse
     @public
     @param {Store} store
@@ -358,12 +315,10 @@ const JSONSerializer = Serializer.extend({
   normalizeFindHasManyResponse(store, primaryModelClass, payload, id, requestType) {
     return this.normalizeArrayResponse(...arguments);
   },
-
   /**
     Called by the default normalizeResponse implementation when the
     type of request is `findMany`
-
-    @since 1.13.0
+     @since 1.13.0
     @method normalizeFindManyResponse
     @public
     @param {Store} store
@@ -376,12 +331,10 @@ const JSONSerializer = Serializer.extend({
   normalizeFindManyResponse(store, primaryModelClass, payload, id, requestType) {
     return this.normalizeArrayResponse(...arguments);
   },
-
   /**
     Called by the default normalizeResponse implementation when the
     type of request is `query`
-
-    @since 1.13.0
+     @since 1.13.0
     @method normalizeQueryResponse
     @public
     @param {Store} store
@@ -394,12 +347,10 @@ const JSONSerializer = Serializer.extend({
   normalizeQueryResponse(store, primaryModelClass, payload, id, requestType) {
     return this.normalizeArrayResponse(...arguments);
   },
-
   /**
     Called by the default normalizeResponse implementation when the
     type of request is `createRecord`
-
-    @since 1.13.0
+     @since 1.13.0
     @method normalizeCreateRecordResponse
     @public
     @param {Store} store
@@ -412,12 +363,10 @@ const JSONSerializer = Serializer.extend({
   normalizeCreateRecordResponse(store, primaryModelClass, payload, id, requestType) {
     return this.normalizeSaveResponse(...arguments);
   },
-
   /**
     Called by the default normalizeResponse implementation when the
     type of request is `deleteRecord`
-
-    @since 1.13.0
+     @since 1.13.0
     @method normalizeDeleteRecordResponse
     @public
     @param {Store} store
@@ -430,12 +379,10 @@ const JSONSerializer = Serializer.extend({
   normalizeDeleteRecordResponse(store, primaryModelClass, payload, id, requestType) {
     return this.normalizeSaveResponse(...arguments);
   },
-
   /**
     Called by the default normalizeResponse implementation when the
     type of request is `updateRecord`
-
-    @since 1.13.0
+     @since 1.13.0
     @method normalizeUpdateRecordResponse
     @public
     @param {Store} store
@@ -448,12 +395,10 @@ const JSONSerializer = Serializer.extend({
   normalizeUpdateRecordResponse(store, primaryModelClass, payload, id, requestType) {
     return this.normalizeSaveResponse(...arguments);
   },
-
   /**
     normalizeUpdateRecordResponse, normalizeCreateRecordResponse and
     normalizeDeleteRecordResponse delegate to this method by default.
-
-    @since 1.13.0
+     @since 1.13.0
     @method normalizeSaveResponse
     @public
     @param {Store} store
@@ -466,12 +411,10 @@ const JSONSerializer = Serializer.extend({
   normalizeSaveResponse(store, primaryModelClass, payload, id, requestType) {
     return this.normalizeSingleResponse(...arguments);
   },
-
   /**
     normalizeQueryResponse and normalizeFindRecordResponse delegate to this
     method by default.
-
-    @since 1.13.0
+     @since 1.13.0
     @method normalizeSingleResponse
     @public
     @param {Store} store
@@ -484,12 +427,10 @@ const JSONSerializer = Serializer.extend({
   normalizeSingleResponse(store, primaryModelClass, payload, id, requestType) {
     return this._normalizeResponse(store, primaryModelClass, payload, id, requestType, true);
   },
-
   /**
     normalizeQueryResponse, normalizeFindManyResponse, and normalizeFindHasManyResponse delegate
     to this method by default.
-
-    @since 1.13.0
+     @since 1.13.0
     @method normalizeArrayResponse
     @public
     @param {Store} store
@@ -502,7 +443,6 @@ const JSONSerializer = Serializer.extend({
   normalizeArrayResponse(store, primaryModelClass, payload, id, requestType) {
     return this._normalizeResponse(store, primaryModelClass, payload, id, requestType, false);
   },
-
   /**
     @method _normalizeResponse
     @param {Store} store
@@ -517,20 +457,18 @@ const JSONSerializer = Serializer.extend({
   _normalizeResponse(store, primaryModelClass, payload, id, requestType, isSingle) {
     let documentHash = {
       data: null,
-      included: [],
+      included: []
     };
-
     let meta = this.extractMeta(store, primaryModelClass, payload);
     if (meta) {
-      assert(
-        'The `meta` returned from `extractMeta` has to be an object, not "' + typeOf(meta) + '".',
-        typeOf(meta) === 'object'
-      );
+      assert('The `meta` returned from `extractMeta` has to be an object, not "' + typeOf(meta) + '".', typeOf(meta) === 'object');
       documentHash.meta = meta;
     }
-
     if (isSingle) {
-      let { data, included } = this.normalize(primaryModelClass, payload);
+      let {
+        data,
+        included
+      } = this.normalize(primaryModelClass, payload);
       documentHash.data = data;
       if (included) {
         documentHash.included = included;
@@ -539,56 +477,47 @@ const JSONSerializer = Serializer.extend({
       let ret = new Array(payload.length);
       for (let i = 0, l = payload.length; i < l; i++) {
         let item = payload[i];
-        let { data, included } = this.normalize(primaryModelClass, item);
+        let {
+          data,
+          included
+        } = this.normalize(primaryModelClass, item);
         if (included) {
           documentHash.included = documentHash.included.concat(included);
         }
         ret[i] = data;
       }
-
       documentHash.data = ret;
     }
-
     return documentHash;
   },
-
   /**
     Normalizes a part of the JSON payload returned by
     the server. You should override this method, munge the hash
     and call super if you have generic normalization to do.
-
-    It takes the type of the record that is being normalized
+     It takes the type of the record that is being normalized
     (as a Model class), the property where the hash was
     originally found, and the hash to normalize.
-
-    You can use this method, for example, to normalize underscored keys to camelized
+     You can use this method, for example, to normalize underscored keys to camelized
     or other general-purpose normalizations.
-
-    Example
-
-    ```app/serializers/application.js
+     Example
+     ```app/serializers/application.js
     import JSONSerializer from '@ember-data/serializer/json';
     import { underscore } from '<app-name>/utils/string-utils';
     import { get } from '@ember/object';
-
-    export default class ApplicationSerializer extends JSONSerializer {
+     export default class ApplicationSerializer extends JSONSerializer {
       normalize(typeClass, hash) {
         let fields = typeClass.fields;
-
-        fields.forEach(function(type, field) {
+         fields.forEach(function(type, field) {
           let payloadField = underscore(field);
           if (field === payloadField) { return; }
-
-          hash[field] = hash[payloadField];
+           hash[field] = hash[payloadField];
           delete hash[payloadField];
         });
-
-        return super.normalize(...arguments);
+         return super.normalize(...arguments);
       }
     }
     ```
-
-    @method normalize
+     @method normalize
     @public
     @param {Model} typeClass
     @param {Object} hash
@@ -596,30 +525,26 @@ const JSONSerializer = Serializer.extend({
   */
   normalize(modelClass, resourceHash) {
     let data = null;
-
     if (resourceHash) {
       this.normalizeUsingDeclaredMapping(modelClass, resourceHash);
       if (typeOf(resourceHash.links) === 'object') {
         this.normalizeUsingDeclaredMapping(modelClass, resourceHash.links);
       }
-
       data = {
         id: this.extractId(modelClass, resourceHash),
         type: modelClass.modelName,
         attributes: this.extractAttributes(modelClass, resourceHash),
-        relationships: this.extractRelationships(modelClass, resourceHash),
+        relationships: this.extractRelationships(modelClass, resourceHash)
       };
-
       this.applyTransforms(modelClass, data.attributes);
     }
-
-    return { data };
+    return {
+      data
+    };
   },
-
   /**
     Returns the resource's ID.
-
-    @method extractId
+     @method extractId
     @public
     @param {Object} modelClass
     @param {Object} resourceHash
@@ -630,13 +555,10 @@ const JSONSerializer = Serializer.extend({
     let id = resourceHash[primaryKey];
     return coerceId(id);
   },
-
   /**
     Returns the resource's attributes formatted as a JSON-API "attributes object".
-
-    http://jsonapi.org/format/#document-resource-object-attributes
-
-    @method extractAttributes
+     http://jsonapi.org/format/#document-resource-object-attributes
+     @method extractAttributes
     @public
     @param {Object} modelClass
     @param {Object} resourceHash
@@ -645,23 +567,18 @@ const JSONSerializer = Serializer.extend({
   extractAttributes(modelClass, resourceHash) {
     let attributeKey;
     let attributes = {};
-
-    modelClass.eachAttribute((key) => {
+    modelClass.eachAttribute(key => {
       attributeKey = this.keyForAttribute(key, 'deserialize');
       if (resourceHash[attributeKey] !== undefined) {
         attributes[key] = resourceHash[attributeKey];
       }
     });
-
     return attributes;
   },
-
   /**
     Returns a relationship formatted as a JSON-API "relationship object".
-
-    http://jsonapi.org/format/#document-resource-object-relationships
-
-    @method extractRelationship
+     http://jsonapi.org/format/#document-resource-object-relationships
+     @method extractRelationship
     @public
     @param {Object} relationshipModelName
     @param {Object} relationshipHash
@@ -680,31 +597,28 @@ const JSONSerializer = Serializer.extend({
       if (relationshipHash.id) {
         relationshipHash.id = coerceId(relationshipHash.id);
       }
-
       let modelClass = this.store.modelFor(relationshipModelName);
       if (relationshipHash.type && !modelClass.fields.has('type')) {
         relationshipHash.type = this.modelNameFromPayloadKey(relationshipHash.type);
       }
-
       return relationshipHash;
     }
-    return { id: coerceId(relationshipHash), type: relationshipModelName };
+    return {
+      id: coerceId(relationshipHash),
+      type: relationshipModelName
+    };
   },
-
   /**
     Returns a polymorphic relationship formatted as a JSON-API "relationship object".
-
-    http://jsonapi.org/format/#document-resource-object-relationships
-
-    `relationshipOptions` is a hash which contains more information about the
+     http://jsonapi.org/format/#document-resource-object-relationships
+     `relationshipOptions` is a hash which contains more information about the
     polymorphic relationship which should be extracted:
       - `resourceHash` complete hash of the resource the relationship should be
         extracted from
       - `relationshipKey` key under which the value for the relationship is
         extracted from the resourceHash
       - `relationshipMeta` meta information about the relationship
-
-    @method extractPolymorphicRelationship
+     @method extractPolymorphicRelationship
     @public
     @param {Object} relationshipModelName
     @param {Object} relationshipHash
@@ -714,13 +628,10 @@ const JSONSerializer = Serializer.extend({
   extractPolymorphicRelationship(relationshipModelName, relationshipHash, relationshipOptions) {
     return this.extractRelationship(relationshipModelName, relationshipHash);
   },
-
   /**
     Returns the resource's relationships formatted as a JSON-API "relationships object".
-
-    http://jsonapi.org/format/#document-resource-object-relationships
-
-    @method extractRelationships
+     http://jsonapi.org/format/#document-resource-object-relationships
+     @method extractRelationships
     @public
     @param {Object} modelClass
     @param {Object} resourceHash
@@ -728,7 +639,6 @@ const JSONSerializer = Serializer.extend({
   */
   extractRelationships(modelClass, resourceHash) {
     let relationships = {};
-
     modelClass.eachRelationship((key, relationshipMeta) => {
       let relationship = null;
       let relationshipKey = this.keyForRelationship(key, relationshipMeta.kind, 'deserialize');
@@ -744,7 +654,7 @@ const JSONSerializer = Serializer.extend({
             data = this.extractPolymorphicRelationship(relationshipMeta.type, relationshipHash, {
               key,
               resourceHash,
-              relationshipMeta,
+              relationshipMeta
             });
           } else {
             data = this.extractRelationship(relationshipMeta.type, relationshipHash);
@@ -758,7 +668,7 @@ const JSONSerializer = Serializer.extend({
                 data[i] = this.extractPolymorphicRelationship(relationshipMeta.type, item, {
                   key,
                   resourceHash,
-                  relationshipMeta,
+                  relationshipMeta
                 });
               }
             } else {
@@ -769,28 +679,27 @@ const JSONSerializer = Serializer.extend({
             }
           }
         }
-        relationship = { data };
+        relationship = {
+          data
+        };
       }
-
       let linkKey = this.keyForLink(key, relationshipMeta.kind);
       if (resourceHash.links && resourceHash.links[linkKey] !== undefined) {
         let related = resourceHash.links[linkKey];
         relationship = relationship || {};
-        relationship.links = { related };
+        relationship.links = {
+          related
+        };
       }
-
       if (relationship) {
         relationships[key] = relationship;
       }
     });
-
     return relationships;
   },
-
   /**
     Dasherizes the model name in the payload
-
-    @method modelNameFromPayloadKey
+     @method modelNameFromPayloadKey
     @public
     @param {String} key
     @return {String} the model's modelName
@@ -798,14 +707,12 @@ const JSONSerializer = Serializer.extend({
   modelNameFromPayloadKey(key) {
     return dasherize(key);
   },
-
   /**
     @method normalizeRelationships
     @private
   */
   normalizeRelationships(typeClass, hash) {
     let payloadKey;
-
     if (this.keyForRelationship) {
       typeClass.eachRelationship((key, relationship) => {
         payloadKey = this.keyForRelationship(key, relationship.kind, 'deserialize');
@@ -815,13 +722,11 @@ const JSONSerializer = Serializer.extend({
         if (hash[payloadKey] === undefined) {
           return;
         }
-
         hash[key] = hash[payloadKey];
         delete hash[payloadKey];
       });
     }
   },
-
   /**
     @method normalizeUsingDeclaredMapping
     @private
@@ -830,23 +735,18 @@ const JSONSerializer = Serializer.extend({
     let attrs = this.attrs;
     let normalizedKey;
     let payloadKey;
-
     if (attrs) {
       for (let key in attrs) {
         normalizedKey = payloadKey = this._getMappedKey(key, modelClass);
-
         if (hash[payloadKey] === undefined) {
           continue;
         }
-
         if (modelClass.attributes.has(key)) {
           normalizedKey = this.keyForAttribute(key, 'deserialize');
         }
-
         if (modelClass.relationshipsByName.has(key)) {
           normalizedKey = this.keyForRelationship(key, modelClass, 'deserialize');
         }
-
         if (payloadKey !== normalizedKey) {
           hash[normalizedKey] = hash[payloadKey];
           delete hash[payloadKey];
@@ -854,29 +754,18 @@ const JSONSerializer = Serializer.extend({
       }
     }
   },
-
   /**
     Looks up the property key that was set by the custom `attr` mapping
     passed to the serializer.
-
-    @method _getMappedKey
+     @method _getMappedKey
     @private
     @param {String} key
     @return {String} key
   */
   _getMappedKey(key, modelClass) {
-    warn(
-      'There is no attribute or relationship with the name `' +
-        key +
-        '` on `' +
-        modelClass.modelName +
-        '`. Check your serializers attrs hash.',
-      modelClass.attributes.has(key) || modelClass.relationshipsByName.has(key),
-      {
-        id: 'ds.serializer.no-mapped-attrs-key',
-      }
-    );
-
+    warn('There is no attribute or relationship with the name `' + key + '` on `' + modelClass.modelName + '`. Check your serializers attrs hash.', modelClass.attributes.has(key) || modelClass.relationshipsByName.has(key), {
+      id: 'ds.serializer.no-mapped-attrs-key'
+    });
     let attrs = this.attrs;
     let mappedKey;
     if (attrs && attrs[key]) {
@@ -890,48 +779,38 @@ const JSONSerializer = Serializer.extend({
         key = mappedKey;
       }
     }
-
     return key;
   },
-
   /**
     Check attrs.key.serialize property to inform if the `key`
     can be serialized
-
-    @method _canSerialize
+     @method _canSerialize
     @private
     @param {String} key
     @return {boolean} true if the key can be serialized
   */
   _canSerialize(key) {
     let attrs = this.attrs;
-
     return !attrs || !attrs[key] || attrs[key].serialize !== false;
   },
-
   /**
     When attrs.key.serialize is set to true then
     it takes priority over the other checks and the related
     attribute/relationship will be serialized
-
-    @method _mustSerialize
+     @method _mustSerialize
     @private
     @param {String} key
     @return {boolean} true if the key must be serialized
   */
   _mustSerialize(key) {
     let attrs = this.attrs;
-
     return attrs && attrs[key] && attrs[key].serialize === true;
   },
-
   /**
     Check if the given hasMany relationship should be serialized
-
-    By default only many-to-many and many-to-none relationships are serialized.
+     By default only many-to-many and many-to-none relationships are serialized.
     This could be configured per relationship by Serializer's `attrs` object.
-
-    @method shouldSerializeHasMany
+     @method shouldSerializeHasMany
     @public
     @param {Snapshot} snapshot
     @param {String} key
@@ -946,156 +825,117 @@ const JSONSerializer = Serializer.extend({
     }
     return this._canSerialize(key) && (relationshipType === 'manyToNone' || relationshipType === 'manyToMany');
   },
-
   // SERIALIZE
   /**
     Called when a record is saved in order to convert the
     record into JSON.
-
-    By default, it creates a JSON object with a key for
+     By default, it creates a JSON object with a key for
     each attribute and belongsTo relationship.
-
-    For example, consider this model:
-
-    ```app/models/comment.js
+     For example, consider this model:
+     ```app/models/comment.js
     import Model, { attr, belongsTo } from '@ember-data/model';
-
-    export default class CommentModel extends Model {
+     export default class CommentModel extends Model {
       @attr title;
       @attr body;
-
-      @belongsTo('user') author;
+       @belongsTo('user') author;
     }
     ```
-
-    The default serialization would create a JSON object like:
-
-    ```javascript
+     The default serialization would create a JSON object like:
+     ```javascript
     {
       "title": "Rails is unagi",
       "body": "Rails? Omakase? O_O",
       "author": 12
     }
     ```
-
-    By default, attributes are passed through as-is, unless
+     By default, attributes are passed through as-is, unless
     you specified an attribute type (`attr('date')`). If
     you specify a transform, the JavaScript value will be
     serialized when inserted into the JSON hash.
-
-    By default, belongs-to relationships are converted into
+     By default, belongs-to relationships are converted into
     IDs when inserted into the JSON hash.
-
-    ## IDs
-
-    `serialize` takes an options hash with a single option:
+     ## IDs
+     `serialize` takes an options hash with a single option:
     `includeId`. If this option is `true`, `serialize` will,
     by default include the ID in the JSON object it builds.
-
-    The adapter passes in `includeId: true` when serializing
+     The adapter passes in `includeId: true` when serializing
     a record for `createRecord`, but not for `updateRecord`.
-
-    ## Customization
-
-    Your server may expect a different JSON format than the
+     ## Customization
+     Your server may expect a different JSON format than the
     built-in serialization format.
-
-    In that case, you can implement `serialize` yourself and
+     In that case, you can implement `serialize` yourself and
     return a JSON hash of your choosing.
-
-    ```app/serializers/post.js
+     ```app/serializers/post.js
     import JSONSerializer from '@ember-data/serializer/json';
-
-    export default class PostSerializer extends JSONSerializer {
+     export default class PostSerializer extends JSONSerializer {
       serialize(snapshot, options) {
         let json = {
           POST_TTL: snapshot.attr('title'),
           POST_BDY: snapshot.attr('body'),
           POST_CMS: snapshot.hasMany('comments', { ids: true })
         };
-
-        if (options.includeId) {
+         if (options.includeId) {
           json.POST_ID_ = snapshot.id;
         }
-
-        return json;
+         return json;
       }
     }
     ```
-
-    ## Customizing an App-Wide Serializer
-
-    If you want to define a serializer for your entire
+     ## Customizing an App-Wide Serializer
+     If you want to define a serializer for your entire
     application, you'll probably want to use `eachAttribute`
     and `eachRelationship` on the record.
-
-    ```app/serializers/application.js
+     ```app/serializers/application.js
     import JSONSerializer from '@ember-data/serializer/json';
     import { singularize } from '<app-name>/utils/string-utils';
-
-    export default class ApplicationSerializer extends JSONSerializer {
+     export default class ApplicationSerializer extends JSONSerializer {
       serialize(snapshot, options) {
         let json = {};
-
-        snapshot.eachAttribute((name) => {
+         snapshot.eachAttribute((name) => {
           json[serverAttributeName(name)] = snapshot.attr(name);
         });
-
-        snapshot.eachRelationship((name, relationship) => {
+         snapshot.eachRelationship((name, relationship) => {
           if (relationship.kind === 'hasMany') {
             json[serverHasManyName(name)] = snapshot.hasMany(name, { ids: true });
           }
         });
-
-        if (options.includeId) {
+         if (options.includeId) {
           json.ID_ = snapshot.id;
         }
-
-        return json;
+         return json;
       }
     }
-
-    function serverAttributeName(attribute) {
+     function serverAttributeName(attribute) {
       return attribute.underscore().toUpperCase();
     }
-
-    function serverHasManyName(name) {
+     function serverHasManyName(name) {
       return serverAttributeName(singularize(name)) + "_IDS";
     }
     ```
-
-    This serializer will generate JSON that looks like this:
-
-    ```javascript
+     This serializer will generate JSON that looks like this:
+     ```javascript
     {
       "TITLE": "Rails is omakase",
       "BODY": "Yep. Omakase.",
       "COMMENT_IDS": [ "1", "2", "3" ]
     }
     ```
-
-    ## Tweaking the Default JSON
-
-    If you just want to do some small tweaks on the default JSON,
+     ## Tweaking the Default JSON
+     If you just want to do some small tweaks on the default JSON,
     you can call `super.serialize` first and make the tweaks on
     the returned JSON.
-
-    ```app/serializers/post.js
+     ```app/serializers/post.js
     import JSONSerializer from '@ember-data/serializer/json';
-
-    export default class PostSerializer extends JSONSerializer {
+     export default class PostSerializer extends JSONSerializer {
       serialize(snapshot, options) {
         let json = super.serialize(...arguments);
-
-        json.subject = json.title;
+         json.subject = json.title;
         delete json.title;
-
-        return json;
+         return json;
       }
     }
     ```
-
-    @method serialize
+     @method serialize
     @public
     @param {Snapshot} snapshot
     @param {Object} options
@@ -1103,18 +943,15 @@ const JSONSerializer = Serializer.extend({
   */
   serialize(snapshot, options) {
     let json = {};
-
     if (options && options.includeId) {
       const id = snapshot.id;
       if (id) {
         json[this.primaryKey] = id;
       }
     }
-
     snapshot.eachAttribute((key, attribute) => {
       this.serializeAttribute(snapshot, json, key, attribute);
     });
-
     snapshot.eachRelationship((key, relationship) => {
       if (relationship.kind === 'belongsTo') {
         this.serializeBelongsTo(snapshot, json, relationship);
@@ -1122,10 +959,8 @@ const JSONSerializer = Serializer.extend({
         this.serializeHasMany(snapshot, json, relationship);
       }
     });
-
     return json;
   },
-
   /**
     You can use this method to customize how a serialized record is added to the complete
     JSON hash to be sent to the server. By default the JSON Serializer does not namespace
@@ -1133,22 +968,18 @@ const JSONSerializer = Serializer.extend({
     If your server expects namespaced keys, you should consider using the RESTSerializer.
     Otherwise you can override this method to customize how the record is added to the hash.
     The hash property should be modified by reference.
-
-    For example, your server may expect underscored root objects.
-
-    ```app/serializers/application.js
+     For example, your server may expect underscored root objects.
+     ```app/serializers/application.js
     import RESTSerializer from '@ember-data/serializer/rest';
     import { decamelize } from '<app-name>/utils/string-utils';
-
-    export default class ApplicationSerializer extends RESTSerializer {
+     export default class ApplicationSerializer extends RESTSerializer {
       serializeIntoHash(data, type, snapshot, options) {
         let root = decamelize(type.modelName);
         data[root] = this.serialize(snapshot, options);
       }
     }
     ```
-
-    @method serializeIntoHash
+     @method serializeIntoHash
     @public
     @param {Object} hash
     @param {Model} typeClass
@@ -1158,27 +989,22 @@ const JSONSerializer = Serializer.extend({
   serializeIntoHash(hash, typeClass, snapshot, options) {
     Object.assign(hash, this.serialize(snapshot, options));
   },
-
   /**
     `serializeAttribute` can be used to customize how `attr`
     properties are serialized
-
-    For example if you wanted to ensure all your attributes were always
+     For example if you wanted to ensure all your attributes were always
     serialized as properties on an `attributes` object you could
     write:
-
-    ```app/serializers/application.js
+     ```app/serializers/application.js
     import JSONSerializer from '@ember-data/serializer/json';
-
-    export default class ApplicationSerializer extends JSONSerializer {
+     export default class ApplicationSerializer extends JSONSerializer {
       serializeAttribute(snapshot, json, key, attributes) {
         json.attributes = json.attributes || {};
         super.serializeAttribute(snapshot, json.attributes, key, attributes);
       }
     }
     ```
-
-    @method serializeAttribute
+     @method serializeAttribute
     @public
     @param {Snapshot} snapshot
     @param {Object} json
@@ -1198,38 +1024,29 @@ const JSONSerializer = Serializer.extend({
       // the serializer
       let schema = this.store.modelFor(snapshot.modelName);
       let payloadKey = this._getMappedKey(key, schema);
-
       if (payloadKey === key && this.keyForAttribute) {
         payloadKey = this.keyForAttribute(key, 'serialize');
       }
-
       json[payloadKey] = value;
     }
   },
-
   /**
     `serializeBelongsTo` can be used to customize how `belongsTo`
     properties are serialized.
-
-    Example
-
-    ```app/serializers/post.js
+     Example
+     ```app/serializers/post.js
     import JSONSerializer from '@ember-data/serializer/json';
     import { isNone } from '@ember/utils';
-
-    export default class PostSerializer extends JSONSerializer {
+     export default class PostSerializer extends JSONSerializer {
       serializeBelongsTo(snapshot, json, relationship) {
         let key = relationship.key;
         let belongsTo = snapshot.belongsTo(key);
-
-        key = this.keyForRelationship ? this.keyForRelationship(key, "belongsTo", "serialize") : key;
-
-        json[key] = isNone(belongsTo) ? belongsTo : belongsTo.record.toJSON();
+         key = this.keyForRelationship ? this.keyForRelationship(key, "belongsTo", "serialize") : key;
+         json[key] = isNone(belongsTo) ? belongsTo : belongsTo.record.toJSON();
       }
     }
     ```
-
-    @method serializeBelongsTo
+     @method serializeBelongsTo
     @public
     @param {Snapshot} snapshot
     @param {Object} json
@@ -1237,9 +1054,10 @@ const JSONSerializer = Serializer.extend({
   */
   serializeBelongsTo(snapshot, json, relationship) {
     let key = relationship.key;
-
     if (this._canSerialize(key)) {
-      let belongsToId = snapshot.belongsTo(key, { id: true });
+      let belongsToId = snapshot.belongsTo(key, {
+        id: true
+      });
 
       // if provided, use the mapping provided by `attrs` in
       // the serializer
@@ -1255,23 +1073,18 @@ const JSONSerializer = Serializer.extend({
       } else {
         json[payloadKey] = belongsToId;
       }
-
       if (relationship.options.polymorphic) {
         this.serializePolymorphicType(snapshot, json, relationship);
       }
     }
   },
-
   /**
    `serializeHasMany` can be used to customize how `hasMany`
    properties are serialized.
-
-   Example
-
-   ```app/serializers/post.js
+    Example
+    ```app/serializers/post.js
    import JSONSerializer from '@ember-data/serializer/json';
-
-   export default class PostSerializer extends JSONSerializer {
+    export default class PostSerializer extends JSONSerializer {
      serializeHasMany(snapshot, json, relationship) {
        let key = relationship.key;
        if (key === 'comments') {
@@ -1282,8 +1095,7 @@ const JSONSerializer = Serializer.extend({
      }
    }
    ```
-
-   @method serializeHasMany
+    @method serializeHasMany
     @public
    @param {Snapshot} snapshot
    @param {Object} json
@@ -1291,9 +1103,10 @@ const JSONSerializer = Serializer.extend({
   */
   serializeHasMany(snapshot, json, relationship) {
     let key = relationship.key;
-
     if (this.shouldSerializeHasMany(snapshot, key, relationship)) {
-      let hasMany = snapshot.hasMany(key, { ids: true });
+      let hasMany = snapshot.hasMany(key, {
+        ids: true
+      });
       if (hasMany !== undefined) {
         // if provided, use the mapping provided by `attrs` in
         // the serializer
@@ -1302,7 +1115,6 @@ const JSONSerializer = Serializer.extend({
         if (payloadKey === key && this.keyForRelationship) {
           payloadKey = this.keyForRelationship(key, 'hasMany', 'serialize');
         }
-
         json[payloadKey] = hasMany;
         // TODO support for polymorphic manyToNone and manyToMany relationships
       }
@@ -1314,21 +1126,16 @@ const JSONSerializer = Serializer.extend({
     serialized. Objects are considered to be polymorphic if
     `{ polymorphic: true }` is pass as the second argument to the
     `belongsTo` function.
-
-    Example
-
-    ```app/serializers/comment.js
+     Example
+     ```app/serializers/comment.js
     import JSONSerializer from '@ember-data/serializer/json';
     import { isNone } from '@ember/utils';
-
-    export default class CommentSerializer extends JSONSerializer {
+     export default class CommentSerializer extends JSONSerializer {
       serializePolymorphicType(snapshot, json, relationship) {
         let key = relationship.key;
         let belongsTo = snapshot.belongsTo(key);
-
-        key = this.keyForAttribute ? this.keyForAttribute(key, 'serialize') : key;
-
-        if (isNone(belongsTo)) {
+         key = this.keyForAttribute ? this.keyForAttribute(key, 'serialize') : key;
+         if (isNone(belongsTo)) {
           json[key + '_type'] = null;
         } else {
           json[key + '_type'] = belongsTo.modelName;
@@ -1336,26 +1143,21 @@ const JSONSerializer = Serializer.extend({
       }
     }
     ```
-
-    @method serializePolymorphicType
+     @method serializePolymorphicType
     @public
     @param {Snapshot} snapshot
     @param {Object} json
     @param {Object} relationship
   */
   serializePolymorphicType() {},
-
   /**
     `extractMeta` is used to deserialize any meta information in the
     adapter payload. By default Ember Data expects meta information to
     be located on the `meta` property of the payload object.
-
-    Example
-
-    ```app/serializers/post.js
+     Example
+     ```app/serializers/post.js
     import JSONSerializer from '@ember-data/serializer/json';
-
-    export default class PostSerializer extends JSONSerializer {
+     export default class PostSerializer extends JSONSerializer {
       extractMeta(store, typeClass, payload) {
         if (payload && payload.hasOwnProperty('_pagination')) {
           let meta = payload._pagination;
@@ -1365,8 +1167,7 @@ const JSONSerializer = Serializer.extend({
       }
     }
     ```
-
-    @method extractMeta
+     @method extractMeta
     @public
     @param {Store} store
     @param {Model} modelClass
@@ -1379,17 +1180,14 @@ const JSONSerializer = Serializer.extend({
       return meta;
     }
   },
-
   /**
     `extractErrors` is used to extract model errors when a call
     to `Model#save` fails with an `InvalidError`. By default
     Ember Data expects error information to be located on the `errors`
     property of the payload object.
-
-    This serializer expects this `errors` object to be an Array similar
+     This serializer expects this `errors` object to be an Array similar
     to the following, compliant with the https://jsonapi.org/format/#errors specification:
-
-    ```js
+     ```js
     {
       "errors": [
         {
@@ -1406,18 +1204,14 @@ const JSONSerializer = Serializer.extend({
       ]
     }
     ```
-
-    The key `detail` provides a textual description of the problem.
+     The key `detail` provides a textual description of the problem.
     Alternatively, the key `title` can be used for the same purpose.
-
-    The nested keys `source.pointer` detail which specific element
+     The nested keys `source.pointer` detail which specific element
     of the request data was invalid.
-
-    Note that JSON-API also allows for object-level errors to be placed
+     Note that JSON-API also allows for object-level errors to be placed
     in an object with pointer `data`, signifying that the problem
     cannot be traced to a specific attribute:
-
-    ```javascript
+     ```javascript
     {
       "errors": [
         {
@@ -1429,25 +1223,20 @@ const JSONSerializer = Serializer.extend({
       ]
     }
     ```
-
-    When turn into a `Errors` object, you can read these errors
+     When turn into a `Errors` object, you can read these errors
     through the property `base`:
-
-    ```handlebars
+     ```handlebars
     {{#each @model.errors.base as |error|}}
       <div class="error">
         {{error.message}}
       </div>
     {{/each}}
     ```
-
-    Example of alternative implementation, overriding the default
+     Example of alternative implementation, overriding the default
     behavior to deal with a different format of errors:
-
-    ```app/serializers/post.js
+     ```app/serializers/post.js
     import JSONSerializer from '@ember-data/serializer/json';
-
-    export default class PostSerializer extends JSONSerializer {
+     export default class PostSerializer extends JSONSerializer {
       extractErrors(store, typeClass, payload, id) {
         if (payload && typeof payload === 'object' && payload._problems) {
           payload = payload._problems;
@@ -1457,8 +1246,7 @@ const JSONSerializer = Serializer.extend({
       }
     }
     ```
-
-    @method extractErrors
+     @method extractErrors
     @public
     @param {Store} store
     @param {Model} typeClass
@@ -1470,17 +1258,14 @@ const JSONSerializer = Serializer.extend({
     if (payload && typeof payload === 'object' && payload.errors) {
       // the default assumption is that errors is already in JSON:API format
       const extracted = {};
-
-      payload.errors.forEach((error) => {
+      payload.errors.forEach(error => {
         if (error.source && error.source.pointer) {
           let key = error.source.pointer.match(SOURCE_POINTER_REGEXP);
-
           if (key) {
             key = key[2];
           } else if (error.source.pointer.search(SOURCE_POINTER_PRIMARY_REGEXP) !== -1) {
             key = PRIMARY_ATTRIBUTE_KEY;
           }
-
           if (key) {
             extracted[key] = extracted[key] || [];
             extracted[key].push(error.detail || error.title);
@@ -1493,46 +1278,38 @@ const JSONSerializer = Serializer.extend({
 
       // for each attr and relationship, make sure that we use
       // the normalized key
-      typeClass.eachAttribute((name) => {
+      typeClass.eachAttribute(name => {
         let key = this.keyForAttribute(name, 'deserialize');
         if (key !== name && extracted[key] !== undefined) {
           extracted[name] = extracted[key];
           delete extracted[key];
         }
       });
-
-      typeClass.eachRelationship((name) => {
+      typeClass.eachRelationship(name => {
         let key = this.keyForRelationship(name, 'deserialize');
         if (key !== name && extracted[key] !== undefined) {
           extracted[name] = extracted[key];
           delete extracted[key];
         }
       });
-
       return extracted;
     }
-
     return payload;
   },
-
   /**
     `keyForAttribute` can be used to define rules for how to convert an
     attribute name in your model to a key in your JSON.
-
-    Example
-
-    ```app/serializers/application.js
+     Example
+     ```app/serializers/application.js
     import JSONSerializer from '@ember-data/serializer/json';
     import { underscore } from '<app-name>/utils/string-utils';
-
-    export default class ApplicationSerializer extends JSONSerializer {
+     export default class ApplicationSerializer extends JSONSerializer {
       keyForAttribute(attr, method) {
         return underscore(attr).toUpperCase();
       }
     }
     ```
-
-    @method keyForAttribute
+     @method keyForAttribute
     @public
     @param {String} key
     @param {String} method
@@ -1541,26 +1318,21 @@ const JSONSerializer = Serializer.extend({
   keyForAttribute(key, method) {
     return key;
   },
-
   /**
     `keyForRelationship` can be used to define a custom key when
     serializing and deserializing relationship properties. By default
     `JSONSerializer` does not provide an implementation of this method.
-
-    Example
-
-      ```app/serializers/post.js
+     Example
+       ```app/serializers/post.js
       import JSONSerializer from '@ember-data/serializer/json';
       import { underscore } from '<app-name>/utils/string-utils';
-
-      export default class PostSerializer extends JSONSerializer {
+       export default class PostSerializer extends JSONSerializer {
         keyForRelationship(key, relationship, method) {
           return `rel_${underscore(key)}`;
         }
       }
       ```
-
-    @method keyForRelationship
+     @method keyForRelationship
     @public
     @param {String} key
     @param {String} typeClass
@@ -1570,12 +1342,10 @@ const JSONSerializer = Serializer.extend({
   keyForRelationship(key, typeClass, method) {
     return key;
   },
-
   /**
    `keyForLink` can be used to define a custom key when deserializing link
    properties.
-
-   @method keyForLink
+    @method keyForLink
     @public
    @param {String} key
    @param {String} kind `belongsTo` or `hasMany`
@@ -1584,7 +1354,6 @@ const JSONSerializer = Serializer.extend({
   keyForLink(key, kind) {
     return key;
   },
-
   // HELPERS
 
   /**
@@ -1596,11 +1365,8 @@ const JSONSerializer = Serializer.extend({
   */
   transformFor(attributeType, skipAssertion) {
     let transform = getOwner(this).lookup('transform:' + attributeType);
-
     assert(`Unable to find the transform for \`attr('${attributeType}')\``, skipAssertion || !!transform);
-
     return transform;
-  },
+  }
 });
-
-export default JSONSerializer;
+export { JSONSerializer as default };