The extract method is used to deserialize payload data from the server. By default the JSONSerializer does not push the records into the store. However records that subclass JSONSerializer such as the RESTSerializer may push records into the store as part of the extract call.

This method delegates to a more specific extract method based on the requestType.

Example

var get = Ember.get;
socket.on('message', function(message) {
  var modelName = message.model;
  var data = message.data;
  var type = store.modelFor(modelName);
  var serializer = store.serializerFor(type.typeKey);
  var record = serializer.extract(store, type, data, get(data, 'id'), 'single');
  store.push(modelName, record);
});

extractArray is used to deserialize an array of records returned from the adapter.

Example

App.PostSerializer = DS.JSONSerializer.extend({
  extractArray: function(store, type, payload) {
    return payload.map(function(json) {
      return this.extractSingle(json);
    }, this);
  }
});

extractCreateRecord is a hook into the extract method used when a call is made to DS.Store#createRecord. By default this method is alias for extractSave.

extractDeleteRecord is a hook into the extract method used when a call is made to DS.Store#deleteRecord. By default this method is alias for extractSave.

extractFind is a hook into the extract method used when a call is made to DS.Store#find. By default this method is alias for extractSingle.

extractFindAll is a hook into the extract method used when a call is made to DS.Store#findAll. By default this method is an alias for extractArray.

extractFindBelongsTo is a hook into the extract method used when a call is made to DS.Store#findBelongsTo. By default this method is alias for extractSingle.

extractFindHasMany is a hook into the extract method used when a call is made to DS.Store#findHasMany. By default this method is alias for extractArray.

extractFindMany is a hook into the extract method used when a call is made to DS.Store#findMany. By default this method is alias for extractArray.

extractFindQuery is a hook into the extract method used when a call is made to DS.Store#findQuery. By default this method is an alias for extractArray.

extractMeta is used to deserialize any meta information in the adapter payload. By default Ember Data expects meta information to be located on the meta property of the payload object.

Example

App.PostSerializer = DS.JSONSerializer.extend({
  extractMeta: function(store, type, payload) {
    if (payload && payload._pagination) {
      store.metaForType(type, payload._pagination);
      delete payload._pagination;
    }
  }
});

extractSave is a hook into the extract method used when a call is made to DS.Model#save. By default this method is alias for extractSingle.

extractSingle is used to deserialize a single record returned from the adapter.

Example

App.PostSerializer = DS.JSONSerializer.extend({
  extractSingle: function(store, type, payload) {
    payload.comments = payload._embedded.comment;
    delete payload._embedded;

    return this._super(store, type, payload);
  },
});

extractUpdateRecord is a hook into the extract method used when a call is made to DS.Store#update. By default this method is alias for extractSave.

Converts attributes to underscore to use conventional Solr field names

keyForRelationship can be used to define a custom key when serializing relationship properties. By default JSONSerializer does not provide an implementation of this method.

Example

App.PostSerializer = DS.JSONSerializer.extend({
  keyForRelationship: function(key, relationship) {
     return 'rel_' + Ember.String.underscore(key);
  }
});

Normalizes a part of the JSON payload returned by the server. You should override this method, munge the hash and call super if you have generic normalization to do.

It takes the type of the record that is being normalized (as a DS.Model class), the property where the hash was originally found, and the hash to normalize.

You can use this method, for example, to normalize underscored keys to camelized or other general-purpose normalizations.

Example

App.ApplicationSerializer = DS.JSONSerializer.extend({
  normalize: function(type, hash) {
    var fields = Ember.get(type, 'fields');
    fields.forEach(function(field) {
      var payloadField = Ember.String.underscore(field);
      if (field === payloadField) { return; }

      hash[field] = hash[payloadField];
      delete hash[payloadField];
    });
    return this._super.apply(this, arguments);
  }
});

Serialize only modified attributes for a snapshot using atomic update operations.

Determines if an attribute can be serialized and if the value is dirty.

serializeBelongsTo can be used to customize how DS.belongsTo properties are serialized.

Example

App.PostSerializer = DS.JSONSerializer.extend({
  serializeBelongsTo: function(record, json, relationship) {
    var key = relationship.key;

    var belongsTo = get(record, key);

    key = this.keyForRelationship ? this.keyForRelationship(key, "belongsTo") : key;

    json[key] = Ember.isNone(belongsTo) ? belongsTo : belongsTo.toJSON();
  }
});

serializeHasMany can be used to customize how DS.hasMany properties are serialized.

Example

App.PostSerializer = DS.JSONSerializer.extend({
  serializeHasMany: function(record, json, relationship) {
    var key = relationship.key;
    if (key === 'comments') {
      return;
    } else {
      this._super.apply(this, arguments);
    }
  }
});

You can use this method to customize how polymorphic objects are serialized. Objects are considered to be polymorphic if {polymorphic: true} is pass as the second argument to the DS.belongsTo function.

Example

App.CommentSerializer = DS.JSONSerializer.extend({
  serializePolymorphicType: function(record, json, relationship) {
    var key = relationship.key,
        belongsTo = get(record, key);
    key = this.keyForAttribute ? this.keyForAttribute(key) : key;
    json[key + "_type"] = belongsTo.constructor.typeKey;
  }
});