ember-data-source 2.1.0 → 2.2.0.beta.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 727101b227d3db097ffa369152182fc4196baf16
-  data.tar.gz: 21ba24679969ed1db06f5c308e8c492a286d7feb
+  metadata.gz: 4b0d9026f83ded0e4079534260c2348ec0e75bb1
+  data.tar.gz: 5f797710c8eeb1f0705a4d349b5c3830f39b1ada
 SHA512:
-  metadata.gz: 87970d22f45fd8c390c8fa280b4f2ba29839519ea3d5388dc3742b84e45cfc4c035b882054b997740d75087150fdc227ee69775ee7ad2ecd9ddb2ce7eec4e227
-  data.tar.gz: eb573e937023d0075c6a77e131a44814dd5485b0f3ca120f2c7958fa2d34e5c37c03e76f299ba1678b577e039c87331e092b2ed171134ff85fb7163fb8b75b74
+  metadata.gz: a56fb9757405c7a8d1783774627ca30d0e417f1d3055836d02d8782297b31e2e46a907a6aab76208f11538128f52548d37d2e23b9d1882e626102bd80085cdc3
+  data.tar.gz: 25eea0b246c05bb969dc44b5bd0461b412ec55d575f8acb2bdec3891364ce8e535815b06cb5c4e6b76c7861fe666a99ea54441ddfb9ff1f50409b23b978d67f8

data/dist/ember-data-tests.js

@@ -7610,6 +7610,157 @@ define(
 );
 
 
+define(
+  "ember-data/tests/integration/polymorphic-belongs-to-test",
+  ["exports"],
+  function(__exports__) {
+    "use strict";
+
+    function __es6_export__(name, value) {
+      __exports__[name] = value;
+    }
+
+    var _DS = DS;
+    var attr = _DS.attr;
+    var belongsTo = _DS.belongsTo;
+    var _Ember = Ember;
+    var run = _Ember.run;
+
+    var store = undefined;
+
+    var Book = DS.Model.extend({
+      title: attr(),
+      author: belongsTo('person', { polymorphic: true, async: false })
+    });
+
+    var Author = DS.Model.extend({
+      name: attr()
+    });
+
+    var AsyncBook = DS.Model.extend({
+      author: belongsTo('person', { polymorphic: true })
+    });
+
+    module('integration/polymorphic-belongs-to - Polymorphic BelongsTo', {
+      setup: function () {
+        var env = setupStore({
+          book: Book,
+          author: Author,
+          'async-book': AsyncBook,
+          person: DS.Model.extend()
+        });
+        store = env.store;
+      },
+
+      teardown: function () {
+        run(store, 'destroy');
+      }
+    });
+
+    test('using store.push with a null value for a payload in relationships sets the Models relationship to null - sync relationship', function () {
+      var payload = {
+        data: {
+          type: 'book',
+          id: 1,
+          title: 'Yes, Please',
+          relationships: {
+            author: {
+              data: {
+                type: 'author',
+                id: 1
+              }
+            }
+          }
+        },
+        included: [{
+          id: 1,
+          name: 'Amy Poehler',
+          type: 'author'
+        }]
+      };
+
+      var book = run(function () {
+        store.push(payload);
+        return store.peekRecord('book', 1);
+      });
+
+      equal(book.get('author.id'), 1);
+
+      var payloadThatResetsBelongToRelationship = {
+        data: {
+          type: 'book',
+          id: 1,
+          title: 'Yes, Please',
+          relationships: {
+            author: {
+              data: null
+            }
+          }
+        }
+      };
+
+      run(function () {
+        return store.push(payloadThatResetsBelongToRelationship);
+      });
+      equal(book.get('author'), null);
+    });
+
+    test('using store.push with a null value for a payload in relationships sets the Models relationship to null - async relationship', function () {
+      var payload = {
+        data: {
+          type: 'async-book',
+          id: 1,
+          title: 'Yes, Please',
+          relationships: {
+            author: {
+              data: {
+                type: 'author',
+                id: 1
+              }
+            }
+          }
+        },
+        included: [{
+          id: 1,
+          name: 'Amy Poehler',
+          type: 'author'
+        }]
+      };
+
+      var book = run(function () {
+        store.push(payload);
+        return store.peekRecord('async-book', 1);
+      });
+
+      var payloadThatResetsBelongToRelationship = {
+        data: {
+          type: 'async-book',
+          id: 1,
+          title: 'Yes, Please',
+          relationships: {
+            author: {
+              data: null
+            }
+          }
+        }
+      };
+
+      stop();
+      book.get('author').then(function (author) {
+        equal(author.get('id'), 1);
+        run(function () {
+          return store.push(payloadThatResetsBelongToRelationship);
+        });
+        return book.get('author');
+      }).then(function (author) {
+        start();
+        equal(author, null);
+      });
+    });
+  }
+);
+
+
 define(
   "ember-data/tests/integration/record-array-manager-test",
   ["exports"],
@@ -17395,6 +17546,41 @@ define(
       });
     });
 
