ember-data-source 1.0.0.beta.9 → 1.0.0.beta.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6a48704e2c701be6be7456d067208521f2182a63
-  data.tar.gz: 264a82a1605a51829f7c203fed1615e56802df15
+  metadata.gz: f48e9de804e7633cde2ee245cb9c063c804d72b1
+  data.tar.gz: c15a96192b9ebd3fc000f41cb44596d6e781eb26
 SHA512:
-  metadata.gz: 8aea6e81d77b2cbe3750cdc9f6e2e1acf9413b552e124ccd5a28104036c3b2ca1b721d609a55437dc808064ca7b7d307bdd1a673a7f957758ae2ab13a945599b
-  data.tar.gz: 59b43228d51f4eeb8dff6e9ffad468a7f8bf3a33c9c406717cc5872b34acf5cce4e34c8809da56735a66e04fe83404e5e4c4b43c6734982aff925d9caffe5799
+  metadata.gz: 1c362c04dfee3d2950f41d76ade8f8d9ec631d19a7f7b5eba29333d7637b2f50c7385518a1a333eb6afe9c5fd2d272fe398db04a1054a1b737c5134258643759
+  data.tar.gz: 0751401cf62b2d2e9d0ebc4e106aa8dbe858150facbfb28e1a8721bad1af95c3a9ffea2a554e10f7d88bedc635de9265db5587ae16a8c907e9addcf80c50940b

data/dist/ember-data.js

