ember-data-source 1.13.3 → 1.13.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9a85f2c10ff7c348810a4af1bf942b4cb27e9579
-  data.tar.gz: bc986aadb0f1276ec0f50f84461d4bc776693568
+  metadata.gz: 697e9db009a98edf76770a04325a458d0883233b
+  data.tar.gz: c55896935e8b62f5354ad01c3b97abe5d9e0fc86
 SHA512:
-  metadata.gz: 86c473314af58edf434dfe7d8a4d90266a24a565d81df4a18552addad9cc9ab88193e3fcdc3f442f829a1ee5efc037cdc277ac62faf6a9f1fae90f4d1f522213
-  data.tar.gz: f288c010085e7d07ec226d9f3a0334c3870a5d2f959f48d54e5df902d10862a0b59a2563b37f200cae12bc71c77337e42b9f67ae2c36d863beedd1f177940456
+  metadata.gz: c22bae99bb68f26d374351eeef8cde7f40eb031c60d83a699a770332ee21b547d996e5e737aec70a65954ee9b67a88a124a07af2571636111f66ff0bb8569543
+  data.tar.gz: d09c254dbdb90ae9a5c1a0f90f8f6f7d749aaf5515cfecda1f9a1a0e5e316e00a3501251741d6ea17eeaa6ee0fcaea1693ef118e567dfa61a923949240f70027

data/dist/ember-data-tests.js

@@ -1845,7 +1845,7 @@ define(
       run(function () {
         expectDeprecation(function () {
           store.findAll('person');
-        }, 'The default behavior of shouldReloadAll will change in Ember Data 2.0 to always return false when there is at least one "person" record in the store. If you would like to preserve the current behavior please override shouldReloadAll in you adapter:application and return true.');
+        }, 'The default behavior of shouldReloadAll will change in Ember Data 2.0 to always return false when there is at least one "person" record in the store. If you would like to preserve the current behavior please override shouldReloadAll in your adapter:application and return true.');
       });
     });
 
@@ -2745,6 +2745,79 @@ define(
         });
       });
     });
+
+    test('update record - serialize hasMany', function () {
+      expect(3);
+
+      ajaxResponse([{
+        data: {
+          type: 'users',
+          id: '1'
+        }
+      }]);
+
+      env.registry.register('serializer:user', DS.JSONAPISerializer.extend({
+        attrs: {
+          handles: { serialize: true }
+        }
+      }));
+
+      run(function () {
+        var user = store.push({ data: {
+            type: 'user',
+            id: '1',
+            attributes: {
+              firstName: 'Yehuda',
+              lastName: 'Katz'
+            }
+          } });
+
+        var githubHandle = store.push({ data: {
+            type: 'github-handle',
+            id: '2',
+            attributes: {
+              username: 'wycats'
+            }
+          } });
+
+        var twitterHandle = store.push({ data: {
+            type: 'twitter-handle',
+            id: '3',
+            attributes: {
+              nickname: '@wycats'
+            }
+          } });
+
+        user.set('firstName', 'Yehuda!');
+
+        user.get('handles').then(function (handles) {
+          handles.addObject(githubHandle);
+          handles.addObject(twitterHandle);
+
+          user.save().then(function () {
+            equal(passedUrl[0], '/users/1');
+            equal(passedVerb[0], 'PATCH');
+            deepEqual(passedHash[0], {
+              data: {
+                data: {
+                  type: 'users',
+                  id: '1',
+                  attributes: {
+                    'first-name': 'Yehuda!',
+                    'last-name': 'Katz'
+                  },
+                  relationships: {
+                    handles: {
+                      data: [{ type: 'github-handles', id: '2' }, { type: 'twitter-handles', id: '3' }]
+                    }
+                  }
+                }
+              }
+            });
+          });
+        });
+      });
+    });
   }
 );
 
@@ -3059,6 +3132,109 @@ define(
 );
 
 