+    test("serialize with embedded objects and a custom keyForAttribute (hasMany relationship)", function () {
+      var tom, league;
+      run(function () {
+        league = env.store.createRecord('home-planet', { name: "Villain League", id: "123" });
+        tom = env.store.createRecord('super-villain', { firstName: "Tom", lastName: "Dale", homePlanet: league, id: '1' });
+      });
+
+      env.registry.register('serializer:home-planet', DS.RESTSerializer.extend(DS.EmbeddedRecordsMixin, {
+        keyForAttribute: function (key) {
+          return key + '-custom';
+        },
+        attrs: {
+          villains: { embedded: 'always' }
+        }
+      }));
+
+      var serializer, json;
+      run(function () {
+        serializer = env.store.serializerFor("home-planet");
+
+        json = serializer.serialize(league._createSnapshot());
+      });
+
+      deepEqual(json, {
+        "name-custom": "Villain League",
+        "villains-custom": [{
+          id: get(tom, "id"),
+          firstName: "Tom",
+          lastName: "Dale",
+          homePlanet: get(league, "id"),
+          secretLab: null
+        }]
+      });
+    });
+
     test("serialize with embedded objects (unknown hasMany relationship)", function () {
       var league;
       run(function () {
@@ -21273,37 +21459,34 @@ define(
       };
     }
 
-    module("integration/store - findRecord { reload: true }", {
-      setup: function () {
-        initializeStore(DS.RESTAdapter.extend());
-      }
-    });
+    module("integration/store - findRecord");
 
-    test("Using store#findRecord on non existing record fetches it from the server", function () {
+    test("store#findRecord fetches record from server when cached record is not present", function () {
       expect(2);
 
+      initializeStore(DS.RESTAdapter.extend());
+
       env.registry.register('serializer:application', DS.RESTSerializer);
       ajaxResponse({
         cars: [{
           id: 20,
-          make: 'BMCW',
+          make: 'BMC',
           model: 'Mini'
         }]
       });
 
-      var car = store.hasRecordForId('car', 20);
-      ok(!car, 'Car with id=20 should not exist');
+      var cachedRecordIsPresent = store.hasRecordForId('car', 20);
+      ok(!cachedRecordIsPresent, 'Car with id=20 should not exist');
 
       run(function () {
-        store.findRecord('car', 20, { reload: true }).then(function (car) {
-          equal(car.get('make'), 'BMCW', 'Car with id=20 is now loaded');
+        store.findRecord('car', 20).then(function (car) {
+          equal(car.get('make'), 'BMC', 'Car with id=20 is now loaded');
         });
       });
     });
 
-    test("Using store#findRecord on existing record reloads it", function () {
+    test("store#findRecord returns cached record immediately and reloads record in the background", function () {
       expect(2);
-      var car;
 
       run(function () {
         store.push({
@@ -21316,22 +21499,81 @@ define(
             }
           }
         });
-        car = store.peekRecord('car', 1);
       });
 
       ajaxResponse({
         cars: [{
           id: 1,
-          make: 'BMCW',
-          model: 'Mini'
+          make: 'BMC',
+          model: 'Princess'
+        }]
+      });
+
+      run(function () {
+        store.findRecord('car', 1).then(function (car) {
+          equal(car.get('model'), 'Mini', 'cached car record is returned');
+        });
+      });
+
+      run(function () {
+        var car = store.peekRecord('car', 1);
+        equal(car.get('model'), 'Princess', 'car record was reloaded');
+      });
+    });
+
+    test("store#findRecord { reload: true } ignores cached record and reloads record from server", function () {
+      expect(2);
+
+      var testAdapter = DS.RESTAdapter.extend({
+        shouldReloadRecord: function (store, type, id, snapshot) {
+          ok(false, 'shouldReloadRecord should not be called when { reload: true }');
+        }
+      });
+
+      initializeStore(testAdapter);
+
+      run(function () {
+        store.push({
+          data: {
+            type: 'car',
+            id: '1',
+            attributes: {
+              make: 'BMC',
+              model: 'Mini'
+            }
+          }
+        });
+      });
+
+      ajaxResponse({
+        cars: [{
+          id: 1,
+          make: 'BMC',
+          model: 'Princess'
         }]
       });
 
-      equal(car.get('make'), 'BMC');
+      var cachedCar = store.peekRecord('car', 1);
+      equal(cachedCar.get('model'), 'Mini', 'cached car has expected model');
 
       run(function () {
         store.findRecord('car', 1, { reload: true }).then(function (car) {
-          equal(car.get('make'), 'BMCW');
+          equal(car.get('model'), 'Princess', 'cached record ignored, record reloaded via server');
+        });
+      });
+    });
+
+    test('store#findRecord call with `id` of type different than non-empty string or number should trigger an assertion', function (assert) {
+      var badValues = ['', undefined, null, NaN, false];
+      assert.expect(badValues.length);
+
+      initializeStore(DS.RESTAdapter.extend());
+
+      run(function () {
+        badValues.map(function (item) {
+          expectAssertion(function () {
+            store.findRecord('car', item);
+          }, '`id` has to be non-empty string or number');
         });
       });
     });
@@ -28644,33 +28886,6 @@ define(
         store.adapterFor(Person);
       }, /Passing classes to store.adapterFor has been removed/);
     });
-
-    module("unit/store/adapter_interop - find preload deprecations", {
-      setup: function () {
-        var Person = DS.Model.extend({
-          name: DS.attr('string')
-        });
-
-        var TestAdapter = DS.Adapter.extend({
-          findRecord: function (store, type, id, snapshot) {
-            equal(snapshot.attr('name'), 'Tom');
-            return Ember.RSVP.resolve({ id: id });
-          }
-        });
-
-        store = createStore({
-          adapter: TestAdapter,
-          person: Person
-        });
-      },
-      teardown: function () {
-        run(function () {
-          if (store) {
-            store.destroy();
-          }
-        });
-      }
-    });
   }
 );
 
@@ -30673,13 +30888,6 @@ QUnit.test('ember-data/lib/system/many-array.js should pass jshint', function(as
   assert.ok(true, 'ember-data/lib/system/many-array.js should pass jshint.'); 
 });
 
-}
-if (!QUnit.urlParams.nojshint) {
-QUnit.module('JSHint - ember-data/lib/system');
-QUnit.test('ember-data/lib/system/map.js should pass jshint', function(assert) { 
-  assert.ok(true, 'ember-data/lib/system/map.js should pass jshint.'); 
-});
-
 }
 if (!QUnit.urlParams.nojshint) {
 QUnit.module('JSHint - ember-data/lib/system');
@@ -31107,6 +31315,13 @@ QUnit.test('ember-data/tests/integration/peek-all-test.js should pass jshint', f
   assert.ok(true, 'ember-data/tests/integration/peek-all-test.js should pass jshint.'); 
 });
 
+}
+if (!QUnit.urlParams.nojshint) {
+QUnit.module('JSHint - ember-data/tests/integration');
+QUnit.test('ember-data/tests/integration/polymorphic-belongs-to-test.js should pass jshint', function(assert) { 
+  assert.ok(true, 'ember-data/tests/integration/polymorphic-belongs-to-test.js should pass jshint.'); 
+});
+
 }
 if (!QUnit.urlParams.nojshint) {
 QUnit.module('JSHint - ember-data/tests/integration');

data/dist/ember-data.js

@@ -878,10 +878,6 @@
     });
 
     var ember$data$lib$system$adapter$$default = ember$data$lib$system$adapter$$Adapter;
