@types/ember-data

property defaultSerializer

defaultSerializer: string;

• If you would like your adapter to use a custom serializer you can set the defaultSerializer property to be the name of the custom serializer.

method createRecord

createRecord: <K extends string | number | symbol>(
    store: Store,
    type: ModelSchema<K>,
    snapshot: Snapshot<K>
) => RSVP.Promise<any>;

• Implement this method in a subclass to handle the creation of new records.

method deleteRecord

deleteRecord: <K extends string | number | symbol>(
    store: Store,
    type: ModelSchema<K>,
    snapshot: Snapshot<K>
) => RSVP.Promise<any>;

• Implement this method in a subclass to handle the deletion of a record.

method findAll

findAll: <K extends string | number | symbol>(
    store: Store,
    type: ModelSchema<K>,
    sinceToken: string,
    snapshotRecordArray: SnapshotRecordArray<K>
) => RSVP.Promise<any>;

• The findAll() method is used to retrieve all records for a given type.

method findMany

findMany: <K extends string | number | symbol>(
    store: Store,
    type: ModelSchema<K>,
    ids: any[],
    snapshots: any[]
) => RSVP.Promise<any>;

• The store will call findMany instead of multiple findRecord requests to find multiple records at once if coalesceFindRequests is true.

method findRecord

findRecord: <K extends string | number | symbol>(
    store: Store,
    type: ModelSchema<K>,
    id: string,
    snapshot: Snapshot<K>
) => RSVP.Promise<any>;

• The findRecord() method is invoked when the store is asked for a record that has not previously been loaded. In response to findRecord() being called, you should query your persistence layer for a record with the given ID. The findRecord method should return a promise that will resolve to a JavaScript object that will be normalized by the serializer.

method generateIdForRecord

generateIdForRecord: <K extends string | number | symbol>(
    store: Store,
    type: ModelSchema<K>,
    inputProperties: {}
) => string | number;

• If the globally unique IDs for your records should be generated on the client, implement the generateIdForRecord() method. This method will be invoked each time you create a new record, and the value returned from it will be assigned to the record's primaryKey.

method groupRecordsForFindMany

groupRecordsForFindMany: (store: Store, snapshots: any[]) => any[];

• Organize records into groups, each of which is to be passed to separate calls to findMany.

method query

query: <K extends string | number | symbol>(
    store: Store,
    type: ModelSchema<K>,
    query: {},
    recordArray: AdapterPopulatedRecordArray<any>
) => RSVP.Promise<any>;

• This method is called when you call query on the store.

method queryRecord

queryRecord: <K extends string | number | symbol>(
    store: Store,
    type: ModelSchema<K>,
    query: {}
) => RSVP.Promise<any>;

• The queryRecord() method is invoked when the store is asked for a single record through a query object.

method serialize

serialize: <K extends string | number | symbol>(
    snapshot: Snapshot<K>,
    options: {}
) => {};

• Proxies to the serializer's serialize method.

method shouldBackgroundReloadAll

shouldBackgroundReloadAll: <K extends string | number | symbol>(
    store: Store,
    snapshotRecordArray: SnapshotRecordArray<K>
) => boolean;

• This method is used by the store to determine if the store should reload a record array after the store.findAll method resolves with a cached record array.

method shouldBackgroundReloadRecord

shouldBackgroundReloadRecord: <K extends string | number | symbol>(
    store: Store,
    snapshot: Snapshot<K>
) => boolean;

• This method is used by the store to determine if the store should reload a record after the store.findRecord method resolves a cached record.

method shouldReloadAll

shouldReloadAll: <K extends string | number | symbol>(
    store: Store,
    snapshotRecordArray: SnapshotRecordArray<K>
) => boolean;

• This method is used by the store to determine if the store should reload all records from the adapter when records are requested by store.findAll.

method shouldReloadRecord

shouldReloadRecord: <K extends string | number | symbol>(
    store: Store,
    snapshot: Snapshot<K>
) => boolean;