@@ -2,26 +2,10 @@
 var define, requireModule, require, requirejs;
 
 (function() {
-
-  var _isArray;
-  if (!Array.isArray) {
-    _isArray = function (x) {
-      return Object.prototype.toString.call(x) === "[object Array]";
-    };
-  } else {
-    _isArray = Array.isArray;
-  }
-  
   var registry = {}, seen = {}, state = {};
   var FAILED = false;
 
   define = function(name, deps, callback) {
-  
-    if (!_isArray(deps)) {
-      callback = deps;
-      deps     =  [];
-    }
-  
     registry[name] = {
       deps: deps,
       callback: callback
@@ -150,13 +134,12 @@ define("activemodel-adapter/system",
     __exports__.ActiveModelSerializer = ActiveModelSerializer;
   });
 define("activemodel-adapter/system/active_model_adapter",
-  ["ember-data/adapters","ember-data/system/adapter","ember-inflector","activemodel-adapter/system/active_model_serializer","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
+  ["ember-data/adapters","ember-data/system/adapter","ember-inflector","exports"],
+  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
     "use strict";
     var RESTAdapter = __dependency1__.RESTAdapter;
     var InvalidError = __dependency2__.InvalidError;
     var pluralize = __dependency3__.pluralize;
-    var ActiveModelSerializer = __dependency4__["default"];
 
     /**
       @module ember-data
@@ -615,8 +598,8 @@ define("activemodel-adapter/system/active_model_serializer",
     __exports__["default"] = ActiveModelSerializer;
   });
 define("ember-data",
-  ["ember-data/core","ember-data/ext/date","ember-data/system/store","ember-data/system/model","ember-data/system/changes","ember-data/system/adapter","ember-data/system/debug","ember-data/system/record_arrays","ember-data/system/record_array_manager","ember-data/adapters","ember-data/serializers/json_serializer","ember-data/serializers/rest_serializer","ember-inflector","ember-data/serializers/embedded_records_mixin","activemodel-adapter","ember-data/transforms","ember-data/system/relationships","ember-data/ember-initializer","ember-data/setup-container","ember-data/system/container_proxy","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __dependency13__, __dependency14__, __dependency15__, __dependency16__, __dependency17__, __dependency18__, __dependency19__, __dependency20__, __exports__) {
+  ["ember-data/core","ember-data/ext/date","ember-data/system/promise_proxies","ember-data/system/store","ember-data/system/model","ember-data/system/adapter","ember-data/system/debug","ember-data/system/record_arrays","ember-data/system/record_array_manager","ember-data/adapters","ember-data/serializers/json_serializer","ember-data/serializers/rest_serializer","ember-inflector","ember-data/serializers/embedded_records_mixin","activemodel-adapter","ember-data/transforms","ember-data/system/relationships","ember-data/ember-initializer","ember-data/setup-container","ember-data/system/container_proxy","ember-data/system/relationships/relationship","exports"],
+  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __dependency13__, __dependency14__, __dependency15__, __dependency16__, __dependency17__, __dependency18__, __dependency19__, __dependency20__, __dependency21__, __exports__) {
     "use strict";
     /**
       Ember Data
@@ -630,21 +613,13 @@ define("ember-data",
 
     var DS = __dependency1__["default"];
 
-    var Store = __dependency3__.Store;
     var PromiseArray = __dependency3__.PromiseArray;
     var PromiseObject = __dependency3__.PromiseObject;
-    var Model = __dependency4__.Model;
-    var Errors = __dependency4__.Errors;
-    var RootState = __dependency4__.RootState;
-    var attr = __dependency4__.attr;
-    var AttributeChange = __dependency5__.AttributeChange;
-    var RelationshipChange = __dependency5__.RelationshipChange;
-    var RelationshipChangeAdd = __dependency5__.RelationshipChangeAdd;
-    var RelationshipChangeRemove = __dependency5__.RelationshipChangeRemove;
-    var OneToManyChange = __dependency5__.OneToManyChange;
-    var ManyToNoneChange = __dependency5__.ManyToNoneChange;
-    var OneToOneChange = __dependency5__.OneToOneChange;
-    var ManyToManyChange = __dependency5__.ManyToManyChange;
+    var Store = __dependency4__.Store;
+    var Model = __dependency5__.Model;
+    var Errors = __dependency5__.Errors;
+    var RootState = __dependency5__.RootState;
+    var attr = __dependency5__.attr;
     var InvalidError = __dependency6__.InvalidError;
     var Adapter = __dependency6__.Adapter;
     var DebugAdapter = __dependency7__["default"];
@@ -672,6 +647,7 @@ define("ember-data",
     var setupContainer = __dependency19__["default"];
 
     var ContainerProxy = __dependency20__["default"];
+    var Relationship = __dependency21__.Relationship;
 
     DS.Store         = Store;
     DS.PromiseArray  = PromiseArray;
@@ -682,14 +658,6 @@ define("ember-data",
     DS.attr      = attr;
     DS.Errors    = Errors;
 
-    DS.AttributeChange       = AttributeChange;
-    DS.RelationshipChange    = RelationshipChange;
-    DS.RelationshipChangeAdd = RelationshipChangeAdd;
-    DS.OneToManyChange       = OneToManyChange;
-    DS.ManyToNoneChange      = OneToManyChange;
-    DS.OneToOneChange        = OneToOneChange;
-    DS.ManyToManyChange      = ManyToManyChange;
-
     DS.Adapter      = Adapter;
     DS.InvalidError = InvalidError;
 
@@ -721,6 +689,8 @@ define("ember-data",
     DS.belongsTo = belongsTo;
     DS.hasMany   = hasMany;
 
+    DS.Relationship  = Relationship;
+
     DS.ContainerProxy = ContainerProxy;
 
     DS._setupContainer = setupContainer;
@@ -1072,15 +1042,16 @@ define("ember-data/adapters/fixture_adapter",
         var adapter = this;
 
         return new Ember.RSVP.Promise(function(resolve) {
+          var value = Ember.copy(callback.call(context), true);
           if (get(adapter, 'simulateRemoteResponse')) {
             // Schedule with setTimeout
             Ember.run.later(function() {
-              resolve(callback.call(context));
+              resolve(value);
             }, get(adapter, 'latency'));
           } else {
             // Asynchronous, but at the of the runloop with zero latency
             Ember.run.schedule('actions', null, function() {
-              resolve(callback.call(context));
+              resolve(value);
             });
           }
         }, "DS: FixtureAdapter#simulateRemoteCall");
@@ -1095,7 +1066,8 @@ define("ember-data/adapters/rest_adapter",
       @module ember-data
     */
 
-    var Adapter = __dependency1__["default"];
+    var Adapter = __dependency1__.Adapter;
+    var InvalidError = __dependency1__.InvalidError;
     var get = Ember.get;
     var forEach = Ember.ArrayPolyfills.forEach;
 
@@ -1482,7 +1454,7 @@ define("ember-data/adapters/rest_adapter",
         @param {String} url
         @return {Promise} promise
       */
-      findHasMany: function(store, record, url) {
+      findHasMany: function(store, record, url, relationship) {
         var host = get(this, 'host');
         var id   = get(record, 'id');
         var type = record.constructor.typeKey;
@@ -1521,7 +1493,7 @@ define("ember-data/adapters/rest_adapter",
         @param {String} url
         @return {Promise} promise
       */
-      findBelongsTo: function(store, record, url) {
+      findBelongsTo: function(store, record, url, relationship) {
         var id   = get(record, 'id');
         var type = record.constructor.typeKey;
 
@@ -1812,9 +1784,10 @@ define("ember-data/adapters/rest_adapter",
 
         @method ajaxError
         @param  {Object} jqXHR
+        @param  {Object} responseText
         @return {Object} jqXHR
       */
-      ajaxError: function(jqXHR) {
+      ajaxError: function(jqXHR, responseText) {
         if (jqXHR && typeof jqXHR === 'object') {
           jqXHR.then = null;
         }
@@ -1822,6 +1795,32 @@ define("ember-data/adapters/rest_adapter",
         return jqXHR;
       },
 
+      /**
+        Takes an ajax response, and returns the json payload.
+
+        By default this hook just returns the jsonPayload passed to it.
+        You might want to override it in two cases:
+
+        1. Your API might return useful results in the request headers.
+        If you need to access these, you can override this hook to copy them
+        from jqXHR to the payload object so they can be processed in you serializer.
+
+
+        2. Your API might return errors as successful responses with status code
+        200 and an Errors text or object. You can return a DS.InvalidError from
+        this hook and it will automatically reject the promise and put your record
+        into the invald state.
+
+        @method ajaxError
+        @param  {Object} jqXHR
+        @param  {Object} jsonPayload
+        @return {Object} jqXHR
+      */
+
+      ajaxSuccess: function(jqXHR, jsonPayload) {
+        return jsonPayload;
+      },
+
       /**
         Takes a URL, an HTTP method and a hash of data, and makes an
         HTTP request.
@@ -1852,12 +1851,17 @@ define("ember-data/adapters/rest_adapter",
         return new Ember.RSVP.Promise(function(resolve, reject) {
           var hash = adapter.ajaxOptions(url, type, options);
 
-          hash.success = function(json) {
-            Ember.run(null, resolve, json);
+          hash.success = function(json, textStatus, jqXHR) {
+            json = adapter.ajaxSuccess(jqXHR, json);
+            if (json instanceof InvalidError) {
+              Ember.run(null, reject, json);
+            } else {
+              Ember.run(null, resolve, json);
+            }
           };
 
           hash.error = function(jqXHR, textStatus, errorThrown) {
-            Ember.run(null, reject, adapter.ajaxError(jqXHR));
+            Ember.run(null, reject, adapter.ajaxError(jqXHR, jqXHR.responseText));
           };
 
           Ember.$.ajax(hash);
@@ -1925,11 +1929,11 @@ define("ember-data/core",
       /**
         @property VERSION
         @type String
-        @default '1.0.0-beta.9'
+        @default '1.0.0-beta.10'
         @static
       */
       DS = Ember.Namespace.create({
-        VERSION: '1.0.0-beta.9'
+        VERSION: '1.0.0-beta.10'
       });
 
       if (Ember.libraries) {
@@ -2200,15 +2204,13 @@ define("ember-data/serializers",
     __exports__.RESTSerializer = RESTSerializer;
   });
 define("ember-data/serializers/embedded_records_mixin",
-  ["ember-inflector","exports"],
-  function(__dependency1__, __exports__) {
+  ["exports"],
+  function(__exports__) {
     "use strict";
     var get = Ember.get;
     var forEach = Ember.EnumerableUtils.forEach;
     var camelize = Ember.String.camelize;
 
-    var pluralize = __dependency1__.pluralize;
-
     /**
       ## Using Embedded Records
 
@@ -2227,6 +2229,11 @@ define("ember-data/serializers/embedded_records_mixin",
         }
       })
       ```
+      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:
 
@@ -2260,7 +2267,11 @@ define("ember-data/serializers/embedded_records_mixin",
 
       ### Model Relationships
 
-      Embedded records must have a model defined to be extracted and serialized.
+      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.  If a model is
+      declared embedded, then do not use `async:true`.
 
       To successfully extract and serialize embedded records the model relationships
       must be setup correcty See the
@@ -2272,9 +2283,9 @@ define("ember-data/serializers/embedded_records_mixin",
 
       ### Example JSON payloads, Models and Serializers
 
-      **When customizing a serializer it is imporant to grok what the cusomizations
-      are, please read the docs for the methods this mixin provides, in case you need
-      to modify to fit your specific needs.**
+      **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)
@@ -2377,7 +2388,6 @@ define("ember-data/serializers/embedded_records_mixin",
       */
       serializeBelongsTo: function(record, json, relationship) {
         var attr = relationship.key;
-        var attrs = this.get('attrs');
         if (this.noSerializeOptionSpecified(attr)) {
           this._super(record, json, relationship);
           return;
@@ -2487,7 +2497,6 @@ define("ember-data/serializers/embedded_records_mixin",
       */
       serializeHasMany: function(record, json, relationship) {
         var attr = relationship.key;
-        var attrs = this.get('attrs');
         if (this.noSerializeOptionSpecified(attr)) {
           this._super(record, json, relationship);
           return;
@@ -2562,8 +2571,6 @@ define("ember-data/serializers/embedded_records_mixin",
       // checks config for attrs option to serialize records
       noSerializeOptionSpecified: function(attr) {
         var option = this.attrsOption(attr);
-        var serializeRecords = this.hasSerializeRecordsOption(attr);
-        var serializeIds = this.hasSerializeIdsOption(attr);
         return !(option && (option.serialize || option.embedded));
       },
 
@@ -2590,7 +2597,12 @@ define("ember-data/serializers/embedded_records_mixin",
         if (serializer.hasDeserializeRecordsOption(key)) {
           var embeddedType = store.modelFor(relationship.type.typeKey);
           if (relationship.kind === "hasMany") {
-            extractEmbeddedHasMany(store, key, embeddedType, partial);
+            if (relationship.options.polymorphic) {
+              extractEmbeddedHasManyPolymorphic(store, key, partial);
+            }
+            else {
+              extractEmbeddedHasMany(store, key, embeddedType, partial);
+            }
           }
           if (relationship.kind === "belongsTo") {
             extractEmbeddedBelongsTo(store, key, embeddedType, partial);
@@ -2620,6 +2632,28 @@ define("ember-data/serializers/embedded_records_mixin",
       return hash;
     }
 
+    function extractEmbeddedHasManyPolymorphic(store, key, hash) {
+      if (!hash[key]) {
+        return hash;
+      }
+
+      var ids = [];
+
+      forEach(hash[key], function(data) {
+        var typeKey = data.type;
+        var embeddedSerializer = store.serializerFor(typeKey);
+        var embeddedType = store.modelFor(typeKey);
+        var primaryKey = get(embeddedSerializer, 'primaryKey');
+
+        var embeddedRecord = embeddedSerializer.normalize(embeddedType, data, null);
+        store.push(embeddedType, embeddedRecord);
+        ids.push({ id: embeddedRecord[primaryKey], type: typeKey });
+      });
+
+      hash[key] = ids;
+      return hash;
+    }
+
     function extractEmbeddedBelongsTo(store, key, embeddedType, hash) {
       if (!hash[key]) {
         return hash;
@@ -2637,12 +2671,10 @@ define("ember-data/serializers/embedded_records_mixin",
     __exports__["default"] = EmbeddedRecordsMixin;
   });
 define("ember-data/serializers/json_serializer",
-  ["ember-data/system/changes","exports"],
-  function(__dependency1__, __exports__) {
+  ["exports"],
+  function(__exports__) {
     "use strict";
-    var RelationshipChange = __dependency1__.RelationshipChange;
     var get = Ember.get;
-    var set = Ember.set;
     var isNone = Ember.isNone;
     var map = Ember.ArrayPolyfills.map;
     var merge = Ember.merge;
@@ -2752,7 +2784,7 @@ define("ember-data/serializers/json_serializer",
        @return {Object} data The transformed data object
       */
       applyTransforms: function(type, data) {
-        type.eachTransformedAttribute(function(key, type) {
+        type.eachTransformedAttribute(function applyTransform(key, type) {
           if (!data.hasOwnProperty(key)) { return; }
 
           var transform = this.transformFor(type);
@@ -2838,7 +2870,7 @@ define("ember-data/serializers/json_serializer",
         @private
       */
       normalizeAttributes: function(type, hash) {
-        var payloadKey, key;
+        var payloadKey;
 
         if (this.keyForAttribute) {
           type.eachAttribute(function(key) {
@@ -2857,7 +2889,7 @@ define("ember-data/serializers/json_serializer",
         @private
       */
       normalizeRelationships: function(type, hash) {
-        var payloadKey, key;
+        var payloadKey;
 
         if (this.keyForRelationship) {
           type.eachRelationship(function(key, relationship) {
@@ -3276,7 +3308,7 @@ define("ember-data/serializers/json_serializer",
             payloadKey = this.keyForRelationship(key, "hasMany");
           }
 
-          var relationshipType = RelationshipChange.determineRelationshipType(record.constructor, relationship);
+          var relationshipType = record.constructor.determineRelationshipType(relationship);
 
           if (relationshipType === 'manyToNone' || relationshipType === 'manyToMany') {
             json[payloadKey] = get(record, key).mapBy('id');
@@ -3686,7 +3718,6 @@ define("ember-data/serializers/rest_serializer",
 
     var JSONSerializer = __dependency1__["default"];
     var get = Ember.get;
-    var set = Ember.set;
     var forEach = Ember.ArrayPolyfills.forEach;
     var map = Ember.ArrayPolyfills.map;
     var camelize = Ember.String.camelize;
@@ -4367,7 +4398,7 @@ define("ember-data/serializers/rest_serializer",
 
       /**
         You can use this method to customize the root keys serialized into the JSON.
-        By default the REST Serializer sends the typeKey of a model, whih is a camelized
+        By default the REST Serializer sends the typeKey of a model, which is a camelized
         version of the name.
 
         For example, your server may expect underscored root objects.
@@ -4444,8 +4475,6 @@ define("ember-data/system/adapter",
     */
 
     var get = Ember.get;
-    var set = Ember.set;
-    var map = Ember.ArrayPolyfills.map;
 
     var errorProps = [
       'description',
@@ -4902,465 +4931,6 @@ define("ember-data/system/adapter",
     __exports__.Adapter = Adapter;
     __exports__["default"] = Adapter;
   });
-define("ember-data/system/changes",
-  ["ember-data/system/changes/relationship_change","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    /**
-      @module ember-data
-    */
-
-    var RelationshipChange = __dependency1__.RelationshipChange;
-    var RelationshipChangeAdd = __dependency1__.RelationshipChangeAdd;
-    var RelationshipChangeRemove = __dependency1__.RelationshipChangeRemove;
-    var OneToManyChange = __dependency1__.OneToManyChange;
-    var ManyToNoneChange = __dependency1__.ManyToNoneChange;
-    var OneToOneChange = __dependency1__.OneToOneChange;
-    var ManyToManyChange = __dependency1__.ManyToManyChange;
-
-    __exports__.RelationshipChange = RelationshipChange;
-    __exports__.RelationshipChangeAdd = RelationshipChangeAdd;
-    __exports__.RelationshipChangeRemove = RelationshipChangeRemove;
-    __exports__.OneToManyChange = OneToManyChange;
-    __exports__.ManyToNoneChange = ManyToNoneChange;
-    __exports__.OneToOneChange = OneToOneChange;
-    __exports__.ManyToManyChange = ManyToManyChange;
-  });
-define("ember-data/system/changes/relationship_change",
-  ["ember-data/system/model/model","ember-data/system/relationship-meta","exports"],
-  function(__dependency1__, __dependency2__, __exports__) {
-    "use strict";
-    /**
-      @module ember-data
-    */
-
-    var Model = __dependency1__["default"];
-    var isSyncRelationship = __dependency2__.isSyncRelationship;
-
-    var get = Ember.get;
-    var set = Ember.set;
-    var forEach = Ember.EnumerableUtils.forEach;
-
-    /**
-      @class RelationshipChange
-      @namespace DS
-      @private
-      @constructor
-    */
-    var RelationshipChange = function(options) {
-      this.parentRecord = options.parentRecord;
-      this.childRecord = options.childRecord;
-      this.firstRecord = options.firstRecord;
-      this.firstRecordKind = options.firstRecordKind;
-      this.firstRecordName = options.firstRecordName;
-      this.secondRecord = options.secondRecord;
-      this.secondRecordKind = options.secondRecordKind;
-      this.secondRecordName = options.secondRecordName;
-      this.changeType = options.changeType;
-      this.store = options.store;
-
-      this.committed = {};
-    };
-
-    /**
-      @class RelationshipChangeAdd
-      @namespace DS
-      @private
-      @constructor
-    */
-    function RelationshipChangeAdd(options){
-      RelationshipChange.call(this, options);
-    }
-
-    /**
-      @class RelationshipChangeRemove
-      @namespace DS
-      @private
-      @constructor
-    */
-    function RelationshipChangeRemove(options){
-      RelationshipChange.call(this, options);
-    }
-
-    RelationshipChange.create = function(options) {
-      return new RelationshipChange(options);
-    };
-
-    RelationshipChangeAdd.create = function(options) {
-      return new RelationshipChangeAdd(options);
-    };
-
-    RelationshipChangeRemove.create = function(options) {
-      return new RelationshipChangeRemove(options);
-    };
-
-    var OneToManyChange = {};
-    var OneToNoneChange = {};
-    var ManyToNoneChange = {};
-    var OneToOneChange = {};
-    var ManyToManyChange = {};
-
-    RelationshipChange._createChange = function(options){
-      if (options.changeType === 'add') {
-        return RelationshipChangeAdd.create(options);
-      }
-      if (options.changeType === 'remove') {
-        return RelationshipChangeRemove.create(options);
-      }
-    };
-
-    RelationshipChange.determineRelationshipType = function(recordType, knownSide){
-      var knownKey = knownSide.key, key, otherKind;
-      var knownKind = knownSide.kind;
-
-      var inverse = recordType.inverseFor(knownKey);
-
-      if (inverse) {
-        key = inverse.name;
-        otherKind = inverse.kind;
-      }
-
-      if (!inverse) {
-        return knownKind === 'belongsTo' ? 'oneToNone' : 'manyToNone';
-      } else {
-        if (otherKind === 'belongsTo') {
-          return knownKind === 'belongsTo' ? 'oneToOne' : 'manyToOne';
-        } else {
-          return knownKind === 'belongsTo' ? 'oneToMany' : 'manyToMany';
-        }
-      }
-    };
-
-    RelationshipChange.createChange = function(firstRecord, secondRecord, store, options){
-      // Get the type of the child based on the child's client ID
-      var firstRecordType = firstRecord.constructor, changeType;
-      changeType = RelationshipChange.determineRelationshipType(firstRecordType, options);
-      if (changeType === 'oneToMany') {
-        return OneToManyChange.createChange(firstRecord, secondRecord, store, options);
-      } else if (changeType === 'manyToOne') {
-        return OneToManyChange.createChange(secondRecord, firstRecord, store, options);
-      } else if (changeType === 'oneToNone') {
-        return OneToNoneChange.createChange(firstRecord, secondRecord, store, options);
-      } else if (changeType === 'manyToNone') {
-        return ManyToNoneChange.createChange(firstRecord, secondRecord, store, options);
-      } else if (changeType === 'oneToOne') {
-        return OneToOneChange.createChange(firstRecord, secondRecord, store, options);
-      } else if (changeType === 'manyToMany') {
-        return ManyToManyChange.createChange(firstRecord, secondRecord, store, options);
-      }
-    };
-
-    OneToNoneChange.createChange = function(childRecord, parentRecord, store, options) {
-      var key = options.key;
-      var change = RelationshipChange._createChange({
-        parentRecord: parentRecord,
-        childRecord: childRecord,
-        firstRecord: childRecord,
-        store: store,
-        changeType: options.changeType,
-        firstRecordName: key,
-        firstRecordKind: 'belongsTo'
-      });
-
-      store.addRelationshipChangeFor(childRecord, key, parentRecord, null, change);
-
-      return change;
-    };
-
-    ManyToNoneChange.createChange = function(childRecord, parentRecord, store, options) {
-      var key = options.key;
-      var change = RelationshipChange._createChange({
-        parentRecord: childRecord,
-        childRecord: parentRecord,
-        secondRecord: childRecord,
-        store: store,
-        changeType: options.changeType,
-        secondRecordName: options.key,
-        secondRecordKind: 'hasMany'
-      });
-
-      store.addRelationshipChangeFor(childRecord, key, parentRecord, null, change);
-      return change;
-    };
-
-
-    ManyToManyChange.createChange = function(childRecord, parentRecord, store, options) {
-      // If the name of the belongsTo side of the relationship is specified,
-      // use that
-      // If the type of the parent is specified, look it up on the child's type
-      // definition.
-      var key = options.key;
-
-      var change = RelationshipChange._createChange({
-        parentRecord: parentRecord,
-        childRecord: childRecord,
-        firstRecord: childRecord,
-        secondRecord: parentRecord,
-        firstRecordKind: 'hasMany',
-        secondRecordKind: 'hasMany',
-        store: store,
-        changeType: options.changeType,
-        firstRecordName:  key
-      });
-
-      store.addRelationshipChangeFor(childRecord, key, parentRecord, null, change);
-
-      return change;
-    };
-
-    OneToOneChange.createChange = function(childRecord, parentRecord, store, options) {
-      var key;
-
-      // If the name of the belongsTo side of the relationship is specified,
-      // use that
-      // If the type of the parent is specified, look it up on the child's type
-      // definition.
-      if (options.parentType) {
-        key = options.parentType.inverseFor(options.key).name;
-      } else if (options.key) {
-        key = options.key;
-      } else {
-        Ember.assert('You must pass either a parentType or belongsToName option to OneToManyChange.forChildAndParent', false);
-      }
-
-      var change = RelationshipChange._createChange({
-        parentRecord: parentRecord,
-        childRecord: childRecord,
-        firstRecord: childRecord,
-        secondRecord: parentRecord,
-        firstRecordKind: 'belongsTo',
-        secondRecordKind: 'belongsTo',
-        store: store,
-        changeType: options.changeType,
-        firstRecordName:  key
-      });
-
-      store.addRelationshipChangeFor(childRecord, key, parentRecord, null, change);
-
-      return change;
-    };
-
-    OneToOneChange.maintainInvariant = function(options, store, childRecord, key){
-      if (options.changeType === 'add' && store.recordIsMaterialized(childRecord)) {
-        var oldParent = get(childRecord, key);
-        if (oldParent) {
-          var correspondingChange = OneToOneChange.createChange(childRecord, oldParent, store, {
-            parentType: options.parentType,
-            hasManyName: options.hasManyName,
-            changeType: 'remove',
-            key: options.key
-          });
-          store.addRelationshipChangeFor(childRecord, key, options.parentRecord , null, correspondingChange);
-          correspondingChange.sync();
-        }
-      }
-    };
-
-    OneToManyChange.createChange = function(childRecord, parentRecord, store, options) {
-      var key;
-
-      // If the name of the belongsTo side of the relationship is specified,
-      // use that
-      // If the type of the parent is specified, look it up on the child's type
-      // definition.
-      if (options.parentType) {
-        key = options.parentType.inverseFor(options.key).name;
-        OneToManyChange.maintainInvariant( options, store, childRecord, key );
-      } else if (options.key) {
-        key = options.key;
-      } else {
-        Ember.assert('You must pass either a parentType or belongsToName option to OneToManyChange.forChildAndParent', false);
-      }
-
-      var change = RelationshipChange._createChange({
-        parentRecord: parentRecord,
-        childRecord: childRecord,
-        firstRecord: childRecord,
-        secondRecord: parentRecord,
-        firstRecordKind: 'belongsTo',
-        secondRecordKind: 'hasMany',
-        store: store,
-        changeType: options.changeType,
-        firstRecordName: key
-      });
-
-      store.addRelationshipChangeFor(childRecord, key, parentRecord, change.getSecondRecordName(), change);
-
-      return change;
-    };
-
-    OneToManyChange.maintainInvariant = function(options, store, childRecord, key){
-      if (options.changeType === 'add' && childRecord) {
-        var oldParent = get(childRecord, key);
-        if (oldParent) {
-          var correspondingChange = OneToManyChange.createChange(childRecord, oldParent, store, {
-            parentType: options.parentType,
-            hasManyName: options.hasManyName,
-            changeType: 'remove',
-            key: options.key
-          });
-          store.addRelationshipChangeFor(childRecord, key, options.parentRecord, correspondingChange.getSecondRecordName(), correspondingChange);
-          correspondingChange.sync();
-        }
-      }
-    };
-
-    /**
-      @class RelationshipChange
-      @namespace DS
-    */
-    RelationshipChange.prototype = {
-      getSecondRecordName: function() {
-        var name = this.secondRecordName, parent;
-
-        if (!name) {
-          parent = this.secondRecord;
-          if (!parent) { return; }
-
-          var childType = this.firstRecord.constructor;
-          var inverse = childType.inverseFor(this.firstRecordName);
-          this.secondRecordName = inverse.name;
-        }
-
-        return this.secondRecordName;
-      },
-
-      /**
-        Get the name of the relationship on the belongsTo side.
-
-        @method getFirstRecordName
-        @return {String}
-      */
-      getFirstRecordName: function() {
-        return this.firstRecordName;
-      },
-
-      /**
-        @method destroy
-        @private
-      */
-      destroy: function() {
-        var childRecord = this.childRecord;
-        var belongsToName = this.getFirstRecordName();
-        var hasManyName = this.getSecondRecordName();
-        var store = this.store;
-
-        store.removeRelationshipChangeFor(childRecord, belongsToName, this.parentRecord, hasManyName, this.changeType);
-      },
-
-      getSecondRecord: function(){
-        return this.secondRecord;
-      },
-
-      /**
-        @method getFirstRecord
-        @private
-      */
-      getFirstRecord: function() {
-        return this.firstRecord;
-      },
-
-      coalesce: function(){
-        var relationshipPairs = this.store.relationshipChangePairsFor(this.firstRecord);
-        forEach(relationshipPairs, function(pair) {
-          var addedChange = pair['add'];
-          var removedChange = pair['remove'];
-          if (addedChange && removedChange) {
-            addedChange.destroy();
-            removedChange.destroy();
-          }
-        });
-      }
-    };
-
-    RelationshipChangeAdd.prototype = Ember.create(RelationshipChange.create({}));
-    RelationshipChangeRemove.prototype = Ember.create(RelationshipChange.create({}));
-
-    RelationshipChangeAdd.prototype.changeType = 'add';
-    RelationshipChangeAdd.prototype.sync = function() {
-      var secondRecordName = this.getSecondRecordName();
-      var firstRecordName = this.getFirstRecordName();
-      var firstRecord = this.getFirstRecord();
-      var secondRecord = this.getSecondRecord();
-
-      //Ember.assert("You specified a hasMany (" + hasManyName + ") on " + (!belongsToName && (newParent || oldParent || this.lastParent).constructor) + " but did not specify an inverse belongsTo on " + child.constructor, belongsToName);
-      //Ember.assert("You specified a belongsTo (" + belongsToName + ") on " + child.constructor + " but did not specify an inverse hasMany on " + (!hasManyName && (newParent || oldParent || this.lastParentRecord).constructor), hasManyName);
-
-      if (secondRecord instanceof Model && firstRecord instanceof Model) {
-        if (this.secondRecordKind === 'belongsTo') {
-          secondRecord.suspendRelationshipObservers(function() {
-            set(secondRecord, secondRecordName, firstRecord);
-          });
-        } else if (this.secondRecordKind === 'hasMany' && isSyncRelationship(secondRecord, secondRecordName)) {
-          secondRecord.suspendRelationshipObservers(function() {
-            var relationship = get(secondRecord, secondRecordName);
-            relationship.addObject(firstRecord);
-          });
-        }
-      }
-
-      if (firstRecord instanceof Model && secondRecord instanceof Model && get(firstRecord, firstRecordName) !== secondRecord) {
-        if (this.firstRecordKind === 'belongsTo') {
-          firstRecord.suspendRelationshipObservers(function() {
-            set(firstRecord, firstRecordName, secondRecord);
-          });
-        } else if (this.firstRecordKind === 'hasMany' && isSyncRelationship(secondRecord, secondRecordName)) {
-          firstRecord.suspendRelationshipObservers(function() {
-            var relationship = get(firstRecord, firstRecordName);
-             relationship.addObject(secondRecord);
-          });
-        }
-      }
-      this.coalesce();
-    };
-
-    RelationshipChangeRemove.prototype.changeType = 'remove';
-    RelationshipChangeRemove.prototype.sync = function() {
-      var secondRecordName = this.getSecondRecordName();
-      var firstRecordName = this.getFirstRecordName();
-      var firstRecord = this.getFirstRecord();
-      var secondRecord = this.getSecondRecord();
-
-      //Ember.assert("You specified a hasMany (" + hasManyName + ") on " + (!belongsToName && (newParent || oldParent || this.lastParent).constructor) + " but did not specify an inverse belongsTo on " + child.constructor, belongsToName);
-      //Ember.assert("You specified a belongsTo (" + belongsToName + ") on " + child.constructor + " but did not specify an inverse hasMany on " + (!hasManyName && (newParent || oldParent || this.lastParentRecord).constructor), hasManyName);
-
-      if (secondRecord instanceof Model && firstRecord instanceof Model) {
-        if (this.secondRecordKind === 'belongsTo') {
-          secondRecord.suspendRelationshipObservers(function() {
-            set(secondRecord, secondRecordName, null);
-          });
-        } else if (this.secondRecordKind === 'hasMany' && isSyncRelationship(secondRecord, secondRecordName)) {
-          secondRecord.suspendRelationshipObservers(function() {
-            var relationship = get(secondRecord, secondRecordName);
-            relationship.removeObject(firstRecord);
-          });
-        }
-      }
-
-      if (firstRecord instanceof Model && get(firstRecord, firstRecordName)) {
-        if (this.firstRecordKind === 'belongsTo') {
-          firstRecord.suspendRelationshipObservers(function() {
-            set(firstRecord, firstRecordName, null);
-          });
-        } else if (this.firstRecordKind === 'hasMany' && isSyncRelationship(firstRecord, firstRecordName)) {
-          firstRecord.suspendRelationshipObservers(function() {
-            var relationship = get(firstRecord, firstRecordName);
-            relationship.removeObject(secondRecord);
-          });
-        }
-      }
-
-      this.coalesce();
-    };
-
-    __exports__.RelationshipChange = RelationshipChange;
-    __exports__.RelationshipChangeAdd = RelationshipChangeAdd;
-    __exports__.RelationshipChangeRemove = RelationshipChangeRemove;
-    __exports__.OneToManyChange = OneToManyChange;
-    __exports__.ManyToNoneChange = ManyToNoneChange;
-    __exports__.OneToOneChange = OneToOneChange;
-    __exports__.ManyToManyChange = ManyToManyChange;
-  });
 define("ember-data/system/container_proxy",
   ["exports"],
   function(__exports__) {
@@ -5403,7 +4973,7 @@ define("ember-data/system/container_proxy",
     };
 
     ContainerProxy.prototype.registerDeprecations = function(proxyPairs) {
-      var i, proxyPair, deprecated, valid, proxy;
+      var i, proxyPair, deprecated, valid;
 
       for (i = proxyPairs.length; i > 0; i--) {
         proxyPair = proxyPairs[i - 1];
@@ -6299,12 +5869,14 @@ define("ember-data/system/model/errors",
     });
   });
 define("ember-data/system/model/model",
-  ["ember-data/system/model/states","ember-data/system/model/errors","ember-data/system/store","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
+  ["ember-data/system/model/states","ember-data/system/model/errors","ember-data/system/promise_proxies","ember-data/system/relationships/relationship","exports"],
+  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
     "use strict";
     var RootState = __dependency1__["default"];
     var Errors = __dependency2__["default"];
     var PromiseObject = __dependency3__.PromiseObject;
+    var createRelationshipFor = __dependency4__.createRelationshipFor;
+
     /**
       @module ember-data
     */
@@ -6314,6 +5886,7 @@ define("ember-data/system/model/model",
     var merge = Ember.merge;
     var Promise = Ember.RSVP.Promise;
     var forEach = Ember.ArrayPolyfills.forEach;
+    var map = Ember.ArrayPolyfills.map;
 
     var JSONSerializer;
     var retrieveFromCurrentState = Ember.computed('currentState', function(key, value) {
@@ -6746,6 +6319,12 @@ define("ember-data/system/model/model",
         this._attributes = {};
         this._inFlightAttributes = {};
         this._relationships = {};
+        var model = this;
+        //TODO Move into a getter for better perf
+        this.constructor.eachRelationship(function(key, descriptor) {
+            model._relationships[key] = createRelationshipFor(model, descriptor, model.store);
+        });
+
       },
 
       /**
@@ -6928,13 +6507,11 @@ define("ember-data/system/model/model",
       */
       clearRelationships: function() {
         this.eachRelationship(function(name, relationship) {
-          if (relationship.kind === 'belongsTo') {
-            set(this, name, null);
-          } else if (relationship.kind === 'hasMany') {
-            var hasMany = this._relationships[name];
-            if (hasMany) { // relationships are created lazily
-              hasMany.destroy();
-            }
+          var rel = this._relationships[name];
+          if (rel){
+            //TODO(Igor) figure out whether we want to clear or disconnect
+            rel.clear();
+            rel.destroy();
           }
         }, this);
       },
@@ -6949,9 +6526,9 @@ define("ember-data/system/model/model",
       },
 
       /**
-        When a find request is triggered on the store, the user can optionally passed in
+        When a find request is triggered on the store, the user can optionally pass in
         attributes and relationships to be preloaded. These are meant to behave as if they
-        came back from the server, expect the user obtained them out of band and is informing
+        came back from the server, except the user obtained them out of band and is informing
         the store of their existence. The most common use case is for supporting client side
         nested URLs, such as `/posts/1/comments/2` so the user can do
         `store.find('comment', 2, {post:1})` without having to fetch the post.
@@ -6991,15 +6568,20 @@ define("ember-data/system/model/model",
         Ember.assert("You need to pass in an array to set a hasMany property on a record", Ember.isArray(preloadValue));
         var record = this;
 
-        forEach.call(preloadValue, function(recordToPush) {
-          recordToPush = record._convertStringOrNumberIntoRecord(recordToPush, type);
-          get(record, key).pushObject(recordToPush);
+        var recordsToSet = map.call(preloadValue, function(recordToPush) {
+          return record._convertStringOrNumberIntoRecord(recordToPush, type);
         });
+        //We use the pathway of setting the hasMany as if it came from the adapter
+        //because the user told us that they know this relationships exists already
+        this._relationships[key].updateRecordsFromAdapter(recordsToSet);
       },
 
       _preloadBelongsTo: function(key, preloadValue, type){
-        var recordToPush = this._convertStringOrNumberIntoRecord(preloadValue, type);
-        set(this, key, recordToPush);
+        var recordToSet = this._convertStringOrNumberIntoRecord(preloadValue, type);
+
+        //We use the pathway of setting the hasMany as if it came from the adapter
+        //because the user told us that they know this relationships exists already
+        this._relationships[key].setRecord(recordToSet);
       },
 
       _convertStringOrNumberIntoRecord: function(value, type) {
@@ -7074,9 +6656,7 @@ define("ember-data/system/model/model",
 
         if (!data) { return; }
 
-        this.suspendRelationshipObservers(function() {
-          this.notifyPropertyChange('data');
-        });
+        this.notifyPropertyChange('data');
       },
 
       /**
@@ -7088,32 +6668,6 @@ define("ember-data/system/model/model",
         this.updateRecordArraysLater();
       },
 
-      dataDidChange: Ember.observer(function() {
-        this.reloadHasManys();
-      }, 'data'),
-
-      reloadHasManys: function() {
-        var relationships = get(this.constructor, 'relationshipsByName');
-        this.updateRecordArraysLater();
-        relationships.forEach(function(name, relationship) {
-          if (this._data.links && this._data.links[name]) { return; }
-          if (relationship.kind === 'hasMany') {
-            this.hasManyDidChange(relationship.key);
-          }
-        }, this);
-      },
-
-      hasManyDidChange: function(key) {
-        var hasMany = this._relationships[key];
-
-        if (hasMany) {
-          var records = this._data[key] || [];
-
-          set(hasMany, 'content', Ember.A(records));
-          set(hasMany, 'isLoaded', true);
-          hasMany.trigger('didLoad');
-        }
-      },
 
       /**
         @method updateRecordArraysLater
@@ -7141,18 +6695,9 @@ define("ember-data/system/model/model",
           this._data = data;
         }
 
-        var relationships = this._relationships;
-
-        this.eachRelationship(function(name, rel) {
-          if (data.links && data.links[name]) { return; }
-          if (rel.options.async) { relationships[name] = null; }
-        });
-
         if (data) { this.pushedData(); }
 
-        this.suspendRelationshipObservers(function() {
-          this.notifyPropertyChange('data');
-        });
+        this.notifyPropertyChange('data');
       },
 
       materializeId: function(id) {
@@ -7168,27 +6713,6 @@ define("ember-data/system/model/model",
         this._data[name] = value;
       },
 
-      /**
-        @method updateHasMany
-        @private
-        @param {String} name
-        @param {Array} records
-      */
-      updateHasMany: function(name, records) {
-        this._data[name] = records;
-        this.hasManyDidChange(name);
-      },
-
-      /**
-        @method updateBelongsTo
-        @private
-        @param {String} name
-        @param {DS.Model} record
-      */
-      updateBelongsTo: function(name, record) {
-        this._data[name] = record;
-      },
-
       /**
         If the model `isDirty` this function will discard any unsaved
         changes
@@ -7219,48 +6743,13 @@ define("ember-data/system/model/model",
 
         this.send('rolledBack');
 
-        this.suspendRelationshipObservers(function() {
-          this.notifyPropertyChange('data');
-        });
+        this.notifyPropertyChange('data');
       },
 
       toStringExtension: function() {
         return get(this, 'id');
       },
 
-      /**
-        The goal of this method is to temporarily disable specific observers
-        that take action in response to application changes.
-
-        This allows the system to make changes (such as materialization and
-        rollback) that should not trigger secondary behavior (such as setting an
-        inverse relationship or marking records as dirty).
-
-        The specific implementation will likely change as Ember proper provides
-        better infrastructure for suspending groups of observers, and if Array
-        observation becomes more unified with regular observers.
-
-        @method suspendRelationshipObservers
-        @private
-        @param callback
-        @param binding
-      */
-      suspendRelationshipObservers: function(callback, binding) {
-        var observers = get(this.constructor, 'relationshipNames').belongsTo;
-        var self = this;
-
-        try {
-          this._suspendedRelationships = true;
-          Ember._suspendObservers(self, observers, null, 'belongsToDidChange', function() {
-            Ember._suspendBeforeObservers(self, observers, null, 'belongsToWillChange', function() {
-              callback.call(binding || self);
-            });
-          });
-        } finally {
-          this._suspendedRelationships = false;
-        }
-      },
-
       /**
         Save the record and persist any changes to the record to an
         extenal source via the adapter.
@@ -7627,18 +7116,6 @@ define("ember-data/system/model/states",
       @class RootState
     */
 
-    function hasDefinedProperties(object) {
-      // Ignore internal property defined by simulated `Ember.create`.
-      var names = Ember.keys(object);
-      var i, l, name;
-      for (i = 0, l = names.length; i < l; i++ ) {
-        name = names[i];
-        if (object.hasOwnProperty(name) && object[name]) { return true; }
-      }
-
-      return false;
-    }
-
     function didSetProperty(record, context) {
       if (context.value === context.originalValue) {
         delete record._attributes[context.name];
@@ -7713,12 +7190,8 @@ define("ember-data/system/model/states",
         loadingData: Ember.K,
 
         propertyWasReset: function(record, name) {
-          var stillDirty = false;
-
-          for (var prop in record._attributes) {
-            stillDirty = true;
-            break;
-          }
+          var length = Ember.keys(record._attributes);
+          var stillDirty = length > 0;
 
           if (!stillDirty) { record.send('rolledBack'); }
         },
@@ -7943,10 +7416,7 @@ define("ember-data/system/model/states",
 
         loadedData: function(record) {
           record.transitionTo('loaded.created.uncommitted');
-
-          record.suspendRelationshipObservers(function() {
-            record.notifyPropertyChange('data');
-          });
+          record.notifyPropertyChange('data');
         },
 
         pushedData: function(record) {
@@ -8190,6 +7660,91 @@ define("ember-data/system/model/states",
 
     __exports__["default"] = RootState;
   });
+define("ember-data/system/promise_proxies",
+  ["exports"],
+  function(__exports__) {
+    "use strict";
+    var Promise = Ember.RSVP.Promise;
+
+    /**
+      A `PromiseArray` is an object that acts like both an `Ember.Array`
+      and a promise. When the promise is resolved the resulting value
+      will be set to the `PromiseArray`'s `content` property. This makes
+      it easy to create data bindings with the `PromiseArray` that will be
+      updated when the promise resolves.
+
+      For more information see the [Ember.PromiseProxyMixin
+      documentation](/api/classes/Ember.PromiseProxyMixin.html).
+
+      Example
+
+      ```javascript
+      var promiseArray = DS.PromiseArray.create({
+        promise: $.getJSON('/some/remote/data.json')
+      });
+
+      promiseArray.get('length'); // 0
+
+      promiseArray.then(function() {
+        promiseArray.get('length'); // 100
+      });
+      ```
+
+      @class PromiseArray
+      @namespace DS
+      @extends Ember.ArrayProxy
+      @uses Ember.PromiseProxyMixin
+    */
+    var PromiseArray = Ember.ArrayProxy.extend(Ember.PromiseProxyMixin);
+
+    /**
+      A `PromiseObject` is an object that acts like both an `Ember.Object`
+      and a promise. When the promise is resolved, then the resulting value
+      will be set to the `PromiseObject`'s `content` property. This makes
+      it easy to create data bindings with the `PromiseObject` that will
+      be updated when the promise resolves.
+
+      For more information see the [Ember.PromiseProxyMixin
+      documentation](/api/classes/Ember.PromiseProxyMixin.html).
+
+      Example
+
+      ```javascript
+      var promiseObject = DS.PromiseObject.create({
+        promise: $.getJSON('/some/remote/data.json')
+      });
+
+      promiseObject.get('name'); // null
+
+      promiseObject.then(function() {
+        promiseObject.get('name'); // 'Tomster'
+      });
+      ```
+
+      @class PromiseObject
+      @namespace DS
+      @extends Ember.ObjectProxy
+      @uses Ember.PromiseProxyMixin
+    */
+    var PromiseObject = Ember.ObjectProxy.extend(Ember.PromiseProxyMixin);
+
+    var promiseObject = function(promise, label) {
+      return PromiseObject.create({
+        promise: Promise.resolve(promise, label)
+      });
+    };
+
+    var promiseArray = function(promise, label) {
+      return PromiseArray.create({
+        promise: Promise.resolve(promise, label)
+      });
+    };
+
+    __exports__.PromiseArray = PromiseArray;
+    __exports__.PromiseObject = PromiseObject;
+    __exports__.promiseArray = promiseArray;
+    __exports__.promiseObject = promiseObject;
+  });
 define("ember-data/system/record_array_manager",
   ["ember-data/system/record_arrays","exports"],
   function(__dependency1__, __exports__) {
@@ -8203,7 +7758,6 @@ define("ember-data/system/record_array_manager",
     var AdapterPopulatedRecordArray = __dependency1__.AdapterPopulatedRecordArray;
     var ManyArray = __dependency1__.ManyArray;
     var get = Ember.get;
-    var set = Ember.set;
     var forEach = Ember.EnumerableUtils.forEach;
 
     /**
@@ -8528,7 +8082,6 @@ define("ember-data/system/record_arrays/adapter_populated_record_array",
     */
 
     var get = Ember.get;
-    var set = Ember.set;
 
     function cloneNull(source) {
       var clone = Object.create(null);
@@ -8654,22 +8207,16 @@ define("ember-data/system/record_arrays/filtered_record_array",
     });
   });
 define("ember-data/system/record_arrays/many_array",
-  ["ember-data/system/record_arrays/record_array","ember-data/system/changes","exports"],
-  function(__dependency1__, __dependency2__, __exports__) {
+  ["ember-data/system/record_arrays/record_array","exports"],
+  function(__dependency1__, __exports__) {
     "use strict";
     var RecordArray = __dependency1__["default"];
-    var RelationshipChange = __dependency2__.RelationshipChange;
 
     /**
       @module ember-data
     */
 
     var get = Ember.get, set = Ember.set;
-    var map = Ember.EnumerableUtils.map;
-
-    function sync(change) {
-      change.sync();
-    }
 
     /**
       A `ManyArray` is a `RecordArray` that represents the contents of a has-many
@@ -8710,7 +8257,6 @@ define("ember-data/system/record_arrays/many_array",
     __exports__["default"] = RecordArray.extend({
       init: function() {
         this._super.apply(this, arguments);
-        this._changesToSync = Ember.OrderedSet.create();
       },
 
       /**
@@ -8741,6 +8287,16 @@ define("ember-data/system/record_arrays/many_array",
 
       isLoaded: false,
 
+       /**
+         The relationship which manages this array.
+
+         @property {DS.Model} owner
+         @private
+       */
+
+      relationship: null,
+
+
       /**
         Used for async `hasMany` arrays
         to keep track of when they will resolve.
@@ -8771,99 +8327,14 @@ define("ember-data/system/record_arrays/many_array",
         }
       },
 
-      /**
-        @method fetch
-        @private
-      */
-      fetch: function() {
-        var records = get(this, 'content');
-        var store = get(this, 'store');
-        var owner = get(this, 'owner');
-
-        var unloadedRecords = records.filterBy('isEmpty', true);
-        store.scheduleFetchMany(unloadedRecords, owner);
-      },
-
-      // Overrides Ember.Array's replace method to implement
-      replaceContent: function(index, removed, added) {
-        // Map the array of record objects into an array of  client ids.
-        added = map(added, function(record) {
-          Ember.assert("You cannot add '" + record.constructor.typeKey + "' records to this relationship (only '" + this.type.typeKey + "' allowed)", !this.type || record instanceof this.type);
-          return record;
-        }, this);
-
-        this._super(index, removed, added);
-      },
-
-      arrangedContentDidChange: function() {
-        Ember.run.once(this, 'fetch');
-      },
-
-      arrayContentWillChange: function(index, removed, added) {
-        var owner = get(this, 'owner');
-        var name = get(this, 'name');
-
-        if (!owner._suspendedRelationships) {
-          // This code is the first half of code that continues inside
-          // of arrayContentDidChange. It gets or creates a change from
-          // the child object, adds the current owner as the old
-          // parent if this is the first time the object was removed
-          // from a ManyArray, and sets `newParent` to null.
-          //
-          // Later, if the object is added to another ManyArray,
-          // the `arrayContentDidChange` will set `newParent` on
-          // the change.
-          for (var i=index; i<index+removed; i++) {
-            var record = get(this, 'content').objectAt(i);
-
-            var change = RelationshipChange.createChange(owner, record, get(this, 'store'), {
-              parentType: owner.constructor,
-              changeType: "remove",
-              kind: "hasMany",
-              key: name
-            });
-
-            this._changesToSync.add(change);
-          }
+      replaceContent: function(idx, amt, objects){
+        var records;
+        if (amt > 0){
+          records = get(this, 'content').slice(idx, idx+amt);
+          this.get('relationship').removeRecords(records);
         }
-
-        return this._super.apply(this, arguments);
-      },
-
-      arrayContentDidChange: function(index, removed, added) {
-        this._super.apply(this, arguments);
-
-        var owner = get(this, 'owner');
-        var name = get(this, 'name');
-        var store = get(this, 'store');
-
-        if (!owner._suspendedRelationships) {
-          // This code is the second half of code that started in
-          // `arrayContentWillChange`. It gets or creates a change
-          // from the child object, and adds the current owner as
-          // the new parent.
-          for (var i=index; i<index+added; i++) {
-            var record = get(this, 'content').objectAt(i);
-
-            var change = RelationshipChange.createChange(owner, record, store, {
-              parentType: owner.constructor,
-              changeType: "add",
-              kind:"hasMany",
-              key: name
-            });
-            change.hasManyName = name;
-
-            this._changesToSync.add(change);
-          }
-
-          // We wait until the array has finished being
-          // mutated before syncing the OneToManyChanges created
-          // in arrayContentWillChange, so that the array
-          // membership test in the sync() logic operates
-          // on the final results.
-          this._changesToSync.forEach(sync);
-
-          this._changesToSync.clear();
+        if (objects){
+          this.get('relationship').addRecords(objects, idx);
         }
       },
 
@@ -8876,8 +8347,7 @@ define("ember-data/system/record_arrays/many_array",
         @return {DS.Model} record
       */
       createRecord: function(hash) {
-        var owner = get(this, 'owner');
-        var store = get(owner, 'store');
+        var store = get(this, 'store');
         var type = get(this, 'type');
         var record;
 
@@ -8891,7 +8361,7 @@ define("ember-data/system/record_arrays/many_array",
     });
   });
 define("ember-data/system/record_arrays/record_array",
-  ["ember-data/system/store","exports"],
+  ["ember-data/system/promise_proxies","exports"],
   function(__dependency1__, __exports__) {
     "use strict";
     /**
@@ -8900,7 +8370,6 @@ define("ember-data/system/record_arrays/record_array",
 
     var PromiseArray = __dependency1__.PromiseArray;
     var get = Ember.get;
-    var set = Ember.set;
 
     /**
       A record array is an array that contains records of a certain type. The record
@@ -9020,9 +8489,17 @@ define("ember-data/system/record_arrays/record_array",
         @method addRecord
         @private
         @param {DS.Model} record
+        @param {DS.Model} an optional index to insert at
       */
-      addRecord: function(record) {
-        get(this, 'content').addObject(record);
+      addRecord: function(record, idx) {
+        var content = get(this, 'content');
+        if (idx === undefined) {
+          content.addObject(record);
+        } else {
+          if (!content.contains(record)) {
+           content.insertAt(idx, record);
+          }
+        }
       },
 
       /**
@@ -9124,14 +8601,7 @@ define("ember-data/system/relationship-meta",
       };
     }
 
-    __exports__.relationshipFromMeta = relationshipFromMeta;function isSyncRelationship(record, relationshipName) {
-      var meta = Ember.meta(record);
-      var desc = meta.descs[relationshipName];
-
-      return desc && !desc._meta.options.async;
-    }
-
-    __exports__.isSyncRelationship = isSyncRelationship;
+    __exports__.relationshipFromMeta = relationshipFromMeta;
   });
 define("ember-data/system/relationships",
   ["./relationships/belongs_to","./relationships/has_many","ember-data/system/relationships/ext","exports"],
@@ -9149,65 +8619,11 @@ define("ember-data/system/relationships",
     __exports__.hasMany = hasMany;
   });
 define("ember-data/system/relationships/belongs_to",
-  ["ember-data/system/model","ember-data/system/store","ember-data/system/changes","ember-data/system/relationship-meta","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
+  ["ember-data/system/model","exports"],
+  function(__dependency1__, __exports__) {
     "use strict";
-    var get = Ember.get;
-    var set = Ember.set;
-    var isNone = Ember.isNone;
-    var Promise = Ember.RSVP.Promise;
-
     var Model = __dependency1__.Model;
-    var PromiseObject = __dependency2__.PromiseObject;
-    var RelationshipChange = __dependency3__.RelationshipChange;
-    var relationshipFromMeta = __dependency4__.relationshipFromMeta;
-    var typeForRelationshipMeta = __dependency4__.typeForRelationshipMeta;
-    var isSyncRelationship = __dependency4__.isSyncRelationship;
 
-    /**
-      @module ember-data
-    */
-
-    function asyncBelongsTo(type, options, meta) {
-      return Ember.computed('data', function(key, value) {
-        var data = get(this, 'data');
-        var store = get(this, 'store');
-        var promiseLabel = "DS: Async belongsTo " + this + " : " + key;
-        var promise;
-
-        meta.key = key;
-
-        if (arguments.length === 2) {
-          Ember.assert("You can only add a '" + type + "' record to this relationship", !value || value instanceof typeForRelationshipMeta(store, meta));
-          return value === undefined ? null : PromiseObject.create({
-            promise: Promise.cast(value, promiseLabel)
-          });
-        }
-
-        var link = data.links && data.links[key];
-        var belongsTo = data[key];
-
-        if (!isNone(belongsTo)) {
-          var inverse = this.constructor.inverseFor(key);
-          //but for now only in the oneToOne case
-          if (inverse && inverse.kind === 'belongsTo'){
-            set(belongsTo, inverse.name, this);
-          }
-          //TODO(Igor) after OR doesn't seem that will be called
-          promise = store.findById(belongsTo.constructor, belongsTo.get('id')) || Promise.cast(belongsTo, promiseLabel);
-          return PromiseObject.create({
-            promise: promise
-          });
-        } else if (link) {
-          promise = store.findBelongsTo(this, link, relationshipFromMeta(store, meta));
-          return PromiseObject.create({
-            promise: promise
-          });
-        } else {
-          return null;
-        }
-      }).meta(meta);
-    }
 
     /**
       `DS.belongsTo` is used to define One-To-One and One-To-Many
@@ -9274,33 +8690,15 @@ define("ember-data/system/relationships/belongs_to",
         key: null
       };
 
-      if (options.async) {
-        return asyncBelongsTo(type, options, meta);
-      }
-
-      return Ember.computed('data', function(key, value) {
-        var data = get(this, 'data');
-        var store = get(this, 'store');
-        var belongsTo, typeClass;
-
-        if (typeof type === 'string') {
-          typeClass = store.modelFor(type);
-        } else {
-          typeClass = type;
-        }
-
-        if (arguments.length === 2) {
-          Ember.assert("You can only add a '" + type + "' record to this relationship", !value || value instanceof typeClass);
-          return value === undefined ? null : value;
+      return Ember.computed(function(key, value) {
+        if (arguments.length>1) {
+          if ( value === undefined ) {
+            value = null;
+          }
+          this._relationships[key].setRecord(value);
         }
 
-        belongsTo = data[key];
-
-        if (isNone(belongsTo)) { return null; }
-
-        store.findById(belongsTo.constructor, belongsTo.get('id'));
-
-        return belongsTo;
+        return this._relationships[key].getRecord();
       }).meta(meta);
     }
 
@@ -9312,72 +8710,26 @@ define("ember-data/system/relationships/belongs_to",
       @namespace DS
     */
     Model.reopen({
+      notifyBelongsToAdded: function(key, relationship) {
+        this.notifyPropertyChange(key);
+      },
 
-      /**
-        @method belongsToWillChange
-        @private
-        @static
-        @param record
-        @param key
-      */
-      belongsToWillChange: Ember.beforeObserver(function(record, key) {
-        if (get(record, 'isLoaded') && isSyncRelationship(record, key)) {
-          var oldParent = get(record, key);
-
-          if (oldParent) {
-            var store = get(record, 'store');
-            var change = RelationshipChange.createChange(record, oldParent, store, {
-              key: key,
-              kind: 'belongsTo',
-              changeType: 'remove'
-            });
-
-            change.sync();
-            this._changesToSync[key] = change;
-          }
-        }
-      }),
-
-      /**
-        @method belongsToDidChange
-        @private
-        @static
-        @param record
-        @param key
-      */
-      belongsToDidChange: Ember.immediateObserver(function(record, key) {
-        if (get(record, 'isLoaded')) {
-          var newParent = get(record, key);
-
-          if (newParent) {
-            var store = get(record, 'store');
-            var change = RelationshipChange.createChange(record, newParent, store, {
-              key: key,
-              kind: 'belongsTo',
-              changeType: 'add'
-            });
-
-            change.sync();
-          }
-        }
-
-        delete this._changesToSync[key];
-      })
+      notifyBelongsToRemoved: function(key) {
+        this.notifyPropertyChange(key);
+      }
     });
 
     __exports__["default"] = belongsTo;
   });
 define("ember-data/system/relationships/ext",
-  ["ember-inflector/system","ember-data/system/relationship-meta","ember-data/system/model"],
-  function(__dependency1__, __dependency2__, __dependency3__) {
+  ["ember-data/system/relationship-meta","ember-data/system/model"],
+  function(__dependency1__, __dependency2__) {
     "use strict";
-    var singularize = __dependency1__.singularize;
-    var typeForRelationshipMeta = __dependency2__.typeForRelationshipMeta;
-    var relationshipFromMeta = __dependency2__.relationshipFromMeta;
-    var Model = __dependency3__.Model;
+    var typeForRelationshipMeta = __dependency1__.typeForRelationshipMeta;
+    var relationshipFromMeta = __dependency1__.relationshipFromMeta;
+    var Model = __dependency2__.Model;
 
     var get = Ember.get;
-    var set = Ember.set;
 
     /**
       @module ember-data
@@ -9429,11 +8781,6 @@ define("ember-data/system/relationships/ext",
           // the computed property.
           var meta = value.meta();
 
-          if (meta.isRelationship && meta.kind === 'belongsTo') {
-            Ember.addObserver(proto, key, null, 'belongsToDidChange');
-            Ember.addBeforeObserver(proto, key, null, 'belongsToWillChange');
-          }
-
           meta.parentType = proto.constructor;
         }
       }
@@ -9815,140 +9162,63 @@ define("ember-data/system/relationships/ext",
         get(this, 'relatedTypes').forEach(function(type) {
           callback.call(binding, type);
         });
-      }
-    });
+      },
 
-    Model.reopen({
-      /**
-        Given a callback, iterates over each of the relationships in the model,
-        invoking the callback with the name of each relationship and its relationship
-        descriptor.
+      determineRelationshipType: function(knownSide) {
+        var knownKey = knownSide.key;
+        var knownKind = knownSide.kind;
+        var inverse = this.inverseFor(knownKey);
+        var key, otherKind;
 
-        @method eachRelationship
-        @param {Function} callback the callback to invoke
-        @param {any} binding the value to which the callback's `this` should be bound
-      */
-      eachRelationship: function(callback, binding) {
-        this.constructor.eachRelationship(callback, binding);
-      }
-    });
-  });
-define("ember-data/system/relationships/has_many",
-  ["ember-data/system/store","ember-data/system/relationship-meta","exports"],
-  function(__dependency1__, __dependency2__, __exports__) {
-    "use strict";
-    /**
-      @module ember-data
-    */
-
-    var PromiseArray = __dependency1__.PromiseArray;
+        if (!inverse) {
+          return knownKind === 'belongsTo' ? 'oneToNone' : 'manyToNone';
+        }
 
-    var relationshipFromMeta = __dependency2__.relationshipFromMeta;
-    var typeForRelationshipMeta = __dependency2__.typeForRelationshipMeta;
+        key = inverse.name;
+        otherKind = inverse.kind;
 
-    var get = Ember.get;
-    var set = Ember.set;
-    var setProperties = Ember.setProperties;
-    var map = Ember.EnumerableUtils.map;
+        if (otherKind === 'belongsTo') {
+          return knownKind === 'belongsTo' ? 'oneToOne' : 'manyToOne';
+        } else {
+          return knownKind === 'belongsTo' ? 'oneToMany' : 'manyToMany';
+        }
+      }
 
-    /**
-      Returns a computed property that synchronously returns a ManyArray for
-      this relationship. If not all of the records in this relationship are
-      loaded, it will raise an exception.
-    */
+    });
 
-    function syncHasMany(type, options, meta) {
-      return Ember.computed('data', function(key) {
-        return buildRelationship(this, key, options, function(store, data) {
-          // Configure the metadata for the computed property to contain
-          // the key.
-          meta.key = key;
+    Model.reopen({
+      /**
+        Given a callback, iterates over each of the relationships in the model,
+        invoking the callback with the name of each relationship and its relationship
+        descriptor.
 
-          var records = data[key];
+        @method eachRelationship
+        @param {Function} callback the callback to invoke
+        @param {any} binding the value to which the callback's `this` should be bound
+      */
+      eachRelationship: function(callback, binding) {
+        this.constructor.eachRelationship(callback, binding);
+      },
 
-          Ember.assert("You looked up the '" + key + "' relationship on '" + this + "' but some of the associated records were not loaded. Either make sure they are all loaded together with the parent record, or specify that the relationship is async (`DS.hasMany({ async: true })`)", Ember.A(records).isEvery('isEmpty', false));
+      relationshipFor: function(name) {
+        return get(this.constructor, 'relationshipsByName').get(name);
+      },
 
-          return store.findMany(this, data[key], typeForRelationshipMeta(store, meta));
-        });
-      }).meta(meta).readOnly();
-    }
+      inverseFor: function(key) {
+        return this.constructor.inverseFor(key);
+      }
 
+    });
+  });
+define("ember-data/system/relationships/has_many",
+  ["ember-data/system/model","exports"],
+  function(__dependency1__, __exports__) {
+    "use strict";
     /**
-      Returns a computed property that itself returns a promise that resolves to a
-      ManyArray.
-     */
-
-    function asyncHasMany(type, options, meta) {
-      return Ember.computed('data', function(key) {
-        // Configure the metadata for the computed property to contain
-        // the key.
-        meta.key = key;
-
-        var relationship = buildRelationship(this, key, options, function(store, data) {
-          var link = data.links && data.links[key];
-          var rel;
-          var promiseLabel = "DS: Async hasMany " + this + " : " + key;
-          var resolver = Ember.RSVP.defer(promiseLabel);
-
-          if (link) {
-            rel = store.findHasMany(this, link, relationshipFromMeta(store, meta), resolver);
-          } else {
-
-            //This is a temporary workaround for setting owner on the relationship
-            //until single source of truth lands. It only works for OneToMany atm
-            var records = data[key];
-            var inverse = this.constructor.inverseFor(key);
-            var owner = this;
-            if (inverse && records) {
-              if (inverse.kind === 'belongsTo'){
-                map(records, function(record){
-                  set(record, inverse.name, owner);
-                });
-              }
-            }
-
-            rel = store.findMany(owner, data[key], typeForRelationshipMeta(store, meta), resolver);
-          }
-
-          // Cache the promise so we can use it when we come back and don't
-          // need to rebuild the relationship.
-          set(rel, 'promise', resolver.promise);
-
-          return rel;
-        });
-
-        var promise = relationship.get('promise').then(function() {
-          return relationship;
-        }, null, "DS: Async hasMany records received");
-
-        return PromiseArray.create({
-          promise: promise
-        });
-      }).meta(meta).readOnly();
-    }
-
-    /*
-      Builds the ManyArray for a relationship using the provided callback,
-      but only if it had not been created previously. After building, it
-      sets some metadata on the created ManyArray, such as the record which
-      owns it and the name of the relationship.
+      @module ember-data
     */
-    function buildRelationship(record, key, options, callback) {
-      var rels = record._relationships;
 
-      if (rels[key]) { return rels[key]; }
-
-      var data = get(record, 'data');
-      var store = get(record, 'store');
-
-      var relationship = rels[key] = callback.call(record, store, data);
-
-      return setProperties(relationship, {
-        owner: record,
-        name: key,
-        isPolymorphic: options.polymorphic
-      });
-    }
+    var Model = __dependency1__.Model;
 
     /**
       `DS.hasMany` is used to define One-To-Many and Many-To-Many
@@ -10048,18 +9318,317 @@ define("ember-data/system/relationships/has_many",
         key: null
       };
 
-      if (options.async) {
-        return asyncHasMany(type, options, meta);
+      return Ember.computed(function(key) {
+        var relationship = this._relationships[key];
+        return relationship.getRecords();
+      }).meta(meta).readOnly();
+    }
+
+    Model.reopen({
+      notifyHasManyAdded: function(key, record, idx) {
+        var relationship = this._relationships[key];
+        var manyArray = relationship.manyArray;
+        manyArray.addRecord(record, idx);
+        //We need to notifyPropertyChange in the adding case because we need to make sure
+        //we fetch the newly added record in case it is unloaded
+        //TODO(Igor): Consider whether we could do this only if the record state is unloaded
+        this.notifyPropertyChange(key);
+      },
+
+      notifyHasManyRemoved: function(key, record) {
+        var relationship = this._relationships[key];
+        var manyArray = relationship.manyArray;
+        manyArray.removeRecord(record);
+      }
+    });
+
+
+    __exports__["default"] = hasMany;
+  });
+define("ember-data/system/relationships/relationship",
+  ["ember-data/system/promise_proxies","exports"],
+  function(__dependency1__, __exports__) {
+    "use strict";
+    var PromiseArray = __dependency1__.PromiseArray;
+    var PromiseObject = __dependency1__.PromiseObject;
+
+    var Relationship = function(store, record, inverseKey, relationshipMeta) {
+      this.members = new Ember.OrderedSet();
+      this.store = store;
+      this.key = relationshipMeta.key;
+      this.inverseKey = inverseKey;
+      this.record = record;
+      this.key = relationshipMeta.key;
+      this.isAsync = relationshipMeta.options.async;
+      this.relationshipMeta = relationshipMeta;
+    };
+
+    Relationship.prototype = {
+      constructor: Relationship,
+      hasFetchedLink: false,
+
+      destroy: Ember.K,
+
+      clear: function() {
+        this.members.forEach(function(member) {
+          this.removeRecord(member);
+        }, this);
+      },
+
+      removeRecords: function(records){
+        var that = this;
+        records.forEach(function(record){
+          that.removeRecord(record);
+        });
+      },
+
+      addRecords: function(records, idx){
+        var that = this;
+        records.forEach(function(record){
+          that.addRecord(record, idx);
+          if (idx !== undefined) {
+            idx++;
+          }
+        });
+      },
+
+
+      addRecord: function(record, idx) {
+        if (!this.members.has(record)) {
+          this.members.add(record);
+          this.notifyRecordRelationshipAdded(record, idx);
+          if (this.inverseKey) {
+            record._relationships[this.inverseKey].addRecord(this.record);
+          }
+          this.record.updateRecordArrays();
+        }
+      },
+
+      removeRecord: function(record) {
+        if (this.members.has(record)) {
+          this.members.remove(record);
+          this.notifyRecordRelationshipRemoved(record);
+          if (this.inverseKey) {
+            var inverseRelationship = record._relationships[this.inverseKey];
+            //Need to check for existence, as the record might unloading at the moment
+            if (inverseRelationship) {
+              inverseRelationship.removeRecord(this.record);
+            }
+          }
+          this.record.updateRecordArrays();
+        }
+      },
+
+      updateLink: function(link) {
+        if (link !== this.link) {
+          this.link = link;
+          this.hasFetchedLink = false;
+          this.record.notifyPropertyChange(this.key);
+        }
+      },
+
+      updateRecordsFromAdapter: function(records) {
+        //TODO Once we have adapter support, we need to handle updated and canonical changes
+        this.computeChanges(records);
+      }
+    };
+
+    var ManyRelationship = function(store, record, inverseKey, relationshipMeta) {
+      this._super$constructor(store, record, inverseKey, relationshipMeta);
+      this.belongsToType = relationshipMeta.type;
+      this.manyArray = store.recordArrayManager.createManyArray(this.belongsToType, Ember.A());
+      this.manyArray.relationship = this;
+      this.isPolymorphic = relationshipMeta.options.polymorphic;
+      this.manyArray.isPolymorphic = this.isPolymorphic;
+    };
+
+    ManyRelationship.prototype = Object.create(Relationship.prototype);
+    ManyRelationship.prototype.constructor = ManyRelationship;
+    ManyRelationship.prototype._super$constructor = Relationship;
+
+    ManyRelationship.prototype.destroy = function() {
+      this.manyArray.destroy();
+    };
+
+    ManyRelationship.prototype.notifyRecordRelationshipAdded = function(record, idx) {
+      Ember.assert("You cannot add '" + record.constructor.typeKey + "' records to this relationship (only '" + this.belongsToType.typeKey + "' allowed)", !this.belongsToType || record instanceof this.belongsToType);
+      this.record.notifyHasManyAdded(this.key, record, idx);
+    };
+
+    ManyRelationship.prototype.notifyRecordRelationshipRemoved = function(record) {
+      this.record.notifyHasManyRemoved(this.key, record);
+    };
+
+    ManyRelationship.prototype.computeChanges = function(records) {
+      var members = this.members;
+
+      records = setForArray(records);
+
+      members.forEach(function(member) {
+        if (records.has(member)) return;
+
+        this.removeRecord(member);
+      }, this);
+
+      var hasManyArray = this.manyArray;
+
+      records.forEach(function(record, index) {
+        //Need to preserve the order of incoming records
+        if (hasManyArray.objectAt(index) === record ) return;
+
+        this.removeRecord(record);
+        this.addRecord(record, index);
+      }, this);
+    };
+
+
+    ManyRelationship.prototype.getRecords = function() {
+      if (this.isAsync) {
+        var self = this;
+        var promise;
+        if (this.link && !this.hasFetchedLink) {
+          promise = this.store.findHasMany(this.record, this.link, this.relationshipMeta).then(function(records){
+            self.updateRecordsFromAdapter(records);
+            self.hasFetchedLink = true;
+            //TODO(Igor) try to abstract the isLoaded part
+            self.manyArray.set('isLoaded', true);
+            return self.manyArray;
+          });
+        } else {
+          var manyArray = this.manyArray;
+          promise = this.store.findMany(manyArray.toArray()).then(function(){
+            self.manyArray.set('isLoaded', true);
+            return manyArray;
+          });
+        }
+        return PromiseArray.create({
+          promise: promise
+        });
       } else {
-        return syncHasMany(type, options, meta);
+          Ember.assert("You looked up the '" + this.key + "' relationship on a '" + this.record.constructor.typeKey + "' with id " + this.record.get('id') +  " but some of the associated records were not loaded. Either make sure they are all loaded together with the parent record, or specify that the relationship is async (`DS.hasMany({ async: true })`)", this.manyArray.isEvery('isEmpty', false));
+
+        this.manyArray.set('isLoaded', true);
+        return this.manyArray;
+     }
+    };
+
+    var BelongsToRelationship = function(store, record, inverseKey, relationshipMeta) {
+      this._super$constructor(store, record, inverseKey, relationshipMeta);
+      this.members.add(record);
+      this.record = record;
+      this.key = relationshipMeta.key;
+      this.inverseKey = inverseKey;
+      this.inverseRecord = null;
+    };
+
+    BelongsToRelationship.prototype = Object.create(Relationship.prototype);
+    BelongsToRelationship.prototype.constructor = BelongsToRelationship;
+    BelongsToRelationship.prototype._super$constructor = Relationship;
+
+    BelongsToRelationship.prototype.setRecord = function(newRecord) {
+      if (newRecord) {
+        this.addRecord(newRecord);
+      } else if (this.inverseRecord) {
+        this.removeRecord(this.inverseRecord);
       }
+    };
+
+    BelongsToRelationship.prototype._super$addRecord = Relationship.prototype.addRecord;
+    BelongsToRelationship.prototype.addRecord = function(newRecord) {
+      if (this.members.has(newRecord)){ return;}
+      var type = this.relationshipMeta.type;
+      Ember.assert("You can only add a '" + type.typeKey + "' record to this relationship", newRecord instanceof type);
+
+      if (this.inverseRecord && this.inverseKey) {
+        this.removeRecord(this.inverseRecord);
+      }
+
+      this.inverseRecord = newRecord;
+      this._super$addRecord(newRecord);
+    };
+
+    BelongsToRelationship.prototype.notifyRecordRelationshipAdded = function(newRecord) {
+      this.record.notifyBelongsToAdded(this.key, this);
+    };
+
+    BelongsToRelationship.prototype.notifyRecordRelationshipRemoved = function(record) {
+      this.record.notifyBelongsToRemoved(this.key, this);
+    };
+
+    BelongsToRelationship.prototype._super$removeRecord = Relationship.prototype.removeRecord;
+    BelongsToRelationship.prototype.removeRecord = function(record) {
+      if (!this.members.has(record)){ return;}
+      this._super$removeRecord(record);
+      this.inverseRecord = null;
+    };
+
+    BelongsToRelationship.prototype.currentOtherSideFor = function() {
+      return this.inverseRecord;
+    };
+
+    BelongsToRelationship.prototype.getRecord = function() {
+      if (this.isAsync) {
+        var promise;
+
+        if (this.link && !this.hasFetchedLink){
+          var self = this;
+          promise = this.store.findBelongsTo(this.record, this.link, this.relationshipMeta).then(function(record){
+            self.addRecord(record);
+            self.hasFetchedLink = true;
+            return record;
+          });
+        } else if (this.inverseRecord) {
+          promise = this.store._findByRecord(this.inverseRecord);
+        } else {
+          promise = Ember.RSVP.Promise.resolve(null);
+        }
+
+        return PromiseObject.create({
+          promise: promise
+        });
+      } else {
+        Ember.assert("You looked up the '" + this.key + "' relationship on a '" + this.record.constructor.typeKey + "' with id " + this.record.get('id') +  " but some of the associated records were not loaded. Either make sure they are all loaded together with the parent record, or specify that the relationship is async (`DS.belongsTo({ async: true })`)", this.inverseRecord === null || !this.inverseRecord.get('isEmpty'));
+        return this.inverseRecord;
+      }
+    };
+
+    function setForArray(array) {
+      var set = new Ember.OrderedSet();
+
+      if (array) {
+        for (var i=0, l=array.length; i<l; i++) {
+          set.add(array[i]);
+        }
+      }
+
+      return set;
     }
 
-    __exports__["default"] = hasMany;
+    var createRelationshipFor = function(record, relationshipMeta, store){
+      var inverseKey;
+      var inverse = record.constructor.inverseFor(relationshipMeta.key);
+
+      if (inverse) {
+        inverseKey = inverse.name;
+      }
+
+      if (relationshipMeta.kind === 'hasMany'){
+        return new ManyRelationship(store, record, inverseKey, relationshipMeta);
+      }
+      else {
+        return new BelongsToRelationship(store, record, inverseKey, relationshipMeta);
+      }
+    };
+
+
+    __exports__.Relationship = Relationship;
+    __exports__.ManyRelationship = ManyRelationship;
+    __exports__.BelongsToRelationship = BelongsToRelationship;
+    __exports__.createRelationshipFor = createRelationshipFor;
   });
 define("ember-data/system/store",
-  ["ember-data/system/adapter","ember-inflector/system/string","exports"],
-  function(__dependency1__, __dependency2__, __exports__) {
+  ["ember-data/system/adapter","ember-inflector/system/string","ember-data/system/promise_proxies","exports"],
+  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
     "use strict";
     /*globals Ember*/
     /*jshint eqnull:true*/
@@ -10072,6 +9641,10 @@ define("ember-data/system/store",
     var Adapter = __dependency1__.Adapter;
     var singularize = __dependency2__.singularize;
 
+    var promiseArray = __dependency3__.promiseArray;
+    var promiseObject = __dependency3__.promiseObject;
+
+
     var get = Ember.get;
     var set = Ember.set;
     var once = Ember.run.once;
@@ -10081,7 +9654,7 @@ define("ember-data/system/store",
     var map = Ember.EnumerableUtils.map;
     var Promise = Ember.RSVP.Promise;
     var copy = Ember.copy;
-    var Store, PromiseObject, PromiseArray, RecordArrayManager, Model;
+    var Store, RecordArrayManager, Model;
 
     var camelize = Ember.String.camelize;
 
@@ -10202,7 +9775,6 @@ define("ember-data/system/store",
         this.recordArrayManager = RecordArrayManager.create({
           store: this
         });
-        this._relationshipChanges = {};
         this._pendingSave = [];
         //Used to keep track of all the find requests that need to be coalesced
         this._pendingFetch = Ember.Map.create();
@@ -10414,10 +9986,10 @@ define("ember-data/system/store",
 
         ---
 
-        You can optionally preload specific attributes and relationships that you know of
+        You can optionally `preload` specific attributes and relationships that you know of
         by passing them as the third argument to find.
 
-        For example, if your Ember route looks like `/posts/1/comments/2` and you API route
+        For example, if your Ember route looks like `/posts/1/comments/2` and your API route
         for the comment also looks like `/posts/1/comments/2` if you want to fetch the comment
         without fetching the post you can pass in the post to the `find` call:
 
@@ -10465,6 +10037,7 @@ define("ember-data/system/store",
         @method find
         @param {String or subclass of DS.Model} type
         @param {Object|String|Integer|null} id
+        @param {Object} preload - optional set of attributes and relationships passed in either as IDs or as actual models
         @return {Promise} promise
       */
       find: function(type, id, preload) {
@@ -10490,14 +10063,20 @@ define("ember-data/system/store",
         @private
         @param {String or subclass of DS.Model} type
         @param {String|Integer} id
+        @param {Object} preload - optional set of attributes and relationships passed in either as IDs or as actual models
         @return {Promise} promise
       */
       findById: function(typeName, id, preload) {
-        var fetchedRecord;
 
         var type = this.modelFor(typeName);
         var record = this.recordForId(type, id);
 
+        return this._findByRecord(record, preload);
+      },
+
+      _findByRecord: function(record, preload) {
+        var fetchedRecord;
+
         if (preload) {
           record._preloadData(preload);
         }
@@ -10509,7 +10088,7 @@ define("ember-data/system/store",
           fetchedRecord = record._loadingPromise;
         }
 
-        return promiseObject(fetchedRecord || record, "DS: Store#findById " + type + " with id: " + id);
+        return promiseObject(fetchedRecord || record, "DS: Store#findByRecord " + record.typeKey + " with id: " + get(record, 'id'));
       },
 
       /**
@@ -10524,7 +10103,6 @@ define("ember-data/system/store",
       */
       findByIds: function(type, ids) {
         var store = this;
-        var promiseLabel = "DS: Store#findByIds " + type;
 
         return promiseArray(Ember.RSVP.all(map(ids, function(id) {
           return store.findById(type, id);
@@ -10595,7 +10173,6 @@ define("ember-data/system/store",
         var adapter = store.adapterFor(type);
         var shouldCoalesce = !!adapter.findMany && adapter.coalesceFindRequests;
         var records = Ember.A(recordResolverPairs).mapBy('record');
-        var resolvers = Ember.A(recordResolverPairs).mapBy('resolver');
 
         function _fetchRecord(recordResolverPair) {
           recordResolverPair.resolver.resolve(store.fetchRecord(recordResolverPair.record));
@@ -10756,29 +10333,14 @@ define("ember-data/system/store",
         @param {Resolver} resolver
         @return {DS.ManyArray} records
       */
-      findMany: function(owner, inputRecords, typeName, resolver) {
-        var type = this.modelFor(typeName);
-        var records = Ember.A(inputRecords);
-        var unloadedRecords = records.filterProperty('isEmpty', true);
-        var manyArray = this.recordArrayManager.createManyArray(type, records);
-
-        manyArray.loadingRecordsCount = unloadedRecords.length;
-
-        if (unloadedRecords.length) {
-          forEach(unloadedRecords, function(record) {
-            this.recordArrayManager.registerWaitingRecordArray(record, manyArray);
-          }, this);
-
-          resolver.resolve(this.scheduleFetchMany(unloadedRecords, owner));
-        } else {
-          if (resolver) { resolver.resolve(); }
-          manyArray.set('isLoaded', true);
-          once(manyArray, 'trigger', 'didLoad');
-        }
-
-        return manyArray;
+      findMany: function(records) {
+        var store = this;
+        return Promise.all( map(records, function(record) {
+          return store._findByRecord(record);
+        }));
       },
 
+
       /**
         If a relationship was originally populated by the adapter as a link
         (as opposed to a list of IDs), this method is called when the
@@ -10797,15 +10359,13 @@ define("ember-data/system/store",
         @param {String or subclass of DS.Model} type
         @return {Promise} promise
       */
-      findHasMany: function(owner, link, relationship, resolver) {
+      findHasMany: function(owner, link, type) {
         var adapter = this.adapterFor(owner.constructor);
 
         Ember.assert("You tried to load a hasMany relationship but you have no adapter (for " + owner.constructor + ")", adapter);
         Ember.assert("You tried to load a hasMany relationship from a specified `link` in the original payload but your adapter does not implement `findHasMany`", adapter.findHasMany);
 
-        var records = this.recordArrayManager.createManyArray(relationship.type, Ember.A([]));
-        resolver.resolve(_findHasMany(adapter, this, owner, link, relationship));
-        return records;
+        return _findHasMany(adapter, this, owner, link, type);
       },
 
       /**
@@ -11151,6 +10711,7 @@ define("ember-data/system/store",
         if (data) {
           // normalize relationship IDs into records
           data = normalizeRelationships(this, record.constructor, data, record);
+          setupRelationships(this, record, data);
 
           this.updateId(record, data);
         }
@@ -11272,11 +10833,11 @@ define("ember-data/system/store",
         var factory;
 
         if (typeof key === 'string') {
-          var normalizedKey = this.container.normalize('model:' + key);
-
-          factory = this.container.lookupFactory(normalizedKey);
-          if (!factory) { throw new Ember.Error("No model was found for '" + key + "'"); }
-          factory.typeKey = this._normalizeTypeKey(normalizedKey.split(':', 2)[1]);
+          factory = this.container.lookupFactory('model:' + key);
+          if (!factory) {
+            throw new Ember.Error("No model was found for '" + key + "'");
+          }
+          factory.typeKey = factory.typeKey || this._normalizeTypeKey(key);
         } else {
           // A factory already supplied. Ensure it has a normalized key.
           factory = key;
@@ -11354,17 +10915,30 @@ define("ember-data/system/store",
         // _partial is an internal param used by `update`.
         // If passed, it means that the data should be
         // merged into the existing data, not replace it.
-
-        Ember.assert("You must include an `id` for " + typeName+ " in a hash passed to `push`", data.id != null);
+        Ember.assert("Expected an object as `data` in a call to push for " + typeName + " , but was " + data, Ember.typeOf(data) === 'object');
+        Ember.assert("You must include an `id` for " + typeName + " in an object passed to `push`", data.id != null);
 
         var type = this.modelFor(typeName);
 
-        // normalize relationship IDs into records
+        // If the payload contains relationships that are specified as
+        // IDs, normalizeRelationships will convert them into DS.Model instances
+        // (possibly unloaded) before we push the payload into the
+        // store.
+
         data = normalizeRelationships(this, type, data);
 
+        // Actually load the record into the store.
+
         this._load(type, data, _partial);
 
-        return this.recordForId(type, data.id);
+        var record = this.recordForId(type, data.id);
+
+        // Now that the pushed record as well as any related records
+        // are in the store, create the data structures used to track
+        // relationships.
+        setupRelationships(this, record, data);
+
+        return record;
       },
 
       /**
@@ -11499,9 +11073,14 @@ define("ember-data/system/store",
         @return {Array}
       */
       pushMany: function(type, datas) {
-        return map(datas, function(data) {
-          return this.push(type, data);
-        }, this);
+        var length = datas.length;
+        var result = new Array(length);
+
+        for (var i = 0; i < length; i++) {
+          result[i] = this.push(type, datas[i]);
+        }
+
+        return result;
       },
 
       /**
@@ -11586,59 +11165,6 @@ define("ember-data/system/store",
         typeMap.records.splice(loc, 1);
       },
 
-      // ........................
-      // . RELATIONSHIP CHANGES .
-      // ........................
-
-      addRelationshipChangeFor: function(childRecord, childKey, parentRecord, parentKey, change) {
-        var clientId = childRecord.clientId;
-        var parentClientId = parentRecord ? parentRecord : parentRecord;
-        var key = childKey + parentKey;
-        var changes = this._relationshipChanges;
-
-        if (!(clientId in changes)) {
-          changes[clientId] = {};
-        }
-        if (!(parentClientId in changes[clientId])) {
-          changes[clientId][parentClientId] = {};
-        }
-        if (!(key in changes[clientId][parentClientId])) {
-          changes[clientId][parentClientId][key] = {};
-        }
-        changes[clientId][parentClientId][key][change.changeType] = change;
-      },
-
-      removeRelationshipChangeFor: function(clientRecord, childKey, parentRecord, parentKey, type) {
-        var clientId = clientRecord.clientId;
-        var parentClientId = parentRecord ? parentRecord.clientId : parentRecord;
-        var changes = this._relationshipChanges;
-        var key = childKey + parentKey;
-
-        if (!(clientId in changes) || !(parentClientId in changes[clientId]) || !(key in changes[clientId][parentClientId])){
-          return;
-        }
-        delete changes[clientId][parentClientId][key][type];
-      },
-
-      relationshipChangePairsFor: function(record){
-        var toReturn = [];
-
-        if( !record ) { return toReturn; }
-
-        //TODO(Igor) What about the other side
-        var changesObject = this._relationshipChanges[record.clientId];
-        for (var objKey in changesObject){
-          if (changesObject.hasOwnProperty(objKey)){
-            for (var changeKey in changesObject[objKey]){
-              if (changesObject[objKey].hasOwnProperty(changeKey)){
-                toReturn.push(changesObject[objKey][changeKey]);
-              }
-            }
-          }
-        }
-        return toReturn;
-      },
-
       // ......................
       // . PER-TYPE ADAPTERS
       // ......................
@@ -11692,7 +11218,6 @@ define("ember-data/system/store",
       willDestroy: function() {
         var typeMaps = this.typeMaps;
         var keys = Ember.keys(typeMaps);
-        var store = this;
 
         var types = map(keys, byType);
 
@@ -11720,30 +11245,15 @@ define("ember-data/system/store",
       }
     });
 
+
     function normalizeRelationships(store, type, data, record) {
       type.eachRelationship(function(key, relationship) {
-        // A link (usually a URL) was already provided in
-        // normalized form
-        if (data.links && data.links[key]) {
-          if (record && relationship.options.async) { record._relationships[key] = null; }
-          return;
-        }
-
         var kind = relationship.kind;
         var value = data[key];
-
-        if (value == null) {
-          if (kind === 'hasMany' && record) {
-            value = data[key] = record.get(key).toArray();
-          }
-          return;
-        }
-
         if (kind === 'belongsTo') {
           deserializeRecordId(store, data, key, relationship, value);
         } else if (kind === 'hasMany') {
           deserializeRecordIds(store, data, key, relationship, value);
-          addUnsavedRecords(record, key, value);
         }
       });
 
@@ -11776,104 +11286,16 @@ define("ember-data/system/store",
     }
 
     function deserializeRecordIds(store, data, key, relationship, ids) {
+      if (!Ember.isArray(ids)) {
+        return;
+      }
       for (var i=0, l=ids.length; i<l; i++) {
         deserializeRecordId(store, ids, i, relationship, ids[i]);
       }
     }
 
-    // If there are any unsaved records that are in a hasMany they won't be
-    // in the payload, so add them back in manually.
-    function addUnsavedRecords(record, key, data) {
-      if(record) {
-        var unsavedRecords = uniqById(Ember.A(data), record.get(key).filterBy('isNew'));
-        Ember.A(data).pushObjects(unsavedRecords);
-      }
-    }
-
-    function uniqById(data, records) {
-      var currentIds = data.mapBy("id");
-      return records.reject(function(record) {
-        return Ember.A(currentIds).contains(record.id);
-      });
-    }
-
     // Delegation to the adapter and promise management
-    /**
-      A `PromiseArray` is an object that acts like both an `Ember.Array`
-      and a promise. When the promise is resolved the resulting value
-      will be set to the `PromiseArray`'s `content` property. This makes
-      it easy to create data bindings with the `PromiseArray` that will be
-      updated when the promise resolves.
 
-      For more information see the [Ember.PromiseProxyMixin
-      documentation](/api/classes/Ember.PromiseProxyMixin.html).
-
-      Example
-
-      ```javascript
-      var promiseArray = DS.PromiseArray.create({
-        promise: $.getJSON('/some/remote/data.json')
-      });
-
-      promiseArray.get('length'); // 0
-
-      promiseArray.then(function() {
-        promiseArray.get('length'); // 100
-      });
-      ```
-
-      @class PromiseArray
-      @namespace DS
-      @extends Ember.ArrayProxy
-      @uses Ember.PromiseProxyMixin
-    */
-    PromiseArray = Ember.ArrayProxy.extend(Ember.PromiseProxyMixin);
-    /**
-      A `PromiseObject` is an object that acts like both an `Ember.Object`
-      and a promise. When the promise is resolved, then the resulting value
-      will be set to the `PromiseObject`'s `content` property. This makes
-      it easy to create data bindings with the `PromiseObject` that will
-      be updated when the promise resolves.
-
-      For more information see the [Ember.PromiseProxyMixin
-      documentation](/api/classes/Ember.PromiseProxyMixin.html).
-
-      Example
-
-      ```javascript
-      var promiseObject = DS.PromiseObject.create({
-        promise: $.getJSON('/some/remote/data.json')
-      });
-
-      promiseObject.get('name'); // null
-
-      promiseObject.then(function() {
-        promiseObject.get('name'); // 'Tomster'
-      });
-      ```
-
-      @class PromiseObject
-      @namespace DS
-      @extends Ember.ObjectProxy
-      @uses Ember.PromiseProxyMixin
-    */
-    PromiseObject = Ember.ObjectProxy.extend(Ember.PromiseProxyMixin);
-
-    function promiseObject(promise, label) {
-      return PromiseObject.create({
-        promise: Promise.cast(promise, label)
-      });
-    }
-
-    function promiseArray(promise, label) {
-      return PromiseArray.create({
-        promise: Promise.cast(promise, label)
-      });
-    }
-
-    function isThenable(object) {
-      return object && typeof object.then === 'function';
-    }
 
     function serializerFor(container, type, defaultSerializer) {
       return container.lookup('serializer:'+type) ||
@@ -11959,8 +11381,6 @@ define("ember-data/system/store",
         throw new Error('adapter.findMany returned undefined, this was very likely a mistake');
       }
 
-      var guardedPromise;
-
       promise = Promise.cast(promise, label);
       promise = _guard(promise, _bind(_objectIsAlive, store));
 
@@ -11988,7 +11408,7 @@ define("ember-data/system/store",
         Ember.assert("The response from a findHasMany must be an Array, not " + Ember.inspect(payload), Ember.typeOf(payload) === 'array');
 
         var records = store.pushMany(relationship.type, payload);
-        record.updateHasMany(relationship.key, records);
+        return records;
       }, null, "DS: Extract payload of " + record + " : hasMany " + relationship.type);
     }
 
@@ -12004,8 +11424,6 @@ define("ember-data/system/store",
       return promise.then(function(adapterPayload) {
         var payload = serializer.extract(store, relationship.type, adapterPayload, null, 'findBelongsTo');
         var record = store.push(relationship.type, payload);
-
-        record.updateBelongsTo(relationship.key, record);
         return record;
       }, null, "DS: Extract payload of " + record + " : " + relationship.type);
     }
@@ -12081,10 +11499,30 @@ define("ember-data/system/store",
       }, label);
     }
 
-    __exports__.Store = Store;
-    __exports__.PromiseArray = PromiseArray;
-    __exports__.PromiseObject = PromiseObject;
+    function setupRelationships(store, record, data) {
+      var type = record.constructor;
+
+      type.eachRelationship(function(key, descriptor) {
+        var kind = descriptor.kind;
+        var value = data[key];
+        var relationship = record._relationships[key];
+
+        if (data.links && data.links[key]) {
+          relationship.updateLink(data.links[key]);
+        }
 
+        if (kind === 'belongsTo') {
+          if (value === undefined) {
+            return;
+          }
+          relationship.setRecord(value);
+        } else if (kind === 'hasMany' && value) {
+         relationship.updateRecordsFromAdapter(value);
+        }
+      });
+    }
+
+    __exports__.Store = Store;
     __exports__["default"] = Store;
   });
 define("ember-data/transforms",