ember-data-source 2.4.0.beta.2 → 2.4.0.beta.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 788b4cae6d4b503aa9b94a977f7e48cc85f869e0
-  data.tar.gz: c7286382f77138c30835a37cdde3294e25ed3328
+  metadata.gz: 6e47c3dfb7d115413d7bf76880c5314088ae5c43
+  data.tar.gz: 7d4fffe9edfd5609464c29ce0406df60490bec6e
 SHA512:
-  metadata.gz: e09bf6338cabb5675a6e5670928ae93fb3f262e0735edef7b9cdeb884af28d884ea01c17e025cae5114528ff84946063288dee7610d542d2b975cb8250a7c7b8
-  data.tar.gz: 6b3e0705e24d14b55539235144ce1fee95be6839abfc2ea8a9c98329f9c6f221005dac1d427cfab970b516e6260b4b0aa0d1c7559f6cc0741f4265146c13a0d3
+  metadata.gz: e8d1bcaa42fe0221c879cf3d3aff669db61472622951637159249e9dbc5ae2683e8504c043b3db5e985c0f00ca77a8d20ef0a26b3fed1c5452eb743cf87e1245
+  data.tar.gz: 0d8b42d598ce4593c3b31b0b233c1722e77a2bce5d4bbd9b57abbdef255dad606ce43557a2f78434668ef04366ebe2b9a8e1db152894b5fc8db72def496b6f24

data/dist/globals/ember-data.js

@@ -6,7 +6,7 @@
  * @copyright Copyright 2011-2016 Tilde Inc. and contributors.
  *            Portions Copyright 2011 LivingSocial Inc.
  * @license   Licensed under MIT license (see license.js)
- * @version   2.4.0-beta.2
+ * @version   2.4.0-beta.3
  */
 
 var define, requireModule, require, requirejs;