• This method is used by the store to determine if the store should reload a record from the adapter when a record is requested by store.findRecord.

method updateRecord

updateRecord: <K extends string | number | symbol>(
    store: Store,
    type: ModelSchema<K>,
    snapshot: Snapshot<K>
) => RSVP.Promise<any>;

• Implement this method in a subclass to handle the updating of a record.

method extend

static extend: (options?: { message?: string }) => typeof AdapterError;

method id

id: () => string;

• The id of the record that this reference refers to. Together, the type() and id() methods form a composite key for the identity map. This can be used to access the id of an async relationship without triggering a fetch that would normally happen if you attempted to use record.get('relationship.id').

method link

link: () => string;

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

method load

load: () => RSVP.Promise<any>;

• Loads a record in a belongs to relationship if it is not already loaded. If the relationship is already loaded this method does not trigger a new load.

method meta

meta: () => {};

• The meta data for the belongs-to relationship.

method push

push: (objectOrPromise: {} | RSVP.Promise<any>) => RSVP.Promise<any>;

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

method reload

reload: () => RSVP.Promise<any>;

• Triggers a reload of the value in this relationship. If the remoteType is "link" Ember Data will use the relationship link to reload the relationship. Otherwise it will reload the record by its id.

method remoteType

remoteType: () => string;

• 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".

method value

value: () => Model | null;

• value() synchronously returns the current value of the belongs-to 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.

method buildQuery

buildQuery: <K extends string | number | symbol>(
    snapshot: Snapshot<K>
) => Record<string, unknown>;

• Used by findAll and findRecord to build the query's data hash supplied to the ajax method.

method buildURL

buildURL: <K extends string | number | symbol>(
    modelName?: K,
    id?: string | any[] | {} | null,
    snapshot?: Snapshot<K> | any[] | null,
    requestType?: string,
    query?: {}
) => string;

• Builds a URL for a given type and optional ID.

method pathForType

pathForType: <K extends string | number | symbol>(modelName: K) => string;

• Determines the pathname for a given type.

method urlForCreateRecord

urlForCreateRecord: <K extends string | number | symbol>(
    modelName: K,
    snapshot: Snapshot<K>
) => string;

• Builds a URL for a record.save() call when the record was created locally using store.createRecord().

method urlForDeleteRecord

urlForDeleteRecord: <K extends string | number | symbol>(
    id: string,
    modelName: K,
    snapshot: Snapshot<K>
) => string;

• Builds a URL for a record.save() call when the record has been deleted locally.

method urlForFindAll

urlForFindAll: <K extends string | number | symbol>(
    modelName: K,
    snapshot: SnapshotRecordArray<K>
) => string;

• Builds a URL for a store.findAll(type) call.

method urlForFindBelongsTo

urlForFindBelongsTo: <K extends string | number | symbol>(
    id: string,
    modelName: K,
    snapshot: Snapshot<K>
) => string;

• Builds a URL for fetching a async belongsTo relationship when a url is not provided by the server.

method urlForFindHasMany

urlForFindHasMany: <K extends string | number | symbol>(
    id: string,
    modelName: K,
    snapshot: Snapshot<K>
) => string;

• Builds a URL for fetching a async hasMany relationship when a url is not provided by the server.

method urlForFindMany

urlForFindMany: <K extends string | number | symbol>(
    ids: any[],
    modelName: K,
    snapshots: any[]
) => string;

• Builds a URL for coalesceing multiple store.findRecord(type, id) records into 1 request when the adapter's coalesceFindRequests property is true.

method urlForFindRecord

urlForFindRecord: <K extends string | number | symbol>(
    id: string,
    modelName: K,
    snapshot: Snapshot<K>
) => string;

• Builds a URL for a store.findRecord(type, id) call.

method urlForQuery

urlForQuery: <K extends string | number | symbol>(
    query: {},
    modelName: K
) => string;