+define(
+  "ember-data/tests/integration/adapter/rest-adapter-new-test",
+  ["exports"],
+  function(__exports__) {
+    "use strict";
+
+    function __es6_export__(name, value) {
+      __exports__[name] = value;
+    }
+
+    var env, store, adapter;
+
+    var passedUrl, passedVerb, passedHash;
+
+    var get = Ember.get;
+    var run = Ember.run;
+
+    var Post, Comment;
+
+    module("integration/adapter/rest_adapter - REST Adapter (new API)", {
+      setup: function () {
+        Post = DS.Model.extend({
+          title: DS.attr("string"),
+          comments: DS.hasMany("comment")
+        });
+
+        Post.toString = function () {
+          return "Post";
+        };
+
+        Comment = DS.Model.extend({
+          text: DS.attr("string")
+        });
+
+        env = setupStore({
+          post: Post,
+          comment: Comment,
+
+          adapter: DS.RESTAdapter.extend({
+            defaultSerializer: "-rest-new"
+          })
+        });
+
+        store = env.store;
+        adapter = env.adapter;
+
+        passedUrl = passedVerb = passedHash = null;
+      }
+    });
+
+    function ajaxResponse(value) {
+      adapter.ajax = function (url, verb, hash) {
+        passedUrl = url;
+        passedVerb = verb;
+        passedHash = hash;
+
+        return run(Ember.RSVP, "resolve", Ember.copy(value, true));
+      };
+    }
+
+    test("metadata is accessible", function () {
+      ajaxResponse({
+        meta: { offset: 5 },
+        posts: [{ id: 1, title: "Rails is very expensive sushi" }]
+      });
+
+      store.findAll("post").then(async(function (posts) {
+        equal(store.metadataFor("post").offset, 5, "Metadata can be accessed with metadataFor.");
+      }));
+    });
+
+    test("create - sideloaded records are pushed to the store", function () {
+      ajaxResponse({
+        post: {
+          id: 1,
+          title: "The Parley Letter",
+          comments: [2, 3]
+        },
+        comments: [{
+          id: 2,
+          text: "First comment"
+        }, {
+          id: 3,
+          text: "Second comment"
+        }]
+      });
+      var post;
+
+      run(function () {
+        post = store.createRecord("post", { name: "The Parley Letter" });
+        post.save().then(function (post) {
+          var comments = store.peekAll("comment");
+
+          equal(get(comments, "length"), 2, "comments.length is correct");
+          equal(get(comments, "firstObject.text"), "First comment", "comments.firstObject.text is correct");
+          equal(get(comments, "lastObject.text"), "Second comment", "comments.lastObject.text is correct");
+        });
+      });
+    });
+  }
+);
+
+
 // Noop
 // NOOP
 // Noop
@@ -15988,24 +16164,109 @@ define(
       __exports__[name] = value;
     }
 
-    var env;
+    var env, store, serializer;
+
+    var get = Ember.get;
     var run = Ember.run;
 
+    var User, Handle, GithubHandle, TwitterHandle, Company;
+
     module('integration/serializers/json-api-serializer - JSONAPISerializer', {
       setup: function () {
-        env = setupStore({});
+        User = DS.Model.extend({
+          firstName: DS.attr('string'),
+          lastName: DS.attr('string'),
+          handles: DS.hasMany('handle', { async: true, polymorphic: true }),
+          company: DS.belongsTo('company', { async: true })
+        });
+
+        Handle = DS.Model.extend({
+          user: DS.belongsTo('user', { async: true })
+        });
+
+        GithubHandle = Handle.extend({
+          username: DS.attr('string')
+        });
+
+        TwitterHandle = Handle.extend({
+          nickname: DS.attr('string')
+        });
+
+        Company = DS.Model.extend({
+          name: DS.attr('string'),
+          employees: DS.hasMany('user', { async: true })
+        });
+
+        env = setupStore({
+          adapter: DS.JSONAPIAdapter,
+
+          user: User,
+          handle: Handle,
+          'github-handle': GithubHandle,
+          'twitter-handle': TwitterHandle,
+          company: Company
+        });
+
+        store = env.store;
+        serializer = env.container.lookup('serializer:-json-api');
       },
 
       teardown: function () {
         run(env.store, 'destroy');
       }
     });
-  }
-);
 