-    var ember$data$lib$system$map$$Map = Ember.Map;
-    var ember$data$lib$system$map$$MapWithDefault = Ember.MapWithDefault;
-
-    var ember$data$lib$system$map$$default = ember$data$lib$system$map$$Map;
     var ember$data$lib$system$empty$object$$default = ember$data$lib$system$empty$object$$EmptyObject;
     // This exists because `Object.create(null)` is absurdly slow compared
     // to `new EmptyObject()`. In either case, you want a null prototype
@@ -1075,7 +1071,8 @@
       @extends DS.Adapter
       @uses DS.BuildURLMixin
     */
-    var ember$data$lib$adapters$rest$adapter$$get = Ember.get;var ember$data$lib$adapters$rest$adapter$$RESTAdapter = ember$data$lib$system$adapter$$default.extend(ember$data$lib$adapters$build$url$mixin$$default, {
+    var ember$data$lib$adapters$rest$adapter$$get = Ember.get;
+    var ember$data$lib$adapters$rest$adapter$$MapWithDefault = Ember.MapWithDefault;var ember$data$lib$adapters$rest$adapter$$RESTAdapter = ember$data$lib$system$adapter$$default.extend(ember$data$lib$adapters$build$url$mixin$$default, {
       defaultSerializer: '-rest',
 
       /**
@@ -1490,7 +1487,7 @@
                           loaded separately by `findMany`.
       */
       groupRecordsForFindMany: function (store, snapshots) {
-        var groups = ember$data$lib$system$map$$MapWithDefault.create({ defaultValue: function () {
+        var groups = ember$data$lib$adapters$rest$adapter$$MapWithDefault.create({ defaultValue: function () {
             return [];
           } });
         var adapter = this;
@@ -1871,7 +1868,7 @@
     });
 
     var ember$data$lib$core$$DS = Ember.Namespace.create({
-      VERSION: '2.1.0'
+      VERSION: '2.2.0-beta.1'
     });
 
     if (Ember.libraries) {
@@ -2070,99 +2067,13 @@
 
     function ember$data$lib$system$store$common$$_objectIsAlive(object) {
       return !(ember$data$lib$system$store$common$$get(object, "isDestroyed") || ember$data$lib$system$store$common$$get(object, "isDestroying"));
-    }
-
-    /**
-    @module ember-data
-    */
-
-    /**
-      Holds validation errors for a given record organized by attribute names.
-
-      Every DS.Model has an `errors` property that is an instance of
-      `DS.Errors`. This can be used to display validation error
-      messages returned from the server when a `record.save()` rejects.
-      This works automatically with `DS.ActiveModelAdapter`, but you
-      can implement [ajaxError](/api/data/classes/DS.RESTAdapter.html#method_ajaxError)
-      in other adapters as well.
-
-      For Example, if you had an `User` model that looked like this:
-
-      ```app/models/user.js
-      import DS from 'ember-data';
-
-      export default DS.Model.extend({
-        username: attr('string'),
-        email: attr('string')
-      });
-      ```
-      And you attempted to save a record that did not validate on the backend.
-
-      ```javascript
-      var user = store.createRecord('user', {
-        username: 'tomster',
-        email: 'invalidEmail'
-      });
-      user.save();
-      ```
-
-      Your backend data store might return a response that looks like
-      this. This response will be used to populate the error object.
-
-      ```javascript
-      {
-        "errors": {
-          "username": ["This username is already taken!"],
-          "email": ["Doesn't look like a valid email."]
-        }
-      }
-      ```
-
-      Errors can be displayed to the user by accessing their property name
-      to get an array of all the error objects for that property. Each
-      error object is a JavaScript object with two keys:
-
-      - `message` A string containing the error message from the backend
-      - `attribute` The name of the property associated with this error message
-
-      ```handlebars
-      <label>Username: {{input value=username}} </label>
-      {{#each model.errors.username as |error|}}
-        <div class="error">
-          {{error.message}}
-        </div>
-      {{/each}}
-
-      <label>Email: {{input value=email}} </label>
-      {{#each model.errors.email as |error|}}
-        <div class="error">
-          {{error.message}}
-        </div>
-      {{/each}}
-      ```
-
-      You can also access the special `messages` property on the error
-      object to get an array of all the error strings.
-
-      ```handlebars
-      {{#each model.errors.messages as |message|}}
-        <div class="error">
-          {{message}}
-        </div>
-      {{/each}}
-      ```
-
-      @class Errors
-      @namespace DS
-      @extends Ember.Object
-      @uses Ember.Enumerable
-      @uses Ember.Evented
-     */
-    var ember$data$lib$system$model$errors$$get = Ember.get;
+    }var ember$data$lib$system$model$errors$$get = Ember.get;
     var ember$data$lib$system$model$errors$$set = Ember.set;
     var ember$data$lib$system$model$errors$$isEmpty = Ember.isEmpty;
     var ember$data$lib$system$model$errors$$makeArray = Ember.makeArray;
 
+    var ember$data$lib$system$model$errors$$MapWithDefault = Ember.MapWithDefault;
+
     var ember$data$lib$system$model$errors$$default = Ember.ArrayProxy.extend(Ember.Evented, {
       /**
         Register with target handler
@@ -2182,7 +2093,7 @@
         @private
       */
       errorsByAttributeName: Ember.computed(function () {
-        return ember$data$lib$system$map$$MapWithDefault.create({
+        return ember$data$lib$system$model$errors$$MapWithDefault.create({
           defaultValue: function () {
             return Ember.A();
           }
@@ -4007,19 +3918,19 @@
 
       return this;
     };
-    var ember$data$lib$system$record$array$manager$$get = Ember.get;
+    var ember$data$lib$system$record$array$manager$$MapWithDefault = Ember.MapWithDefault;var ember$data$lib$system$record$array$manager$$get = Ember.get;
 
     var ember$data$lib$system$record$array$manager$$default = Ember.Object.extend({
       init: function () {
         var _this = this;
 
-        this.filteredRecordArrays = ember$data$lib$system$map$$MapWithDefault.create({
+        this.filteredRecordArrays = ember$data$lib$system$record$array$manager$$MapWithDefault.create({
           defaultValue: function () {
             return [];
           }
         });
 
-        this.liveRecordArrays = ember$data$lib$system$map$$MapWithDefault.create({
+        this.liveRecordArrays = ember$data$lib$system$record$array$manager$$MapWithDefault.create({
           defaultValue: function (typeClass) {
             return _this.createRecordArray(typeClass);
           }
@@ -6456,6 +6367,7 @@
       this.isReloading = false;
       this.isError = false;
       this.error = null;
+      this.__ember_meta__ = null;
       this[Ember.GUID_KEY] = ember$data$lib$system$model$internal$model$$guid++ + 'internal-model';
       /*
         implicit relationships are relationship which have not been declared but the inverse side exists on
@@ -7134,7 +7046,10 @@
       }
     };
 
+    var ember$data$lib$system$store$$badIdFormatAssertion = '`id` has to be non-empty string or number';
+
     var ember$data$lib$system$store$$Backburner = Ember._Backburner || Ember.Backburner || Ember.__loader.require('backburner')['default'] || Ember.__loader.require('backburner')['Backburner'];
+    var ember$data$lib$system$store$$Map = Ember.Map;
 
     //Shim Backburner.join
     if (!ember$data$lib$system$store$$Backburner.prototype.join) {
@@ -7304,7 +7219,7 @@
         this._pendingSave = [];
         this._instanceCache = new ember$data$lib$system$store$container$instance$cache$$default(this.container);
         //Used to keep track of all the find requests that need to be coalesced
-        this._pendingFetch = ember$data$lib$system$map$$Map.create();
+        this._pendingFetch = ember$data$lib$system$store$$Map.create();
       },
 
       /**
@@ -7546,6 +7461,8 @@
       */
       findRecord: function (modelName, id, options) {
         Ember.assert('Passing classes to store methods has been removed. Please pass a dasherized string instead of ' + Ember.inspect(modelName), typeof modelName === 'string');
+        Ember.assert(ember$data$lib$system$store$$badIdFormatAssertion, typeof id === 'string' && id.length > 0 || typeof id === 'number' && !isNaN(id));
+
         var internalModel = this._internalModelForId(modelName, id);
         options = options || {};
 
@@ -7687,7 +7604,7 @@
         }
 
         this._pendingFetch.forEach(this._flushPendingFetchForType, this);
-        this._pendingFetch = ember$data$lib$system$map$$Map.create();
+        this._pendingFetch = ember$data$lib$system$store$$Map.create();
       },
 
       _flushPendingFetchForType: function (pendingFetchItems, typeClass) {
@@ -12010,6 +11927,7 @@
     */
 
     var ember$data$lib$system$model$attributes$$get = Ember.get;
+    var ember$data$lib$system$model$attributes$$Map = Ember.Map;
 
     /**
       @class Model
@@ -12049,7 +11967,7 @@
       attributes: Ember.computed(function () {
         var _this = this;
 
-        var map = ember$data$lib$system$map$$Map.create();
+        var map = ember$data$lib$system$model$attributes$$Map.create();
 
         this.eachComputedProperty(function (name, meta) {
           if (meta.isAttribute) {
@@ -12094,7 +12012,7 @@
         @readOnly
       */
       transformedAttributes: Ember.computed(function () {
-        var map = ember$data$lib$system$map$$Map.create();
+        var map = ember$data$lib$system$model$attributes$$Map.create();
 
         this.eachAttribute(function (key, meta) {
           if (meta.type) {
@@ -12887,13 +12805,18 @@
             json[key] = embeddedSnapshot.id;
           }
         } else if (includeRecords) {
-          key = this.keyForAttribute(attr, 'serialize');
-          if (!embeddedSnapshot) {
-            json[key] = null;
-          } else {
-            json[key] = embeddedSnapshot.record.serialize({ includeId: true });
-            this.removeEmbeddedForeignKey(snapshot, embeddedSnapshot, relationship, json[key]);
-          }
+          this._serializeEmbeddedBelongsTo(snapshot, json, relationship);
+        }
+      },
+
+      _serializeEmbeddedBelongsTo: function (snapshot, json, relationship) {
+        var embeddedSnapshot = snapshot.belongsTo(relationship.key);
+        var serializedKey = this.keyForAttribute(relationship.key, 'serialize');
+        if (!embeddedSnapshot) {
+          json[serializedKey] = null;
+        } else {
+          json[serializedKey] = embeddedSnapshot.record.serialize({ includeId: true });
+          this.removeEmbeddedForeignKey(snapshot, embeddedSnapshot, relationship, json[serializedKey]);
         }
       },
 
@@ -12968,8 +12891,6 @@
         @param {Object} relationship
       */
       serializeHasMany: function (snapshot, json, relationship) {
-        var _this = this;
-
         var attr = relationship.key;
         if (this.noSerializeOptionSpecified(attr)) {
           this._super(snapshot, json, relationship);
@@ -12977,22 +12898,34 @@
         }
         var includeIds = this.hasSerializeIdsOption(attr);
         var includeRecords = this.hasSerializeRecordsOption(attr);
-        var key, hasMany;
         if (includeIds) {
-          key = this.keyForRelationship(attr, relationship.kind, 'serialize');
-          json[key] = snapshot.hasMany(attr, { ids: true });
+          var serializedKey = this.keyForRelationship(attr, relationship.kind, 'serialize');
+          json[serializedKey] = snapshot.hasMany(attr, { ids: true });
         } else if (includeRecords) {
-          key = this.keyForAttribute(attr, 'serialize');
-          hasMany = snapshot.hasMany(attr);
+          this._serializeEmbeddedHasMany(snapshot, json, relationship);
+        }
+      },
 
-          Ember.warn('The embedded relationship \'' + key + '\' is undefined for \'' + snapshot.modelName + '\' with id \'' + snapshot.id + '\'. Please include it in your original payload.', Ember.typeOf(hasMany) !== 'undefined', { id: 'ds.serializer.embedded-relationship-undefined' });
+      _serializeEmbeddedHasMany: function (snapshot, json, relationship) {
+        var serializedKey = this.keyForAttribute(relationship.key, 'serialize');
 
-          json[key] = Ember.A(hasMany).map(function (embeddedSnapshot) {
-            var embeddedJson = embeddedSnapshot.record.serialize({ includeId: true });
-            _this.removeEmbeddedForeignKey(snapshot, embeddedSnapshot, relationship, embeddedJson);
-            return embeddedJson;
-          });
-        }
+        Ember.warn('The embedded relationship \'' + serializedKey + '\' is undefined for \'' + snapshot.modelName + '\' with id \'' + snapshot.id + '\'. Please include it in your original payload.', Ember.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 _this = this;
+
+        var hasMany = snapshot.hasMany(relationship.key);
+        return Ember.A(hasMany).map(function (embeddedSnapshot) {
+          var embeddedJson = embeddedSnapshot.record.serialize({ includeId: true });
+          _this.removeEmbeddedForeignKey(snapshot, embeddedSnapshot, relationship, embeddedJson);
+          return embeddedJson;
+        });
       },
 
       /**
@@ -13519,13 +13452,15 @@
     }
 
     var ember$data$lib$system$relationships$ext$$get = Ember.get;
+    var ember$data$lib$system$relationships$ext$$Map = Ember.Map;
+    var ember$data$lib$system$relationships$ext$$MapWithDefault = Ember.MapWithDefault;
 
     var ember$data$lib$system$relationships$ext$$relationshipsDescriptor = Ember.computed(function () {
       if (Ember.testing === true && ember$data$lib$system$relationships$ext$$relationshipsDescriptor._cacheable === true) {
         ember$data$lib$system$relationships$ext$$relationshipsDescriptor._cacheable = false;
       }
 
-      var map = new ember$data$lib$system$map$$MapWithDefault({
+      var map = new ember$data$lib$system$relationships$ext$$MapWithDefault({
         defaultValue: function () {
           return [];
         }
@@ -13584,7 +13519,7 @@
         ember$data$lib$system$relationships$ext$$relationshipsByNameDescriptor._cacheable = false;
       }
 
-      var map = ember$data$lib$system$map$$Map.create();
+      var map = ember$data$lib$system$relationships$ext$$Map.create();
 
       this.eachComputedProperty(function (name, meta) {
         if (meta.isRelationship) {
@@ -13986,7 +13921,7 @@
         @readOnly
       */
       fields: Ember.computed(function () {
-        var map = ember$data$lib$system$map$$Map.create();
+        var map = ember$data$lib$system$relationships$ext$$Map.create();
 
         this.eachComputedProperty(function (name, meta) {
           if (meta.isRelationship) {