DS.Model Class packages/ember-data/lib/system/relationships/ext.js:14

A map whose keys are the attributes of the model (properties described by DS.attr) and whose values are the meta object for the property.

Example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

App.Person = DS.Model.extend({
  firstName: attr('string'),
  lastName: attr('string'),
  birthday: attr('date')
});

var attributes = Ember.get(App.Person, 'attributes')

attributes.forEach(function(name, meta) {
  console.log(name, meta);
});

// prints:
// firstName {type: "string", isAttribute: true, options: Object, parentType: function, name: "firstName"}
// lastName {type: "string", isAttribute: true, options: Object, parentType: function, name: "lastName"}
// birthday {type: "date", isAttribute: true, options: Object, parentType: function, name: "birthday"}

If the record is in the dirty state this property will report what kind of change has caused it to move into the dirty state. Possible values are:

• created The record has been created by the client and not yet saved to the adapter.
• updated The record has been updated by the client and not yet saved to the adapter.
• deleted The record has been deleted by the client and not yet saved to the adapter.

Example

1
2

var record = store.createRecord(App.Model);
record.get('dirtyType'); // 'created'

When the record is in the invalid state this object will contain any errors returned by the adapter. When present the errors hash typically contains keys coresponding to the invalid property names and values which are an array of error messages.

1
2
3
4
5

record.get('errors'); // null
record.set('foo', 'invalid value');
record.save().then(null, function() {
  record.get('errors'); // {foo: ['foo should be a number.']}
});

A map whose keys are the fields of the model and whose values are strings describing the kind of the field. A model's fields are the union of all of its attributes and relationships.

For example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

App.Blog = DS.Model.extend({
  users: DS.hasMany('user'),
  owner: DS.belongsTo('user'),

  posts: DS.hasMany('post'),

  title: DS.attr('string')
});

var fields = Ember.get(App.Blog, 'fields');
fields.forEach(function(field, kind) {
  console.log(field, kind);
});

// prints:
// users, hasMany
// owner, belongsTo
// posts, hasMany
// title, attribute

All ember models have an id property. This is an identifier managed by an external source. These are always coerced to be strings before being used internally. Note when declaring the attributes for a model it is an error to declare an id attribute.

1
2
3
4
5
6

var record = store.createRecord(App.Model);
record.get('id'); // null

store.find('model', 1).then(function(model) {
  model.get('id'); // '1'
});

If this property is true the record is in the deleted state and has been marked for deletion. When isDeleted is true and isDirty is true, the record is deleted locally but the deletion was not yet persisted. When isSaving is true, the change is in-flight. When both isDirty and isSaving are false, the change has persisted.

Example

1
2
3
4

var record = store.createRecord(App.Model);
record.get('isDeleted'); // false
record.deleteRecord();
record.get('isDeleted'); // true

If this property is true the record is in the dirty state. The record has local changes that have not yet been saved by the adapter. This includes records that have been created (but not yet saved) or deleted.

Example

1
2
3
4
5
6
7
8

var record = store.createRecord(App.Model);
record.get('isDirty'); // true

store.find('model', 1).then(function(model) {
  model.get('isDirty'); // false
  model.set('foo', 'some value');
  model.set('isDirty'); // true
});

If this property is true the record is in the empty state. Empty is the first state all records enter after they have been created. Most records created by the store will quickly transition to the loading state if data needs to be fetched from the server or the created state if the record is created on the client. A record can also enter the empty state if the adapter is unable to locate the record.

If true the adapter reported that it was unable to save local changes to the backend. This may also result in the record having its isValid property become false if the adapter reported that server-side validations failed.

Example

1
2
3
4
5

record.get('isError'); // false
record.set('foo', 'invalid value');
record.save().then(null, function() {
  record.get('isError'); // true
});

If this property is true the record is in the loaded state. A record enters this state when its data is populated. Most of a record's lifecycle is spent inside substates of the loaded state.

Example

1
2
3
4
5
6

var record = store.createRecord(App.Model);
record.get('isLoaded'); // true

