Class DS.RESTSerializer

Extends: DS.JSONSerializer
Defined in: packages/ember-data/lib/serializers/rest-serializer.js:23
Module: ember-data

Normally, applications will use the RESTSerializer by implementing the normalize method and individual normalizations under normalizeHash.

This allows you to do whatever kind of munging you need, and is especially useful if your server is inconsistent and you need to do munging differently for many different kinds of responses.

See the normalize documentation for more information.

Across the Board Normalization

There are also a number of hooks that you might find useful to define across-the-board rules for your payload. These rules will be useful if your server is consistent, or if you're building an adapter for an infrastructure service, like Parse, and want to encode service conventions.

For example, if all of your keys are underscored and all-caps, but otherwise consistent with the names you use in your models, you can implement across-the-board rules for how to convert an attribute name in your model to a key in your JSON.

app/serializers/application.js 
1
2
3
4
5
6
7

import DS from 'ember-data';

export default DS.RESTSerializer.extend({
  keyForAttribute: function(attr, method) {
    return Ember.String.underscore(attr).toUpperCase();
  }
});

You can also implement keyForRelationship, which takes the name of the relationship as the first parameter, the kind of relationship (hasMany or belongsTo) as the second parameter, and the method (serialize or deserialize) as the third parameter.

Show:

attrs

Module: ember-data

Inherited from DS.JSONSerializer packages/ember-data/lib/serializers/json-serializer.js:101

The attrs object can be used to declare a simple mapping between property names on DS.Model records and payload keys in the serialized JSON object representing the record. An object with the property key can also be used to designate the attribute's key on the response payload.

Example

app/models/person.js 
1
2
3
4
5
6
7
8

import DS from 'ember-data';

export default DS.Model.extend({
  firstName: DS.attr('string'),
  lastName: DS.attr('string'),
  occupation: DS.attr('string'),
  admin: DS.attr('boolean')
});
app/serializers/person.js 
1
2
3
4
5
6
7
8

import DS from 'ember-data';

export default DS.JSONSerializer.extend({
  attrs: {
    admin: 'is_admin',
    occupation: { key: 'career' }
  }
});

You can also remove attributes by setting the serialize key to false in your mapping object.

Example

app/serializers/person.js 
1
2
3
4
5
6
7
8

import DS from 'ember-data';

export default DS.JSONSerializer.extend({
  attrs: {
    admin: {serialize: false},
    occupation: { key: 'career' }
  }
});

When serialized:

1
2
3
4
5

{
  "firstName": "Harry",
  "lastName": "Houdini",
  "career": "magician"
}

Note that the admin is now not included in the payload.

primaryKey

Module: ember-data

Inherited from DS.JSONSerializer packages/ember-data/lib/serializers/json-serializer.js:77

The primaryKey is used when serializing and deserializing data. Ember Data always uses the id property to store the id of the record. The external source may not always follow this convention. In these cases it is useful to override the primaryKey property to match the primaryKey of your external store.

Example

app/serializers/application.js 
1
2
3
4
5

import DS from 'ember-data';

export default DS.JSONSerializer.extend({
  primaryKey: '_id'
});

store public

Module: ember-data

Inherited from DS.Serializer packages/ember-data/lib/system/serializer.js:52

The store property is the application's store that contains all records. It's injected as a service. It can be used to push records from a non flat data structure server response.