Defining Models

You can specify which attributes a model has by using DS.attr.

export default DS.Model.extend({
  firstName: DS.attr(),
  lastName: DS.attr(),
  birthday: DS.attr()
});

Attributes are used when turning the JSON payload returned from your server into a record, and when serializing a record to save back to the server after it has been modified.

You can use attributes just like any other property, including as part of a computed property. Frequently, you will want to define computed properties that combine or transform primitive attributes.

export default DS.Model.extend({
  firstName: attr(),
  lastName: attr(),

  fullName: function() {
    return this.get('firstName') + ' ' + this.get('lastName');
  }.property('firstName', 'lastName')
});

For more about adding computed properties to your classes, see Computed Properties.

If you don't specify the type of the attribute, it will be whatever was provided by the server. You can make sure that an attribute is always coerced into a particular type by passing a type to attr:

export default DS.Model.extend({
  birthday: DS.attr('date')
});

The default adapter supports attribute types of string, number, boolean, and date. Custom adapters may offer additional attribute types, and new types can be registered as transforms. See the documentation section on the REST Adapter.

Please note: Ember Data serializes and deserializes dates according to ISO 8601. For example: 2014-05-27T12:54:01

DS.attr takes an optional hash as a second parameter:

• defaultValue: Pass a string or a function to be called to set the attribute to a default value if none is supplied.

  Example

  export default DS.Model.extend({
      username: DS.attr('string'),
      email: DS.attr('string'),
      verified: DS.attr('boolean', {defaultValue: false}),
      createdAt: DS.attr('string', {
          defaultValue: function() { return new Date(); }
      })
  });

Ember Data includes several built-in relationship types to help you define how your models relate to each other.

To declare a one-to-one relationship between two models, use DS.belongsTo:

export default DS.Model.extend({
  profile: DS.belongsTo('profile')
});

export default DS.Model.extend({
  user: DS.belongsTo('user')
});

To declare a one-to-many relationship between two models, use DS.belongsTo in combination with DS.hasMany, like this:

export default DS.Model.extend({
  comments: DS.hasMany('comment')
});

export default DS.Model.extend({
  post: DS.belongsTo('post')
});

To declare a many-to-many relationship between two models, use DS.hasMany:

export default DS.Model.extend({
  tags: DS.hasMany('tag')
});

export default DS.Model.extend({
  posts: DS.hasMany('post')
});

Ember Data will do its best to discover which relationships map to one another. In the one-to-many code above, for example, Ember Data can figure out that changing the comments relationship should update the post relationship on the inverse because post is the only relationship to that model.

However, sometimes you may have multiple belongsTo/hasManys for the same type. You can specify which property on the related model is the inverse using DS.hasMany's inverse option:

export default DS.Model.extend({
  onePost: DS.belongsTo('post'),
  twoPost: DS.belongsTo('post'),
  redPost: DS.belongsTo('post'),
  bluePost: DS.belongsTo('post')
});

export default DS.Model.extend({
  comments: DS.hasMany('comment', {
    inverse: 'redPost'
  })
});

You can also specify an inverse on a belongsTo, which works how you'd expect.

When you want to define a reflexive relation, you must either explicitly define the other side, and set the explicit inverse accordingly, and if you don't need the other side, set the inverse to null.

export default DS.Model.extend({
  children: DS.hasMany('folder', {inverse: 'parent'}),
  parent: DS.belongsTo('folder', {inverse: 'children'})
});

or

export default DS.Model.extend({
  parent: belongsTo('folder', {inverse: null})
});