DS.Store Class packages/ember-data/lib/system/store.js:44

This method returns a filtered array that contains all of the known records for a given type.

Note that because it's just a filter, it will have any locally created records of the type.

Also note that multiple calls to all for a given type will always return the same RecordArray.

Create a new record in the current store. The properties passed to this method are set on the newly created record.

To create a new instance of App.Post:

1
2
3

store.createRecord('post', {
  title: "Rails is omakase"
});

For symmetry, a record can be deleted via the store.

Takes a type and filter function, and returns a live RecordArray that remains up to date as new records are loaded into the store or created locally.

The callback function takes a materialized record, and returns true if the record should be included in the filter and false if it should not.

The filter function is called once on all records for the type when it is created, and then once on each newly loaded or created record.

If any of a record's properties change, or if it changes state, the filter function will be invoked again to determine whether it should still be in the array.

Optionally you can pass a query which will be triggered at first. The results returned by the server could then appear in the filter if they match the filter function.

This is the main entry point into finding records. The first parameter to this method is the model's name as a string.

To find a record by ID, pass the id as the second parameter:

1

store.find('person', 1);

The find method will always return a promise that will be resolved with the record. If the record was already in the store, the promise will be resolved immediately. Otherwise, the store will ask the adapter's find method to find the necessary data.

The find method will always resolve its promise with the same object for a given type and id.

To find all records for a type, call find with no additional parameters:

1

store.find('person');

This will ask the adapter's findAll method to find the records for the given type, and return a promise that will be resolved once the server returns the values.

To find a record by a query, call find with a hash as the second parameter:

1

store.find(App.Person, { page: 1 });

This will ask the adapter's findQuery method to find the records for the query, and return a promise that will be resolved once the server responds.

If possible, this method asks the adapter to generate an ID for a newly created record.

Get a record by a given type and ID without triggering a fetch.

This method will synchronously return the record if it's available. Otherwise, it will return null.

1

var post = store.getById('post', 1);

Returns true if a record for a given type and ID is already loaded.

If you have some metadata to set for a type you can call metaForType.

This method returns the metadata for a specific type.

Returns a model class for a particular key. Used by methods that take a type key (like find, createRecord, etc.)

Push some data for a given type into the store.

This method expects normalized data:

• The ID is a key named id (an ID is mandatory)
• The names of attributes are the ones you used in your model's DS.attrs.
• Your relationships must be:
  • represented as IDs or Arrays of IDs
  • represented as model instances
  • represented as URLs, under the links key

For this model:

1
2
3
4
5
6

App.Person = DS.Model.extend({
  firstName: DS.attr(),
  lastName: DS.attr(),

  children: DS.hasMany('person')
});

To represent the children as IDs:

1
2
3
4
5
6

{
  id: 1,
  firstName: "Tom",
  lastName: "Dale",
  children: [1, 2, 3]
}

To represent the children relationship as a URL:

1
2
3
4
5
6
7
8

{
  id: 1,
  firstName: "Tom",
  lastName: "Dale",
  links: {
    children: "/people/1/children"
  }
}

If you're streaming data or implementing an adapter, make sure that you have converted the incoming data into this form.

This method can be used both to push in brand new records, as well as to update existing records.

If you have an Array of normalized data to push, you can call pushMany with the Array, and it will call push repeatedly for you.

Push some raw data into the store.

The data will be automatically deserialized using the serializer for the type param.

This method can be used both to push in brand new records, as well as to update existing records.

You can push in more than one type of object at once. All objects should be in the format expected by the serializer.

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

App.ApplicationSerializer = DS.ActiveModelSerializer;

var pushData = {
  posts: [
    {id: 1, post_title: "Great post", comment_ids: [2]}
  ],
  comments: [
    {id: 2, comment_body: "Insightful comment"}
  ]
}

store.pushPayload('post', pushData);

Returns id record for a given type and ID. If one isn't already loaded, it builds a new record and leaves it in the empty state.

This method returns if a certain record is already loaded in the store. Use this function to know beforehand if a find() will result in a request or that it will be a cache hit.

This method unloads all of the known records for a given type.

For symmetry, a record can be unloaded via the store.