• Builds a URL for a store.query(type, query) call.

method urlForQueryRecord

urlForQueryRecord: <K extends string | number | symbol>(
    query: {},
    modelName: K
) => string;

• Builds a URL for a store.queryRecord(type, query) call.

method urlForUpdateRecord

urlForUpdateRecord: <K extends string | number | symbol>(
    id: string,
    modelName: K,
    snapshot: Snapshot<K>
) => string;

• Builds a URL for a record.save() call when the record has been update locally.

method normalize

normalize: (typeClass: ModelSchema, hash: {}, prop: string) => {};

• Normalize the record and recursively normalize/extract all the embedded records while pushing them into the store as they are encountered

method removeEmbeddedForeignKey

removeEmbeddedForeignKey: <K extends string | number | symbol>(
    snapshot: Snapshot<K>,
    embeddedSnapshot: Snapshot<K>,
    relationship: {},
    json: {}
) => any;

• When serializing an embedded record, modify the property (in the json payload) that refers to the parent record (foreign key for relationship).

method serializeBelongsTo

serializeBelongsTo: <K extends string | number | symbol>(
    snapshot: Snapshot<K>,
    json: {},
    relationship: {}
) => any;

• Serialize belongsTo relationship when it is configured as an embedded object.

method serializeHasMany

serializeHasMany: <K extends string | number | symbol>(
    snapshot: Snapshot<K>,
    json: {},
    relationship: {}
) => any;

• Serializes hasMany relationships when it is configured as embedded objects.

property isEmpty

isEmpty: Ember.ComputedProperty<boolean>;

property length

length: Ember.ComputedProperty<number>;

• Total number of errors.

property messages

messages: Ember.ComputedProperty<any[]>;

• An array containing all of the error messages for this record. This is useful for displaying all errors to the user.

method add

add: (attribute: string, messages: any[] | string) => any;

• DEPRECATED: Adds error messages to a given attribute and sends becameInvalid event to the record.

method clear

clear: () => any;

• DEPRECATED: Removes all error messages and sends becameValid event to the record.

method errorsFor

errorsFor: (attribute: string) => any[];

• Returns errors for a given attribute

method has

has: (attribute: string) => boolean;

• Checks if there is error messages for the given attribute.

method registerHandlers

registerHandlers: (
    target: {},
    becameInvalid: Function,
    becameValid: Function
) => any;

• DEPRECATED: Register with target handler

method remove

remove: (attribute: string) => any;

• DEPRECATED: Removes all error messages from the given attribute and sends becameValid event to the record if there no more errors left.

method filterFunction

filterFunction: (record: Model) => boolean;

• The filterFunction is a function used to test records from the store to determine if they should be part of the record array.

method ids

ids: () => string[];

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

method link

link: () => string;

• The link Ember Data will use to fetch or reload this has-many relationship.

method load

load: () => RSVP.Promise<any>;

• Loads the relationship if it is not already loaded. If the relationship is already loaded this method does not trigger a new load.

method meta

meta: () => {};

• The meta data for the has-many relationship.

method push

push: (objectOrPromise: T[] | RSVP.Promise<T[]>) => ManyArray<T>;

• 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.

method reload

reload: () => RSVP.Promise<any>;

• Reloads this has-many relationship.

method remoteType

remoteType: () => string;

• 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".

method value

value: () => ManyArray<T> | null;

• 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.

constructor

constructor(errors: any[]);

method keyForAttribute

keyForAttribute: (key: string, method: string) => string;

• keyForAttribute can be used to define rules for how to convert an attribute name in your model to a key in your JSON. By default JSONAPISerializer follows the format used on the examples of http://jsonapi.org/format and uses dashes as the word separator in the JSON attribute keys.

method keyForRelationship

keyForRelationship: (key: string, typeClass: string, method: string) => string;

• keyForRelationship can be used to define a custom key when serializing and deserializing relationship properties. By default JSONAPISerializer follows the format used on the examples of http://jsonapi.org/format and uses dashes as word separators in relationship properties.

