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

package/addon/json-api.js

@@ -1,14 +1,9 @@
-/**
- * @module @ember-data/serializer/json-api
- */
+import { macroCondition, isDevelopingApp } from '@embroider/macros';
 import { assert, warn } from '@ember/debug';
 import { dasherize } from '@ember/string';
-import { isNone, typeOf } from '@ember/utils';
-import { DEBUG } from '@glimmer/env';
-
-import { pluralize, singularize } from 'ember-inflector';
-
-import JSONSerializer from '@ember-data/serializer/json';
+import { typeOf, isNone } from '@ember/utils';
+import { singularize, pluralize } from 'ember-inflector';
+import JSONSerializer from "./json";
 
 /**
   Ember Data 2.0 Serializer:
@@ -141,15 +136,12 @@ const JSONAPISerializer = JSONSerializer.extend({
       documentHash.data = this._normalizeResourceHelper(documentHash.data);
     } else if (Array.isArray(documentHash.data)) {
       let ret = new Array(documentHash.data.length);
-
       for (let i = 0; i < documentHash.data.length; i++) {
         let data = documentHash.data[i];
         ret[i] = this._normalizeResourceHelper(data);
       }
-
       documentHash.data = ret;
     }
-
     if (Array.isArray(documentHash.included)) {
       let ret = new Array();
       for (let i = 0; i < documentHash.included.length; i++) {
@@ -160,13 +152,10 @@ const JSONAPISerializer = JSONSerializer.extend({
           ret.push(normalized);
         }
       }
-
       documentHash.included = ret;
     }
-
     return documentHash;
   },
-
   /**
     @method _normalizeRelationshipDataHelper
     @param {Object} relationshipDataHash
@@ -175,10 +164,8 @@ const JSONAPISerializer = JSONSerializer.extend({
   */
   _normalizeRelationshipDataHelper(relationshipDataHash) {
     relationshipDataHash.type = this.modelNameFromPayloadKey(relationshipDataHash.type);
-
     return relationshipDataHash;
   },
-
   /**
     @method _normalizeResourceHelper
     @param {Object} resourceHash
@@ -187,29 +174,25 @@ const JSONAPISerializer = JSONSerializer.extend({
   */
   _normalizeResourceHelper(resourceHash) {
     assert(this.warnMessageForUndefinedType(), !isNone(resourceHash.type));
-
     let modelName, usedLookup;
-
     modelName = this.modelNameFromPayloadKey(resourceHash.type);
     usedLookup = 'modelNameFromPayloadKey';
-
     if (!this.store.getSchemaDefinitionService().doesTypeExist(modelName)) {
       warn(this.warnMessageNoModelForType(modelName, resourceHash.type, usedLookup), false, {
-        id: 'ds.serializer.model-for-type-missing',
+        id: 'ds.serializer.model-for-type-missing'
       });
       return null;
     }
-
     let modelClass = this.store.modelFor(modelName);
     let serializer = this.store.serializerFor(modelName);
-    let { data } = serializer.normalize(modelClass, resourceHash);
+    let {
+      data
+    } = serializer.normalize(modelClass, resourceHash);
     return data;
   },
