Class HasManyReference

public
Extends: Reference
Defined in: ../store/addon/-private/system/references/has-many.ts:25
Module: @ember-data/store

A HasManyReference is a low-level API that allows users and addon authors to perform meta-operations on a has-many relationship.

Show:

ids Array public

Module: @ember-data/store

Defined in ../store/addon/-private/system/references/has-many.ts:167

returns
Array
The ids in this has-many relationship

ids() returns an array of the record IDs in this relationship.

Example

app/models/post.js 
1
2
3
4
5

import Model, { hasMany } from '@ember-data/model';

export default class PostModel extends Model {
  @hasMany({ async: true }) comments;
}
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

let post = store.push({
  data: {
    type: 'post',
    id: 1,
    relationships: {
      comments: {
        data: [{ type: 'comment', id: 1 }]
      }
    }
  }
});

let commentsRef = post.hasMany('comments');

commentsRef.ids(); // ['1']

link String public

Module: @ember-data/store

Inherited from Reference ../store/addon/-private/system/references/reference.ts:98

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

The link Ember Data will use to fetch or reload this belongs-to relationship. By default it uses only the "related" resource linkage.

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

// models/blog.js
import Model, { belongsTo } from '@ember-data/model';
export default Model.extend({
   user: 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();
 }

load (options) Promise public

Module: @ember-data/store

Defined in ../store/addon/-private/system/references/has-many.ts:362

options
Object
the options to pass in.
returns
Promise
a promise that resolves with the ManyArray in this has-many relationship.

Loads the relationship if it is not already loaded. If the relationship is already loaded this method does not trigger a new load. This causes a request to the specified relationship link or reloads all items currently in the relationship.

Example

app/models/post.js 
1
2
3
4
5

import Model, { hasMany } from '@ember-data/model';

export default class PostModel extends Model {
  @hasMany({ async: true }) comments;
}
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

let post = store.push({
  data: {
    type: 'post',
    id: 1,
    relationships: {
      comments: {
        data: [{ type: 'comment', id: 1 }]
      }
    }
  }
});

let commentsRef = post.hasMany('comments');

commentsRef.load().then(function(comments) {
  //...
});

You may also pass in an options object whose properties will be fed forward. This enables you to pass adapterOptions into the request given to the adapter via the reference.

Example

1
2
3
4

commentsRef.load({ adapterOptions: { isPrivate: true } })
  .then(function(comments) {
    //...
  });
app/adapters/comment.js 
1
2
3
4
5
6

export default ApplicationAdapter.extend({
  findMany(store, type, id, snapshots) {
    // In the adapter you will have access to adapterOptions.
    let adapterOptions = snapshots[0].adapterOptions;
  }
});

meta Object public

Module: @ember-data/store

Inherited from Reference ../store/addon/-private/system/references/reference.ts:155

returns
Object
The meta information for the belongs-to relationship.

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
28

// models/blog.js
import Model, { belongsTo } from '@ember-data/model';
export default Model.extend({
   user: 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 }

push (objectOrPromise) ManyArray public

Module: @ember-data/store

Defined in ../store/addon/-private/system/references/has-many.ts:206

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

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

Example

app/models/post.js 
1
2
3
4
5

import Model, { hasMany } from '@ember-data/model';

export default class PostModel extends Model {
  @hasMany({ async: true }) comments;
}
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

let post = store.push({
  data: {
    type: 'post',
    id: 1,
    relationships: {
      comments: {
        data: [{ type: 'comment', id: 1 }]
      }
    }
  }
});

let commentsRef = post.hasMany('comments');

commentsRef.ids(); // ['1']

commentsRef.push([
[{ type: 'comment', id: 2 }],
[{ type: 'comment', id: 3 }],
])

commentsRef.ids(); // ['2', '3']

reload (options) Promise public

Module: @ember-data/store

Defined in ../store/addon/-private/system/references/has-many.ts:431

options
Object
the options to pass in.
returns
Promise
a promise that resolves with the ManyArray in this has-many relationship.

Reloads this has-many relationship. This causes a request to the specified relationship link or reloads all items currently in the relationship.

Example

app/models/post.js 
1
2
3
4
5

import Model, { hasMany } from '@ember-data/model';

export default class PostModel extends Model {
  @hasMany({ async: true }) comments;
}
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

let post = store.push({
  data: {
    type: 'post',
    id: 1,
    relationships: {
      comments: {
        data: [{ type: 'comment', id: 1 }]
      }
    }
  }
});

let commentsRef = post.hasMany('comments');

commentsRef.reload().then(function(comments) {
  //...
});

You may also pass in an options object whose properties will be fed forward. This enables you to pass adapterOptions into the request given to the adapter via the reference. A full example can be found in the load method.

Example

1

commentsRef.reload({ adapterOptions: { isPrivate: true } })

remoteType String public

Module: @ember-data/store

Defined in ../store/addon/-private/system/references/has-many.ts:116

returns
String
The name of the remote type. This should either be `link` or `ids`

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

app/models/post.js 
1
2
3
4
5

import Model, { hasMany } from '@ember-data/model';

export default class PostModel extends Model {
  @hasMany({ async: true }) comments;
}
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

let post = store.push({
  data: {
    type: 'post',
    id: 1,
    relationships: {
      comments: {
        data: [{ type: 'comment', id: 1 }]
      }
    }
  }
});

let commentsRef = post.hasMany('comments');

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

value ManyArray public

Module: @ember-data/store

Defined in ../store/addon/-private/system/references/has-many.ts:312

returns
ManyArray

value() synchronously returns the current value of the has-many 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

app/models/post.js 
1
2
3
4
5

import Model, { hasMany } from '@ember-data/model';

export default class PostModel extends Model {
  @hasMany({ async: true }) comments;
}
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

let post = store.push({
  data: {
    type: 'post',
    id: 1,
    relationships: {
      comments: {
        data: [{ type: 'comment', id: 1 }]
      }
    }
  }
});

let commentsRef = post.hasMany('comments');

post.get('comments').then(function(comments) {
  commentsRef.value() === comments
})