-/*test('...', function() {
+    test('Calling pushPayload works', function () {
+      run(function () {
+        serializer.pushPayload(store, {
+          data: {
+            type: 'users',
+            id: '1',
+            attributes: {
+              'first-name': 'Yehuda',
+              'last-name': 'Katz'
+            },
+            relationships: {
+              company: {
+                data: { type: 'companies', id: '2' }
+              },
+              handles: {
+                data: [{ type: 'github-handles', id: '3' }, { type: 'twitter-handles', id: '4' }]
+              }
+            }
+          },
+          included: [{
+            type: 'companies',
+            id: '2',
+            attributes: {
+              name: 'Tilde Inc.'
+            }
+          }, {
+            type: 'github-handles',
+            id: '3',
+            attributes: {
+              username: 'wycats'
+            }
+          }, {
+            type: 'twitter-handles',
+            id: '4',
+            attributes: {
+              nickname: '@wycats'
+            }
+          }]
+        });
+
+        var user = store.peekRecord('user', 1);
 
-});*/
+        equal(get(user, 'firstName'), 'Yehuda', 'firstName is correct');
+        equal(get(user, 'lastName'), 'Katz', 'lastName is correct');
+        equal(get(user, 'company.name'), 'Tilde Inc.', 'company.name is correct');
+        equal(get(user, 'handles.firstObject.username'), 'wycats', 'handles.firstObject.username is correct');
+        equal(get(user, 'handles.lastObject.nickname'), '@wycats', 'handles.lastObject.nickname is correct');
+      });
+    });
+  }
+);
 
 
 define(
@@ -26977,6 +27238,13 @@ test('ember-data/tests/integration/adapter/record-persistence-test.js should pas
   ok(true, 'ember-data/tests/integration/adapter/record-persistence-test.js should pass jshint.'); 
 });
 