-
   /**
     Normalize some data and push it into the store.
-
-    @method pushPayload
+     @method pushPayload
     @public
     @param {Store} store
     @param {Object} payload
@@ -218,7 +201,6 @@ const JSONAPISerializer = JSONSerializer.extend({
     let normalizedPayload = this._normalizeDocumentHelper(payload);
     store.push(normalizedPayload);
   },
-
   /**
     @method _normalizeResponse
     @param {Store} store
@@ -234,47 +216,32 @@ const JSONAPISerializer = JSONSerializer.extend({
     let normalizedPayload = this._normalizeDocumentHelper(payload);
     return normalizedPayload;
   },
-
   normalizeQueryRecordResponse() {
     let normalized = this._super(...arguments);
-
-    assert(
-      'Expected the primary data returned by the serializer for a `queryRecord` response to be a single object but instead it was an array.',
-      !Array.isArray(normalized.data)
-    );
-
+    assert('Expected the primary data returned by the serializer for a `queryRecord` response to be a single object but instead it was an array.', !Array.isArray(normalized.data));
     return normalized;
   },
-
   extractAttributes(modelClass, resourceHash) {
     let attributes = {};
-
     if (resourceHash.attributes) {
-      modelClass.eachAttribute((key) => {
+      modelClass.eachAttribute(key => {
         let attributeKey = this.keyForAttribute(key, 'deserialize');
         if (resourceHash.attributes[attributeKey] !== undefined) {
           attributes[key] = resourceHash.attributes[attributeKey];
         }
-        if (DEBUG) {
+        if (macroCondition(isDevelopingApp())) {
           if (resourceHash.attributes[attributeKey] === undefined && resourceHash.attributes[key] !== undefined) {
-            assert(
-              `Your payload for '${modelClass.modelName}' contains '${key}', but your serializer is setup to look for '${attributeKey}'. This is most likely because Ember Data's JSON API serializer dasherizes attribute keys by default. You should subclass JSONAPISerializer and implement 'keyForAttribute(key) { return key; }' to prevent Ember Data from customizing your attribute keys.`,
-              false
-            );
+            assert(`Your payload for '${modelClass.modelName}' contains '${key}', but your serializer is setup to look for '${attributeKey}'. This is most likely because Ember Data's JSON API serializer dasherizes attribute keys by default. You should subclass JSONAPISerializer and implement 'keyForAttribute(key) { return key; }' to prevent Ember Data from customizing your attribute keys.`, false);
           }
         }
       });
     }
-
     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} relationshipHash
      @return {Object}
@@ -283,27 +250,20 @@ const JSONAPISerializer = JSONSerializer.extend({
     if (typeOf(relationshipHash.data) === 'object') {
       relationshipHash.data = this._normalizeRelationshipDataHelper(relationshipHash.data);
     }
-
     if (Array.isArray(relationshipHash.data)) {
       let ret = new Array(relationshipHash.data.length);
-
       for (let i = 0; i < relationshipHash.data.length; i++) {
         let data = relationshipHash.data[i];
         ret[i] = this._normalizeRelationshipDataHelper(data);
       }
-
       relationshipHash.data = ret;
     }
-
     return 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
@@ -311,7 +271,6 @@ const JSONAPISerializer = JSONSerializer.extend({
   */
   extractRelationships(modelClass, resourceHash) {
     let relationships = {};
-
     if (resourceHash.relationships) {
       modelClass.eachRelationship((key, relationshipMeta) => {
         let relationshipKey = this.keyForRelationship(key, relationshipMeta.kind, 'deserialize');
@@ -319,23 +278,15 @@ const JSONAPISerializer = JSONSerializer.extend({
           let relationshipHash = resourceHash.relationships[relationshipKey];
           relationships[key] = this.extractRelationship(relationshipHash);
         }
-        if (DEBUG) {
-          if (
-            resourceHash.relationships[relationshipKey] === undefined &&
-            resourceHash.relationships[key] !== undefined
-          ) {
-            assert(
-              `Your payload for '${modelClass.modelName}' contains '${key}', but your serializer is setup to look for '${relationshipKey}'. This is most likely because Ember Data's JSON API serializer dasherizes relationship keys by default. You should subclass JSONAPISerializer and implement 'keyForRelationship(key) { return key; }' to prevent Ember Data from customizing your relationship keys.`,
-              false
-            );
+        if (macroCondition(isDevelopingApp())) {
+          if (resourceHash.relationships[relationshipKey] === undefined && resourceHash.relationships[key] !== undefined) {
+            assert(`Your payload for '${modelClass.modelName}' contains '${key}', but your serializer is setup to look for '${relationshipKey}'. This is most likely because Ember Data's JSON API serializer dasherizes relationship keys by default. You should subclass JSONAPISerializer and implement 'keyForRelationship(key) { return key; }' to prevent Ember Data from customizing your relationship keys.`, false);
           }
         }
       });
     }
-
     return relationships;
   },
-
   /**
     @method _extractType
     @param {Model} modelClass
@@ -346,15 +297,12 @@ const JSONAPISerializer = JSONSerializer.extend({
   _extractType(modelClass, resourceHash) {
     return this.modelNameFromPayloadKey(resourceHash.type);
   },
-
   /**
     Dasherizes and singularizes the model name in the payload to match
     the format Ember Data uses internally for the model name.
-
-    For example the key `posts` would be converted to `post` and the
+     For example the key `posts` would be converted to `post` and the
     key `studentAssesments` would be converted to `student-assesment`.
-
-    @method modelNameFromPayloadKey
+     @method modelNameFromPayloadKey
     @public
     @param {String} key
     @return {String} the model's modelName
@@ -362,14 +310,11 @@ const JSONAPISerializer = JSONSerializer.extend({
   modelNameFromPayloadKey(key) {
     return singularize(dasherize(key));
   },
-
   /**
     Converts the model name to a pluralized version of the model name.
-
-    For example `post` would be converted to `posts` and
+     For example `post` would be converted to `posts` and
     `student-assesment` would be converted to `student-assesments`.
-
-    @method payloadKeyFromModelName
+     @method payloadKeyFromModelName
     @public
     @param {String} modelName
     @return {String}
@@ -377,51 +322,42 @@ const JSONAPISerializer = JSONSerializer.extend({
   payloadKeyFromModelName(modelName) {
     return pluralize(modelName);
   },
-
   normalize(modelClass, resourceHash) {
     if (resourceHash.attributes) {
       this.normalizeUsingDeclaredMapping(modelClass, resourceHash.attributes);
     }
-
     if (resourceHash.relationships) {
       this.normalizeUsingDeclaredMapping(modelClass, resourceHash.relationships);
     }
-
     let data = {
       id: this.extractId(modelClass, resourceHash),
       type: this._extractType(modelClass, resourceHash),
       attributes: this.extractAttributes(modelClass, resourceHash),
-      relationships: this.extractRelationships(modelClass, resourceHash),
+      relationships: this.extractRelationships(modelClass, resourceHash)
     };
-
     this.applyTransforms(modelClass, data.attributes);
-
-    return { data };
+    return {
+      data
+    };
   },
-
   /**
     `keyForAttribute` can be used to define rules for how to convert an
     attribute name in your model to a key in your JSON.
     By default `JSONAPISerializer` follows the format used on the examples of
     http://jsonapi.org/format and uses dashes as the word separator in the JSON
     attribute keys.
-
-    This behaviour can be easily customized by extending this method.
-
-    Example
-
-    ```app/serializers/application.js
+     This behaviour can be easily customized by extending this method.
+     Example
+     ```app/serializers/application.js
     import JSONAPISerializer from '@ember-data/serializer/json-api';
     import { dasherize } from '<app-name>/utils/string-utils';
-
-    export default class ApplicationSerializer extends JSONAPISerializer {
+     export default class ApplicationSerializer extends JSONAPISerializer {
       keyForAttribute(attr, method) {
         return dasherize(attr).toUpperCase();
       }
     }
     ```
-
-    @method keyForAttribute
+     @method keyForAttribute
     @public
     @param {String} key
     @param {String} method
@@ -430,23 +366,18 @@ const JSONAPISerializer = JSONSerializer.extend({
   keyForAttribute(key, method) {
     return dasherize(key);
   },
-
   /**
    `keyForRelationship` can be used to define a custom key when
    serializing and deserializing relationship properties.
    By default `JSONAPISerializer` follows the format used on the examples of
    http://jsonapi.org/format and uses dashes as word separators in
    relationship properties.
-
-   This behaviour can be easily customized by extending this method.
-
-   Example
-
-    ```app/serializers/post.js
+    This behaviour can be easily customized by extending this method.
+    Example
+     ```app/serializers/post.js
     import JSONAPISerializer from '@ember-data/serializer/json-api';
     import { underscore } from '<app-name>/utils/string-utils';
-
-    export default class ApplicationSerializer extends JSONAPISerializer {
+     export default class ApplicationSerializer extends JSONAPISerializer {
       keyForRelationship(key, relationship, method) {
         return underscore(key);
       }
@@ -462,28 +393,21 @@ const JSONAPISerializer = JSONSerializer.extend({
   keyForRelationship(key, typeClass, method) {
     return dasherize(key);
   },
-
   /**
     Called when a record is saved in order to convert the
     record into JSON.
-
-    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', { async: false, inverse: null })
+       @belongsTo('user', { async: false, inverse: null })
       author;
     }
     ```
-
-    The default serialization would create a JSON-API resource object like:
-
-    ```javascript
+     The default serialization would create a JSON-API resource object like:
+     ```javascript
     {
       "data": {
         "type": "comments",
@@ -502,131 +426,99 @@ const JSONAPISerializer = JSONSerializer.extend({
       }
     }
     ```
-
-    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 attributes hash.
-
-    Belongs-to relationships are converted into JSON-API
+     Belongs-to relationships are converted into JSON-API
     resource identifier objects.
-
-    ## 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 JSONAPIAdapter passes in `includeId: true` when serializing a record
+     The JSONAPIAdapter passes in `includeId: true` when serializing a record
     for `createRecord` or `updateRecord`.
-
-    ## Customization
-
-    Your server may expect data in a different format than the
+     ## Customization
+     Your server may expect data in a different 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 data formatted to match your API's expectations, or override
     the invoked adapter method and do the serialization in the adapter directly
     by using the provided snapshot.
-
-    If your API's format differs greatly from the JSON:API spec, you should
+     If your API's format differs greatly from the JSON:API spec, you should
     consider authoring your own adapter and serializer instead of extending
     this class.
-
-    ```app/serializers/post.js
+     ```app/serializers/post.js
     import JSONAPISerializer from '@ember-data/serializer/json-api';
-
-    export default class PostSerializer extends JSONAPISerializer {
+     export default class PostSerializer extends JSONAPISerializer {
       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 JSONAPISerializer from '@ember-data/serializer/json-api';
     import { underscore, singularize } from '<app-name>/utils/string-utils';
-
-    export default class ApplicationSerializer extends JSONAPISerializer {
+     export default class ApplicationSerializer extends JSONAPISerializer {
       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 underscore(attribute).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 Formatting
-
-    If you just want to do some small tweaks on the default JSON:API formatted response,
+     ## Tweaking the Default Formatting
+     If you just want to do some small tweaks on the default JSON:API formatted response,
     you can call `super.serialize` first and make the tweaks
     on the returned object.
-
-    ```app/serializers/post.js
+     ```app/serializers/post.js
     import JSONAPISerializer from '@ember-data/serializer/json-api';
-
-    export default class PostSerializer extends JSONAPISerializer {
+     export default class PostSerializer extends JSONAPISerializer {
       serialize(snapshot, options) {
         let json = super.serialize(...arguments);
-
-        json.data.attributes.subject = json.data.attributes.title;
+         json.data.attributes.subject = json.data.attributes.title;
         delete json.data.attributes.title;
-
-        return json;
+         return json;
       }
     }
     ```
-
-    @method serialize
+     @method serialize
     @public
     @param {Snapshot} snapshot
     @param {Object} options
@@ -635,72 +527,59 @@ const JSONAPISerializer = JSONSerializer.extend({
   serialize(snapshot, options) {
     let data = this._super(...arguments);
     data.type = this.payloadKeyFromModelName(snapshot.modelName);
-
-    return { data };
+    return {
+      data
+    };
   },
-
   serializeAttribute(snapshot, json, key, attribute) {
     let type = attribute.type;
-
     if (this._canSerialize(key)) {
       json.attributes = json.attributes || {};
-
       let value = snapshot.attr(key);
       if (type) {
         let transform = this.transformFor(type);
         value = transform.serialize(value, attribute.options);
       }
-
       let schema = this.store.modelFor(snapshot.modelName);
       let payloadKey = this._getMappedKey(key, schema);
-
       if (payloadKey === key) {
         payloadKey = this.keyForAttribute(key, 'serialize');
       }
-
       json.attributes[payloadKey] = value;
     }
   },
-
   serializeBelongsTo(snapshot, json, relationship) {
     let key = relationship.key;
-
     if (this._canSerialize(key)) {
       let belongsTo = snapshot.belongsTo(key);
       let belongsToIsNotNew = belongsTo && !belongsTo.isNew;
-
       if (belongsTo === null || belongsToIsNotNew) {
         json.relationships = json.relationships || {};
-
         let schema = this.store.modelFor(snapshot.modelName);
         let payloadKey = this._getMappedKey(key, schema);
         if (payloadKey === key) {
           payloadKey = this.keyForRelationship(key, 'belongsTo', 'serialize');
         }
-
         let data = null;
         if (belongsTo) {
           let payloadType = this.payloadKeyFromModelName(belongsTo.modelName);
-
           data = {
             type: payloadType,
-            id: belongsTo.id,
+            id: belongsTo.id
           };
         }
-
-        json.relationships[payloadKey] = { data };
+        json.relationships[payloadKey] = {
+          data
+        };
       }
     }
   },
-
   serializeHasMany(snapshot, json, relationship) {
     let key = relationship.key;
-
     if (this.shouldSerializeHasMany(snapshot, key, relationship)) {
       let hasMany = snapshot.hasMany(key);
       if (hasMany !== undefined) {
         json.relationships = json.relationships || {};
-
         let schema = this.store.modelFor(snapshot.modelName);
         let payloadKey = this._getMappedKey(key, schema);
         if (payloadKey === key && this.keyForRelationship) {
@@ -708,55 +587,39 @@ const JSONAPISerializer = JSONSerializer.extend({
         }
 
         // only serialize has many relationships that are not new
-        let nonNewHasMany = hasMany.filter((item) => item.record && !item.record.isNew);
+        let nonNewHasMany = hasMany.filter(item => item.record && !item.record.isNew);
         let data = new Array(nonNewHasMany.length);
-
         for (let i = 0; i < nonNewHasMany.length; i++) {
           let item = hasMany[i];
           let payloadType = this.payloadKeyFromModelName(item.modelName);
-
           data[i] = {
             type: payloadType,
-            id: item.id,
+            id: item.id
           };
         }
-
-        json.relationships[payloadKey] = { data };
+        json.relationships[payloadKey] = {
+          data
+        };
       }
     }
-  },
+  }
 });
-
-if (DEBUG) {
+if (macroCondition(isDevelopingApp())) {
   JSONAPISerializer.reopen({
     init(...args) {
       this._super(...args);
-
-      assert(
-        `You've used the EmbeddedRecordsMixin in ${this.toString()} which is not fully compatible with the JSON:API specification. Please confirm that this works for your specific API and add \`this.isEmbeddedRecordsMixinCompatible = true\` to your serializer.`,
-        !this.isEmbeddedRecordsMixin || this.isEmbeddedRecordsMixinCompatible === true
-      );
-
+      assert(`You've used the EmbeddedRecordsMixin in ${this.toString()} which is not fully compatible with the JSON:API specification. Please confirm that this works for your specific API and add \`this.isEmbeddedRecordsMixinCompatible = true\` to your serializer.`, !this.isEmbeddedRecordsMixin || this.isEmbeddedRecordsMixinCompatible === true);
       let constructor = this.constructor;
-      warn(
-        `You've defined 'extractMeta' in ${constructor.toString()} which is not used for serializers extending JSONAPISerializer. Read more at https://api.emberjs.com/ember-data/release/classes/JSONAPISerializer on how to customize meta when using JSON API.`,
-        this.extractMeta === JSONSerializer.prototype.extractMeta,
-        {
-          id: 'ds.serializer.json-api.extractMeta',
-        }
-      );
+      warn(`You've defined 'extractMeta' in ${constructor.toString()} which is not used for serializers extending JSONAPISerializer. Read more at https://api.emberjs.com/ember-data/release/classes/JSONAPISerializer on how to customize meta when using JSON API.`, this.extractMeta === JSONSerializer.prototype.extractMeta, {
+        id: 'ds.serializer.json-api.extractMeta'
+      });
     },
     warnMessageForUndefinedType() {
-      return (
-        'Encountered a resource object with an undefined type (resolved resource using ' +
-        this.constructor.toString() +
-        ')'
-      );
+      return 'Encountered a resource object with an undefined type (resolved resource using ' + this.constructor.toString() + ')';
     },
     warnMessageNoModelForType(modelName, originalType, usedLookup) {
       return `Encountered a resource object with type "${originalType}", but no model was found for model name "${modelName}" (resolved model name using '${this.constructor.toString()}.${usedLookup}("${originalType}")').`;
-    },
+    }
   });
 }
-
-export default JSONAPISerializer;
+export { JSONAPISerializer as default };