Store

Stores data by type. { todos: { records: observable.map(), // records by id cache: observable.map(), // cached ids by url meta: observable.map() // meta information by url } }

The most recent response headers according to settings specified as headersOfInterest

Map of data that has been loaded into the store. This can be observed to know if a given type (or tag) has finished loading.

• Key is a tag that is either the model type or a custom value
• Falue is a Set of JSON-encoded objects with unique urls and queryParams Set[JSON.stringify({ url, type, queryParams, queryTag })]

Map of data that is in flight. This can be observed to know if a given type (or tag) is still processing.

• Key is a tag that is either the model type or a custom value
• Falue is a Set of JSON-encoded objects with unique urls and queryParams Set[JSON.stringify({ url, type, queryParams, queryTag })]

True if models in the store should stop taking snapshots. This is useful when updating records without causing records to become 'dirty', for example when initializing records using add

Adds an instance or an array of instances to the store. Adds the model to the type records index Adds relationships explicitly. This is less efficient than adding via data if there are also inverse relationships.

const todo = store.add('todos', { name: "A good thing to measure" })
todo.name
=> "A good thing to measure"

const todoArray = [{ name: "Another good thing to measure" }]
const [todo] = store.add('todos', [{ name: "Another good thing to measure" }])
todo.name
=> "Another good thing to measure"

Save a collection of new records via a bulk-supported JSONApi endpoint. All records need to be of the same type and not have an existing id.

Saves a collection of records via a bulk-supported JSONApi endpoint. All records need to be of the same type.

Updates a collection of records via a bulk-supported JSONApi endpoint. All records need to be of the same type and have an existing id.

Clears the cache for provided record type

Helper to create a new model

Creates or updates a model

Create multiple models from an array of data. It will only build objects with defined models, and ignore everything else in the data.

Removes a loading state. If that leaves an empty array for the map key in loadingStates, will also delete the set. Also adds to loadedStates.

Wrapper around fetch applies user defined fetch options

Finds all records with the given type. Always fetches from the server.

Fetch all records with the given type and ids from the server.

Fetches record by id from the server and returns a Promise.

Builds fetch url based on type, queryParams, id, and options

Finds all records of the given type. If any records from the given type from url are in the store, it returns those. Otherwise, it fetches all records from the server.

store.findAll('todos') // fetch triggered => [todo1, todo2, todo3]

store.findAll('todos') // no fetch triggered => [todo1, todo2, todo3]

Query params can be passed as part of the options hash. The response will be cached, so the next time findAll is called with identical params and values, the store will first look for the local result.

store.findAll('todos', { queryParams: { filter: { start_time: '2020-06-01T00:00:00.000Z', end_time: '2020-06-02T00:00:00.000Z' } } })

Finds multiple records of the given type with the given ids and returns them wrapped in a Promise. If all records are in the store, it returns those. If some records are in the store, it returns those plus fetches all other records. Otherwise, it fetches all records from the server.

store.findMany('todos', [1, 2, 3]) // fetch triggered => [todo1, todo2, todo3]

store.findMany('todos', [3, 2, 1]) // no fetch triggered => [todo1, todo2, todo3]

Finds a record by id, always returning a Promise. If available in the store, it returns that record. Otherwise, it fetches the record from the server.

store.findOne('todos', 5) // fetch triggered => Promise(todo) store.findOne('todos', 5) // no fetch triggered => Promise(todo)

Gets all records with the given type from the store. This will never fetch from the server.

Gets a record from store based on cached query

Gets records from store based on cached query

Gets single from store based on cached query

Gets records from store based on cached query and any previously requested ids

Helper to look up model class for type.

Get all records with the given type and ids from the store. This will never fetch from the server.

Gets a record from the store. Will never fetch from the server. If given queryParams, it will check the cache for the record.

Gets individual record from store

Gets records for type of collection

Get multiple records by id

Entry point for configuring the store

Configure the error messages returned from the store when API requests fail

Creates the key/value index of model types

Configures the store's network options

Given a set of properties and type, returns an object with only the properties that are defined as attributes in the model for that type.

properties = { title: 'Do laundry', unrelatedProperty: 'Do nothing' }
pickAttributes(properties, 'todos')
=> { title: 'Do laundry' }

Given a set of properties and type, returns an object with only the properties that are defined as relationships in the model for that type.

properties = { notes: [note1, note2], category: cat1, title: 'Fold Laundry' }
pickRelationships(properties, 'todos')
=> {
      notes: {
        data: [{ id: '1', type: 'notes' }, { id: '2', type: 'notes' }]
      },
      category: {
        data: { id: '1', type: 'categories' }
      }
   }

Removes a record from the store by deleting it from the type's record map

Clears the store of a given type, or clears all if no type given

store.reset('todos') // removes all todos from store store.reset() // clears store

Sets a loading state when a fetch / deserialization is in flight. Loading states are Sets inside of the loadingStates Map, so multiple loading states can be in flight at the same time. An optional query tag can be passed to identify the particular query.

const todos = store.fetchAll('todos', { queryTag: 'myTodos' }) store.loadingStates.get('myTodos') => Set([JSON.stringify({ url, type, queryParams, queryTag })])

Updates a record from a jsonapi hash

Defines a resolution for an API call that will update a record or set of records with the data returned from the API