+}
+if (!QUnit.urlParams.nojshint) {
+module('JSHint - ember-data/tests/integration/adapter');
+test('ember-data/tests/integration/adapter/rest-adapter-new-test.js should pass jshint', function() { 
+  ok(true, 'ember-data/tests/integration/adapter/rest-adapter-new-test.js should pass jshint.'); 
+});
+
 }
 if (!QUnit.urlParams.nojshint) {
 module('JSHint - ember-data/tests/integration/adapter');

data/dist/ember-data.js

@@ -252,7 +252,7 @@
       /**
         Implement this method in a subclass to handle the creation of
         new records.
-         Serializes the record and send it to the server.
+         Serializes the record and sends it to the server.
          Example
          ```app/adapters/application.js
         import DS from 'ember-data';
@@ -287,7 +287,7 @@
       /**
         Implement this method in a subclass to handle the updating of
         a record.
-         Serializes the record update and send it to the server.
+         Serializes the record update and sends it to the server.
          Example
          ```app/adapters/application.js
         import DS from 'ember-data';
@@ -360,14 +360,14 @@
         By default the store will try to coalesce all `fetchRecord` calls within the same runloop
         into as few requests as possible by calling groupRecordsForFindMany and passing it into a findMany call.
         You can opt out of this behaviour by either not implementing the findMany hook or by setting
-        coalesceFindRequests to false
+        coalesceFindRequests to false.
          @property coalesceFindRequests
         @type {boolean}
       */
       coalesceFindRequests: true,
 
       /**
-        Find multiple records at once if coalesceFindRequests is true
+        Find multiple records at once if coalesceFindRequests is true.
          @method findMany
         @param {DS.Store} store
         @param {DS.Model} type   the DS.Model class of the records
@@ -396,7 +396,7 @@
         This method is used by the store to determine if the store should
         reload a record from the adapter when a record is requested by
         `store.findRecord`.
-         If this method returns true the store will re fetch a record form
+         If this method returns true the store will re fetch a record from
         the adapter. If is method returns false the store will resolve
         immediately using the cached record.
          @method shouldReloadRecord
@@ -412,7 +412,7 @@
         This method is used by the store to determine if the store should
         reload all records from the adapter when records are requested by
         `store.findAll`.
-         If this method returns true the store will re fetch all records form
+         If this method returns true the store will re fetch all records from
         the adapter. If is method returns false the store will resolve
         immediately using the cached record.
          @method shouldReloadRecord
@@ -422,17 +422,17 @@
       */
       shouldReloadAll: function (store, snapshotRecordArray) {
         var modelName = snapshotRecordArray.type.modelName;
-        Ember.deprecate('The default behavior of shouldReloadAll will change in Ember Data 2.0 to always return false when there is at least one "' + modelName + '" record in the store. If you would like to preserve the current behavior please override shouldReloadAll in you adapter:application and return true.');
+        Ember.deprecate('The default behavior of shouldReloadAll will change in Ember Data 2.0 to always return false when there is at least one "' + modelName + '" record in the store. If you would like to preserve the current behavior please override shouldReloadAll in your adapter:application and return true.');
         return true;
       },
 
       /**
         This method is used by the store to determine if the store should
         reload a record after the `store.findRecord` method resolves a
-        chached record.
+        cached record.
          This method is *only* checked by the store when the store is
         returning a cached record.
-         If this method returns true the store will re-fetch a record form
+         If this method returns true the store will re-fetch a record from
         the adapter.
          @method shouldBackgroundReloadRecord
         @param {DS.Store} store
@@ -440,18 +440,18 @@
         @return {Boolean}
       */
       shouldBackgroundReloadRecord: function (store, snapshot) {
-        Ember.deprecate('The default behavior of `shouldBackgroundReloadRecord` will change in Ember Data 2.0 to always return true. If you would like to preserve the current behavior please override `shouldBackgroundReloadRecord` in you adapter:application and return false.');
+        Ember.deprecate('The default behavior of `shouldBackgroundReloadRecord` will change in Ember Data 2.0 to always return true. If you would like to preserve the current behavior please override `shouldBackgroundReloadRecord` in your adapter:application and return false.');
         return false;
       },
 
       /**
         This method is used by the store to determine if the store should
         reload a record array after the `store.findAll` method resolves
-        with a chached record array.
+        with a cached record array.
          This method is *only* checked by the store when the store is
         returning a cached record array.
          If this method returns true the store will re-fetch all records
-        form the adapter.
+        from the adapter.
          @method shouldBackgroundReloadAll
         @param {DS.Store} store
         @param {DS.SnapshotRecordArray} snapshotRecordArray
@@ -4347,7 +4347,7 @@
         }
 
         if (payload && payload.meta) {
-          store.setMetadataFor(typeClass, payload.meta);
+          store._setMetadataFor(typeClass, payload.meta);
           delete payload.meta;
         }
       },
@@ -5691,7 +5691,12 @@
     */
     function ember$data$lib$system$store$serializer$response$$normalizeResponseHelper(serializer, store, modelClass, payload, id, requestType) {
       if (serializer.get('isNewSerializerAPI')) {
-        return serializer.normalizeResponse(store, modelClass, payload, id, requestType);
+        var normalizedResponse = serializer.normalizeResponse(store, modelClass, payload, id, requestType);
+        // TODO: Remove after metadata refactor
+        if (normalizedResponse.meta) {
+          store._setMetadataFor(modelClass.modelName, normalizedResponse.meta);
+        }
+        return normalizedResponse;
       } else {
         Ember.deprecate('Your custom serializer uses the old version of the Serializer API, with `extract` hooks. Please upgrade your serializers to the new Serializer API using `normalizeResponse` hooks instead.');
         var serializerPayload = serializer.extract(store, modelClass, payload, id, requestType);
@@ -5712,7 +5717,7 @@
       var data = null;
 
       if (payload) {
-        if (Ember.isArray(payload)) {
+        if (Ember.typeOf(payload) === 'array') {
           data = ember$data$lib$system$store$serializer$response$$map.call(payload, function (payload) {
             return ember$data$lib$system$store$serializer$response$$_normalizeSerializerPayloadItem(modelClass, payload);
           });
@@ -6905,7 +6910,7 @@
       @module ember-data
     */
 
-    var activemodel$adapter$lib$system$active$model$serializer$$forEach = Ember.EnumerableUtils.forEach;
+    var activemodel$adapter$lib$system$active$model$serializer$$forEach = Ember.ArrayPolyfills.forEach;
     var activemodel$adapter$lib$system$active$model$serializer$$camelize = Ember.String.camelize;
     var activemodel$adapter$lib$system$active$model$serializer$$classify = Ember.String.classify;
     var activemodel$adapter$lib$system$active$model$serializer$$decamelize = Ember.String.decamelize;
@@ -7166,7 +7171,7 @@
                 payload.type = this.modelNameFromPayloadKey(payload.type);
               } else if (payload && relationship.kind === "hasMany") {
                 var self = this;
-                activemodel$adapter$lib$system$active$model$serializer$$forEach(payload, function (single) {
+                activemodel$adapter$lib$system$active$model$serializer$$forEach.call(payload, function (single) {
                   single.type = self.modelNameFromPayloadKey(single.type);
                 });
               }
@@ -7249,7 +7254,7 @@
       registry.register("adapter:-active-model", activemodel$adapter$lib$system$active$model$adapter$$default);
     }
     var ember$data$lib$core$$DS = Ember.Namespace.create({
-      VERSION: '1.13.3'
+      VERSION: '1.13.4'
     });
 
     if (Ember.libraries) {
@@ -7785,7 +7790,7 @@
         var store = ember$data$lib$system$record$arrays$adapter$populated$record$array$$get(this, "store");
         var type = ember$data$lib$system$record$arrays$adapter$populated$record$array$$get(this, "type");
         var modelName = type.modelName;
-        var meta = store.metadataFor(modelName);
+        var meta = store._metadataFor(modelName);
 
         //TODO Optimize
         var internalModels = Ember.A(records).mapBy("_internalModel");
@@ -12312,8 +12317,20 @@
          @method metadataFor
         @param {String} modelName
         @return {object}
+        @deprecated
       */
       metadataFor: function (modelName) {
+        Ember.deprecate("`store.metadataFor()` has been deprecated. You can use `.get('meta')` on relationships and arrays returned from `store.query()`.");
+        return this._metadataFor(modelName);
+      },
+
+      /**
+        @method _metadataFor
+        @param {String} modelName
+        @return {object}
+        @private
+      */
+      _metadataFor: function (modelName) {
         Ember.assert("Passing classes to store methods has been removed. Please pass a dasherized string instead of " + Ember.inspect(modelName), typeof modelName === "string");
         var typeClass = this.modelFor(modelName);
         return this.typeMapFor(typeClass).metadata;
@@ -12325,8 +12342,20 @@
         @param {String} modelName
         @param {Object} metadata metadata to set
         @return {object}
+        @deprecated
       */
       setMetadataFor: function (modelName, metadata) {
+        Ember.deprecate("`store.setMetadataFor()` has been deprecated. Please return meta from your serializer's `extractMeta` hook.");
+        this._setMetadataFor(modelName, metadata);
+      },
+
+      /**
+        @method _setMetadataFor
+        @param {String} modelName
+        @param {Object} metadata metadata to set
+        @private
+      */
+      _setMetadataFor: function (modelName, metadata) {
         Ember.assert("Passing classes to store methods has been removed. Please pass a dasherized string instead of " + Ember.inspect(modelName), typeof modelName === "string");
         var typeClass = this.modelFor(modelName);
         Ember.merge(this.typeMapFor(typeClass).metadata, metadata);
@@ -12674,11 +12703,11 @@
         if (Ember.typeOf(modelNameArg) === "object" && Ember.typeOf(dataArg) === "undefined") {
           data = modelNameArg;
         } else {
+          Ember.deprecate("store.push(type, data) has been deprecated. Please provide a JSON-API document object as the first and only argument to store.push.");
           Ember.assert("Expected an object as `data` in a call to `push` for " + modelNameArg + " , but was " + Ember.typeOf(dataArg), Ember.typeOf(dataArg) === "object");
           Ember.assert("You must include an `id` for " + modelNameArg + " in an object passed to `push`", dataArg.id != null && dataArg.id !== "");
           data = ember$data$lib$system$store$serializer$response$$_normalizeSerializerPayload(this.modelFor(modelNameArg), dataArg);
           modelName = modelNameArg;
-          Ember.deprecate("store.push(type, data) has been deprecated. Please provide a JSON-API document object as the first and only argument to store.push.");
           Ember.assert("Passing classes to store methods has been removed. Please pass a dasherized string instead of " + Ember.inspect(modelName), typeof modelName === "string" || typeof data === "undefined");
         }
 
@@ -13141,6 +13170,9 @@
           var payload, data;
           if (adapterPayload) {
             payload = ember$data$lib$system$store$serializer$response$$normalizeResponseHelper(serializer, store, typeClass, adapterPayload, snapshot.id, operation);
+            if (payload.included) {
+              store.push({ data: payload.included });
+            }
             data = ember$data$lib$system$store$serializer$response$$convertResourceObject(payload.data);
           }
           store.didSaveRecord(internalModel, ember$data$lib$system$store$serializer$response$$_normalizeSerializerPayload(internalModel.type, data));
@@ -13227,7 +13259,7 @@
     var ember$data$lib$system$store$$default = ember$data$lib$system$store$$Store;
 
     var ember$data$lib$serializers$json$api$serializer$$dasherize = Ember.String.dasherize;
-    var ember$data$lib$serializers$json$api$serializer$$map = Ember.EnumerableUtils.map;
+    var ember$data$lib$serializers$json$api$serializer$$map = Ember.ArrayPolyfills.map;
 
     var ember$data$lib$serializers$json$api$serializer$$default = ember$data$lib$serializers$json$serializer$$default.extend({
 
@@ -13239,6 +13271,27 @@
       */
       isNewSerializerAPI: true,
 
+      /*
+        @method _normalizeDocumentHelper
+        @param {Object} documentHash
+        @return {Object}
+        @private
+      */
+      _normalizeDocumentHelper: function (documentHash) {
+
+        if (Ember.typeOf(documentHash.data) === 'object') {
+          documentHash.data = this._normalizeResourceHelper(documentHash.data);
+        } else {
+          documentHash.data = ember$data$lib$serializers$json$api$serializer$$map.call(documentHash.data, this._normalizeResourceHelper, this);
+        }
+
+        if (Ember.typeOf(documentHash.included) === 'array') {
+          documentHash.included = ember$data$lib$serializers$json$api$serializer$$map.call(documentHash.included, this._normalizeResourceHelper, this);
+        }
+
+        return documentHash;
+      },
+
       /*
         @method _normalizeRelationshipDataHelper
         @param {Object} relationshipDataHash
@@ -13269,6 +13322,16 @@
         return data;
       },
 
+      /**
+        @method pushPayload
+        @param {DS.Store} store
+        @param {Object} payload
+      */
+      pushPayload: function (store, payload) {
+        var normalizedPayload = this._normalizeDocumentHelper(payload);
+        store.push(normalizedPayload);
+      },
+
       /**
         @method _normalizeResponse
         @param {DS.Store} store
@@ -13282,17 +13345,8 @@
       */
       _normalizeResponse: function (store, primaryModelClass, payload, id, requestType, isSingle) {
 
-        if (Ember.typeOf(payload.data) === 'object') {
-          payload.data = this._normalizeResourceHelper(payload.data);
-        } else {
-          payload.data = ember$data$lib$serializers$json$api$serializer$$map(payload.data, this._normalizeResourceHelper, this);
-        }
-
-        if (Ember.typeOf(payload.included) === 'array') {
-          payload.included = ember$data$lib$serializers$json$api$serializer$$map(payload.included, this._normalizeResourceHelper, this);
-        }
-
-        return payload;
+        var normalizedPayload = this._normalizeDocumentHelper(payload);
+        return normalizedPayload;
       },
 
       /*
@@ -13330,7 +13384,7 @@
         }
 
         if (Ember.typeOf(relationshipHash.data) === 'array') {
-          relationshipHash.data = ember$data$lib$serializers$json$api$serializer$$map(relationshipHash.data, this._normalizeRelationshipDataHelper, this);
+          relationshipHash.data = ember$data$lib$serializers$json$api$serializer$$map.call(relationshipHash.data, this._normalizeRelationshipDataHelper, this);
         }
 
         return relationshipHash;
@@ -13512,6 +13566,8 @@
        @param {Object} relationship
       */
       serializeHasMany: function (snapshot, json, relationship) {
+        var _this3 = this;
+
         var key = relationship.key;
 
         if (this._shouldSerializeHasMany(snapshot, key, relationship)) {
@@ -13525,9 +13581,9 @@
               payloadKey = this.keyForRelationship(key, 'hasMany', 'serialize');
             }
 
-            var data = ember$data$lib$serializers$json$api$serializer$$map(hasMany, function (item) {
+            var data = ember$data$lib$serializers$json$api$serializer$$map.call(hasMany, function (item) {
               return {
-                type: item.modelName,
+                type: _this3.payloadKeyFromModelName(item.modelName),
                 id: item.id
               };
             });