method modelNameFromPayloadKey

modelNameFromPayloadKey: (key: string) => string;

• Dasherizes and singularizes the model name in the payload to match the format Ember Data uses internally for the model name.

method modelNameFromPayloadType

modelNameFromPayloadType: (payloadType: string) => string;

• modelNameFromPayloadType can be used to change the mapping for a DS model name, taken from the value in the payload.

method payloadKeyFromModelName

payloadKeyFromModelName: <K extends string | number | symbol>(
    modelName: K
) => string;

• Converts the model name to a pluralized version of the model name.

method payloadTypeFromModelName

payloadTypeFromModelName: <K extends string | number | symbol>(
    modelName: K
) => string;

• payloadTypeFromModelName can be used to change the mapping for the type in the payload, taken from the model name.

method pushPayload

pushPayload: (store: Store, payload: {}) => any;

property attrs

attrs: {};

• The attrs object can be used to declare a simple mapping between property names on DS.Model records and payload keys in the serialized JSON object representing the record. An object with the property key can also be used to designate the attribute's key on the response payload.

property primaryKey

primaryKey: string;

• The primaryKey is used when serializing and deserializing data. Ember Data always uses the id property to store the id of the record. The external source may not always follow this convention. In these cases it is useful to override the primaryKey property to match the primaryKey of your external store.

method extractAttributes

extractAttributes: (modelClass: ModelSchema, resourceHash: {}) => {};

• Returns the resource's attributes formatted as a JSON-API "attributes object".

method extractErrors

extractErrors: (
    store: Store,
    typeClass: ModelSchema,
    payload: {},
    id: string | number
) => {};

• extractErrors is used to extract model errors when a call to DS.Model#save fails with an InvalidError. By default Ember Data expects error information to be located on the errors property of the payload object.

method extractId

extractId: (modelClass: {}, resourceHash: {}) => string;

• Returns the resource's ID.

method extractMeta

extractMeta: (store: Store, modelClass: ModelSchema, payload: {}) => any;

• extractMeta is used to deserialize any meta information in the adapter payload. By default Ember Data expects meta information to be located on the meta property of the payload object.

method extractPolymorphicRelationship

extractPolymorphicRelationship: (
    relationshipModelName: {},
    relationshipHash: {},
    relationshipOptions: {}
) => {};

• Returns a polymorphic relationship formatted as a JSON-API "relationship object".

method extractRelationship

extractRelationship: (relationshipModelName: {}, relationshipHash: {}) => {};

• Returns a relationship formatted as a JSON-API "relationship object".

method extractRelationships

extractRelationships: (modelClass: ModelSchema, resourceHash: {}) => {};

• Returns the resource's relationships formatted as a JSON-API "relationships object".

method keyForAttribute

keyForAttribute: (key: string, method: string) => string;

• keyForAttribute can be used to define rules for how to convert an attribute name in your model to a key in your JSON.

method keyForLink

keyForLink: (key: string, kind: string) => string;

• keyForLink can be used to define a custom key when deserializing link properties.

method keyForRelationship

keyForRelationship: (key: string, typeClass: string, method: string) => string;

• keyForRelationship can be used to define a custom key when serializing and deserializing relationship properties. By default JSONSerializer does not provide an implementation of this method.

method modelNameFromPayloadKey

modelNameFromPayloadKey: (key: string) => string;

method modelNameFromPayloadType

modelNameFromPayloadType: (type: string) => string;

method normalize

normalize: (typeClass: ModelSchema, hash: {}) => {};

• Normalizes a part of the JSON payload returned by the server. You should override this method, munge the hash and call super if you have generic normalization to do.

method normalizeArrayResponse

normalizeArrayResponse: (
    store: Store,
    primaryModelClass: ModelSchema,
    payload: {},
    id: string | number,
    requestType: string
) => {};

method normalizeCreateRecordResponse