store.find('model', 1).then(function(model) {
  model.get('isLoaded'); // true
});

If this property is true the record is in the loading state. A record enters this state when the store askes the adapter for its data. It remains in this state until the adapter provides the requested data.

If this property is true the record is in the new state. A record will be in the new state when it has been created on the client and the adapter has not yet report that it was successfully saved.

Example

1
2
3
4
5
6

var record = store.createRecord(App.Model);
record.get('isNew'); // true

store.find('model', 1).then(function(model) {
  model.get('isNew'); // false
});

If true the store is attempting to reload the record form the adapter.

Example

1
2
3

record.get('isReloading'); // false
record.reload();
record.get('isReloading'); // true

If this property is true the record is in the saving state. A record enters the saving state when save is called, but the adapter has not yet acknowledged that the changes have been persisted to the backend.

Example

1
2
3
4
5
6
7

var record = store.createRecord(App.Model);
record.get('isSaving'); // false
var promise = record.save();
record.get('isSaving'); // true
promise.then(function() {
  record.get('isSaving'); // false
});

If this property is true the record is in the valid state. A record will be in the valid state when no client-side validations have failed and the adapter did not report any server-side validation failures.

An array of types directly related to a model. Each type will be included once, regardless of the number of relationships it has with the model.

For example, given a model with this definition:

1
2
3
4
5
6

App.Blog = DS.Model.extend({
  users: DS.hasMany('user'),
  owner: DS.belongsTo('user'),

  posts: DS.hasMany('post')
});

This property would contain the following:

1
2

var relatedTypes = Ember.get(App.Blog, 'relatedTypes');
//=> [ App.User, App.Post ]

A hash containing lists of the model's relationships, grouped by the relationship kind. For example, given a model with this definition:

1
2
3
4
5
6

App.Blog = DS.Model.extend({
  users: DS.hasMany('user'),
  owner: DS.belongsTo('user'),

  posts: DS.hasMany('post')
});

This property would contain the following:

1
2
3
4
5

var relationshipNames = Ember.get(App.Blog, 'relationshipNames');
relationshipNames.hasMany;
//=> ['users', 'posts']
relationshipNames.belongsTo;
//=> ['owner']

The model's relationships as a map, keyed on the type of the relationship. The value of each entry is an array containing a descriptor for each relationship with that type, describing the name of the relationship as well as the type.

For example, given the following model definition:

1
2
3
4
5

App.Blog = DS.Model.extend({
  users: DS.hasMany('user'),
  owner: DS.belongsTo('user'),
  posts: DS.hasMany('post')
});

This computed property would return a map describing these relationships, like this:

1
2
3
4
5
6

var relationships = Ember.get(App.Blog, 'relationships');
relationships.get(App.User);
//=> [ { name: 'users', kind: 'hasMany' },
//     { name: 'owner', kind: 'belongsTo' } ]
relationships.get(App.Post);
//=> [ { name: 'posts', kind: 'hasMany' } ]

A map whose keys are the relationships of a model and whose values are relationship descriptors.

For example, given a model with this definition:

1
2
3
4
5
6

App.Blog = DS.Model.extend({
  users: DS.hasMany('user'),
  owner: DS.belongsTo('user'),

  posts: DS.hasMany('post')
});

This property would contain the following:

1
2
3
4
5

var relationshipsByName = Ember.get(App.Blog, 'relationshipsByName');
relationshipsByName.get('users');
//=> { key: 'users', kind: 'hasMany', type: App.User }
relationshipsByName.get('owner');
//=> { key: 'owner', kind: 'belongsTo', type: App.User }

A map whose keys are the attributes of the model (properties described by DS.attr) and whose values are type of transformation applied to each attribute. This map does not include any attributes that do not have an transformation type.

Example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

App.Person = DS.Model.extend({
  firstName: attr(),
  lastName: attr('string'),
  birthday: attr('date')
});

var transformedAttributes = Ember.get(App.Person, 'transformedAttributes')

transformedAttributes.forEach(function(field, type) {
  console.log(field, type);
});

// prints:
// lastName string
// birthday date