An object with default parse and stringify functions from qs

Adds a record to a related array and updates the jsonapi reference in the relationships

Strips observers and returns a plain JS array

Takes any object with { id, type } properties and gets an object from the store with that structure. Useful for allowing objects to be serialized in real time, saving overhead, while at the same time always returning an object of the same type.

Coerces a string or date to a date

Takes the toMany definitions from a document type and creates getters and setters. A getter finds records from the store, falling back to a lookup of the inverse records if none are defined in the relationships hash.

The setter will unset the previous inverse and set the current inverse. Both return a RelatedRecordsArray, which is an array with added methods add, remove, and replace

A definition will look like this:

categories: { direction: 'toMany', inverse: { name: 'organization', direction: 'toOne' } }

Takes the toOne definitions from a document type and creates getters and setters. A getter finds a record from the store. The setter calls setRelatedRecord, which will return an instance of a model and add it to the inverse relationship if necessary. A definition will look something like this:

todo: { direction: 'toOne', inverse: { name: 'notes', direction: 'toMany' } }

Gets only the relationships from one direction, ie 'toOne' or 'toMany'

Returns true if the value is an empty string

Annotations for mobx observability. We can't use makeAutoObservable because we have subclasses.

Annotations for mobx observability. We can't use makeAutoObservable because we have subclasses.

Coerces a value to a number

Strips observers and returns a plain JS object

Removes a record from an array of related records, removing both the object and the reference.

Encodes models into full compliant JSONAPI payload, as if it were being sent with all relevant relationships and inclusions. The resulting payload will look like { data: { id: '1', type: 'zones', attributes: {}, relationships: {}, }, included: [] }

Sets a related record, as well as the inverse. Can also remove the record from a relationship.

Coerces a value to a string

Returns valid if the value is an array

Is valid if the array has at least one object

Valid if target options are not blank

Is valid if the value is not an empty string

JSONAPI uses included only at the top level. To recursively add models to this array, we preserve the top-level object and pass it in to the next round Because objects can have multiple relationships, we do a check of the array to make sure it's not already there.

Will throw an error if fetch is called from the mockServer, usually due to a POST or PATCH called by a save

Throws an error if MockServer tries to findOne or findAll from itself.

Avoids making racing requests by blocking a request if an identical one is already in-flight. Blocked requests will be resolved when the initial request resolves by cloning the response.

Decreases a counter by 1

Splits an array of ids into a series of strings that can be used to form queries that conform to a max length of URL_MAX_LENGTH. This is to prevent 414 errors.

deeply compare objects a and b and return object paths for attributes which differ. it is important to note that this comparison is biased toward object a. object a is walked and compared against values in object b. if a property exists in object b, but not in object a, it will not be counted as a difference.

Overrides store methods that could trigger a fetch to throw errors. MockServer should only provide data for fetches, never call a fetch itself.

Implements a retry in case a fetch fails

Finds or creates a model that will match an id. This is useful for creating a response on the fly if no object already exists

Increments a counter by 1

Returns true if the value is truthy

convert a value into a date, pass Date or Moment instances thru untouched

Generates a temporary id to be used for reference in the store

Parses the pointer of the error to retrieve the index of the record the error belongs to and the full path to the attribute which will serve as the key for the error.

If there is no parsed index, then assume the payload was for a single record and default to 0.

ex. error = { detail: "Foo can't be blank", source: { pointer: '/data/1/attributes/options/foo' }, title: 'Invalid foo' }

parsePointer(error)

{ index: 1, key: 'options.foo' }

Parses JSONAPI error objects from a fetch response. If the response's body is undefined or is not formatted with a top-level errors key containing an array of errors, it builds a JSONAPI error object from the response status and a errorMessages configuration.

Errors that are returned which contain a status also have their detail overridden with values from this configuration.

Build request url from base url, endpoint, query params, and ids.

Interpret a PATCH request

Interpret a POST request

Coerces all ids to strings

Encodes a model to a jsonapi document with all relationships

returns true as long as the value is not null, undefined, or ''

Maps the passed-in property names through and runs validations against those properties

recursively walk an object and call the iteratee function for each property. returns an array of results of calls to the iteratee.

Wraps response JSON or object in a Response object that is itself wrapped in a resolved Promise. If no status is given then it will fill in a default based on the method.