normalizeCreateRecordResponse: (
    store: Store,
    primaryModelClass: ModelSchema,
    payload: {},
    id: string | number,
    requestType: string
) => {};

method normalizeDeleteRecordResponse

normalizeDeleteRecordResponse: (
    store: Store,
    primaryModelClass: ModelSchema,
    payload: {},
    id: string | number,
    requestType: string
) => {};

method normalizeFindAllResponse

normalizeFindAllResponse: (
    store: Store,
    primaryModelClass: ModelSchema,
    payload: {},
    id: string | number,
    requestType: string
) => {};

method normalizeFindBelongsToResponse

normalizeFindBelongsToResponse: (
    store: Store,
    primaryModelClass: ModelSchema,
    payload: {},
    id: string | number,
    requestType: string
) => {};

method normalizeFindHasManyResponse

normalizeFindHasManyResponse: (
    store: Store,
    primaryModelClass: ModelSchema,
    payload: {},
    id: string | number,
    requestType: string
) => {};

method normalizeFindManyResponse

normalizeFindManyResponse: (
    store: Store,
    primaryModelClass: ModelSchema,
    payload: {},
    id: string | number,
    requestType: string
) => {};

method normalizeFindRecordResponse

normalizeFindRecordResponse: (
    store: Store,
    primaryModelClass: ModelSchema,
    payload: {},
    id: string | number,
    requestType: string
) => {};

method normalizeQueryRecordResponse

normalizeQueryRecordResponse: (
    store: Store,
    primaryModelClass: ModelSchema,
    payload: {},
    id: string | number,
    requestType: string
) => {};

method normalizeQueryResponse

normalizeQueryResponse: (
    store: Store,
    primaryModelClass: ModelSchema,
    payload: {},
    id: string | number,
    requestType: string
) => {};

method normalizeResponse

normalizeResponse: (
    store: Store,
    primaryModelClass: ModelSchema,
    payload: {},
    id: string | number,
    requestType: string
) => {};

• The normalizeResponse method is used to normalize a payload from the server to a JSON-API Document.

method normalizeSaveResponse

normalizeSaveResponse: (
    store: Store,
    primaryModelClass: ModelSchema,
    payload: {},
    id: string | number,
    requestType: string
) => {};

method normalizeSingleResponse

normalizeSingleResponse: (
    store: Store,
    primaryModelClass: ModelSchema,
    payload: {},
    id: string | number,
    requestType: string
) => {};

method normalizeUpdateRecordResponse

normalizeUpdateRecordResponse: (
    store: Store,
    primaryModelClass: ModelSchema,
    payload: {},
    id: string | number,
    requestType: string
) => {};

method serialize

serialize: <K extends string | number | symbol>(
    snapshot: Snapshot<K>,
    options: {}
) => {};

• Called when a record is saved in order to convert the record into JSON.

method serializeAttribute

serializeAttribute: <K extends string | number | symbol>(
    snapshot: Snapshot<K>,
    json: {},
    key: string,
    attribute: {}
) => any;

• serializeAttribute can be used to customize how DS.attr properties are serialized

method serializeBelongsTo

serializeBelongsTo: <K extends string | number | symbol>(
    snapshot: Snapshot<K>,
    json: {},
    relationship: {}
) => any;

• serializeBelongsTo can be used to customize how DS.belongsTo properties are serialized.

method serializeHasMany

serializeHasMany: <K extends string | number | symbol>(
    snapshot: Snapshot<K>,
    json: {},
    relationship: {}
) => any;

• serializeHasMany can be used to customize how DS.hasMany properties are serialized.

method serializeId

serializeId: <K extends string | number | symbol>(
    snapshot: Snapshot<K>,
    json: {},
    primaryKey: string
) => any;

• serializeId can be used to customize how id is serialized For example, your server may expect integer datatype of id

method serializeIntoHash

