@ember-data/serializer 5.4.0-beta.1 → 5.4.0-beta.2

package/addon/json.js

@@ -3,7 +3,7 @@ import { assert, warn } from '@ember/debug';
 import { dasherize } from '@ember/string';
 import { singularize } from 'ember-inflector';
 import _class from "./index";
-import { c as coerceId } from "./utils-075c5b79";
+import { c as coerceId } from "./utils-N1ERF6HN";
 
 /**
  * @module @ember-data/serializer/json
@@ -177,13 +177,13 @@ const JSONSerializer = _class.extend({
    @return {Object} data The transformed data object
   */
   applyTransforms(typeClass, data) {
-    let attributes = typeClass.attributes;
+    const attributes = typeClass.attributes;
     typeClass.eachTransformedAttribute((key, typeClass) => {
       if (data[key] === undefined) {
         return;
       }
-      let transform = this.transformFor(typeClass);
-      let transformMeta = attributes.get(key);
+      const transform = this.transformFor(typeClass);
+      const transformMeta = attributes.get(key);
       data[key] = transform.deserialize(data[key], transformMeta.options);
     });
     return data;
@@ -461,17 +461,17 @@ const JSONSerializer = _class.extend({
     @private
   */
   _normalizeResponse(store, primaryModelClass, payload, id, requestType, isSingle) {
-    let documentHash = {
+    const documentHash = {
       data: null,
       included: []
     };
-    let meta = this.extractMeta(store, primaryModelClass, payload);
+    const 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');
       documentHash.meta = meta;
     }
     if (isSingle) {
-      let {
+      const {
         data,
         included
       } = this.normalize(primaryModelClass, payload);
@@ -480,10 +480,10 @@ const JSONSerializer = _class.extend({
         documentHash.included = included;
       }
     } else {
-      let ret = new Array(payload.length);
+      const ret = new Array(payload.length);
       for (let i = 0, l = payload.length; i < l; i++) {
-        let item = payload[i];
-        let {
+        const item = payload[i];
+        const {
           data,
           included
         } = this.normalize(primaryModelClass, item);
@@ -557,8 +557,8 @@ const JSONSerializer = _class.extend({
     @return {String}
   */
   extractId(modelClass, resourceHash) {
-    let primaryKey = this.primaryKey;
-    let id = resourceHash[primaryKey];
+    const primaryKey = this.primaryKey;
+    const id = resourceHash[primaryKey];
     return coerceId(id);
   },
   /**
@@ -572,7 +572,7 @@ const JSONSerializer = _class.extend({
   */
   extractAttributes(modelClass, resourceHash) {
     let attributeKey;
-    let attributes = {};
+    const attributes = {};
     modelClass.eachAttribute(key => {
       attributeKey = this.keyForAttribute(key, 'deserialize');
       if (resourceHash[attributeKey] !== undefined) {
@@ -603,7 +603,7 @@ const JSONSerializer = _class.extend({
       if (relationshipHash.id) {
         relationshipHash.id = coerceId(relationshipHash.id);
       }
-      let modelClass = this.store.modelFor(relationshipModelName);
+      const modelClass = this.store.modelFor(relationshipModelName);
       if (relationshipHash.type && !modelClass.fields.has('type')) {
         relationshipHash.type = this.modelNameFromPayloadKey(relationshipHash.type);
       }
@@ -644,13 +644,13 @@ const JSONSerializer = _class.extend({
     @return {Object}
   */
   extractRelationships(modelClass, resourceHash) {
-    let relationships = {};
+    const relationships = {};
     modelClass.eachRelationship((key, relationshipMeta) => {
       let relationship = null;
-      let relationshipKey = this.keyForRelationship(key, relationshipMeta.kind, 'deserialize');
+      const relationshipKey = this.keyForRelationship(key, relationshipMeta.kind, 'deserialize');
       if (resourceHash[relationshipKey] !== undefined) {
         let data = null;
-        let relationshipHash = resourceHash[relationshipKey];
+        const relationshipHash = resourceHash[relationshipKey];
         if (relationshipMeta.kind === 'belongsTo') {
           if (relationshipMeta.options.polymorphic) {
             // extracting a polymorphic belongsTo may need more information
@@ -670,7 +670,7 @@ const JSONSerializer = _class.extend({
             data = new Array(relationshipHash.length);
             if (relationshipMeta.options.polymorphic) {
               for (let i = 0, l = relationshipHash.length; i < l; i++) {
-                let item = relationshipHash[i];
+                const item = relationshipHash[i];
                 data[i] = this.extractPolymorphicRelationship(relationshipMeta.type, item, {
                   key,
                   resourceHash,
@@ -679,7 +679,7 @@ const JSONSerializer = _class.extend({
               }
             } else {
               for (let i = 0, l = relationshipHash.length; i < l; i++) {
-                let item = relationshipHash[i];
+                const item = relationshipHash[i];
                 data[i] = this.extractRelationship(relationshipMeta.type, item);
               }
             }
@@ -689,9 +689,9 @@ const JSONSerializer = _class.extend({
           data
         };
       }
-      let linkKey = this.keyForLink(key, relationshipMeta.kind);
+      const linkKey = this.keyForLink(key, relationshipMeta.kind);
       if (resourceHash.links && resourceHash.links[linkKey] !== undefined) {
-        let related = resourceHash.links[linkKey];
+        const related = resourceHash.links[linkKey];
         relationship = relationship || {};
         relationship.links = {
           related
@@ -738,11 +738,11 @@ const JSONSerializer = _class.extend({
     @private
   */
   normalizeUsingDeclaredMapping(modelClass, hash) {
-    let attrs = this.attrs;
+    const attrs = this.attrs;
     let normalizedKey;
     let payloadKey;
     if (attrs) {
-      for (let key in attrs) {
+      for (const key in attrs) {
         normalizedKey = payloadKey = this._getMappedKey(key, modelClass);
         if (hash[payloadKey] === undefined) {
           continue;
@@ -772,7 +772,7 @@ const JSONSerializer = _class.extend({
     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;
+    const attrs = this.attrs;
     let mappedKey;
     if (attrs && attrs[key]) {
       mappedKey = attrs[key];
@@ -796,7 +796,7 @@ const JSONSerializer = _class.extend({
     @return {boolean} true if the key can be serialized
   */
   _canSerialize(key) {
-    let attrs = this.attrs;
+    const attrs = this.attrs;
     return !attrs || !attrs[key] || attrs[key].serialize !== false;
   },
   /**
@@ -809,7 +809,7 @@ const JSONSerializer = _class.extend({
     @return {boolean} true if the key must be serialized
   */
   _mustSerialize(key) {
-    let attrs = this.attrs;
+    const attrs = this.attrs;
     return attrs && attrs[key] && attrs[key].serialize === true;
   },
   /**
@@ -825,7 +825,7 @@ const JSONSerializer = _class.extend({
   */
   shouldSerializeHasMany(snapshot, key, relationship) {
     const schema = this.store.modelFor(snapshot.modelName);
-    let relationshipType = schema.determineRelationshipType(relationship, this.store);
+    const relationshipType = schema.determineRelationshipType(relationship, this.store);
     if (this._mustSerialize(key)) {
       return true;
     }
@@ -948,7 +948,7 @@ const JSONSerializer = _class.extend({
     @return {Object} json
   */
   serialize(snapshot, options) {
-    let json = {};
+    const json = {};
     if (options && options.includeId) {
       const id = snapshot.id;
       if (id) {
@@ -1019,16 +1019,16 @@ const JSONSerializer = _class.extend({
   */
   serializeAttribute(snapshot, json, key, attribute) {
     if (this._canSerialize(key)) {
-      let type = attribute.type;
+      const type = attribute.type;
       let value = snapshot.attr(key);
       if (type) {
-        let transform = this.transformFor(type);
+        const transform = this.transformFor(type);
         value = transform.serialize(value, attribute.options);
       }
 
       // if provided, use the mapping provided by `attrs` in
       // the serializer
-      let schema = this.store.modelFor(snapshot.modelName);
+      const schema = this.store.modelFor(snapshot.modelName);
       let payloadKey = this._getMappedKey(key, schema);
       if (payloadKey === key && this.keyForAttribute) {
         payloadKey = this.keyForAttribute(key, 'serialize');
@@ -1044,7 +1044,7 @@ const JSONSerializer = _class.extend({
     import JSONSerializer from '@ember-data/serializer/json';
      export default class PostSerializer extends JSONSerializer {
       serializeBelongsTo(snapshot, json, relationship) {
-        let key = relationship.key;
+        let key = relationship.name;
         let belongsTo = snapshot.belongsTo(key);
          key = this.keyForRelationship ? this.keyForRelationship(key, "belongsTo", "serialize") : key;
          json[key] = !belongsTo ? null : belongsTo.record.toJSON();
@@ -1058,18 +1058,18 @@ const JSONSerializer = _class.extend({
     @param {Object} relationship
   */
   serializeBelongsTo(snapshot, json, relationship) {
-    let key = relationship.key;
-    if (this._canSerialize(key)) {
-      let belongsToId = snapshot.belongsTo(key, {
+    const name = relationship.name;
+    if (this._canSerialize(name)) {
+      const belongsToId = snapshot.belongsTo(name, {
         id: true
       });
 
       // if provided, use the mapping provided by `attrs` in
       // the serializer
-      let schema = this.store.modelFor(snapshot.modelName);
-      let payloadKey = this._getMappedKey(key, schema);
-      if (payloadKey === key && this.keyForRelationship) {
-        payloadKey = this.keyForRelationship(key, 'belongsTo', 'serialize');
+      const schema = this.store.modelFor(snapshot.modelName);
+      let payloadKey = this._getMappedKey(name, schema);
+      if (payloadKey === name && this.keyForRelationship) {
+        payloadKey = this.keyForRelationship(name, 'belongsTo', 'serialize');
       }
 
       //Need to check whether the id is there for new&async records
@@ -1091,7 +1091,7 @@ const JSONSerializer = _class.extend({
    import JSONSerializer from '@ember-data/serializer/json';
     export default class PostSerializer extends JSONSerializer {
      serializeHasMany(snapshot, json, relationship) {
-       let key = relationship.key;
+       let key = relationship.name;
        if (key === 'comments') {
          return;
        } else {
@@ -1107,25 +1107,24 @@ const JSONSerializer = _class.extend({
    @param {Object} relationship
   */
   serializeHasMany(snapshot, json, relationship) {
-    let key = relationship.key;
-    if (this.shouldSerializeHasMany(snapshot, key, relationship)) {
-      let hasMany = snapshot.hasMany(key, {
+    const name = relationship.name;
+    if (this.shouldSerializeHasMany(snapshot, name, relationship)) {
+      const hasMany = snapshot.hasMany(name, {
         ids: true
       });
       if (hasMany !== undefined) {
         // if provided, use the mapping provided by `attrs` in
         // the serializer
-        let schema = this.store.modelFor(snapshot.modelName);
-        let payloadKey = this._getMappedKey(key, schema);
-        if (payloadKey === key && this.keyForRelationship) {
-          payloadKey = this.keyForRelationship(key, 'hasMany', 'serialize');
+        const schema = this.store.modelFor(snapshot.modelName);
+        let payloadKey = this._getMappedKey(name, schema);
+        if (payloadKey === name && this.keyForRelationship) {
+          payloadKey = this.keyForRelationship(name, 'hasMany', 'serialize');
         }
         json[payloadKey] = hasMany;
         // TODO support for polymorphic manyToNone and manyToMany relationships
       }
     }
   },
-
   /**
     You can use this method to customize how polymorphic objects are
     serialized. Objects are considered to be polymorphic if
@@ -1136,7 +1135,7 @@ const JSONSerializer = _class.extend({
     import JSONSerializer from '@ember-data/serializer/json';
      export default class CommentSerializer extends JSONSerializer {
       serializePolymorphicType(snapshot, json, relationship) {
-        let key = relationship.key;
+        let key = relationship.name;
         let belongsTo = snapshot.belongsTo(key);
          key = this.keyForAttribute ? this.keyForAttribute(key, 'serialize') : key;
          if (!belongsTo) {
@@ -1179,7 +1178,7 @@ const JSONSerializer = _class.extend({
   */
   extractMeta(store, modelClass, payload) {
     if (payload && payload['meta'] !== undefined) {
-      let meta = payload.meta;
+      const meta = payload.meta;
       delete payload.meta;
       return meta;
     }
@@ -1283,14 +1282,14 @@ const JSONSerializer = _class.extend({
       // for each attr and relationship, make sure that we use
       // the normalized key
       typeClass.eachAttribute(name => {
-        let key = this.keyForAttribute(name, 'deserialize');
+        const key = this.keyForAttribute(name, 'deserialize');
         if (key !== name && extracted[key] !== undefined) {
           extracted[name] = extracted[key];
           delete extracted[key];
         }
       });
       typeClass.eachRelationship(name => {
-        let key = this.keyForRelationship(name, 'deserialize');
+        const key = this.keyForRelationship(name, 'deserialize');
         if (key !== name && extracted[key] !== undefined) {
           extracted[name] = extracted[key];
           delete extracted[key];
@@ -1368,7 +1367,7 @@ const JSONSerializer = _class.extend({
    @return {Transform} transform
   */
   transformFor(attributeType, skipAssertion) {
-    let transform = getOwner(this).lookup('transform:' + attributeType);
+    const transform = getOwner(this).lookup('transform:' + attributeType);
     assert(`Unable to find the transform for \`attr('${attributeType}')\``, skipAssertion || !!transform);
     return transform;
   }