DS.BelongsToReference Class addon/-private/system/references/belongs-to.js:9


Extends: DS.Reference

Defined in: addon/-private/system/references/belongs-to.js:9

Module: ember-data

A BelongsToReference is a low level API that allows users and addon author to perform meta-operations on a belongs-to relationship.

Show:

Methods

Show:

id

String

The id of the record that this reference refers to. Together, the type() and id() methods form a composite key for the identity map. This can be used to access the id of an async relationship without triggering a fetch that would normally happen if you attempted to use record.get('relationship.id').

Example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 // models/blog.js
 export default DS.Model.extend({
   user: DS.belongsTo({ async: true })
 });

 let blog = store.push({
   data: {
     type: 'blog',
     id: 1,
     relationships: {
       user: {
         data: { type: 'user', id: 1 }
       }
     }
   }
 });
 let userRef = blog.belongsTo('user');

 // get the identifier of the reference
 if (userRef.remoteType() === "id") {
   let id = userRef.id();
 }

Returns:

String
The id of the record in this belongsTo relationship.

link

String

The link Ember Data will use to fetch or reload this belongs-to relationship.

Example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 // models/blog.js
 export default DS.Model.extend({
   user: DS.belongsTo({ async: true })
 });

 let blog = store.push({
   data: {
     type: 'blog',
     id: 1,
     relationships: {
       user: {
         links: {
           related: '/articles/1/author'
         }
       }
     }
   }
 });
 let userRef = blog.belongsTo('user');

 // get the identifier of the reference
 if (userRef.remoteType() === "link") {
   let link = userRef.link();
 }

Returns:

String
The link Ember Data will use to fetch or reload this belongs-to relationship.

load

Promise

Loads a record in a belongs to relationship if it is not already loaded. If the relationship is already loaded this method does not trigger a new load.

Example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 // models/blog.js
 export default DS.Model.extend({
   user: DS.belongsTo({ async: true })
 });

 let blog = store.push({
   data: {
     type: 'blog',
     id: 1,
     relationships: {
       user: {
         data: { type: 'user', id: 1 }
       }
     }
   }
 });
 let userRef = blog.belongsTo('user');

 userRef.value(); // null

 userRef.load().then(function(user) {
   userRef.value() === user
 });

Returns:

Promise
a promise that resolves with the record in this belongs-to relationship.

meta

Object

The meta data for the belongs-to relationship.

Example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 // models/blog.js
 export default DS.Model.extend({
   user: DS.belongsTo({ async: true })
 });

 let blog = store.push({
   data: {
     type: 'blog',
     id: 1,
     relationships: {
       user: {
         links: {
           related: {
             href: '/articles/1/author',
             meta: {
               lastUpdated: 1458014400000
             }
           }
         }
       }
     }
   }
 });

 let userRef = blog.belongsTo('user');

 userRef.meta() // { lastUpdated: 1458014400000 }

Returns:

Object
The meta information for the belongs-oo relationship.

push

(objectOrPromise) Promise

push can be used to update the data in the relationship and Ember Data will treat the new data as the conanical value of this relationship on the backend.

Example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 // models/blog.js
 export default DS.Model.extend({
   user: DS.belongsTo({ async: true })
 });

 let blog = store.push({
   data: {
     type: 'blog',
     id: 1,
     relationships: {
       user: {
         data: { type: 'user', id: 1 }
       }
     }
   }
 });
 let userRef = blog.belongsTo('user');

 // provide data for reference
 userRef.push({
   data: {
     type: 'user',
     id: 1,
     attributes: {
       username: "@user"
     }
   }
 }).then(function(user) {
   userRef.value() === user;
 });

Parameters:

objectOrPromise Object|Promise
a promise that resolves to a JSONAPI document object describing the new value of this relationship.

Returns:

Promise
A promise that resolves with the new value in this belongs-to relationship.

reload

Promise

Triggers a reload of the value in this relationship. If the remoteType is "link" Ember Data will use the relationship link to reload the relationship. Otherwise it will reload the record by its id.

Example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 // models/blog.js
 export default DS.Model.extend({
   user: DS.belongsTo({ async: true })
 });

 let blog = store.push({
   data: {
     type: 'blog',
     id: 1,
     relationships: {
       user: {
         data: { type: 'user', id: 1 }
       }
     }
   }
 });
 let userRef = blog.belongsTo('user');

 userRef.reload().then(function(user) {
   userRef.value() === user
 });

Returns:

Promise
a promise that resolves with the record in this belongs-to relationship after the reload has completed.

remoteType

String

This returns a string that represents how the reference will be looked up when it is loaded. If the relationship has a link it will use the "link" otherwise it defaults to "id".

Example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 // models/blog.js
 export default DS.Model.extend({
   user: DS.belongsTo({ async: true })
 });

 let blog = store.push({
   type: 'blog',
   id: 1,
   relationships: {
     user: {
       data: { type: 'user', id: 1 }
     }
   }
 });
 let userRef = blog.belongsTo('user');

 // get the identifier of the reference
 if (userRef.remoteType() === "id") {
   let id = userRef.id();
 } else if (userRef.remoteType() === "link") {
   let link = userRef.link();
 }

Returns:

String
The name of the remote type. This should either be "link" or "id"

value

(objectOrPromise) DS.Model

value() synchronously returns the current value of the belongs-to relationship. Unlike record.get('relationshipName'), calling value() on a reference does not trigger a fetch if the async relationship is not yet loaded. If the relationship is not loaded it will always return null.

Example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 // models/blog.js
 export default DS.Model.extend({
   user: DS.belongsTo({ async: true })
 });

 let blog = store.push({
   data: {
     type: 'blog',
     id: 1,
     relationships: {
       user: {
         data: { type: 'user', id: 1 }
       }
     }
   }
 });
 let userRef = blog.belongsTo('user');

 userRef.value(); // null

 // provide data for reference
 userRef.push({
   data: {
     type: 'user',
     id: 1,
     attributes: {
       username: "@user"
     }
   }
 }).then(function(user) {
   userRef.value(); // user
 });

Parameters:

objectOrPromise Object|Promise
a promise that resolves to a JSONAPI document object describing the new value of this relationship.

Returns:

DS.Model
the record in this relationship