serializeIntoHash: <K extends string | number | symbol>(
    hash: {},
    typeClass: ModelSchema<K>,
    snapshot: Snapshot<K>,
    options?: {}
) => any;

• You can use this method to customize how a serialized record is added to the complete JSON hash to be sent to the server. By default the JSON Serializer does not namespace the payload and just sends the raw serialized JSON object. If your server expects namespaced keys, you should consider using the RESTSerializer. Otherwise you can override this method to customize how the record is added to the hash. The hash property should be modified by reference.

method serializePolymorphicType

serializePolymorphicType: <K extends string | number | symbol>(
    snapshot: Snapshot<K>,
    json: {},
    relationship: {}
) => any;

• You can use this method to customize how polymorphic objects are serialized. Objects are considered to be polymorphic if { polymorphic: true } is pass as the second argument to the DS.belongsTo function.

method shouldSerializeHasMany

shouldSerializeHasMany: <K extends string | number | symbol>(
    snapshot: Snapshot<K>,
    key: string,
    relationshipType: string
) => boolean;

• Check if the given hasMany relationship should be serialized

property isLoaded

isLoaded: boolean;

• The loading state of this array

property meta

meta: {};

• Metadata associated with the request for async hasMany relationships.

method createRecord

createRecord: (inputProperties?: {}) => T;

• Create a child record within the owner

method reload

reload: () => PromiseArray<T>;

• Reloads all of the records in the manyArray. If the manyArray holds a relationship that was originally fetched using a links url Ember Data will revisit the original links url to repopulate the relationship.

method save

save: () => PromiseArray<T>;

• Saves all of the records in the ManyArray.

property adapterError

adapterError: AdapterError;

• This property holds the DS.AdapterError object with which last adapter operation was rejected.

property attributes

static attributes: Ember.ComputedProperty<Map<string, unknown>>;

• A map whose keys are the attributes of the model (properties described by DS.attr) and whose values are the meta object for the property.

property dirtyType

dirtyType: Ember.ComputedProperty<string>;

• If the record is in the dirty state this property will report what kind of change has caused it to move into the dirty state. Possible values are:

property errors

errors: Errors;

• When the record is in the invalid state this object will contain any errors returned by the adapter. When present the errors hash contains keys corresponding to the invalid property names and values which are arrays of Javascript objects with two keys:

property fields

static fields: Ember.ComputedProperty<Map<string, unknown>>;

• A map whose keys are the fields of the model and whose values are strings describing the kind of the field. A model's fields are the union of all of its attributes and relationships.

property hasDirtyAttributes

hasDirtyAttributes: Ember.ComputedProperty<boolean>;

• If this property is true the record is in the dirty state. The record has local changes that have not yet been saved by the adapter. This includes records that have been created (but not yet saved) or deleted.

property id

id: string;

• All ember models have an id property. This is an identifier managed by an external source. These are always coerced to be strings before being used internally. Note when declaring the attributes for a model it is an error to declare an id attribute.

property isDeleted

isDeleted: Ember.ComputedProperty<boolean>;

• If this property is true the record is in the deleted state and has been marked for deletion. When isDeleted is true and hasDirtyAttributes is true, the record is deleted locally but the deletion was not yet persisted. When isSaving is true, the change is in-flight. When both hasDirtyAttributes and isSaving are false, the change has persisted.

property isEmpty

isEmpty: Ember.ComputedProperty<boolean>;

• If this property is true the record is in the empty state. Empty is the first state all records enter after they have been created. Most records created by the store will quickly transition to the loading state if data needs to be fetched from the server or the created state if the record is created on the client. A record can also enter the empty state if the adapter is unable to locate the record.

property isError

isError: boolean;

• If true the adapter reported that it was unable to save local changes to the backend for any reason other than a server-side validation error.

property isLoaded

isLoaded: Ember.ComputedProperty<boolean>;

• If this property is true the record is in the loaded state. A record enters this state when its data is populated. Most of a record's lifecycle is spent inside substates of the loaded state.