home
  • Blog
  • Home
  • Projects
    • Ember
    • EmberData
    • Ember CLI
4.12
  • Packages
    • @ember-data/adapter
    • @ember-data/adapter/error
    • @ember-data/adapter/json-api
    • @ember-data/adapter/rest
    • @ember-data/canary-features
    • @ember-data/debug
    • @ember-data/deprecations
    • @ember-data/experimental-preview-types
    • @ember-data/graph
    • @ember-data/json-api
    • @ember-data/legacy-compat
    • @ember-data/model
    • @ember-data/request
    • @ember-data/request/fetch
    • @ember-data/serializer
    • @ember-data/serializer/json
    • @ember-data/serializer/json-api
    • @ember-data/serializer/rest
    • @ember-data/store
    • @ember-data/tracking
  • Classes
    • <Interface> Adapter
    • <Interface> Cache
    • <Interface> Handler
    • <Interface> Serializer
    • AbortError
    • Adapter
    • AdapterError
    • BelongsToReference
    • BooleanTransform
    • BuildURLMixin
    • Cache
    • CacheManager
    • CacheStoreWrapper
    • CanaryFeatureFlags
    • ConflictError
    • CurrentDeprecations
    • DateTransform
    • DebugLogging
    • EmbeddedRecordsMixin
    • Errors
    • Fetch
    • ForbiddenError
    • Future
    • HasManyReference
    • IdentifierCache
    • InvalidError
    • JSONAPIAdapter
    • JSONAPISerializer
    • JSONSerializer
    • ManyArray
    • Model
    • NotFoundError
    • NotificationManager
    • NumberTransform
    • PromiseArray
    • PromiseManyArray
    • PromiseObject
    • RESTAdapter
    • RESTSerializer
    • RecordArray
    • RecordReference
    • RequestManager
    • RequestStateService
    • SchemaService
    • Serializer
    • ServerError
    • Snapshot
    • SnapshotRecordArray
    • StableRecordIdentifier
    • Store
    • StringTransform
    • TimeoutError
    • Transform
    • UnauthorizedError

Class HasManyReference public


Extends: Reference
Defined in: ../model/src/-private/references/has-many.ts:48
Module: @ember-data/model

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


Methods

ids : Array public

Module: @ember-data/model

Defined in ../packages/model/src/-private/references/has-many.ts:209

returns
Array

The ids in this has-many relationship

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

Example

```js {data-filename=app/models/post.js} import Model, { hasMany } from '@ember-data/model';

export default class PostModel extends Model {

link : String public

Module: @ember-data/model

Defined in ../packages/model/src/-private/references/has-many.ts:248

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

// models/blog.js
import Model, { belongsTo } from '@ember-data/model';
export default Model.extend({
   user: belongsTo('user', { async: true, inverse: null })
 });

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();
 }

links : public

Module: @ember-data/model

Defined in ../packages/model/src/-private/references/has-many.ts:298

returns

any links that have been received for this relationship

load (options) : Promise public

Module: @ember-data/model

Defined in ../packages/model/src/-private/references/has-many.ts:544

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

```js {data-filename=app/models/post.js} import Model, { hasMany } from '@ember-data/model';

export default class PostModel extends Model {

meta : Object public

Module: @ember-data/model

Defined in ../packages/model/src/-private/references/has-many.ts:311

returns
Object

The meta information for the belongs-to relationship.

The meta data for the has-many relationship.

Example

// models/blog.js
import Model, { hasMany } from '@ember-data/model';
export default Model.extend({
   users: hasMany('user', { async: true, inverse: null })
 });

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

let usersRef = blog.hasMany('user');

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

push (objectOrPromise) : ManyArray public

Module: @ember-data/model

Defined in ../packages/model/src/-private/references/has-many.ts:360

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

```js {data-filename=app/models/post.js} import Model, { hasMany } from '@ember-data/model';

export default class PostModel extends Model {

reload (options) : Promise public

Module: @ember-data/model

Defined in ../packages/model/src/-private/references/has-many.ts:619

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

```js {data-filename=app/models/post.js} import Model, { hasMany } from '@ember-data/model';

export default class PostModel extends Model {

remoteType : String public

Module: @ember-data/model

Defined in ../packages/model/src/-private/references/has-many.ts:158

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

```js {data-filename=app/models/post.js} import Model, { hasMany } from '@ember-data/model';

export default class PostModel extends Model {

value : ManyArray public

Module: @ember-data/model

Defined in ../packages/model/src/-private/references/has-many.ts:486

returns
ManyArray

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

```js {data-filename=app/models/post.js} import Model, { hasMany } from '@ember-data/model';

export default class PostModel extends Model {

Properties

identifiers public

Module: @ember-data/model

Defined in ../packages/model/src/-private/references/has-many.ts:104

An array of identifiers for the records that this reference refers to.

On this page


Methods

  • ids
  • link
  • links
  • load
  • meta
  • push
  • reload
  • remoteType
  • value

Properties

  • identifiers
Team Sponsors Security Legal Branding Community Guidelines
Twitter GitHub Discord Mastodon

If you want help you can contact us by email, open an issue, or get realtime help by joining the Ember Discord.

© Copyright 2025 - Tilde Inc.
Ember.js is free, open source and always will be.


Ember is generously supported by
blue Created with Sketch.