@@ -932,1248 +932,747 @@ define("ember-data/-private/serializers", ["exports", "ember-data/serializers/js
 /**
   @module ember-data
 */
-define('ember-data/-private/serializers/embedded-records-mixin', ['exports', 'ember', 'ember-data/-private/debug'], function (exports, _ember, _emberDataPrivateDebug) {
-  function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i]; return arr2; } else { return Array.from(arr); } }
+define("ember-data/-private/system/clone-null", ["exports", "ember-data/-private/system/empty-object"], function (exports, _emberDataPrivateSystemEmptyObject) {
+  exports.default = cloneNull;
 
-  var get = _ember.default.get;
-  var set = _ember.default.set;
-  var camelize = _ember.default.String.camelize;
+  function cloneNull(source) {
+    var clone = new _emberDataPrivateSystemEmptyObject.default();
+    for (var key in source) {
+      clone[key] = source[key];
+    }
+    return clone;
+  }
+});
+define('ember-data/-private/system/coerce-id', ['exports'], function (exports) {
+  exports.default = coerceId;
+  // Used by the store to normalize IDs entering the store.  Despite the fact
+  // that developers may provide IDs as numbers (e.g., `store.findRecord('person', 1)`),
+  // it is important that internally we use strings, since IDs may be serialized
+  // and lose type information.  For example, Ember's router may put a record's
+  // ID into the URL, and if we later try to deserialize that URL and find the
+  // corresponding record, we will not know if it is a string or a number.
 
-  /**
-    ## Using Embedded Records
-  
-    `DS.EmbeddedRecordsMixin` supports serializing embedded records.
-  
-    To set up embedded records, include the mixin when extending a serializer,
-    then define and configure embedded (model) relationships.
-  
-    Below is an example of a per-type serializer (`post` type).
-  
-    ```app/serializers/post.js
-    import DS from 'ember-data';
+  function coerceId(id) {
+    return id == null || id === '' ? null : id + '';
+  }
+});
+define('ember-data/-private/system/container-proxy', ['exports', 'ember-data/-private/debug'], function (exports, _emberDataPrivateDebug) {
+  exports.default = ContainerProxy;
+
+  /*
+    This is used internally to enable deprecation of container paths and provide
+    a decent message to the user indicating how to fix the issue.
   
-    export default DS.RESTSerializer.extend(DS.EmbeddedRecordsMixin, {
-      attrs: {
-        author: { embedded: 'always' },
-        comments: { serialize: 'ids' }
+    @class ContainerProxy
+    @namespace DS
+    @private
+  */
+
+  function ContainerProxy(container) {
+    this.container = container;
+  }
+
+  ContainerProxy.prototype.aliasedFactory = function (path, preLookup) {
+    var _this = this;
+
+    return {
+      create: function () {
+        if (preLookup) {
+          preLookup();
+        }
+
+        return _this.container.lookup(path);
       }
-    });
-    ```
-    Note that this use of `{ embedded: 'always' }` is unrelated to
-    the `{ embedded: 'always' }` that is defined as an option on `DS.attr` as part of
-    defining a model while working with the `ActiveModelSerializer`.  Nevertheless,
-    using `{ embedded: 'always' }` as an option to `DS.attr` is not a valid way to setup
-    embedded records.
-  
-    The `attrs` option for a resource `{ embedded: 'always' }` is shorthand for:
-  
-    ```js
-    {
-      serialize: 'records',
-      deserialize: 'records'
+    };
+  };
+
+  ContainerProxy.prototype.registerAlias = function (source, dest, preLookup) {
+    var factory = this.aliasedFactory(dest, preLookup);
+
+    return this.container.register(source, factory);
+  };
+
+  ContainerProxy.prototype.registerDeprecation = function (deprecated, valid) {
+    var preLookupCallback = function () {
+      (0, _emberDataPrivateDebug.deprecate)('You tried to look up \'' + deprecated + '\', but this has been deprecated in favor of \'' + valid + '\'.', false, {
+        id: 'ds.store.deprecated-lookup',
+        until: '2.0.0'
+      });
+    };
+
+    return this.registerAlias(deprecated, valid, preLookupCallback);
+  };
+
+  ContainerProxy.prototype.registerDeprecations = function (proxyPairs) {
+    var i, proxyPair, deprecated, valid;
+
+    for (i = proxyPairs.length; i > 0; i--) {
+      proxyPair = proxyPairs[i - 1];
+      deprecated = proxyPair['deprecated'];
+      valid = proxyPair['valid'];
+
+      this.registerDeprecation(deprecated, valid);
     }
-    ```
-  
-    ### Configuring Attrs
-  
-    A resource's `attrs` option may be set to use `ids`, `records` or false for the
-    `serialize`  and `deserialize` settings.
-  
-    The `attrs` property can be set on the `ApplicationSerializer` or a per-type
-    serializer.
-  
-    In the case where embedded JSON is expected while extracting a payload (reading)
-    the setting is `deserialize: 'records'`, there is no need to use `ids` when
-    extracting as that is the default behavior without this mixin if you are using
-    the vanilla `EmbeddedRecordsMixin`. Likewise, to embed JSON in the payload while
-    serializing `serialize: 'records'` is the setting to use. There is an option of
-    not embedding JSON in the serialized payload by using `serialize: 'ids'`. If you
-    do not want the relationship sent at all, you can use `serialize: false`.
-  
-  
-    ### EmbeddedRecordsMixin defaults
-    If you do not overwrite `attrs` for a specific relationship, the `EmbeddedRecordsMixin`
-    will behave in the following way:
-  
-    BelongsTo: `{ serialize: 'id', deserialize: 'id' }`
-    HasMany:   `{ serialize: false, deserialize: 'ids' }`
-  
-    ### Model Relationships
-  
-    Embedded records must have a model defined to be extracted and serialized. Note that
-    when defining any relationships on your model such as `belongsTo` and `hasMany`, you
-    should not both specify `async: true` and also indicate through the serializer's
-    `attrs` attribute that the related model should be embedded for deserialization.
-    If a model is declared embedded for deserialization (`embedded: 'always'` or `deserialize: 'records'`),
-    then do not use `async: true`.
-  
-    To successfully extract and serialize embedded records the model relationships
-    must be setup correcty. See the
-    [defining relationships](/guides/models/defining-models/#toc_defining-relationships)
-    section of the **Defining Models** guide page.
-  
-    Records without an `id` property are not considered embedded records, model
-    instances must have an `id` property to be used with Ember Data.
-  
-    ### Example JSON payloads, Models and Serializers
-  
-    **When customizing a serializer it is important to grok what the customizations
-    are. Please read the docs for the methods this mixin provides, in case you need
-    to modify it to fit your specific needs.**
-  
-    For example review the docs for each method of this mixin:
-    * [normalize](/api/data/classes/DS.EmbeddedRecordsMixin.html#method_normalize)
-    * [serializeBelongsTo](/api/data/classes/DS.EmbeddedRecordsMixin.html#method_serializeBelongsTo)
-    * [serializeHasMany](/api/data/classes/DS.EmbeddedRecordsMixin.html#method_serializeHasMany)
+  };
+});
+define("ember-data/-private/system/debug", ["exports", "ember-data/-private/system/debug/debug-adapter"], function (exports, _emberDataPrivateSystemDebugDebugAdapter) {
+  exports.default = _emberDataPrivateSystemDebugDebugAdapter.default;
+});
+/**
+  @module ember-data
+*/
+define('ember-data/-private/system/debug/debug-adapter', ['exports', 'ember', 'ember-data/model'], function (exports, _ember, _emberDataModel) {
+  var get = _ember.default.get;
+  var capitalize = _ember.default.String.capitalize;
+  var underscore = _ember.default.String.underscore;
+  var assert = _ember.default.assert;
+
+  /*
+    Extend `Ember.DataAdapter` with ED specific code.
   
-    @class EmbeddedRecordsMixin
+    @class DebugAdapter
     @namespace DS
+    @extends Ember.DataAdapter
+    @private
   */
-  exports.default = _ember.default.Mixin.create({
+  exports.default = _ember.default.DataAdapter.extend({
+    getFilters: function () {
+      return [{ name: 'isNew', desc: 'New' }, { name: 'isModified', desc: 'Modified' }, { name: 'isClean', desc: 'Clean' }];
+    },
 
-    /**
-      Normalize the record and recursively normalize/extract all the embedded records
-      while pushing them into the store as they are encountered
-       A payload with an attr configured for embedded records needs to be extracted:
-       ```js
-      {
-        "post": {
-          "id": "1"
-          "title": "Rails is omakase",
-          "comments": [{
-            "id": "1",
-            "body": "Rails is unagi"
-          }, {
-            "id": "2",
-            "body": "Omakase O_o"
-          }]
+    detect: function (typeClass) {
+      return typeClass !== _emberDataModel.default && _emberDataModel.default.detect(typeClass);
+    },
+
+    columnsForType: function (typeClass) {
+      var columns = [{
+        name: 'id',
+        desc: 'Id'
+      }];
+      var count = 0;
+      var self = this;
+      get(typeClass, 'attributes').forEach(function (meta, name) {
+        if (count++ > self.attributeLimit) {
+          return false;
         }
-      }
-      ```
-     @method normalize
-     @param {DS.Model} typeClass
-     @param {Object} hash to be normalized
-     @param {String} prop the hash has been referenced by
-     @return {Object} the normalized hash
-    **/
-    normalize: function (typeClass, hash, prop) {
-      var normalizedHash = this._super(typeClass, hash, prop);
-      return this._extractEmbeddedRecords(this, this.store, typeClass, normalizedHash);
+        var desc = capitalize(underscore(name).replace('_', ' '));
+        columns.push({ name: name, desc: desc });
+      });
+      return columns;
     },
 
-    keyForRelationship: function (key, typeClass, method) {
-      if (method === 'serialize' && this.hasSerializeRecordsOption(key) || method === 'deserialize' && this.hasDeserializeRecordsOption(key)) {
-        return this.keyForAttribute(key, method);
-      } else {
-        return this._super(key, typeClass, method) || key;
+    getRecords: function (modelClass, modelName) {
+      if (arguments.length < 2) {
+        // Legacy Ember.js < 1.13 support
+        var containerKey = modelClass._debugContainerKey;
+        if (containerKey) {
+          var match = containerKey.match(/model:(.*)/);
+          if (match) {
+            modelName = match[1];
+          }
+        }
       }
+      assert("Cannot find model name. Please upgrade to Ember.js >= 1.13 for Ember Inspector support", !!modelName);
+      return this.get('store').peekAll(modelName);
     },
 
-    /**
-      Serialize `belongsTo` relationship when it is configured as an embedded object.
-       This example of an author model belongs to a post model:
-       ```js
-      Post = DS.Model.extend({
-        title:    DS.attr('string'),
-        body:     DS.attr('string'),
-        author:   DS.belongsTo('author')
-      });
-       Author = DS.Model.extend({
-        name:     DS.attr('string'),
-        post:     DS.belongsTo('post')
-      });
-      ```
-       Use a custom (type) serializer for the post model to configure embedded author
-       ```app/serializers/post.js
-      import DS from 'ember-data;
-       export default DS.RESTSerializer.extend(DS.EmbeddedRecordsMixin, {
-        attrs: {
-          author: { embedded: 'always' }
-        }
-      })
-      ```
-       A payload with an attribute configured for embedded records can serialize
-      the records together under the root attribute's payload:
-       ```js
-      {
-        "post": {
-          "id": "1"
-          "title": "Rails is omakase",
-          "author": {
-            "id": "2"
-            "name": "dhh"
-          }
-        }
-      }
-      ```
-       @method serializeBelongsTo
-      @param {DS.Snapshot} snapshot
-      @param {Object} json
-      @param {Object} relationship
-    */
-    serializeBelongsTo: function (snapshot, json, relationship) {
-      var attr = relationship.key;
-      if (this.noSerializeOptionSpecified(attr)) {
-        this._super(snapshot, json, relationship);
-        return;
-      }
-      var includeIds = this.hasSerializeIdsOption(attr);
-      var includeRecords = this.hasSerializeRecordsOption(attr);
-      var embeddedSnapshot = snapshot.belongsTo(attr);
-      var key;
-      if (includeIds) {
-        key = this.keyForRelationship(attr, relationship.kind, 'serialize');
-        if (!embeddedSnapshot) {
-          json[key] = null;
-        } else {
-          json[key] = embeddedSnapshot.id;
-
-          if (relationship.options.polymorphic) {
-            this.serializePolymorphicType(snapshot, json, relationship);
-          }
-        }
-      } else if (includeRecords) {
-        this._serializeEmbeddedBelongsTo(snapshot, json, relationship);
-      }
-    },
+    getRecordColumnValues: function (record) {
+      var _this = this;
 
-    _serializeEmbeddedBelongsTo: function (snapshot, json, relationship) {
-      var embeddedSnapshot = snapshot.belongsTo(relationship.key);
-      var serializedKey = this.keyForRelationship(relationship.key, relationship.kind, 'serialize');
-      if (!embeddedSnapshot) {
-        json[serializedKey] = null;
-      } else {
-        json[serializedKey] = embeddedSnapshot.record.serialize({ includeId: true });
-        this.removeEmbeddedForeignKey(snapshot, embeddedSnapshot, relationship, json[serializedKey]);
+      var count = 0;
+      var columnValues = { id: get(record, 'id') };
 
-        if (relationship.options.polymorphic) {
-          this.serializePolymorphicType(snapshot, json, relationship);
+      record.eachAttribute(function (key) {
+        if (count++ > _this.attributeLimit) {
+          return false;
         }
-      }
+        var value = get(record, key);
+        columnValues[key] = value;
+      });
+      return columnValues;
     },
 
-    /**
-      Serialize `hasMany` relationship when it is configured as embedded objects.
-       This example of a post model has many comments:
-       ```js
-      Post = DS.Model.extend({
-        title:    DS.attr('string'),
-        body:     DS.attr('string'),
-        comments: DS.hasMany('comment')
+    getRecordKeywords: function (record) {
+      var keywords = [];
+      var keys = _ember.default.A(['id']);
+      record.eachAttribute(function (key) {
+        return keys.push(key);
       });
-       Comment = DS.Model.extend({
-        body:     DS.attr('string'),
-        post:     DS.belongsTo('post')
+      keys.forEach(function (key) {
+        return keywords.push(get(record, key));
       });
-      ```
-       Use a custom (type) serializer for the post model to configure embedded comments
-       ```app/serializers/post.js
-      import DS from 'ember-data;
-       export default DS.RESTSerializer.extend(DS.EmbeddedRecordsMixin, {
-        attrs: {
-          comments: { embedded: 'always' }
-        }
-      })
-      ```
-       A payload with an attribute configured for embedded records can serialize
-      the records together under the root attribute's payload:
-       ```js
-      {
-        "post": {
-          "id": "1"
-          "title": "Rails is omakase",
-          "body": "I want this for my ORM, I want that for my template language..."
-          "comments": [{
-            "id": "1",
-            "body": "Rails is unagi"
-          }, {
-            "id": "2",
-            "body": "Omakase O_o"
-          }]
-        }
-      }
-      ```
-       The attrs options object can use more specific instruction for extracting and
-      serializing. When serializing, an option to embed `ids` or `records` can be set.
-      When extracting the only option is `records`.
-       So `{ embedded: 'always' }` is shorthand for:
-      `{ serialize: 'records', deserialize: 'records' }`
-       To embed the `ids` for a related object (using a hasMany relationship):
-       ```app/serializers/post.js
-      import DS from 'ember-data;
-       export default DS.RESTSerializer.extend(DS.EmbeddedRecordsMixin, {
-        attrs: {
-          comments: { serialize: 'ids', deserialize: 'records' }
-        }
-      })
-      ```
-       ```js
-      {
-        "post": {
-          "id": "1"
-          "title": "Rails is omakase",
-          "body": "I want this for my ORM, I want that for my template language..."
-          "comments": ["1", "2"]
-        }
-      }
-      ```
-       @method serializeHasMany
-      @param {DS.Snapshot} snapshot
-      @param {Object} json
-      @param {Object} relationship
-    */
-    serializeHasMany: function (snapshot, json, relationship) {
-      var attr = relationship.key;
-      if (this.noSerializeOptionSpecified(attr)) {
-        this._super(snapshot, json, relationship);
-        return;
-      }
-      var includeIds = this.hasSerializeIdsOption(attr);
-      var includeRecords = this.hasSerializeRecordsOption(attr);
-      if (includeIds) {
-        var serializedKey = this.keyForRelationship(attr, relationship.kind, 'serialize');
-        json[serializedKey] = snapshot.hasMany(attr, { ids: true });
-      } else if (includeRecords) {
-        this._serializeEmbeddedHasMany(snapshot, json, relationship);
-      }
-    },
-
-    _serializeEmbeddedHasMany: function (snapshot, json, relationship) {
-      var serializedKey = this.keyForRelationship(relationship.key, relationship.kind, 'serialize');
-
-      (0, _emberDataPrivateDebug.warn)('The embedded relationship \'' + serializedKey + '\' is undefined for \'' + snapshot.modelName + '\' with id \'' + snapshot.id + '\'. Please include it in your original payload.', _ember.default.typeOf(snapshot.hasMany(relationship.key)) !== 'undefined', { id: 'ds.serializer.embedded-relationship-undefined' });
-
-      json[serializedKey] = this._generateSerializedHasMany(snapshot, relationship);
+      return keywords;
     },
 
-    /*
-      Returns an array of embedded records serialized to JSON
-    */
-    _generateSerializedHasMany: function (snapshot, relationship) {
-      var hasMany = snapshot.hasMany(relationship.key);
-      var manyArray = _ember.default.A(hasMany);
-      var ret = new Array(manyArray.length);
-
-      for (var i = 0; i < manyArray.length; i++) {
-        var embeddedSnapshot = manyArray[i];
-        var embeddedJson = embeddedSnapshot.record.serialize({ includeId: true });
-        this.removeEmbeddedForeignKey(snapshot, embeddedSnapshot, relationship, embeddedJson);
-        ret[i] = embeddedJson;
-      }
-
-      return ret;
+    getRecordFilterValues: function (record) {
+      return {
+        isNew: record.get('isNew'),
+        isModified: record.get('hasDirtyAttributes') && !record.get('isNew'),
+        isClean: !record.get('hasDirtyAttributes')
+      };
     },
 
-    /**
-      When serializing an embedded record, modify the property (in the json payload)
-      that refers to the parent record (foreign key for relationship).
-       Serializing a `belongsTo` relationship removes the property that refers to the
-      parent record
-       Serializing a `hasMany` relationship does not remove the property that refers to
-      the parent record.
-       @method removeEmbeddedForeignKey
-      @param {DS.Snapshot} snapshot
-      @param {DS.Snapshot} embeddedSnapshot
-      @param {Object} relationship
-      @param {Object} json
-    */
-    removeEmbeddedForeignKey: function (snapshot, embeddedSnapshot, relationship, json) {
-      if (relationship.kind === 'hasMany') {
-        return;
-      } else if (relationship.kind === 'belongsTo') {
-        var parentRecord = snapshot.type.inverseFor(relationship.key, this.store);
-        if (parentRecord) {
-          var name = parentRecord.name;
-          var embeddedSerializer = this.store.serializerFor(embeddedSnapshot.modelName);
-          var parentKey = embeddedSerializer.keyForRelationship(name, parentRecord.kind, 'deserialize');
-          if (parentKey) {
-            delete json[parentKey];
-          }
-        }
+    getRecordColor: function (record) {
+      var color = 'black';
+      if (record.get('isNew')) {
+        color = 'green';
+      } else if (record.get('hasDirtyAttributes')) {
+        color = 'blue';
       }
+      return color;
     },
 
-    // checks config for attrs option to embedded (always) - serialize and deserialize
-    hasEmbeddedAlwaysOption: function (attr) {
-      var option = this.attrsOption(attr);
-      return option && option.embedded === 'always';
-    },
+    observeRecord: function (record, recordUpdated) {
+      var releaseMethods = _ember.default.A();
+      var keysToObserve = _ember.default.A(['id', 'isNew', 'hasDirtyAttributes']);
 
-    // checks config for attrs option to serialize ids
-    hasSerializeRecordsOption: function (attr) {
-      var alwaysEmbed = this.hasEmbeddedAlwaysOption(attr);
-      var option = this.attrsOption(attr);
-      return alwaysEmbed || option && option.serialize === 'records';
-    },
+      record.eachAttribute(function (key) {
+        return keysToObserve.push(key);
+      });
+      var adapter = this;
 
-    // checks config for attrs option to serialize records
-    hasSerializeIdsOption: function (attr) {
-      var option = this.attrsOption(attr);
-      return option && (option.serialize === 'ids' || option.serialize === 'id');
-    },
-
-    // checks config for attrs option to serialize records
-    noSerializeOptionSpecified: function (attr) {
-      var option = this.attrsOption(attr);
-      return !(option && (option.serialize || option.embedded));
-    },
+      keysToObserve.forEach(function (key) {
+        var handler = function () {
+          recordUpdated(adapter.wrapRecord(record));
+        };
+        _ember.default.addObserver(record, key, handler);
+        releaseMethods.push(function () {
+          _ember.default.removeObserver(record, key, handler);
+        });
+      });
 
-    // checks config for attrs option to deserialize records
-    // a defined option object for a resource is treated the same as
-    // `deserialize: 'records'`
-    hasDeserializeRecordsOption: function (attr) {
-      var alwaysEmbed = this.hasEmbeddedAlwaysOption(attr);
-      var option = this.attrsOption(attr);
-      return alwaysEmbed || option && option.deserialize === 'records';
-    },
+      var release = function () {
+        releaseMethods.forEach(function (fn) {
+          return fn();
+        });
+      };
 
-    attrsOption: function (attr) {
-      var attrs = this.get('attrs');
-      return attrs && (attrs[camelize(attr)] || attrs[attr]);
-    },
+      return release;
+    }
+  });
+});
+/**
+  @module ember-data
+*/
+define('ember-data/-private/system/debug/debug-info', ['exports', 'ember'], function (exports, _ember) {
+  exports.default = _ember.default.Mixin.create({
 
     /**
-     @method _extractEmbeddedRecords
-     @private
+      Provides info about the model for debugging purposes
+      by grouping the properties into more semantic groups.
+       Meant to be used by debugging tools such as the Chrome Ember Extension.
+       - Groups all attributes in "Attributes" group.
+      - Groups all belongsTo relationships in "Belongs To" group.
+      - Groups all hasMany relationships in "Has Many" group.
+      - Groups all flags in "Flags" group.
+      - Flags relationship CPs as expensive properties.
+       @method _debugInfo
+      @for DS.Model
+      @private
     */
-    _extractEmbeddedRecords: function (serializer, store, typeClass, partial) {
-      var _this = this;
+    _debugInfo: function () {
+      var attributes = ['id'];
+      var relationships = { belongsTo: [], hasMany: [] };
+      var expensiveProperties = [];
 
-      typeClass.eachRelationship(function (key, relationship) {
-        if (serializer.hasDeserializeRecordsOption(key)) {
-          if (relationship.kind === "hasMany") {
-            _this._extractEmbeddedHasMany(store, key, partial, relationship);
-          }
-          if (relationship.kind === "belongsTo") {
-            _this._extractEmbeddedBelongsTo(store, key, partial, relationship);
-          }
-        }
+      this.eachAttribute(function (name, meta) {
+        return attributes.push(name);
       });
-      return partial;
-    },
-
-    /**
-     @method _extractEmbeddedHasMany
-     @private
-    */
-    _extractEmbeddedHasMany: function (store, key, hash, relationshipMeta) {
-      var relationshipHash = get(hash, 'data.relationships.' + key + '.data');
-
-      if (!relationshipHash) {
-        return;
-      }
-
-      var hasMany = new Array(relationshipHash.length);
-
-      for (var i = 0; i < relationshipHash.length; i++) {
-        var item = relationshipHash[i];
-
-        var _normalizeEmbeddedRelationship = this._normalizeEmbeddedRelationship(store, relationshipMeta, item);
 
-        var data = _normalizeEmbeddedRelationship.data;
-        var included = _normalizeEmbeddedRelationship.included;
+      this.eachRelationship(function (name, relationship) {
+        relationships[relationship.kind].push(name);
+        expensiveProperties.push(name);
+      });
 
-        hash.included = hash.included || [];
-        hash.included.push(data);
-        if (included) {
-          var _hash$included;
+      var groups = [{
+        name: 'Attributes',
+        properties: attributes,
+        expand: true
+      }, {
+        name: 'Belongs To',
+        properties: relationships.belongsTo,
+        expand: true
+      }, {
+        name: 'Has Many',
+        properties: relationships.hasMany,
+        expand: true
+      }, {
+        name: 'Flags',
+        properties: ['isLoaded', 'hasDirtyAttributes', 'isSaving', 'isDeleted', 'isError', 'isNew', 'isValid']
+      }];
 
-          (_hash$included = hash.included).push.apply(_hash$included, _toConsumableArray(included));
+      return {
+        propertyInfo: {
+          // include all other mixins / properties (not just the grouped ones)
+          includeOtherProperties: true,
+          groups: groups,
+          // don't pre-calculate unless cached
+          expensiveProperties: expensiveProperties
         }
+      };
+    }
+  });
+});
+define("ember-data/-private/system/empty-object", ["exports"], function (exports) {
+  exports.default = EmptyObject;
+  // This exists because `Object.create(null)` is absurdly slow compared
+  // to `new EmptyObject()`. In either case, you want a null prototype
+  // when you're treating the object instances as arbitrary dictionaries
+  // and don't want your keys colliding with build-in methods on the
+  // default object prototype.
+  var proto = Object.create(null, {
+    // without this, we will always still end up with (new
+    // EmptyObject()).constructor === Object
+    constructor: {
+      value: undefined,
+      enumerable: false,
+      writable: true
+    }
+  });
 
-        hasMany[i] = { id: data.id, type: data.type };
-      }
-
-      var relationship = { data: hasMany };
-      set(hash, 'data.relationships.' + key, relationship);
-    },
-
-    /**
-     @method _extractEmbeddedBelongsTo
-     @private
-    */
-    _extractEmbeddedBelongsTo: function (store, key, hash, relationshipMeta) {
-      var relationshipHash = get(hash, 'data.relationships.' + key + '.data');
-      if (!relationshipHash) {
-        return;
-      }
-
-      var _normalizeEmbeddedRelationship2 = this._normalizeEmbeddedRelationship(store, relationshipMeta, relationshipHash);
-
-      var data = _normalizeEmbeddedRelationship2.data;
-      var included = _normalizeEmbeddedRelationship2.included;
-
-      hash.included = hash.included || [];
-      hash.included.push(data);
-      if (included) {
-        var _hash$included2;
-
-        (_hash$included2 = hash.included).push.apply(_hash$included2, _toConsumableArray(included));
-      }
-
-      var belongsTo = { id: data.id, type: data.type };
-      var relationship = { data: belongsTo };
+  function EmptyObject() {}
 
-      set(hash, 'data.relationships.' + key, relationship);
-    },
+  EmptyObject.prototype = proto;
+});
+define('ember-data/-private/system/is-array-like', ['exports', 'ember'], function (exports, _ember) {
+  exports.default = isArrayLike;
 
-    /**
-     @method _normalizeEmbeddedRelationship
-     @private
-    */
-    _normalizeEmbeddedRelationship: function (store, relationshipMeta, relationshipHash) {
-      var modelName = relationshipMeta.type;
-      if (relationshipMeta.options.polymorphic) {
-        modelName = relationshipHash.type;
-      }
-      var modelClass = store.modelFor(modelName);
-      var serializer = store.serializerFor(modelName);
+  /*
+    We're using this to detect arrays and "array-like" objects.
+  
+    This is a copy of the `isArray` method found in `ember-runtime/utils` as we're
+    currently unable to import non-exposed modules.
+  
+    This method was previously exposed as `Ember.isArray` but since
+    https://github.com/emberjs/ember.js/pull/11463 `Ember.isArray` is an alias of
+    `Array.isArray` hence removing the "array-like" part.
+   */
 
-      return serializer.normalize(modelClass, relationshipHash, null);
+  function isArrayLike(obj) {
+    if (!obj || obj.setInterval) {
+      return false;
+    }
+    if (Array.isArray(obj)) {
+      return true;
+    }
+    if (_ember.default.Array.detect(obj)) {
+      return true;
     }
-  });
-});
-define("ember-data/-private/system/clone-null", ["exports", "ember-data/-private/system/empty-object"], function (exports, _emberDataPrivateSystemEmptyObject) {
-  exports.default = cloneNull;
 
-  function cloneNull(source) {
-    var clone = new _emberDataPrivateSystemEmptyObject.default();
-    for (var key in source) {
-      clone[key] = source[key];
+    var type = _ember.default.typeOf(obj);
+    if ('array' === type) {
+      return true;
     }
-    return clone;
+    if (obj.length !== undefined && 'object' === type) {
+      return true;
+    }
+    return false;
   }
 });
-define('ember-data/-private/system/coerce-id', ['exports'], function (exports) {
-  exports.default = coerceId;
-  // Used by the store to normalize IDs entering the store.  Despite the fact
-  // that developers may provide IDs as numbers (e.g., `store.findRecord('person', 1)`),
-  // it is important that internally we use strings, since IDs may be serialized
-  // and lose type information.  For example, Ember's router may put a record's
-  // ID into the URL, and if we later try to deserialize that URL and find the
-  // corresponding record, we will not know if it is a string or a number.
+define("ember-data/-private/system/many-array", ["exports", "ember", "ember-data/-private/debug", "ember-data/-private/system/promise-proxies"], function (exports, _ember, _emberDataPrivateDebug, _emberDataPrivateSystemPromiseProxies) {
 
-  function coerceId(id) {
-    return id == null || id === '' ? null : id + '';
-  }
-});
-define('ember-data/-private/system/container-proxy', ['exports', 'ember-data/-private/debug'], function (exports, _emberDataPrivateDebug) {
-  exports.default = ContainerProxy;
+  var get = _ember.default.get;
+  var set = _ember.default.set;
 
-  /*
-    This is used internally to enable deprecation of container paths and provide
-    a decent message to the user indicating how to fix the issue.
+  /**
+    A `ManyArray` is a `MutableArray` that represents the contents of a has-many
+    relationship.
   
-    @class ContainerProxy
+    The `ManyArray` is instantiated lazily the first time the relationship is
+    requested.
+  
+    ### Inverses
+  
+    Often, the relationships in Ember Data applications will have
+    an inverse. For example, imagine the following models are
+    defined:
+  
+    ```app/models/post.js
+    import DS from 'ember-data';
+  
+    export default DS.Model.extend({
+      comments: DS.hasMany('comment')
+    });
+    ```
+  
+    ```app/models/comment.js
+    import DS from 'ember-data';
+  
+    export default DS.Model.extend({
+      post: DS.belongsTo('post')
+    });
+    ```
+  
+    If you created a new instance of `App.Post` and added
+    a `App.Comment` record to its `comments` has-many
+    relationship, you would expect the comment's `post`
+    property to be set to the post that contained
+    the has-many.
+  
+    We call the record to which a relationship belongs the
+    relationship's _owner_.
+  
+    @class ManyArray
     @namespace DS
-    @private
+    @extends Ember.Object
+    @uses Ember.MutableArray, Ember.Evented
   */
+  exports.default = _ember.default.Object.extend(_ember.default.MutableArray, _ember.default.Evented, {
+    init: function () {
+      this._super.apply(this, arguments);
+      this.currentState = _ember.default.A([]);
+    },
 
-  function ContainerProxy(container) {
-    this.container = container;
-  }
+    record: null,
 
-  ContainerProxy.prototype.aliasedFactory = function (path, preLookup) {
-    var _this = this;
+    canonicalState: null,
+    currentState: null,
 
-    return {
-      create: function () {
-        if (preLookup) {
-          preLookup();
-        }
+    length: 0,
 
-        return _this.container.lookup(path);
+    objectAt: function (index) {
+      //Ember observers such as 'firstObject', 'lastObject' might do out of bounds accesses
+      if (!this.currentState[index]) {
+        return undefined;
       }
-    };
-  };
-
-  ContainerProxy.prototype.registerAlias = function (source, dest, preLookup) {
-    var factory = this.aliasedFactory(dest, preLookup);
-
-    return this.container.register(source, factory);
-  };
+      return this.currentState[index].getRecord();
+    },
 
-  ContainerProxy.prototype.registerDeprecation = function (deprecated, valid) {
-    var preLookupCallback = function () {
-      (0, _emberDataPrivateDebug.deprecate)('You tried to look up \'' + deprecated + '\', but this has been deprecated in favor of \'' + valid + '\'.', false, {
-        id: 'ds.store.deprecated-lookup',
-        until: '2.0.0'
+    flushCanonical: function () {
+      //TODO make this smarter, currently its plenty stupid
+      var toSet = this.canonicalState.filter(function (internalModel) {
+        return !internalModel.isDeleted();
       });
-    };
 
-    return this.registerAlias(deprecated, valid, preLookupCallback);
-  };
+      //a hack for not removing new records
+      //TODO remove once we have proper diffing
+      var newRecords = this.currentState.filter(function (internalModel) {
+        return internalModel.isNew();
+      });
+      toSet = toSet.concat(newRecords);
+      var oldLength = this.length;
+      this.arrayContentWillChange(0, this.length, toSet.length);
+      this.set('length', toSet.length);
+      this.currentState = toSet;
+      this.arrayContentDidChange(0, oldLength, this.length);
+      //TODO Figure out to notify only on additions and maybe only if unloaded
+      this.relationship.notifyHasManyChanged();
+      this.record.updateRecordArrays();
+    },
+    /**
+      `true` if the relationship is polymorphic, `false` otherwise.
+       @property {Boolean} isPolymorphic
+      @private
+    */
+    isPolymorphic: false,
 
-  ContainerProxy.prototype.registerDeprecations = function (proxyPairs) {
-    var i, proxyPair, deprecated, valid;
+    /**
+      The loading state of this array
+       @property {Boolean} isLoaded
+    */
+    isLoaded: false,
 
-    for (i = proxyPairs.length; i > 0; i--) {
-      proxyPair = proxyPairs[i - 1];
-      deprecated = proxyPair['deprecated'];
-      valid = proxyPair['valid'];
+    /**
+      The relationship which manages this array.
+       @property {ManyRelationship} relationship
+      @private
+    */
+    relationship: null,
 
-      this.registerDeprecation(deprecated, valid);
-    }
-  };
-});
-define("ember-data/-private/system/debug", ["exports", "ember-data/-private/system/debug/debug-adapter"], function (exports, _emberDataPrivateSystemDebugDebugAdapter) {
-  exports.default = _emberDataPrivateSystemDebugDebugAdapter.default;
-});
-/**
-  @module ember-data
-*/
-define('ember-data/-private/system/debug/debug-adapter', ['exports', 'ember', 'ember-data/model'], function (exports, _ember, _emberDataModel) {
-  var get = _ember.default.get;
-  var capitalize = _ember.default.String.capitalize;
-  var underscore = _ember.default.String.underscore;
-  var assert = _ember.default.assert;
+    /**
+      Metadata associated with the request for async hasMany relationships.
+       Example
+       Given that the server returns the following JSON payload when fetching a
+      hasMany relationship:
+       ```js
+      {
+        "comments": [{
+          "id": 1,
+          "comment": "This is the first comment",
+        }, {
+          // ...
+        }],
+         "meta": {
+          "page": 1,
+          "total": 5
+        }
+      }
+      ```
+       You can then access the metadata via the `meta` property:
+       ```js
+      post.get('comments').then(function(comments) {
+        var meta = comments.get('meta');
+         // meta.page => 1
+        // meta.total => 5
+      });
+      ```
+       @property {Object} meta
+      @public
+    */
+    meta: null,
 
-  /*
-    Extend `Ember.DataAdapter` with ED specific code.
-  
-    @class DebugAdapter
-    @namespace DS
-    @extends Ember.DataAdapter
-    @private
-  */
-  exports.default = _ember.default.DataAdapter.extend({
-    getFilters: function () {
-      return [{ name: 'isNew', desc: 'New' }, { name: 'isModified', desc: 'Modified' }, { name: 'isClean', desc: 'Clean' }];
+    internalReplace: function (idx, amt, objects) {
+      if (!objects) {
+        objects = [];
+      }
+      this.arrayContentWillChange(idx, amt, objects.length);
+      this.currentState.splice.apply(this.currentState, [idx, amt].concat(objects));
+      this.set('length', this.currentState.length);
+      this.arrayContentDidChange(idx, amt, objects.length);
+      if (objects) {
+        //TODO(Igor) probably needed only for unloaded records
+        this.relationship.notifyHasManyChanged();
+      }
+      this.record.updateRecordArrays();
     },
 
-    detect: function (typeClass) {
-      return typeClass !== _emberDataModel.default && _emberDataModel.default.detect(typeClass);
+    //TODO(Igor) optimize
+    internalRemoveRecords: function (records) {
+      var index;
+      for (var i = 0; i < records.length; i++) {
+        index = this.currentState.indexOf(records[i]);
+        this.internalReplace(index, 1);
+      }
     },
 
-    columnsForType: function (typeClass) {
-      var columns = [{
-        name: 'id',
-        desc: 'Id'
-      }];
-      var count = 0;
-      var self = this;
-      get(typeClass, 'attributes').forEach(function (meta, name) {
-        if (count++ > self.attributeLimit) {
-          return false;
-        }
-        var desc = capitalize(underscore(name).replace('_', ' '));
-        columns.push({ name: name, desc: desc });
-      });
-      return columns;
+    //TODO(Igor) optimize
+    internalAddRecords: function (records, idx) {
+      if (idx === undefined) {
+        idx = this.currentState.length;
+      }
+      this.internalReplace(idx, 0, records);
     },
 
-    getRecords: function (modelClass, modelName) {
-      if (arguments.length < 2) {
-        // Legacy Ember.js < 1.13 support
-        var containerKey = modelClass._debugContainerKey;
-        if (containerKey) {
-          var match = containerKey.match(/model:(.*)/);
-          if (match) {
-            modelName = match[1];
-          }
-        }
+    replace: function (idx, amt, objects) {
+      var records;
+      if (amt > 0) {
+        records = this.currentState.slice(idx, idx + amt);
+        this.get('relationship').removeRecords(records);
+      }
+      if (objects) {
+        this.get('relationship').addRecords(objects.map(function (obj) {
+          return obj._internalModel;
+        }), idx);
       }
-      assert("Cannot find model name. Please upgrade to Ember.js >= 1.13 for Ember Inspector support", !!modelName);
-      return this.get('store').peekAll(modelName);
     },
+    /**
+      Used for async `hasMany` arrays
+      to keep track of when they will resolve.
+       @property {Ember.RSVP.Promise} promise
+      @private
+    */
+    promise: null,
 
-    getRecordColumnValues: function (record) {
-      var _this = this;
-
-      var count = 0;
-      var columnValues = { id: get(record, 'id') };
-
-      record.eachAttribute(function (key) {
-        if (count++ > _this.attributeLimit) {
-          return false;
-        }
-        var value = get(record, key);
-        columnValues[key] = value;
-      });
-      return columnValues;
-    },
-
-    getRecordKeywords: function (record) {
-      var keywords = [];
-      var keys = _ember.default.A(['id']);
-      record.eachAttribute(function (key) {
-        return keys.push(key);
-      });
-      keys.forEach(function (key) {
-        return keywords.push(get(record, key));
-      });
-      return keywords;
-    },
-
-    getRecordFilterValues: function (record) {
-      return {
-        isNew: record.get('isNew'),
-        isModified: record.get('hasDirtyAttributes') && !record.get('isNew'),
-        isClean: !record.get('hasDirtyAttributes')
-      };
+    /**
+      @method loadingRecordsCount
+      @param {Number} count
+      @private
+    */
+    loadingRecordsCount: function (count) {
+      this.loadingRecordsCount = count;
     },
 
-    getRecordColor: function (record) {
-      var color = 'black';
-      if (record.get('isNew')) {
-        color = 'green';
-      } else if (record.get('hasDirtyAttributes')) {
-        color = 'blue';
+    /**
+      @method loadedRecord
+      @private
+    */
+    loadedRecord: function () {
+      this.loadingRecordsCount--;
+      if (this.loadingRecordsCount === 0) {
+        set(this, 'isLoaded', true);
+        this.trigger('didLoad');
       }
-      return color;
     },
 
-    observeRecord: function (record, recordUpdated) {
-      var releaseMethods = _ember.default.A();
-      var keysToObserve = _ember.default.A(['id', 'isNew', 'hasDirtyAttributes']);
-
-      record.eachAttribute(function (key) {
-        return keysToObserve.push(key);
-      });
-      var adapter = this;
+    /**
+      @method reload
+      @public
+    */
+    reload: function () {
+      return this.relationship.reload();
+    },
 
-      keysToObserve.forEach(function (key) {
-        var handler = function () {
-          recordUpdated(adapter.wrapRecord(record));
-        };
-        _ember.default.addObserver(record, key, handler);
-        releaseMethods.push(function () {
-          _ember.default.removeObserver(record, key, handler);
+    /**
+      Saves all of the records in the `ManyArray`.
+       Example
+       ```javascript
+      store.findRecord('inbox', 1).then(function(inbox) {
+        inbox.get('messages').then(function(messages) {
+          messages.forEach(function(message) {
+            message.set('isRead', true);
+          });
+          messages.save()
         });
       });
+      ```
+       @method save
+      @return {DS.PromiseArray} promise
+    */
+    save: function () {
+      var manyArray = this;
+      var promiseLabel = "DS: ManyArray#save " + get(this, 'type');
+      var promise = _ember.default.RSVP.all(this.invoke("save"), promiseLabel).then(function (array) {
+        return manyArray;
+      }, null, "DS: ManyArray#save return ManyArray");
 
-      var release = function () {
-        releaseMethods.forEach(function (fn) {
-          return fn();
-        });
-      };
-
-      return release;
-    }
-  });
-});
-/**
-  @module ember-data
-*/
-define('ember-data/-private/system/debug/debug-info', ['exports', 'ember'], function (exports, _ember) {
-  exports.default = _ember.default.Mixin.create({
+      return _emberDataPrivateSystemPromiseProxies.PromiseArray.create({ promise: promise });
+    },
 
     /**
-      Provides info about the model for debugging purposes
-      by grouping the properties into more semantic groups.
-       Meant to be used by debugging tools such as the Chrome Ember Extension.
-       - Groups all attributes in "Attributes" group.
-      - Groups all belongsTo relationships in "Belongs To" group.
-      - Groups all hasMany relationships in "Has Many" group.
-      - Groups all flags in "Flags" group.
-      - Flags relationship CPs as expensive properties.
-       @method _debugInfo
-      @for DS.Model
+      Create a child record within the owner
+       @method createRecord
       @private
+      @param {Object} hash
+      @return {DS.Model} record
     */
-    _debugInfo: function () {
-      var attributes = ['id'];
-      var relationships = { belongsTo: [], hasMany: [] };
-      var expensiveProperties = [];
-
-      this.eachAttribute(function (name, meta) {
-        return attributes.push(name);
-      });
-
-      this.eachRelationship(function (name, relationship) {
-        relationships[relationship.kind].push(name);
-        expensiveProperties.push(name);
-      });
+    createRecord: function (hash) {
+      var store = get(this, 'store');
+      var type = get(this, 'type');
+      var record;
 
-      var groups = [{
-        name: 'Attributes',
-        properties: attributes,
-        expand: true
-      }, {
-        name: 'Belongs To',
-        properties: relationships.belongsTo,
-        expand: true
-      }, {
-        name: 'Has Many',
-        properties: relationships.hasMany,
-        expand: true
-      }, {
-        name: 'Flags',
-        properties: ['isLoaded', 'hasDirtyAttributes', 'isSaving', 'isDeleted', 'isError', 'isNew', 'isValid']
-      }];
+      (0, _emberDataPrivateDebug.assert)("You cannot add '" + type.modelName + "' records to this polymorphic relationship.", !get(this, 'isPolymorphic'));
+      record = store.createRecord(type.modelName, hash);
+      this.pushObject(record);
 
-      return {
-        propertyInfo: {
-          // include all other mixins / properties (not just the grouped ones)
-          includeOtherProperties: true,
-          groups: groups,
-          // don't pre-calculate unless cached
-          expensiveProperties: expensiveProperties
-        }
-      };
+      return record;
     }
   });
 });
-define("ember-data/-private/system/empty-object", ["exports"], function (exports) {
-  exports.default = EmptyObject;
-  // This exists because `Object.create(null)` is absurdly slow compared
-  // to `new EmptyObject()`. In either case, you want a null prototype
-  // when you're treating the object instances as arbitrary dictionaries
-  // and don't want your keys colliding with build-in methods on the
-  // default object prototype.
-  var proto = Object.create(null, {
-    // without this, we will always still end up with (new
-    // EmptyObject()).constructor === Object
-    constructor: {
-      value: undefined,
-      enumerable: false,
-      writable: true
-    }
-  });
-
-  function EmptyObject() {}
+/**
+  @module ember-data
+*/
+define('ember-data/-private/system/merge', ['exports'], function (exports) {
+  exports.default = merge;
 
-  EmptyObject.prototype = proto;
-});
-define('ember-data/-private/system/is-array-like', ['exports', 'ember'], function (exports, _ember) {
-  exports.default = isArrayLike;
+  function merge(original, updates) {
+    if (!updates || typeof updates !== 'object') {
+      return original;
+    }
 
-  /*
-    We're using this to detect arrays and "array-like" objects.
-  
-    This is a copy of the `isArray` method found in `ember-runtime/utils` as we're
-    currently unable to import non-exposed modules.
-  
-    This method was previously exposed as `Ember.isArray` but since
-    https://github.com/emberjs/ember.js/pull/11463 `Ember.isArray` is an alias of
-    `Array.isArray` hence removing the "array-like" part.
-   */
+    var props = Object.keys(updates);
+    var prop;
+    var length = props.length;
 
-  function isArrayLike(obj) {
-    if (!obj || obj.setInterval) {
-      return false;
-    }
-    if (Array.isArray(obj)) {
-      return true;
-    }
-    if (_ember.default.Array.detect(obj)) {
-      return true;
+    for (var i = 0; i < length; i++) {
+      prop = props[i];
+      original[prop] = updates[prop];
     }
 
-    var type = _ember.default.typeOf(obj);
-    if ('array' === type) {
-      return true;
-    }
-    if (obj.length !== undefined && 'object' === type) {
-      return true;
-    }
-    return false;
+    return original;
   }
 });
-define("ember-data/-private/system/many-array", ["exports", "ember", "ember-data/-private/debug", "ember-data/-private/system/promise-proxies"], function (exports, _ember, _emberDataPrivateDebug, _emberDataPrivateSystemPromiseProxies) {
+define("ember-data/-private/system/model", ["exports", "ember-data/-private/system/model/model", "ember-data/attr", "ember-data/-private/system/model/states", "ember-data/-private/system/model/errors"], function (exports, _emberDataPrivateSystemModelModel, _emberDataAttr, _emberDataPrivateSystemModelStates, _emberDataPrivateSystemModelErrors) {
+  exports.RootState = _emberDataPrivateSystemModelStates.default;
+  exports.attr = _emberDataAttr.default;
+  exports.Errors = _emberDataPrivateSystemModelErrors.default;
+  exports.default = _emberDataPrivateSystemModelModel.default;
+});
+/**
+  @module ember-data
+*/
+define("ember-data/-private/system/model/attr", ["exports", "ember", "ember-data/-private/debug"], function (exports, _ember, _emberDataPrivateDebug) {
 
   var get = _ember.default.get;
-  var set = _ember.default.set;
+  var Map = _ember.default.Map;
 
   /**
-    A `ManyArray` is a `MutableArray` that represents the contents of a has-many
-    relationship.
-  
-    The `ManyArray` is instantiated lazily the first time the relationship is
-    requested.
-  
-    ### Inverses
-  
-    Often, the relationships in Ember Data applications will have
-    an inverse. For example, imagine the following models are
-    defined:
-  
-    ```app/models/post.js
-    import DS from 'ember-data';
-  
-    export default DS.Model.extend({
-      comments: DS.hasMany('comment')
-    });
-    ```
-  
-    ```app/models/comment.js
-    import DS from 'ember-data';
-  
-    export default DS.Model.extend({
-      post: DS.belongsTo('post')
-    });
-    ```
-  
-    If you created a new instance of `App.Post` and added
-    a `App.Comment` record to its `comments` has-many
-    relationship, you would expect the comment's `post`
-    property to be set to the post that contained
-    the has-many.
-  
-    We call the record to which a relationship belongs the
-    relationship's _owner_.
-  
-    @class ManyArray
-    @namespace DS
-    @extends Ember.Object
-    @uses Ember.MutableArray, Ember.Evented
+    @module ember-data
   */
-  exports.default = _ember.default.Object.extend(_ember.default.MutableArray, _ember.default.Evented, {
-    init: function () {
-      this._super.apply(this, arguments);
-      this.currentState = _ember.default.A([]);
-    },
 
-    record: null,
-
-    canonicalState: null,
-    currentState: null,
-
-    length: 0,
-
-    objectAt: function (index) {
-      //Ember observers such as 'firstObject', 'lastObject' might do out of bounds accesses
-      if (!this.currentState[index]) {
-        return undefined;
-      }
-      return this.currentState[index].getRecord();
-    },
+  /**
+    @class Model
+    @namespace DS
+  */
 
-    flushCanonical: function () {
-      //TODO make this smarter, currently its plenty stupid
-      var toSet = this.canonicalState.filter(function (internalModel) {
-        return !internalModel.isDeleted();
+  var AttrClassMethodsMixin = _ember.default.Mixin.create({
+    /**
+      A map whose keys are the attributes of the model (properties
+      described by DS.attr) and whose values are the meta object for the
+      property.
+       Example
+       ```app/models/person.js
+      import DS from 'ember-data';
+       export default DS.Model.extend({
+        firstName: attr('string'),
+        lastName: attr('string'),
+        birthday: attr('date')
       });
-
-      //a hack for not removing new records
-      //TODO remove once we have proper diffing
-      var newRecords = this.currentState.filter(function (internalModel) {
-        return internalModel.isNew();
+      ```
+       ```javascript
+      import Ember from 'ember';
+      import Person from 'app/models/person';
+       var attributes = Ember.get(Person, 'attributes')
+       attributes.forEach(function(meta, name) {
+        console.log(name, meta);
       });
-      toSet = toSet.concat(newRecords);
-      var oldLength = this.length;
-      this.arrayContentWillChange(0, this.length, toSet.length);
-      this.set('length', toSet.length);
-      this.currentState = toSet;
-      this.arrayContentDidChange(0, oldLength, this.length);
-      //TODO Figure out to notify only on additions and maybe only if unloaded
-      this.relationship.notifyHasManyChanged();
-      this.record.updateRecordArrays();
-    },
-    /**
-      `true` if the relationship is polymorphic, `false` otherwise.
-       @property {Boolean} isPolymorphic
-      @private
+       // prints:
+      // firstName {type: "string", isAttribute: true, options: Object, parentType: function, name: "firstName"}
+      // lastName {type: "string", isAttribute: true, options: Object, parentType: function, name: "lastName"}
+      // birthday {type: "date", isAttribute: true, options: Object, parentType: function, name: "birthday"}
+      ```
+       @property attributes
+      @static
+      @type {Ember.Map}
+      @readOnly
     */
-    isPolymorphic: false,
+    attributes: _ember.default.computed(function () {
+      var _this = this;
 
-    /**
-      The loading state of this array
-       @property {Boolean} isLoaded
-    */
-    isLoaded: false,
+      var map = Map.create();
 
-    /**
-      The relationship which manages this array.
-       @property {ManyRelationship} relationship
-      @private
-    */
-    relationship: null,
+      this.eachComputedProperty(function (name, meta) {
+        if (meta.isAttribute) {
+          (0, _emberDataPrivateDebug.assert)("You may not set `id` as an attribute on your model. Please remove any lines that look like: `id: DS.attr('<type>')` from " + _this.toString(), name !== 'id');
+
+          meta.name = name;
+          map.set(name, meta);
+        }
+      });
+
+      return map;
+    }).readOnly(),
 
     /**
-      Metadata associated with the request for async hasMany relationships.
+      A map whose keys are the attributes of the model (properties
+      described by DS.attr) and whose values are type of transformation
+      applied to each attribute. This map does not include any
+      attributes that do not have an transformation type.
        Example
-       Given that the server returns the following JSON payload when fetching a
-      hasMany relationship:
-       ```js
-      {
-        "comments": [{
-          "id": 1,
-          "comment": "This is the first comment",
-        }, {
-          // ...
-        }],
-         "meta": {
-          "page": 1,
-          "total": 5
-        }
-      }
+       ```app/models/person.js
+      import DS from 'ember-data';
+       export default DS.Model.extend({
+        firstName: attr(),
+        lastName: attr('string'),
+        birthday: attr('date')
+      });
       ```
-       You can then access the metadata via the `meta` property:
-       ```js
-      post.get('comments').then(function(comments) {
-        var meta = comments.get('meta');
-         // meta.page => 1
-        // meta.total => 5
+       ```javascript
+      import Ember from 'ember';
+      import Person from 'app/models/person';
+       var transformedAttributes = Ember.get(Person, 'transformedAttributes')
+       transformedAttributes.forEach(function(field, type) {
+        console.log(field, type);
       });
+       // prints:
+      // lastName string
+      // birthday date
       ```
-       @property {Object} meta
-      @public
+       @property transformedAttributes
+      @static
+      @type {Ember.Map}
+      @readOnly
     */
-    meta: null,
-
-    internalReplace: function (idx, amt, objects) {
-      if (!objects) {
-        objects = [];
-      }
-      this.arrayContentWillChange(idx, amt, objects.length);
-      this.currentState.splice.apply(this.currentState, [idx, amt].concat(objects));
-      this.set('length', this.currentState.length);
-      this.arrayContentDidChange(idx, amt, objects.length);
-      if (objects) {
-        //TODO(Igor) probably needed only for unloaded records
-        this.relationship.notifyHasManyChanged();
-      }
-      this.record.updateRecordArrays();
-    },
-
-    //TODO(Igor) optimize
-    internalRemoveRecords: function (records) {
-      var index;
-      for (var i = 0; i < records.length; i++) {
-        index = this.currentState.indexOf(records[i]);
-        this.internalReplace(index, 1);
-      }
-    },
-
-    //TODO(Igor) optimize
-    internalAddRecords: function (records, idx) {
-      if (idx === undefined) {
-        idx = this.currentState.length;
-      }
-      this.internalReplace(idx, 0, records);
-    },
+    transformedAttributes: _ember.default.computed(function () {
+      var map = Map.create();
 
-    replace: function (idx, amt, objects) {
-      var records;
-      if (amt > 0) {
-        records = this.currentState.slice(idx, idx + amt);
-        this.get('relationship').removeRecords(records);
-      }
-      if (objects) {
-        this.get('relationship').addRecords(objects.map(function (obj) {
-          return obj._internalModel;
-        }), idx);
-      }
-    },
-    /**
-      Used for async `hasMany` arrays
-      to keep track of when they will resolve.
-       @property {Ember.RSVP.Promise} promise
-      @private
-    */
-    promise: null,
+      this.eachAttribute(function (key, meta) {
+        if (meta.type) {
+          map.set(key, meta.type);
+        }
+      });
 
-    /**
-      @method loadingRecordsCount
-      @param {Number} count
-      @private
-    */
-    loadingRecordsCount: function (count) {
-      this.loadingRecordsCount = count;
-    },
-
-    /**
-      @method loadedRecord
-      @private
-    */
-    loadedRecord: function () {
-      this.loadingRecordsCount--;
-      if (this.loadingRecordsCount === 0) {
-        set(this, 'isLoaded', true);
-        this.trigger('didLoad');
-      }
-    },
-
-    /**
-      @method reload
-      @public
-    */
-    reload: function () {
-      return this.relationship.reload();
-    },
-
-    /**
-      Saves all of the records in the `ManyArray`.
-       Example
-       ```javascript
-      store.findRecord('inbox', 1).then(function(inbox) {
-        inbox.get('messages').then(function(messages) {
-          messages.forEach(function(message) {
-            message.set('isRead', true);
-          });
-          messages.save()
-        });
-      });
-      ```
-       @method save
-      @return {DS.PromiseArray} promise
-    */
-    save: function () {
-      var manyArray = this;
-      var promiseLabel = "DS: ManyArray#save " + get(this, 'type');
-      var promise = _ember.default.RSVP.all(this.invoke("save"), promiseLabel).then(function (array) {
-        return manyArray;
-      }, null, "DS: ManyArray#save return ManyArray");
-
-      return _emberDataPrivateSystemPromiseProxies.PromiseArray.create({ promise: promise });
-    },
-
-    /**
-      Create a child record within the owner
-       @method createRecord
-      @private
-      @param {Object} hash
-      @return {DS.Model} record
-    */
-    createRecord: function (hash) {
-      var store = get(this, 'store');
-      var type = get(this, 'type');
-      var record;
-
-      (0, _emberDataPrivateDebug.assert)("You cannot add '" + type.modelName + "' records to this polymorphic relationship.", !get(this, 'isPolymorphic'));
-      record = store.createRecord(type.modelName, hash);
-      this.pushObject(record);
-
-      return record;
-    }
-  });
-});
-/**
-  @module ember-data
-*/
-define('ember-data/-private/system/merge', ['exports'], function (exports) {
-  exports.default = merge;
-
-  function merge(original, updates) {
-    if (!updates || typeof updates !== 'object') {
-      return original;
-    }
-
-    var props = Object.keys(updates);
-    var prop;
-    var length = props.length;
-
-    for (var i = 0; i < length; i++) {
-      prop = props[i];
-      original[prop] = updates[prop];
-    }
-
-    return original;
-  }
-});
-define("ember-data/-private/system/model", ["exports", "ember-data/-private/system/model/model", "ember-data/attr", "ember-data/-private/system/model/states", "ember-data/-private/system/model/errors"], function (exports, _emberDataPrivateSystemModelModel, _emberDataAttr, _emberDataPrivateSystemModelStates, _emberDataPrivateSystemModelErrors) {
-  exports.RootState = _emberDataPrivateSystemModelStates.default;
-  exports.attr = _emberDataAttr.default;
-  exports.Errors = _emberDataPrivateSystemModelErrors.default;
-  exports.default = _emberDataPrivateSystemModelModel.default;
-});
-/**
-  @module ember-data
-*/
-define("ember-data/-private/system/model/attr", ["exports", "ember", "ember-data/-private/debug"], function (exports, _ember, _emberDataPrivateDebug) {
-
-  var get = _ember.default.get;
-  var Map = _ember.default.Map;
-
-  /**
-    @module ember-data
-  */
-
-  /**
-    @class Model
-    @namespace DS
-  */
-
-  var AttrClassMethodsMixin = _ember.default.Mixin.create({
-    /**
-      A map whose keys are the attributes of the model (properties
-      described by DS.attr) and whose values are the meta object for the
-      property.
-       Example
-       ```app/models/person.js
-      import DS from 'ember-data';
-       export default DS.Model.extend({
-        firstName: attr('string'),
-        lastName: attr('string'),
-        birthday: attr('date')
-      });
-      ```
-       ```javascript
-      import Ember from 'ember';
-      import Person from 'app/models/person';
-       var attributes = Ember.get(Person, 'attributes')
-       attributes.forEach(function(meta, name) {
-        console.log(name, meta);
-      });
-       // prints:
-      // firstName {type: "string", isAttribute: true, options: Object, parentType: function, name: "firstName"}
-      // lastName {type: "string", isAttribute: true, options: Object, parentType: function, name: "lastName"}
-      // birthday {type: "date", isAttribute: true, options: Object, parentType: function, name: "birthday"}
-      ```
-       @property attributes
-      @static
-      @type {Ember.Map}
-      @readOnly
-    */
-    attributes: _ember.default.computed(function () {
-      var _this = this;
-
-      var map = Map.create();
-
-      this.eachComputedProperty(function (name, meta) {
-        if (meta.isAttribute) {
-          (0, _emberDataPrivateDebug.assert)("You may not set `id` as an attribute on your model. Please remove any lines that look like: `id: DS.attr('<type>')` from " + _this.toString(), name !== 'id');
-
-          meta.name = name;
-          map.set(name, meta);
-        }
-      });
-
-      return map;
-    }).readOnly(),
-
-    /**
-      A map whose keys are the attributes of the model (properties
-      described by DS.attr) and whose values are type of transformation
-      applied to each attribute. This map does not include any
-      attributes that do not have an transformation type.
-       Example
-       ```app/models/person.js
-      import DS from 'ember-data';
-       export default DS.Model.extend({
-        firstName: attr(),
-        lastName: attr('string'),
-        birthday: attr('date')
-      });
-      ```
-       ```javascript
-      import Ember from 'ember';
-      import Person from 'app/models/person';
-       var transformedAttributes = Ember.get(Person, 'transformedAttributes')
-       transformedAttributes.forEach(function(field, type) {
-        console.log(field, type);
-      });
-       // prints:
-      // lastName string
-      // birthday date
-      ```
-       @property transformedAttributes
-      @static
-      @type {Ember.Map}
-      @readOnly
-    */
-    transformedAttributes: _ember.default.computed(function () {
-      var map = Map.create();
-
-      this.eachAttribute(function (key, meta) {
-        if (meta.type) {
-          map.set(key, meta.type);
-        }
-      });
-
-      return map;
-    }).readOnly(),
+      return map;
+    }).readOnly(),
 
     /**
       Iterates through the attributes of the model, calling the passed function on each
@@ -2360,6 +1859,33 @@ define('ember-data/-private/system/model/errors', ['exports', 'ember', 'ember-da
     {{/each}}
     ```
   
+    The JSON API spec also allows for object level errors to be placed
+    in an object with pointer `data`.
+  
+    ```javascript
+    {
+      "errors": [
+        {
+          "detail": "Some generic non property error message",
+          "source": {
+            "pointer": "data"
+          }
+        }
+      ]
+    }
+    ```
+  
+    You can access these errors by using the `base` property on the errors
+    object.
+  
+    ```handlebars
+    {{#each model.errors.base as |error|}}
+      <div class="error">
+        {{error.message}}
+      </div>
+    {{/each}}
+    ```
+  
     @class Errors
     @namespace DS
     @extends Ember.Object
@@ -7271,11 +6797,10 @@ define("ember-data/-private/system/relationships/has-many", ["exports", "ember",
         return relationship.getRecords();
       },
       set: function (key, records) {
-        var Model = require('ember-data/model').default;
         (0, _emberDataPrivateDebug.assert)("You must pass an array of records to set a hasMany relationship", (0, _emberDataPrivateSystemIsArrayLike.default)(records));
         (0, _emberDataPrivateDebug.assert)("All elements of a hasMany relationship must be instances of DS.Model, you passed " + _ember.default.inspect(records), (function () {
           return _ember.default.A(records).every(function (record) {
-            return Model.detectInstance(record);
+            return record.hasOwnProperty('_internalModel') === true;
           });
         })());
 
@@ -8001,106 +7526,26 @@ define("ember-data/-private/system/relationships/state/relationship", ["exports"
     }
   };
 });
-define('ember-data/-private/system/serializer', ['exports', 'ember'], function (exports, _ember) {
+define('ember-data/-private/system/snapshot-record-array', ['exports', 'ember-data/-private/features'], function (exports, _emberDataPrivateFeatures) {
+  exports.default = SnapshotRecordArray;
 
   /**
-    `DS.Serializer` is an abstract base class that you should override in your
-    application to customize it for your backend. The minimum set of methods
-    that you should implement is:
-  
-      * `normalizeResponse()`
-      * `serialize()`
-  
-    And you can optionally override the following methods:
-  
-      * `normalize()`
-  
-    For an example implementation, see
-    [DS.JSONSerializer](DS.JSONSerializer.html), the included JSON serializer.
-  
-    @class Serializer
+    @class SnapshotRecordArray
     @namespace DS
-    @extends Ember.Object
+    @private
+    @constructor
+    @param {Array} snapshots An array of snapshots
+    @param {Object} meta
   */
 
-  exports.default = _ember.default.Object.extend({
+  function SnapshotRecordArray(recordArray, meta) {
+    var options = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];
 
     /**
-      The `store` property is the application's `store` that contains all records.
-      It's injected as a service.
-      It can be used to push records from a non flat data structure server
-      response.
-       @property store
-      @type {DS.Store}
-      @public
-    */
-
-    /**
-      The `normalizeResponse` method is used to normalize a payload from the
-      server to a JSON-API Document.
-       http://jsonapi.org/format/#document-structure
-       @method normalizeResponse
-      @param {DS.Store} store
-      @param {DS.Model} primaryModelClass
-      @param {Object} payload
-      @param {String|Number} id
-      @param {String} requestType
-      @return {Object} JSON-API Document
-    */
-    normalizeResponse: null,
-
-    /**
-      The `serialize` method is used when a record is saved in order to convert
-      the record into the form that your external data source expects.
-       `serialize` takes an optional `options` hash with a single option:
-       - `includeId`: If this is `true`, `serialize` should include the ID
-        in the serialized object it builds.
-       @method serialize
-      @param {DS.Model} record
-      @param {Object} [options]
-      @return {Object}
-    */
-    serialize: null,
-
-    /**
-      The `normalize` method is used to convert a payload received from your
-      external data source into the normalized form `store.push()` expects. You
-      should override this method, munge the hash and return the normalized
-      payload.
-       @method normalize
-      @param {DS.Model} typeClass
-      @param {Object} hash
-      @return {Object}
-    */
-    normalize: function (typeClass, hash) {
-      return hash;
-    }
-
-  });
-});
-/**
-  @module ember-data
-*/
-define('ember-data/-private/system/snapshot-record-array', ['exports', 'ember-data/-private/features'], function (exports, _emberDataPrivateFeatures) {
-  exports.default = SnapshotRecordArray;
-
-  /**
-    @class SnapshotRecordArray
-    @namespace DS
-    @private
-    @constructor
-    @param {Array} snapshots An array of snapshots
-    @param {Object} meta
-  */
-
-  function SnapshotRecordArray(recordArray, meta) {
-    var options = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];
-
-    /**
-      An array of snapshots
-      @private
-      @property _snapshots
-      @type {Array}
+      An array of snapshots
+      @private
+      @property _snapshots
+      @type {Array}
     */
     this._snapshots = null;
     /**
@@ -11190,6 +10635,42 @@ define('ember-data/-private/utils', ['exports', 'ember', 'ember-data/-private/de
   exports.modelHasAttributeOrRelationshipNamedType = modelHasAttributeOrRelationshipNamedType;
   exports.getOwner = getOwner;
 });
+define('ember-data/-private/utils/parse-response-headers', ['exports', 'ember-data/-private/system/empty-object'], function (exports, _emberDataPrivateSystemEmptyObject) {
+  exports.default = parseResponseHeaders;
+
+  function _toArray(arr) { return Array.isArray(arr) ? arr : Array.from(arr); }
+
+  var CLRF = '\u000d\u000a';
+
+  function parseResponseHeaders(headersString) {
+    var headers = new _emberDataPrivateSystemEmptyObject.default();
+
+    if (!headersString) {
+      return headers;
+    }
+
+    var headerPairs = headersString.split(CLRF);
+
+    headerPairs.forEach(function (header) {
+      var _header$split = header.split(':');
+
+      var _header$split2 = _toArray(_header$split);
+
+      var field = _header$split2[0];
+
+      var value = _header$split2.slice(1);
+
+      field = field.trim();
+      value = value.join(':').trim();
+
+      if (value) {
+        headers[field] = value;
+      }
+    });
+
+    return headers;
+  }
+});
 define('ember-data/adapter', ['exports', 'ember'], function (exports, _ember) {
   var get = _ember.default.get;
 
@@ -11782,7 +11263,7 @@ define('ember-data/adapters/json-api', ['exports', 'ember', 'ember-data/adapters
 /**
   @module ember-data
 */
-define('ember-data/adapters/rest', ['exports', 'ember', 'ember-data/adapter', 'ember-data/-private/adapters/errors', 'ember-data/-private/system/empty-object', 'ember-data/-private/adapters/build-url-mixin', 'ember-data/-private/features'], function (exports, _ember, _emberDataAdapter, _emberDataPrivateAdaptersErrors, _emberDataPrivateSystemEmptyObject, _emberDataPrivateAdaptersBuildUrlMixin, _emberDataPrivateFeatures) {
+define('ember-data/adapters/rest', ['exports', 'ember', 'ember-data/adapter', 'ember-data/-private/adapters/errors', 'ember-data/-private/adapters/build-url-mixin', 'ember-data/-private/features', 'ember-data/-private/utils/parse-response-headers'], function (exports, _ember, _emberDataAdapter, _emberDataPrivateAdaptersErrors, _emberDataPrivateAdaptersBuildUrlMixin, _emberDataPrivateFeatures, _emberDataPrivateUtilsParseResponseHeaders) {
   var MapWithDefault = _ember.default.MapWithDefault;
   var get = _ember.default.get;
 
@@ -12526,7 +12007,7 @@ define('ember-data/adapters/rest', ['exports', 'ember', 'ember-data/adapter', 'e
 
         hash.success = function (payload, textStatus, jqXHR) {
 
-          var response = adapter.handleResponse(jqXHR.status, parseResponseHeaders(jqXHR.getAllResponseHeaders()), payload, requestData);
+          var response = adapter.handleResponse(jqXHR.status, (0, _emberDataPrivateUtilsParseResponseHeaders.default)(jqXHR.getAllResponseHeaders()), payload, requestData);
 
           if (response && response.isAdapterError) {
             _ember.default.run.join(null, reject, response);
@@ -12545,7 +12026,7 @@ define('ember-data/adapters/rest', ['exports', 'ember', 'ember-data/adapter', 'e
           } else if (textStatus === 'abort') {
             error = new _emberDataPrivateAdaptersErrors.AbortError();
           } else {
-            error = adapter.handleResponse(jqXHR.status, parseResponseHeaders(jqXHR.getAllResponseHeaders()), adapter.parseErrorResponse(jqXHR.responseText) || errorThrown, requestData);
+            error = adapter.handleResponse(jqXHR.status, (0, _emberDataPrivateUtilsParseResponseHeaders.default)(jqXHR.getAllResponseHeaders()), adapter.parseErrorResponse(jqXHR.responseText) || errorThrown, requestData);
           }
 
           _ember.default.run.join(null, reject, error);
@@ -12673,28 +12154,6 @@ define('ember-data/adapters/rest', ['exports', 'ember', 'ember-data/adapter', 'e
     }
   });
 
-  function parseResponseHeaders(headerStr) {
-    var headers = new _emberDataPrivateSystemEmptyObject.default();
-    if (!headerStr) {
-      return headers;
-    }
-
-    var headerPairs = headerStr.split('\u000d\u000a');
-    for (var i = 0; i < headerPairs.length; i++) {
-      var headerPair = headerPairs[i];
-      // Can't use split() here because it does the wrong thing
-      // if the header value has the string ": " in it.
-      var index = headerPair.indexOf('\u003a\u0020');
-      if (index > 0) {
-        var key = headerPair.substring(0, index);
-        var val = headerPair.substring(index + 2);
-        headers[key] = val;
-      }
-    }
-
-    return headers;
-  }
-
   //From http://stackoverflow.com/questions/280634/endswith-in-javascript
   function endsWith(string, suffix) {
     if (typeof String.prototype.endsWith !== 'function') {
@@ -12806,137 +12265,725 @@ define("ember-data/attr", ["exports", "ember", "ember-data/-private/debug"], fun
       options: options
     };
 
-    return _ember.default.computed({
-      get: function (key) {
-        var internalModel = this._internalModel;
-        if (hasValue(internalModel, key)) {
-          return getValue(internalModel, key);
-        } else {
-          return getDefaultValue(this, options, key);
-        }
-      },
-      set: function (key, value) {
-        var internalModel = this._internalModel;
-        var oldValue = getValue(internalModel, key);
+    return _ember.default.computed({
+      get: function (key) {
+        var internalModel = this._internalModel;
+        if (hasValue(internalModel, key)) {
+          return getValue(internalModel, key);
+        } else {
+          return getDefaultValue(this, options, key);
+        }
+      },
+      set: function (key, value) {
+        var internalModel = this._internalModel;
+        var oldValue = getValue(internalModel, key);
+
+        if (value !== oldValue) {
+          // Add the new value to the changed attributes hash; it will get deleted by
+          // the 'didSetProperty' handler if it is no different from the original value
+          internalModel._attributes[key] = value;
+
+          this._internalModel.send('didSetProperty', {
+            name: key,
+            oldValue: oldValue,
+            originalValue: internalModel._data[key],
+            value: value
+          });
+        }
+
+        return value;
+      }
+    }).meta(meta);
+  }
+});
+define("ember-data", ["exports", "ember", "ember-data/-private/debug", "ember-data/-private/core", "ember-data/-private/system/normalize-model-name", "ember-data/-private/system/model/internal-model", "ember-data/-private/system/promise-proxies", "ember-data/-private/system/store", "ember-data/-private/system/model", "ember-data/model", "ember-data/-private/system/snapshot", "ember-data/adapter", "ember-data/serializer", "ember-data/-private/system/debug", "ember-data/-private/adapters/errors", "ember-data/-private/system/record-arrays", "ember-data/-private/system/many-array", "ember-data/-private/system/record-array-manager", "ember-data/-private/adapters", "ember-data/-private/adapters/build-url-mixin", "ember-data/-private/serializers", "ember-inflector", "ember-data/serializers/embedded-records-mixin", "ember-data/-private/transforms", "ember-data/relationships", "ember-data/setup-container", "ember-data/-private/instance-initializers/initialize-store-service", "ember-data/-private/system/container-proxy", "ember-data/-private/system/relationships/state/relationship"], function (exports, _ember, _emberDataPrivateDebug, _emberDataPrivateCore, _emberDataPrivateSystemNormalizeModelName, _emberDataPrivateSystemModelInternalModel, _emberDataPrivateSystemPromiseProxies, _emberDataPrivateSystemStore, _emberDataPrivateSystemModel, _emberDataModel, _emberDataPrivateSystemSnapshot, _emberDataAdapter, _emberDataSerializer, _emberDataPrivateSystemDebug, _emberDataPrivateAdaptersErrors, _emberDataPrivateSystemRecordArrays, _emberDataPrivateSystemManyArray, _emberDataPrivateSystemRecordArrayManager, _emberDataPrivateAdapters, _emberDataPrivateAdaptersBuildUrlMixin, _emberDataPrivateSerializers, _emberInflector, _emberDataSerializersEmbeddedRecordsMixin, _emberDataPrivateTransforms, _emberDataRelationships, _emberDataSetupContainer, _emberDataPrivateInstanceInitializersInitializeStoreService, _emberDataPrivateSystemContainerProxy, _emberDataPrivateSystemRelationshipsStateRelationship) {
+  /**
+    Ember Data
+    @module ember-data
+    @main ember-data
+  */
+
+  if (_ember.default.VERSION.match(/^1\.([0-9]|1[0-2])\./)) {
+    throw new _ember.default.Error("Ember Data requires at least Ember 1.13.0, but you have " + _ember.default.VERSION + ". Please upgrade your version of Ember, then upgrade Ember Data.");
+  }
+
+  if (_ember.default.VERSION.match(/^1\.13\./)) {
+    (0, _emberDataPrivateDebug.warn)("Use of Ember Data 2+ with Ember 1.13 is unsupported. Please upgrade your version of Ember to 2.0 or higher.", false, {
+      id: 'ds.version.ember-1-13'
+    });
+  }
+
+  _emberDataPrivateCore.default.Store = _emberDataPrivateSystemStore.Store;
+  _emberDataPrivateCore.default.PromiseArray = _emberDataPrivateSystemPromiseProxies.PromiseArray;
+  _emberDataPrivateCore.default.PromiseObject = _emberDataPrivateSystemPromiseProxies.PromiseObject;
+
+  _emberDataPrivateCore.default.PromiseManyArray = _emberDataPrivateSystemPromiseProxies.PromiseManyArray;
+
+  _emberDataPrivateCore.default.Model = _emberDataModel.default;
+  _emberDataPrivateCore.default.RootState = _emberDataPrivateSystemModel.RootState;
+  _emberDataPrivateCore.default.attr = _emberDataPrivateSystemModel.attr;
+  _emberDataPrivateCore.default.Errors = _emberDataPrivateSystemModel.Errors;
+
+  _emberDataPrivateCore.default.InternalModel = _emberDataPrivateSystemModelInternalModel.default;
+  _emberDataPrivateCore.default.Snapshot = _emberDataPrivateSystemSnapshot.default;
+
+  _emberDataPrivateCore.default.Adapter = _emberDataAdapter.default;
+
+  _emberDataPrivateCore.default.AdapterError = _emberDataPrivateAdaptersErrors.AdapterError;
+  _emberDataPrivateCore.default.InvalidError = _emberDataPrivateAdaptersErrors.InvalidError;
+  _emberDataPrivateCore.default.TimeoutError = _emberDataPrivateAdaptersErrors.TimeoutError;
+  _emberDataPrivateCore.default.AbortError = _emberDataPrivateAdaptersErrors.AbortError;
+
+  _emberDataPrivateCore.default.errorsHashToArray = _emberDataPrivateAdaptersErrors.errorsHashToArray;
+  _emberDataPrivateCore.default.errorsArrayToHash = _emberDataPrivateAdaptersErrors.errorsArrayToHash;
+
+  _emberDataPrivateCore.default.Serializer = _emberDataSerializer.default;
+
+  _emberDataPrivateCore.default.DebugAdapter = _emberDataPrivateSystemDebug.default;
+
+  _emberDataPrivateCore.default.RecordArray = _emberDataPrivateSystemRecordArrays.RecordArray;
+  _emberDataPrivateCore.default.FilteredRecordArray = _emberDataPrivateSystemRecordArrays.FilteredRecordArray;
+  _emberDataPrivateCore.default.AdapterPopulatedRecordArray = _emberDataPrivateSystemRecordArrays.AdapterPopulatedRecordArray;
+  _emberDataPrivateCore.default.ManyArray = _emberDataPrivateSystemManyArray.default;
+
+  _emberDataPrivateCore.default.RecordArrayManager = _emberDataPrivateSystemRecordArrayManager.default;
+
+  _emberDataPrivateCore.default.RESTAdapter = _emberDataPrivateAdapters.RESTAdapter;
+  _emberDataPrivateCore.default.BuildURLMixin = _emberDataPrivateAdaptersBuildUrlMixin.default;
+
+  _emberDataPrivateCore.default.RESTSerializer = _emberDataPrivateSerializers.RESTSerializer;
+  _emberDataPrivateCore.default.JSONSerializer = _emberDataPrivateSerializers.JSONSerializer;
+
+  _emberDataPrivateCore.default.JSONAPIAdapter = _emberDataPrivateAdapters.JSONAPIAdapter;
+  _emberDataPrivateCore.default.JSONAPISerializer = _emberDataPrivateSerializers.JSONAPISerializer;
+
+  _emberDataPrivateCore.default.Transform = _emberDataPrivateTransforms.Transform;
+  _emberDataPrivateCore.default.DateTransform = _emberDataPrivateTransforms.DateTransform;
+  _emberDataPrivateCore.default.StringTransform = _emberDataPrivateTransforms.StringTransform;
+  _emberDataPrivateCore.default.NumberTransform = _emberDataPrivateTransforms.NumberTransform;
+  _emberDataPrivateCore.default.BooleanTransform = _emberDataPrivateTransforms.BooleanTransform;
+
+  _emberDataPrivateCore.default.EmbeddedRecordsMixin = _emberDataSerializersEmbeddedRecordsMixin.default;
+
+  _emberDataPrivateCore.default.belongsTo = _emberDataRelationships.belongsTo;
+  _emberDataPrivateCore.default.hasMany = _emberDataRelationships.hasMany;
+
+  _emberDataPrivateCore.default.Relationship = _emberDataPrivateSystemRelationshipsStateRelationship.default;
+
+  _emberDataPrivateCore.default.ContainerProxy = _emberDataPrivateSystemContainerProxy.default;
+
+  _emberDataPrivateCore.default._setupContainer = _emberDataSetupContainer.default;
+  _emberDataPrivateCore.default._initializeStoreService = _emberDataPrivateInstanceInitializersInitializeStoreService.default;
+
+  Object.defineProperty(_emberDataPrivateCore.default, 'normalizeModelName', {
+    enumerable: true,
+    writable: false,
+    configurable: false,
+    value: _emberDataPrivateSystemNormalizeModelName.default
+  });
+
+  _ember.default.lookup.DS = _emberDataPrivateCore.default;
+
+  exports.default = _emberDataPrivateCore.default;
+});
+define("ember-data/model", ["exports", "ember-data/-private/system/model"], function (exports, _emberDataPrivateSystemModel) {
+  exports.default = _emberDataPrivateSystemModel.default;
+});
+define("ember-data/relationships", ["exports", "ember-data/-private/system/relationships/belongs-to", "ember-data/-private/system/relationships/has-many"], function (exports, _emberDataPrivateSystemRelationshipsBelongsTo, _emberDataPrivateSystemRelationshipsHasMany) {
+  exports.belongsTo = _emberDataPrivateSystemRelationshipsBelongsTo.default;
+  exports.hasMany = _emberDataPrivateSystemRelationshipsHasMany.default;
+});
+/**
+  @module ember-data
+*/
+define('ember-data/serializer', ['exports', 'ember'], function (exports, _ember) {
+
+  /**
+    `DS.Serializer` is an abstract base class that you should override in your
+    application to customize it for your backend. The minimum set of methods
+    that you should implement is:
+  
+      * `normalizeResponse()`
+      * `serialize()`
+  
+    And you can optionally override the following methods:
+  
+      * `normalize()`
+  
+    For an example implementation, see
+    [DS.JSONSerializer](DS.JSONSerializer.html), the included JSON serializer.
+  
+    @class Serializer
+    @namespace DS
+    @extends Ember.Object
+  */
+
+  exports.default = _ember.default.Object.extend({
+
+    /**
+      The `store` property is the application's `store` that contains all records.
+      It's injected as a service.
+      It can be used to push records from a non flat data structure server
+      response.
+       @property store
+      @type {DS.Store}
+      @public
+    */
+
+    /**
+      The `normalizeResponse` method is used to normalize a payload from the
+      server to a JSON-API Document.
+       http://jsonapi.org/format/#document-structure
+       @method normalizeResponse
+      @param {DS.Store} store
+      @param {DS.Model} primaryModelClass
+      @param {Object} payload
+      @param {String|Number} id
+      @param {String} requestType
+      @return {Object} JSON-API Document
+    */
+    normalizeResponse: null,
+
+    /**
+      The `serialize` method is used when a record is saved in order to convert
+      the record into the form that your external data source expects.
+       `serialize` takes an optional `options` hash with a single option:
+       - `includeId`: If this is `true`, `serialize` should include the ID
+        in the serialized object it builds.
+       @method serialize
+      @param {DS.Model} record
+      @param {Object} [options]
+      @return {Object}
+    */
+    serialize: null,
+
+    /**
+      The `normalize` method is used to convert a payload received from your
+      external data source into the normalized form `store.push()` expects. You
+      should override this method, munge the hash and return the normalized
+      payload.
+       @method normalize
+      @param {DS.Model} typeClass
+      @param {Object} hash
+      @return {Object}
+    */
+    normalize: function (typeClass, hash) {
+      return hash;
+    }
+
+  });
+});
+/**
+  @module ember-data
+*/
+define('ember-data/serializers/embedded-records-mixin', ['exports', 'ember', 'ember-data/-private/debug'], function (exports, _ember, _emberDataPrivateDebug) {
+  function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i]; return arr2; } else { return Array.from(arr); } }
+
+  var get = _ember.default.get;
+  var set = _ember.default.set;
+  var camelize = _ember.default.String.camelize;
+
+  /**
+    ## Using Embedded Records
+  
+    `DS.EmbeddedRecordsMixin` supports serializing embedded records.
+  
+    To set up embedded records, include the mixin when extending a serializer,
+    then define and configure embedded (model) relationships.
+  
+    Below is an example of a per-type serializer (`post` type).
+  
+    ```app/serializers/post.js
+    import DS from 'ember-data';
+  
+    export default DS.RESTSerializer.extend(DS.EmbeddedRecordsMixin, {
+      attrs: {
+        author: { embedded: 'always' },
+        comments: { serialize: 'ids' }
+      }
+    });
+    ```
+    Note that this use of `{ embedded: 'always' }` is unrelated to
+    the `{ embedded: 'always' }` that is defined as an option on `DS.attr` as part of
+    defining a model while working with the `ActiveModelSerializer`.  Nevertheless,
+    using `{ embedded: 'always' }` as an option to `DS.attr` is not a valid way to setup
+    embedded records.
+  
+    The `attrs` option for a resource `{ embedded: 'always' }` is shorthand for:
+  
+    ```js
+    {
+      serialize: 'records',
+      deserialize: 'records'
+    }
+    ```
+  
+    ### Configuring Attrs
+  
+    A resource's `attrs` option may be set to use `ids`, `records` or false for the
+    `serialize`  and `deserialize` settings.
+  
+    The `attrs` property can be set on the `ApplicationSerializer` or a per-type
+    serializer.
+  
+    In the case where embedded JSON is expected while extracting a payload (reading)
+    the setting is `deserialize: 'records'`, there is no need to use `ids` when
+    extracting as that is the default behavior without this mixin if you are using
+    the vanilla `EmbeddedRecordsMixin`. Likewise, to embed JSON in the payload while
+    serializing `serialize: 'records'` is the setting to use. There is an option of
+    not embedding JSON in the serialized payload by using `serialize: 'ids'`. If you
+    do not want the relationship sent at all, you can use `serialize: false`.
+  
+  
+    ### EmbeddedRecordsMixin defaults
+    If you do not overwrite `attrs` for a specific relationship, the `EmbeddedRecordsMixin`
+    will behave in the following way:
+  
+    BelongsTo: `{ serialize: 'id', deserialize: 'id' }`
+    HasMany:   `{ serialize: false, deserialize: 'ids' }`
+  
+    ### Model Relationships
+  
+    Embedded records must have a model defined to be extracted and serialized. Note that
+    when defining any relationships on your model such as `belongsTo` and `hasMany`, you
+    should not both specify `async: true` and also indicate through the serializer's
+    `attrs` attribute that the related model should be embedded for deserialization.
+    If a model is declared embedded for deserialization (`embedded: 'always'` or `deserialize: 'records'`),
+    then do not use `async: true`.
+  
+    To successfully extract and serialize embedded records the model relationships
+    must be setup correcty. See the
+    [defining relationships](/guides/models/defining-models/#toc_defining-relationships)
+    section of the **Defining Models** guide page.
+  
+    Records without an `id` property are not considered embedded records, model
+    instances must have an `id` property to be used with Ember Data.
+  
+    ### Example JSON payloads, Models and Serializers
+  
+    **When customizing a serializer it is important to grok what the customizations
+    are. Please read the docs for the methods this mixin provides, in case you need
+    to modify it to fit your specific needs.**
+  
+    For example review the docs for each method of this mixin:
+    * [normalize](/api/data/classes/DS.EmbeddedRecordsMixin.html#method_normalize)
+    * [serializeBelongsTo](/api/data/classes/DS.EmbeddedRecordsMixin.html#method_serializeBelongsTo)
+    * [serializeHasMany](/api/data/classes/DS.EmbeddedRecordsMixin.html#method_serializeHasMany)
+  
+    @class EmbeddedRecordsMixin
+    @namespace DS
+  */
+  exports.default = _ember.default.Mixin.create({
+
+    /**
+      Normalize the record and recursively normalize/extract all the embedded records
+      while pushing them into the store as they are encountered
+       A payload with an attr configured for embedded records needs to be extracted:
+       ```js
+      {
+        "post": {
+          "id": "1"
+          "title": "Rails is omakase",
+          "comments": [{
+            "id": "1",
+            "body": "Rails is unagi"
+          }, {
+            "id": "2",
+            "body": "Omakase O_o"
+          }]
+        }
+      }
+      ```
+     @method normalize
+     @param {DS.Model} typeClass
+     @param {Object} hash to be normalized
+     @param {String} prop the hash has been referenced by
+     @return {Object} the normalized hash
+    **/
+    normalize: function (typeClass, hash, prop) {
+      var normalizedHash = this._super(typeClass, hash, prop);
+      return this._extractEmbeddedRecords(this, this.store, typeClass, normalizedHash);
+    },
+
+    keyForRelationship: function (key, typeClass, method) {
+      if (method === 'serialize' && this.hasSerializeRecordsOption(key) || method === 'deserialize' && this.hasDeserializeRecordsOption(key)) {
+        return this.keyForAttribute(key, method);
+      } else {
+        return this._super(key, typeClass, method) || key;
+      }
+    },
+
+    /**
+      Serialize `belongsTo` relationship when it is configured as an embedded object.
+       This example of an author model belongs to a post model:
+       ```js
+      Post = DS.Model.extend({
+        title:    DS.attr('string'),
+        body:     DS.attr('string'),
+        author:   DS.belongsTo('author')
+      });
+       Author = DS.Model.extend({
+        name:     DS.attr('string'),
+        post:     DS.belongsTo('post')
+      });
+      ```
+       Use a custom (type) serializer for the post model to configure embedded author
+       ```app/serializers/post.js
+      import DS from 'ember-data;
+       export default DS.RESTSerializer.extend(DS.EmbeddedRecordsMixin, {
+        attrs: {
+          author: { embedded: 'always' }
+        }
+      })
+      ```
+       A payload with an attribute configured for embedded records can serialize
+      the records together under the root attribute's payload:
+       ```js
+      {
+        "post": {
+          "id": "1"
+          "title": "Rails is omakase",
+          "author": {
+            "id": "2"
+            "name": "dhh"
+          }
+        }
+      }
+      ```
+       @method serializeBelongsTo
+      @param {DS.Snapshot} snapshot
+      @param {Object} json
+      @param {Object} relationship
+    */
+    serializeBelongsTo: function (snapshot, json, relationship) {
+      var attr = relationship.key;
+      if (this.noSerializeOptionSpecified(attr)) {
+        this._super(snapshot, json, relationship);
+        return;
+      }
+      var includeIds = this.hasSerializeIdsOption(attr);
+      var includeRecords = this.hasSerializeRecordsOption(attr);
+      var embeddedSnapshot = snapshot.belongsTo(attr);
+      var key;
+      if (includeIds) {
+        key = this.keyForRelationship(attr, relationship.kind, 'serialize');
+        if (!embeddedSnapshot) {
+          json[key] = null;
+        } else {
+          json[key] = embeddedSnapshot.id;
+
+          if (relationship.options.polymorphic) {
+            this.serializePolymorphicType(snapshot, json, relationship);
+          }
+        }
+      } else if (includeRecords) {
+        this._serializeEmbeddedBelongsTo(snapshot, json, relationship);
+      }
+    },
+
+    _serializeEmbeddedBelongsTo: function (snapshot, json, relationship) {
+      var embeddedSnapshot = snapshot.belongsTo(relationship.key);
+      var serializedKey = this._getMappedKey(relationship.key, snapshot.type);
+      if (serializedKey === relationship.key && this.keyForRelationship) {
+        serializedKey = this.keyForRelationship(relationship.key, relationship.kind, "serialize");
+      }
+
+      if (!embeddedSnapshot) {
+        json[serializedKey] = null;
+      } else {
+        json[serializedKey] = embeddedSnapshot.record.serialize({ includeId: true });
+        this.removeEmbeddedForeignKey(snapshot, embeddedSnapshot, relationship, json[serializedKey]);
+
+        if (relationship.options.polymorphic) {
+          this.serializePolymorphicType(snapshot, json, relationship);
+        }
+      }
+    },
+
+    /**
+      Serialize `hasMany` relationship when it is configured as embedded objects.
+       This example of a post model has many comments:
+       ```js
+      Post = DS.Model.extend({
+        title:    DS.attr('string'),
+        body:     DS.attr('string'),
+        comments: DS.hasMany('comment')
+      });
+       Comment = DS.Model.extend({
+        body:     DS.attr('string'),
+        post:     DS.belongsTo('post')
+      });
+      ```
+       Use a custom (type) serializer for the post model to configure embedded comments
+       ```app/serializers/post.js
+      import DS from 'ember-data;
+       export default DS.RESTSerializer.extend(DS.EmbeddedRecordsMixin, {
+        attrs: {
+          comments: { embedded: 'always' }
+        }
+      })
+      ```
+       A payload with an attribute configured for embedded records can serialize
+      the records together under the root attribute's payload:
+       ```js
+      {
+        "post": {
+          "id": "1"
+          "title": "Rails is omakase",
+          "body": "I want this for my ORM, I want that for my template language..."
+          "comments": [{
+            "id": "1",
+            "body": "Rails is unagi"
+          }, {
+            "id": "2",
+            "body": "Omakase O_o"
+          }]
+        }
+      }
+      ```
+       The attrs options object can use more specific instruction for extracting and
+      serializing. When serializing, an option to embed `ids` or `records` can be set.
+      When extracting the only option is `records`.
+       So `{ embedded: 'always' }` is shorthand for:
+      `{ serialize: 'records', deserialize: 'records' }`
+       To embed the `ids` for a related object (using a hasMany relationship):
+       ```app/serializers/post.js
+      import DS from 'ember-data;
+       export default DS.RESTSerializer.extend(DS.EmbeddedRecordsMixin, {
+        attrs: {
+          comments: { serialize: 'ids', deserialize: 'records' }
+        }
+      })
+      ```
+       ```js
+      {
+        "post": {
+          "id": "1"
+          "title": "Rails is omakase",
+          "body": "I want this for my ORM, I want that for my template language..."
+          "comments": ["1", "2"]
+        }
+      }
+      ```
+       @method serializeHasMany
+      @param {DS.Snapshot} snapshot
+      @param {Object} json
+      @param {Object} relationship
+    */
+    serializeHasMany: function (snapshot, json, relationship) {
+      var attr = relationship.key;
+      if (this.noSerializeOptionSpecified(attr)) {
+        this._super(snapshot, json, relationship);
+        return;
+      }
+      var includeIds = this.hasSerializeIdsOption(attr);
+      var includeRecords = this.hasSerializeRecordsOption(attr);
+      if (includeIds) {
+        var serializedKey = this.keyForRelationship(attr, relationship.kind, 'serialize');
+        json[serializedKey] = snapshot.hasMany(attr, { ids: true });
+      } else if (includeRecords) {
+        this._serializeEmbeddedHasMany(snapshot, json, relationship);
+      }
+    },
+
+    _serializeEmbeddedHasMany: function (snapshot, json, relationship) {
+      var serializedKey = this._getMappedKey(relationship.key, snapshot.type);
+      if (serializedKey === relationship.key && this.keyForRelationship) {
+        serializedKey = this.keyForRelationship(relationship.key, relationship.kind, "serialize");
+      }
+
+      (0, _emberDataPrivateDebug.warn)('The embedded relationship \'' + serializedKey + '\' is undefined for \'' + snapshot.modelName + '\' with id \'' + snapshot.id + '\'. Please include it in your original payload.', _ember.default.typeOf(snapshot.hasMany(relationship.key)) !== 'undefined', { id: 'ds.serializer.embedded-relationship-undefined' });
+
+      json[serializedKey] = this._generateSerializedHasMany(snapshot, relationship);
+    },
+
+    /*
+      Returns an array of embedded records serialized to JSON
+    */
+    _generateSerializedHasMany: function (snapshot, relationship) {
+      var hasMany = snapshot.hasMany(relationship.key);
+      var manyArray = _ember.default.A(hasMany);
+      var ret = new Array(manyArray.length);
 
-        if (value !== oldValue) {
-          // Add the new value to the changed attributes hash; it will get deleted by
-          // the 'didSetProperty' handler if it is no different from the original value
-          internalModel._attributes[key] = value;
+      for (var i = 0; i < manyArray.length; i++) {
+        var embeddedSnapshot = manyArray[i];
+        var embeddedJson = embeddedSnapshot.record.serialize({ includeId: true });
+        this.removeEmbeddedForeignKey(snapshot, embeddedSnapshot, relationship, embeddedJson);
+        ret[i] = embeddedJson;
+      }
 
-          this._internalModel.send('didSetProperty', {
-            name: key,
-            oldValue: oldValue,
-            originalValue: internalModel._data[key],
-            value: value
-          });
-        }
+      return ret;
+    },
 
-        return value;
+    /**
+      When serializing an embedded record, modify the property (in the json payload)
+      that refers to the parent record (foreign key for relationship).
+       Serializing a `belongsTo` relationship removes the property that refers to the
+      parent record
+       Serializing a `hasMany` relationship does not remove the property that refers to
+      the parent record.
+       @method removeEmbeddedForeignKey
+      @param {DS.Snapshot} snapshot
+      @param {DS.Snapshot} embeddedSnapshot
+      @param {Object} relationship
+      @param {Object} json
+    */
+    removeEmbeddedForeignKey: function (snapshot, embeddedSnapshot, relationship, json) {
+      if (relationship.kind === 'hasMany') {
+        return;
+      } else if (relationship.kind === 'belongsTo') {
+        var parentRecord = snapshot.type.inverseFor(relationship.key, this.store);
+        if (parentRecord) {
+          var name = parentRecord.name;
+          var embeddedSerializer = this.store.serializerFor(embeddedSnapshot.modelName);
+          var parentKey = embeddedSerializer.keyForRelationship(name, parentRecord.kind, 'deserialize');
+          if (parentKey) {
+            delete json[parentKey];
+          }
+        }
       }
-    }).meta(meta);
-  }
-});
-define("ember-data", ["exports", "ember", "ember-data/-private/debug", "ember-data/-private/core", "ember-data/-private/system/normalize-model-name", "ember-data/-private/system/model/internal-model", "ember-data/-private/system/promise-proxies", "ember-data/-private/system/store", "ember-data/-private/system/model", "ember-data/model", "ember-data/-private/system/snapshot", "ember-data/adapter", "ember-data/-private/system/serializer", "ember-data/-private/system/debug", "ember-data/-private/adapters/errors", "ember-data/-private/system/record-arrays", "ember-data/-private/system/many-array", "ember-data/-private/system/record-array-manager", "ember-data/-private/adapters", "ember-data/-private/adapters/build-url-mixin", "ember-data/-private/serializers", "ember-inflector", "ember-data/-private/serializers/embedded-records-mixin", "ember-data/-private/transforms", "ember-data/relationships", "ember-data/setup-container", "ember-data/-private/instance-initializers/initialize-store-service", "ember-data/-private/system/container-proxy", "ember-data/-private/system/relationships/state/relationship"], function (exports, _ember, _emberDataPrivateDebug, _emberDataPrivateCore, _emberDataPrivateSystemNormalizeModelName, _emberDataPrivateSystemModelInternalModel, _emberDataPrivateSystemPromiseProxies, _emberDataPrivateSystemStore, _emberDataPrivateSystemModel, _emberDataModel, _emberDataPrivateSystemSnapshot, _emberDataAdapter, _emberDataPrivateSystemSerializer, _emberDataPrivateSystemDebug, _emberDataPrivateAdaptersErrors, _emberDataPrivateSystemRecordArrays, _emberDataPrivateSystemManyArray, _emberDataPrivateSystemRecordArrayManager, _emberDataPrivateAdapters, _emberDataPrivateAdaptersBuildUrlMixin, _emberDataPrivateSerializers, _emberInflector, _emberDataPrivateSerializersEmbeddedRecordsMixin, _emberDataPrivateTransforms, _emberDataRelationships, _emberDataSetupContainer, _emberDataPrivateInstanceInitializersInitializeStoreService, _emberDataPrivateSystemContainerProxy, _emberDataPrivateSystemRelationshipsStateRelationship) {
-  /**
-    Ember Data
-    @module ember-data
-    @main ember-data
-  */
+    },
 
-  if (_ember.default.VERSION.match(/^1\.([0-9]|1[0-2])\./)) {
-    throw new _ember.default.Error("Ember Data requires at least Ember 1.13.0, but you have " + _ember.default.VERSION + ". Please upgrade your version of Ember, then upgrade Ember Data.");
-  }
+    // checks config for attrs option to embedded (always) - serialize and deserialize
+    hasEmbeddedAlwaysOption: function (attr) {
+      var option = this.attrsOption(attr);
+      return option && option.embedded === 'always';
+    },
 
-  if (_ember.default.VERSION.match(/^1\.13\./)) {
-    (0, _emberDataPrivateDebug.warn)("Use of Ember Data 2+ with Ember 1.13 is unsupported. Please upgrade your version of Ember to 2.0 or higher.", false, {
-      id: 'ds.version.ember-1-13'
-    });
-  }
+    // checks config for attrs option to serialize ids
+    hasSerializeRecordsOption: function (attr) {
+      var alwaysEmbed = this.hasEmbeddedAlwaysOption(attr);
+      var option = this.attrsOption(attr);
+      return alwaysEmbed || option && option.serialize === 'records';
+    },
 
-  _emberDataPrivateCore.default.Store = _emberDataPrivateSystemStore.Store;
-  _emberDataPrivateCore.default.PromiseArray = _emberDataPrivateSystemPromiseProxies.PromiseArray;
-  _emberDataPrivateCore.default.PromiseObject = _emberDataPrivateSystemPromiseProxies.PromiseObject;
+    // checks config for attrs option to serialize records
+    hasSerializeIdsOption: function (attr) {
+      var option = this.attrsOption(attr);
+      return option && (option.serialize === 'ids' || option.serialize === 'id');
+    },
 
-  _emberDataPrivateCore.default.PromiseManyArray = _emberDataPrivateSystemPromiseProxies.PromiseManyArray;
+    // checks config for attrs option to serialize records
+    noSerializeOptionSpecified: function (attr) {
+      var option = this.attrsOption(attr);
+      return !(option && (option.serialize || option.embedded));
+    },
 
-  _emberDataPrivateCore.default.Model = _emberDataModel.default;
-  _emberDataPrivateCore.default.RootState = _emberDataPrivateSystemModel.RootState;
-  _emberDataPrivateCore.default.attr = _emberDataPrivateSystemModel.attr;
-  _emberDataPrivateCore.default.Errors = _emberDataPrivateSystemModel.Errors;
+    // checks config for attrs option to deserialize records
+    // a defined option object for a resource is treated the same as
+    // `deserialize: 'records'`
+    hasDeserializeRecordsOption: function (attr) {
+      var alwaysEmbed = this.hasEmbeddedAlwaysOption(attr);
+      var option = this.attrsOption(attr);
+      return alwaysEmbed || option && option.deserialize === 'records';
+    },
 
-  _emberDataPrivateCore.default.InternalModel = _emberDataPrivateSystemModelInternalModel.default;
-  _emberDataPrivateCore.default.Snapshot = _emberDataPrivateSystemSnapshot.default;
+    attrsOption: function (attr) {
+      var attrs = this.get('attrs');
+      return attrs && (attrs[camelize(attr)] || attrs[attr]);
+    },
 
-  _emberDataPrivateCore.default.Adapter = _emberDataAdapter.default;
+    /**
+     @method _extractEmbeddedRecords
+     @private
+    */
+    _extractEmbeddedRecords: function (serializer, store, typeClass, partial) {
+      var _this = this;
 
-  _emberDataPrivateCore.default.AdapterError = _emberDataPrivateAdaptersErrors.AdapterError;
-  _emberDataPrivateCore.default.InvalidError = _emberDataPrivateAdaptersErrors.InvalidError;
-  _emberDataPrivateCore.default.TimeoutError = _emberDataPrivateAdaptersErrors.TimeoutError;
-  _emberDataPrivateCore.default.AbortError = _emberDataPrivateAdaptersErrors.AbortError;
+      typeClass.eachRelationship(function (key, relationship) {
+        if (serializer.hasDeserializeRecordsOption(key)) {
+          if (relationship.kind === "hasMany") {
+            _this._extractEmbeddedHasMany(store, key, partial, relationship);
+          }
+          if (relationship.kind === "belongsTo") {
+            _this._extractEmbeddedBelongsTo(store, key, partial, relationship);
+          }
+        }
+      });
+      return partial;
+    },
 
-  _emberDataPrivateCore.default.errorsHashToArray = _emberDataPrivateAdaptersErrors.errorsHashToArray;
-  _emberDataPrivateCore.default.errorsArrayToHash = _emberDataPrivateAdaptersErrors.errorsArrayToHash;
+    /**
+     @method _extractEmbeddedHasMany
+     @private
+    */
+    _extractEmbeddedHasMany: function (store, key, hash, relationshipMeta) {
+      var relationshipHash = get(hash, 'data.relationships.' + key + '.data');
+
+      if (!relationshipHash) {
+        return;
+      }
 
-  _emberDataPrivateCore.default.Serializer = _emberDataPrivateSystemSerializer.default;
+      var hasMany = new Array(relationshipHash.length);
 
-  _emberDataPrivateCore.default.DebugAdapter = _emberDataPrivateSystemDebug.default;
+      for (var i = 0; i < relationshipHash.length; i++) {
+        var item = relationshipHash[i];
 
-  _emberDataPrivateCore.default.RecordArray = _emberDataPrivateSystemRecordArrays.RecordArray;
-  _emberDataPrivateCore.default.FilteredRecordArray = _emberDataPrivateSystemRecordArrays.FilteredRecordArray;
-  _emberDataPrivateCore.default.AdapterPopulatedRecordArray = _emberDataPrivateSystemRecordArrays.AdapterPopulatedRecordArray;
-  _emberDataPrivateCore.default.ManyArray = _emberDataPrivateSystemManyArray.default;
+        var _normalizeEmbeddedRelationship = this._normalizeEmbeddedRelationship(store, relationshipMeta, item);
 
-  _emberDataPrivateCore.default.RecordArrayManager = _emberDataPrivateSystemRecordArrayManager.default;
+        var data = _normalizeEmbeddedRelationship.data;
+        var included = _normalizeEmbeddedRelationship.included;
 
-  _emberDataPrivateCore.default.RESTAdapter = _emberDataPrivateAdapters.RESTAdapter;
-  _emberDataPrivateCore.default.BuildURLMixin = _emberDataPrivateAdaptersBuildUrlMixin.default;
+        hash.included = hash.included || [];
+        hash.included.push(data);
+        if (included) {
+          var _hash$included;
 
-  _emberDataPrivateCore.default.RESTSerializer = _emberDataPrivateSerializers.RESTSerializer;
-  _emberDataPrivateCore.default.JSONSerializer = _emberDataPrivateSerializers.JSONSerializer;
+          (_hash$included = hash.included).push.apply(_hash$included, _toConsumableArray(included));
+        }
 
-  _emberDataPrivateCore.default.JSONAPIAdapter = _emberDataPrivateAdapters.JSONAPIAdapter;
-  _emberDataPrivateCore.default.JSONAPISerializer = _emberDataPrivateSerializers.JSONAPISerializer;
+        hasMany[i] = { id: data.id, type: data.type };
+      }
 
-  _emberDataPrivateCore.default.Transform = _emberDataPrivateTransforms.Transform;
-  _emberDataPrivateCore.default.DateTransform = _emberDataPrivateTransforms.DateTransform;
-  _emberDataPrivateCore.default.StringTransform = _emberDataPrivateTransforms.StringTransform;
-  _emberDataPrivateCore.default.NumberTransform = _emberDataPrivateTransforms.NumberTransform;
-  _emberDataPrivateCore.default.BooleanTransform = _emberDataPrivateTransforms.BooleanTransform;
+      var relationship = { data: hasMany };
+      set(hash, 'data.relationships.' + key, relationship);
+    },
 
-  _emberDataPrivateCore.default.EmbeddedRecordsMixin = _emberDataPrivateSerializersEmbeddedRecordsMixin.default;
+    /**
+     @method _extractEmbeddedBelongsTo
+     @private
+    */
+    _extractEmbeddedBelongsTo: function (store, key, hash, relationshipMeta) {
+      var relationshipHash = get(hash, 'data.relationships.' + key + '.data');
+      if (!relationshipHash) {
+        return;
+      }
 
-  _emberDataPrivateCore.default.belongsTo = _emberDataRelationships.belongsTo;
-  _emberDataPrivateCore.default.hasMany = _emberDataRelationships.hasMany;
+      var _normalizeEmbeddedRelationship2 = this._normalizeEmbeddedRelationship(store, relationshipMeta, relationshipHash);
 
-  _emberDataPrivateCore.default.Relationship = _emberDataPrivateSystemRelationshipsStateRelationship.default;
+      var data = _normalizeEmbeddedRelationship2.data;
+      var included = _normalizeEmbeddedRelationship2.included;
 
-  _emberDataPrivateCore.default.ContainerProxy = _emberDataPrivateSystemContainerProxy.default;
+      hash.included = hash.included || [];
+      hash.included.push(data);
+      if (included) {
+        var _hash$included2;
 
-  _emberDataPrivateCore.default._setupContainer = _emberDataSetupContainer.default;
-  _emberDataPrivateCore.default._initializeStoreService = _emberDataPrivateInstanceInitializersInitializeStoreService.default;
+        (_hash$included2 = hash.included).push.apply(_hash$included2, _toConsumableArray(included));
+      }
 
-  Object.defineProperty(_emberDataPrivateCore.default, 'normalizeModelName', {
-    enumerable: true,
-    writable: false,
-    configurable: false,
-    value: _emberDataPrivateSystemNormalizeModelName.default
-  });
+      var belongsTo = { id: data.id, type: data.type };
+      var relationship = { data: belongsTo };
 
-  _ember.default.lookup.DS = _emberDataPrivateCore.default;
+      set(hash, 'data.relationships.' + key, relationship);
+    },
 
-  exports.default = _emberDataPrivateCore.default;
-});
-define("ember-data/model", ["exports", "ember-data/-private/system/model"], function (exports, _emberDataPrivateSystemModel) {
-  exports.default = _emberDataPrivateSystemModel.default;
-});
-define("ember-data/relationships", ["exports", "ember-data/-private/system/relationships/belongs-to", "ember-data/-private/system/relationships/has-many"], function (exports, _emberDataPrivateSystemRelationshipsBelongsTo, _emberDataPrivateSystemRelationshipsHasMany) {
-  exports.belongsTo = _emberDataPrivateSystemRelationshipsBelongsTo.default;
-  exports.hasMany = _emberDataPrivateSystemRelationshipsHasMany.default;
+    /**
+     @method _normalizeEmbeddedRelationship
+     @private
+    */
+    _normalizeEmbeddedRelationship: function (store, relationshipMeta, relationshipHash) {
+      var modelName = relationshipMeta.type;
+      if (relationshipMeta.options.polymorphic) {
+        modelName = relationshipHash.type;
+      }
+      var modelClass = store.modelFor(modelName);
+      var serializer = store.serializerFor(modelName);
+
+      return serializer.normalize(modelClass, relationshipHash, null);
+    }
+  });
 });
-/**
-  @module ember-data
-*/
 define('ember-data/serializers/json-api', ['exports', 'ember', 'ember-data/-private/debug', 'ember-data/serializers/json', 'ember-data/-private/system/normalize-model-name', 'ember-inflector'], function (exports, _ember, _emberDataPrivateDebug, _emberDataSerializersJson, _emberDataPrivateSystemNormalizeModelName, _emberInflector) {
 
   var dasherize = _ember.default.String.dasherize;
@@ -13438,7 +13485,7 @@ define('ember-data/serializers/json-api', ['exports', 'ember', 'ember-data/-priv
 /**
   @module ember-data
 */
-define('ember-data/serializers/json', ['exports', 'ember', 'ember-data/-private/debug', 'ember-data/-private/system/serializer', 'ember-data/-private/system/coerce-id', 'ember-data/-private/system/normalize-model-name', 'ember-data/-private/utils', 'ember-data/-private/adapters/errors'], function (exports, _ember, _emberDataPrivateDebug, _emberDataPrivateSystemSerializer, _emberDataPrivateSystemCoerceId, _emberDataPrivateSystemNormalizeModelName, _emberDataPrivateUtils, _emberDataPrivateAdaptersErrors) {
+define('ember-data/serializers/json', ['exports', 'ember', 'ember-data/-private/debug', 'ember-data/serializer', 'ember-data/-private/system/coerce-id', 'ember-data/-private/system/normalize-model-name', 'ember-data/-private/utils', 'ember-data/-private/adapters/errors'], function (exports, _ember, _emberDataPrivateDebug, _emberDataSerializer, _emberDataPrivateSystemCoerceId, _emberDataPrivateSystemNormalizeModelName, _emberDataPrivateUtils, _emberDataPrivateAdaptersErrors) {
   function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i]; return arr2; } else { return Array.from(arr); } }
 
   var get = _ember.default.get;
@@ -13511,7 +13558,7 @@ define('ember-data/serializers/json', ['exports', 'ember', 'ember-data/-private/
     @namespace DS
     @extends DS.Serializer
   */
-  exports.default = _emberDataPrivateSystemSerializer.default.extend({
+  exports.default = _emberDataSerializer.default.extend({
 
     /**
       The `primaryKey` is used when serializing and deserializing
@@ -15551,7 +15598,7 @@ define('ember-data/transform', ['exports', 'ember'], function (exports, _ember)
   });
 });
 define("ember-data/version", ["exports"], function (exports) {
-  exports.default = "2.4.0-beta.2";
+  exports.default = "2.4.0-beta.3";
 });
 define("ember-inflector", ["exports", "ember", "ember-inflector/lib/system", "ember-inflector/lib/ext/string"], function (exports, _ember, _emberInflectorLibSystem, _emberInflectorLibExtString) {
 
@@ -16022,10 +16069,12 @@ require("ember-data");
     var shims = {
       'ember-data':                          { default: DS },
       'ember-data/model':                    { default: DS.Model },
+      'ember-data/mixins/embedded-records':  { default: DS.EmbeddedRecordsMixin },
       'ember-data/serializers/rest':         { default: DS.RESTSerializer },
       'ember-data/serializers/active-model': { default: DS.ActiveModelSerializer },
       'ember-data/serializers/json':         { default: DS.JSONSerializer },
       'ember-data/serializers/json-api':     { default: DS.JSONAPISerializer },
+      'ember-data/serializer':               { default: DS.Serializer },
       'ember-data/adapters/json-api':        { default: DS.JSONAPIAdapter },
       'ember-data/adapters/rest':            { default: DS.RESTAdapter },
       'ember-data/adapter':                  { default: DS.Adapter },