Appearance

Documentation / @ember-data/model / index / default

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:36

Base class from which Models can be defined.

js
import { Model, attr, belongsTo, hasMany } from '@warp-drive/legacy/model';

export default class User extends Model {
  @attr name;
  @attr('number') age;
  @hasMany('post', { async: true, inverse: null }) posts;
  @belongsTo('group', { async: false, inverse: 'users' }) group;
}
ts
import { Model, attr, belongsTo, hasMany, type AsyncHasMany } from '@warp-drive/legacy/model';
import type { NumberTransform } from '@ember-data/serializer/transform';
import type Group from './group';
import type Post from './post';

export default class User extends Model {
  @attr declare name: string;

  @attr<NumberTransform>('number')
  declare age: number;

  @hasMany('post', { async: true, inverse: null })
  declare posts: AsyncHasMany<Post>;

  @belongsTo('group', { async: false, inverse: 'users' })
  declare group: Group | null;
}

Models both define the schema for a resource type and provide the class to use as the reactive object for data of resource of that type.

Extends ​

  • unknown

Implements ​

  • MinimalLegacyRecord

Constructors ​

Constructor ​

ts
new default(): Model;

Returns ​

Model

Properties ​

isReloading ​

ts
readonly isReloading: boolean;

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:648

If true the store is attempting to reload the record from the adapter.

Example

javascript
record.isReloading; // false
record.reload();
record.isReloading; // true

store ​

ts
store: default;

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:415

The store service instance which created this record instance

modelName ​

ts
readonly static modelName: string;

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:835

Represents the model's class name as a string. This can be used to look up the model's class name through Store's modelFor method.

modelName is generated for you by EmberData. It will be a lowercased, dasherized string. For example:

javascript
store.modelFor('post').modelName; // 'post'
store.modelFor('blog-post').modelName; // 'blog-post'

The most common place you'll want to access modelName is in your serializer's payloadKeyFromModelName method. For example, to change payload keys to underscore (instead of dasherized), you might use the following code:

javascript
import RESTSerializer from '@ember-data/serializer/rest';
import { underscore } from '<app-name>/utils/string-utils';

export default const PostSerializer = RESTSerializer.extend({
  payloadKeyFromModelName(modelName) {
    return underscore(modelName);
  }
});

Accessors ​

adapterError ​

Get Signature ​

ts
get adapterError(): unknown;

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:741

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

Returns ​

unknown

Set Signature ​

ts
set adapterError(v): void;

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:742

Parameters ​
v ​

unknown

Returns ​

void

currentState ​

Set Signature ​

ts
set currentState(_v): void;

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:675

Parameters ​
_v ​

RecordState

Returns ​

void

dirtyType ​

Get Signature ​

ts
get dirtyType(): "" | "created" | "updated" | "deleted";

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:611

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:

  • created The record has been created by the client and not yet saved to the adapter.
  • updated The record has been updated by the client and not yet saved to the adapter.
  • deleted The record has been deleted by the client and not yet saved to the adapter.

Example

javascript
let record = store.createRecord('model');
record.dirtyType; // 'created'
Returns ​

"" | "created" | "updated" | "deleted"

errors ​

Get Signature ​

ts
get errors(): Errors;

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:733

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:

  • message A string containing the error message from the backend
  • attribute The name of the property associated with this error message
javascript
record.errors.length; // 0
record.set('foo', 'invalid value');
record.save().catch(function() {
  record.errors.foo;
  // [{message: 'foo should be a number.', attribute: 'foo'}]
});

The errors property is useful for displaying error messages to the user.

handlebars
<label>Username: <Input @value={{@model.username}} /> </label>
{{#each @model.errors.username as |error|}}
  <div class="error">
    {{error.message}}
  </div>
{{/each}}
<label>Email: <Input @value={{@model.email}} /> </label>
{{#each @model.errors.email as |error|}}
  <div class="error">
    {{error.message}}
  </div>
{{/each}}

You can also access the special messages property on the error object to get an array of all the error strings.

handlebars
{{#each @model.errors.messages as |message|}}
  <div class="error">
    {{message}}
  </div>
{{/each}}
Returns ​

Errors

hasDirtyAttributes ​

Get Signature ​

ts
get hasDirtyAttributes(): boolean;

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:496

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.

Example

javascript
let record = store.createRecord('model');
record.hasDirtyAttributes; // true

const { content: { data: model } } = await store.request(findRecord({ type: 'model', id: '1' }));

model.hasDirtyAttributes; // false
model.foo = 'some value';
model.hasDirtyAttributes; // true
Since ​

1.13.0

Returns ​

boolean

id ​

Get Signature ​

ts
get id(): null | string;

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:667

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.

javascript
let record = store.createRecord('model');
record.id; // null

const { content: { data: model } } = await store.request(findRecord({ type: 'model', id: '1' }));
model.id; // '1'
Returns ​

null | string

Set Signature ​

ts
set id(id): void;

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:668

Parameters ​
id ​

null | string

Returns ​

void

isDeleted ​

Get Signature ​

ts
get isDeleted(): boolean;

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:557

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.

Example

javascript
let record = store.createRecord('model');
record.isDeleted;    // false
record.deleteRecord();

// Locally deleted
record.isDeleted;           // true
record.hasDirtyAttributes;  // true
record.isSaving;            // false

// Persisting the deletion
let promise = record.save();
record.isDeleted;    // true
record.isSaving;     // true

// Deletion Persisted
promise.then(function() {
  record.isDeleted;          // true
  record.isSaving;           // false
  record.hasDirtyAttributes; // false
});
Returns ​

boolean

isEmpty ​

Get Signature ​

ts
get isEmpty(): boolean;

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:439

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.

Returns ​

boolean

isError ​

Get Signature ​

ts
get isError(): boolean;

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:631

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.

Example

javascript
record.isError; // false
record.set('foo', 'valid value');
record.save().then(null, function() {
  record.isError; // true
});
Returns ​

boolean

isLoaded ​

Get Signature ​

ts
get isLoaded(): boolean;

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:471

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.

Example

javascript
let record = store.createRecord('model');
record.isLoaded; // true

const { content: { data: model } } = await store.request(findRecord({ type: 'model', id: '1' }));
model.isLoaded;
Returns ​

boolean

isLoading ​

Get Signature ​

ts
get isLoading(): boolean;

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:450

If this property is true the record is in the loading state. A record enters this state when the store asks the adapter for its data. It remains in this state until the adapter provides the requested data.

Returns ​

boolean

isNew ​

Get Signature ​

ts
get isNew(): boolean;

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:579

If this property is true the record is in the new state. A record will be in the new state when it has been created on the client and the adapter has not yet report that it was successfully saved.

Example

javascript
let record = store.createRecord('model');
record.isNew; // true

record.save().then(function(model) {
  model.isNew; // false
});
Returns ​

boolean

isSaving ​

Get Signature ​

ts
get isSaving(): boolean;

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:519

If this property is true the record is in the saving state. A record enters the saving state when save is called, but the adapter has not yet acknowledged that the changes have been persisted to the backend.

Example

javascript
let record = store.createRecord('model');
record.isSaving; // false
let promise = record.save();
record.isSaving; // true
promise.then(function() {
  record.isSaving; // false
});
Returns ​

boolean

isValid ​

Get Signature ​

ts
get isValid(): boolean;

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:590

If this property is true the record is in the valid state.

A record will be in the valid state when the adapter did not report any server-side validation failures.

Returns ​

boolean

attributes ​

Get Signature ​

ts
get static attributes(): Map<string, LegacyAttributeField>;

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:1137

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

Example

app/models/person.js
js
import { Model, attr } from '@warp-drive/legacy/model';

export default class PersonModel extends Model {
   @attr('string') firstName;
   @attr('string') lastName;
   @attr('date') birthday;
 }
javascript
import Person from 'app/models/person'

let attributes = Person.attributes

attributes.forEach(function(meta, name) {
   // do thing
 });

// prints:
// firstName {type: "string", kind: 'attribute', options: Object, parentType: function, name: "firstName"}
// lastName {type: "string", kind: 'attribute', options: Object, parentType: function, name: "lastName"}
// birthday {type: "date", kind: 'attribute', options: Object, parentType: function, name: "birthday"}
Returns ​

Map<string, LegacyAttributeField>

fields ​

Get Signature ​

ts
get static fields(): Map<string, "belongsTo" | "hasMany" | "attribute">;

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:1073

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.

For example:

app/models/blog.js
js
import { Model, attr, belongsTo, hasMany } from '@warp-drive/legacy/model';

export default class BlogModel extends Model {
   @hasMany('user') users;
   @belongsTo('user') owner;

   @hasMany('post') posts;

   @attr('string') title;
 }
js
import Blog from 'app/models/blog'

let fields = Blog.fields;
fields.forEach(function(kind, field) {
   // do thing
 });

// prints:
// users, hasMany
// owner, belongsTo
// posts, hasMany
// title, attribute
Returns ​

Map<string, "belongsTo" | "hasMany" | "attribute">

inverseMap ​

Get Signature ​

ts
get static inverseMap(): Record<string, 
  | null
| LegacyRelationshipField>;

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:857

Returns ​

Record<string, | null | LegacyRelationshipField>

relatedTypes ​

Get Signature ​

ts
get static relatedTypes(): string[];

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:997

An array of types directly related to a model. Each type will be included once, regardless of the number of relationships it has with the model.

For example, given a model with this definition:

app/models/blog.js
js
import { Model, belongsTo, hasMany } from '@warp-drive/legacy/model';

export default class BlogModel extends Model {
   @hasMany('user') users;
   @belongsTo('user') owner;

   @hasMany('post') posts;
 }

This property would contain the following:

javascript
import Blog from 'app/models/blog';

let relatedTypes = Blog.relatedTypes');
//=> ['user', 'post']
Returns ​

string[]

relationshipNames ​

Get Signature ​

ts
get static relationshipNames(): object;

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:962

A hash containing lists of the model's relationships, grouped by the relationship kind. For example, given a model with this definition:

app/models/blog.js
js
import { Model, belongsTo, hasMany } from '@warp-drive/legacy/model';

export default class BlogModel extends Model {
   @hasMany('user') users;
   @belongsTo('user') owner;

   @hasMany('post') posts;
 }

This property would contain the following:

javascript
import Blog from 'app/models/blog';

let relationshipNames = Blog.relationshipNames;
relationshipNames.hasMany;
//=> ['users', 'posts']
relationshipNames.belongsTo;
//=> ['owner']
Returns ​

object

belongsTo ​
ts
belongsTo: string[];
hasMany ​
ts
hasMany: string[];

relationships ​

Get Signature ​

ts
get static relationships(): Map<string, LegacyRelationshipField[]>;

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:929

The model's relationships as a map, keyed on the type of the relationship. The value of each entry is an array containing a descriptor for each relationship with that type, describing the name of the relationship as well as the type.

For example, given the following model definition:

app/models/blog.js
js
import { Model, belongsTo, hasMany } from '@warp-drive/legacy/model';

export default class BlogModel extends Model {
   @hasMany('user') users;
   @belongsTo('user') owner;
   @hasMany('post') posts;
 }

This computed property would return a map describing these relationships, like this:

javascript
import Blog from 'app/models/blog';
import User from 'app/models/user';
import Post from 'app/models/post';

let relationships = Blog.relationships;
relationships.user;
//=> [ { name: 'users', kind: 'hasMany' },
//     { name: 'owner', kind: 'belongsTo' } ]
relationships.post;
//=> [ { name: 'posts', kind: 'hasMany' } ]
Returns ​

Map<string, LegacyRelationshipField[]>

relationshipsByName ​

Get Signature ​

ts
get static relationshipsByName(): Map<string, LegacyRelationshipField>;

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:1032

A map whose keys are the relationships of a model and whose values are relationship descriptors.

For example, given a model with this definition:

app/models/blog.js
js
import { Model, belongsTo, hasMany } from '@warp-drive/legacy/model';

export default class BlogModel extends Model {
   @hasMany('user') users;
   @belongsTo('user') owner;

   @hasMany('post') posts;
 }

This property would contain the following:

javascript
import Blog from 'app/models/blog';

let relationshipsByName = Blog.relationshipsByName;
relationshipsByName.users;
//=> { name: 'users', kind: 'hasMany', type: 'user', options: Object }
relationshipsByName.owner;
//=> { name: 'owner', kind: 'belongsTo', type: 'user', options: Object }
Returns ​

Map<string, LegacyRelationshipField>

relationshipsObject ​

Get Signature ​

ts
get static relationshipsObject(): Record<string, LegacyRelationshipField>;

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:1033

Returns ​

Record<string, LegacyRelationshipField>

transformedAttributes ​

Get Signature ​

ts
get static transformedAttributes(): Map<string, string>;

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:1174

A map whose keys are the attributes of the model (properties described by attr) and whose values are type of transformation applied to each attribute. This map does not include any attributes that do not have an transformation type.

Example

app/models/person.js
js
import { Model, attr } from '@warp-drive/legacy/model';

export default class PersonModel extends Model {
   @attr firstName;
   @attr('string') lastName;
   @attr('date') birthday;
 }
javascript
import Person from 'app/models/person';

let transformedAttributes = Person.transformedAttributes

transformedAttributes.forEach(function(field, type) {
   // do thing
 });

// prints:
// lastName string
// birthday date
Returns ​

Map<string, string>

Methods ​

belongsTo() ​

ts
belongsTo<T, K>(this, prop): BelongsToReference<T, K>;

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:286

Get the reference for the specified belongsTo relationship.

For instance, given the following model

app/models/blog-post.js
js
import { Model, belongsTo } from '@warp-drive/legacy/model';

export default class BlogPost extends Model {
  @belongsTo('user', { async: true, inverse: null }) author;
}

Then the reference for the author relationship would be retrieved from a record instance like so:

js
blogPost.belongsTo('author');

A BelongsToReference is a low-level API that allows access and manipulation of a belongsTo relationship.

It is especially useful when you're dealing with async relationships as it allows synchronous access to the relationship data if loaded, as well as APIs for loading, reloading the data or accessing available information without triggering a load.

It may also be useful when using sync relationships that need to be loaded/reloaded with more precise timing than marking the relationship as async and relying on autofetch would have allowed.

However,keep in mind that marking a relationship as async: false will introduce bugs into your application if the data is not always guaranteed to be available by the time the relationship is accessed. Ergo, it is recommended when using this approach to utilize links for unloaded relationship state instead of identifiers.

Reference APIs are entangled with the relationship's underlying state, thus any getters or cached properties that utilize these will properly invalidate if the relationship state changes.

References are "stable", meaning that multiple calls to retrieve the reference for a given relationship will always return the same HasManyReference.

Type Parameters ​

T ​

T extends Model

K ​

K extends string

Parameters ​

this ​

T

prop ​

K & K extends _MaybeBelongsToFields<T> ? K<K> : never

Returns ​

BelongsToReference<T, K>

reference for this relationship

Since ​

2.5.0

changedAttributes() ​

ts
changedAttributes<T>(this): ChangedAttributesHash;

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:147

Returns an object, whose keys are changed properties, and value is an [oldProp, newProp] array.

The array represents the diff of the canonical state with the local state of the model. Note: if the model is created locally, the canonical state is empty since the adapter hasn't acknowledged the attributes yet:

Example

app/models/mascot.js
js
import { Model, attr } from '@warp-drive/legacy/model';

export default class MascotModel extends Model {
  @attr('string') name;
  @attr('boolean', {
    defaultValue: false
  })
  isAdmin;
}
javascript
let mascot = store.createRecord('mascot');

mascot.changedAttributes(); // {}

mascot.set('name', 'Tomster');
mascot.changedAttributes(); // { name: [undefined, 'Tomster'] }

mascot.set('isAdmin', true);
mascot.changedAttributes(); // { isAdmin: [undefined, true], name: [undefined, 'Tomster'] }

mascot.save().then(function() {
  mascot.changedAttributes(); // {}

  mascot.set('isAdmin', false);
  mascot.changedAttributes(); // { isAdmin: [true, false] }
});

Type Parameters ​

T ​

T extends MinimalLegacyRecord

Parameters ​

this ​

T

Returns ​

ChangedAttributesHash

an object, whose keys are changed properties, and value is an [oldProp, newProp] array.

deleteRecord() ​

ts
deleteRecord<T>(this): void;

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:365

Marks the record as deleted but does not save it. You must call save afterwards if you want to persist it. You might use this method if you want to allow the user to still rollbackAttributes() after a delete was made.

Example

js
import Component from '@glimmer/component';

export default class extends Component {
  softDelete = () => {
    this.args.model.deleteRecord();
  }

  confirm = () => {
    this.args.model.save();
  }

  undo = () => {
    this.args.model.rollbackAttributes();
  }
}

Type Parameters ​

T ​

T extends MinimalLegacyRecord

Parameters ​

this ​

T

Returns ​

void

destroyRecord() ​

ts
destroyRecord<T>(this, options?): Promise<Model>;

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:94

Same as deleteRecord, but saves the record immediately.

Example

js
import Component from '@glimmer/component';

export default class extends Component {
  delete = () => {
    this.args.model.destroyRecord().then(function() {
      this.transitionToRoute('model.index');
    });
  }
}

If you pass an object on the adapterOptions property of the options argument it will be passed to your adapter via the snapshot

js
record.destroyRecord({ adapterOptions: { subscribe: false } });
app/adapters/post.js
js
import MyCustomAdapter from './custom-adapter';

export default class PostAdapter extends MyCustomAdapter {
  deleteRecord(store, type, snapshot) {
    if (snapshot.adapterOptions.subscribe) {
      // ...
    }
    // ...
  }
}

Type Parameters ​

T ​

T extends MinimalLegacyRecord

Parameters ​

this ​

T

options? ​

Record<string, unknown>

Returns ​

Promise<Model>

a promise that will be resolved when the adapter returns successfully or rejected if the adapter returns with an error.

eachAttribute() ​

ts
eachAttribute<T>(callback, binding?): void;

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:801

Type Parameters ​

T ​

T

Parameters ​

callback ​

(this, key, meta) => void

binding? ​

T

Returns ​

void

eachRelationship() ​

ts
eachRelationship<T>(callback, binding?): void;

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:798

Given a callback, iterates over each of the relationships in the model, invoking the callback with the name of each relationship and its relationship descriptor.

The callback method you provide should have the following signature (all parameters are optional):

javascript
function(name, descriptor);
  • name the name of the current property in the iteration
  • descriptor the meta object that describes this relationship

The relationship descriptor argument is an object with the following properties.

  • name String the name of this relationship on the Model
  • kind String "hasMany" or "belongsTo"
  • options Object the original options hash passed when the relationship was declared
  • parentType Model the type of the Model that owns this relationship
  • type String the type name of the related Model

Note that in addition to a callback, you can also pass an optional target object that will be set as this on the context.

Example

app/serializers/application.js
js
import JSONSerializer from '@ember-data/serializer/json';

export default class ApplicationSerializer extends JSONSerializer {
   serialize(record, options) {
   let json = {};

   record.eachRelationship(function(name, descriptor) {
     if (descriptor.kind === 'hasMany') {
       let serializedHasManyName = name.toUpperCase() + '_IDS';
       json[serializedHasManyName] = record.get(name).map(r => r.id);
     }
   });

   return json;
 }
}

Type Parameters ​

T ​

T

Parameters ​

callback ​

(this, key, meta) => void

the callback to invoke

binding? ​

T

the value to which the callback's this should be bound

Returns ​

void

hasMany() ​

ts
hasMany<T, K>(this, prop): HasManyReference<T, K>;

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:336

Get the reference for the specified hasMany relationship.

For instance, given the following model

app/models/blog-post.js
js
import { Model, hasMany } from '@warp-drive/legacy/model';

export default class BlogPost extends Model {
  @hasMany('comment', { async: true, inverse: null }) comments;
}

Then the reference for the comments relationship would be retrieved from a record instance like so:

js
blogPost.hasMany('comments');

A HasManyReference is a low-level API that allows access and manipulation of a hasMany relationship.

It is especially useful when you are dealing with async relationships as it allows synchronous access to the relationship data if loaded, as well as APIs for loading, reloading the data or accessing available information without triggering a load.

It may also be useful when using sync relationships with @ember-data/model that need to be loaded/reloaded with more precise timing than marking the relationship as async and relying on autofetch would have allowed.

However,keep in mind that marking a relationship as async: false will introduce bugs into your application if the data is not always guaranteed to be available by the time the relationship is accessed. Ergo, it is recommended when using this approach to utilize links for unloaded relationship state instead of identifiers.

Reference APIs are entangled with the relationship's underlying state, thus any getters or cached properties that utilize these will properly invalidate if the relationship state changes.

References are "stable", meaning that multiple calls to retrieve the reference for a given relationship will always return the same HasManyReference.

Type Parameters ​

T ​

T extends MinimalLegacyRecord

K ​

K extends string

Parameters ​

this ​

T

prop ​

K

Returns ​

HasManyReference<T, K>

reference for this relationship

Since ​

2.5.0

inverseFor() ​

ts
inverseFor(name): 
  | null
  | LegacyRelationshipField;

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:800

Parameters ​

name ​

string

Returns ​

| null | LegacyRelationshipField

notifyPropertyChange() ​

ts
notifyPropertyChange(prop): this;

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:743

Parameters ​

prop ​

string

Returns ​

this

relationshipFor() ​

ts
relationshipFor(name): 
  | undefined
  | LegacyRelationshipField;

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:799

Parameters ​

name ​

string

Returns ​

| undefined | LegacyRelationshipField

reload() ​

ts
reload<T>(this, options?): Promise<T>;

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:236

Reload the record from the adapter.

This will only work if the record has already finished loading.

Example

js
import Component from '@glimmer/component';

export default class extends Component {
  async reload = () => {
    await this.args.model.reload();
    // do something with the reloaded model
  }
}

Type Parameters ​

T ​

T extends MinimalLegacyRecord

Parameters ​

this ​

T

options? ​

Record<string, unknown>

optional, may include adapterOptions hash which will be passed to adapter request

Returns ​

Promise<T>

a promise that will be resolved with the record when the adapter returns successfully or rejected if the adapter returns with an error.

rollbackAttributes() ​

ts
rollbackAttributes<T>(this): void;

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:165

If the model hasDirtyAttributes this function will discard any unsaved changes. If the model isNew it will be removed from the store.

Example

javascript
record.name; // 'Untitled Document'
record.set('name', 'Doc 1');
record.name; // 'Doc 1'
record.rollbackAttributes();
record.name; // 'Untitled Document'

Type Parameters ​

T ​

T extends MinimalLegacyRecord

Parameters ​

this ​

T

Returns ​

void

Since ​

1.13.0

save() ​

ts
save<T>(this, options?): Promise<Model>;

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:210

Save the record and persist any changes to the record to an external source via the adapter.

Example

javascript
record.set('name', 'Tomster');
record.save().then(function() {
  // Success callback
}, function() {
  // Error callback
});

If you pass an object using the adapterOptions property of the options argument it will be passed to your adapter via the snapshot.

js
record.save({ adapterOptions: { subscribe: false } });
app/adapters/post.js
js
import MyCustomAdapter from './custom-adapter';

export default class PostAdapter extends MyCustomAdapter {
  updateRecord(store, type, snapshot) {
    if (snapshot.adapterOptions.subscribe) {
      // ...
    }
    // ...
  }
}

Type Parameters ​

T ​

T extends MinimalLegacyRecord

Parameters ​

this ​

T

options? ​

Record<string, unknown>

Returns ​

Promise<Model>

a promise that will be resolved when the adapter returns successfully or rejected if the adapter returns with an error.

serialize() ​

ts
serialize<T>(this, options?): unknown;

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:51

Create a JSON representation of the record, using the serialization strategy of the store's adapter.

serialize takes an optional hash as a parameter, currently supported options are:

  • includeId: true if the record's ID should be included in the JSON representation.

Type Parameters ​

T ​

T extends MinimalLegacyRecord

Parameters ​

this ​

T

options? ​

Record<string, unknown>

Returns ​

unknown

an object whose values are primitive JSON values only

toString() ​

ts
toString(): string;

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:669

Returns a string representation of an object.

Returns ​

string

unloadRecord() ​

ts
unloadRecord<T>(this): void;

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:101

Unloads the record from the store. This will not send a delete request to your server, it just unloads the record from memory.

Type Parameters ​

T ​

T extends MinimalLegacyRecord

Parameters ​

this ​

T

Returns ​

void

_findInverseFor() ​

ts
static _findInverseFor(name, store): 
  | null
  | LegacyRelationshipField;

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:890

Parameters ​

name ​

string

store ​

default

Returns ​

| null | LegacyRelationshipField

eachAttribute() ​

ts
static eachAttribute<T, Schema>(callback, binding?): void;

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:1217

Iterates through the attributes of the model, calling the passed function on each attribute.

The callback method you provide should have the following signature (all parameters are optional):

javascript
function(name, meta);
  • name the name of the current property in the iteration
  • meta the meta object for the attribute property in the iteration

Note that in addition to a callback, you can also pass an optional target object that will be set as this on the context.

Example

javascript
import { Model, attr } from '@warp-drive/legacy/model';

class PersonModel extends Model {
   @attr('string') firstName;
   @attr('string') lastName;
   @attr('date') birthday;
 }

PersonModel.eachAttribute(function(name, meta) {
   // do thing
 });

// prints:
// firstName {type: "string", kind: 'attribute', options: Object, parentType: function, name: "firstName"}
// lastName {type: "string", kind: 'attribute', options: Object, parentType: function, name: "lastName"}
// birthday {type: "date", kind: 'attribute', options: Object, parentType: function, name: "birthday"}

Type Parameters ​

T ​

T

Schema ​

Schema extends Model

Parameters ​

callback ​

(this, key, attribute) => void

The callback to execute

binding? ​

T

the value to which the callback's this should be bound

Returns ​

void

eachRelatedType() ​

ts
static eachRelatedType<T>(callback, binding?): void;

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:1094

Given a callback, iterates over each of the types related to a model, invoking the callback with the related type's class. Each type will be returned just once, regardless of how many different relationships it has with a model.

Type Parameters ​

T ​

T

Parameters ​

callback ​

(this, type) => void

the callback to invoke

binding? ​

T

the value to which the callback's this should be bound

Returns ​

void

eachRelationship() ​

ts
static eachRelationship<T, Schema>(callback, binding?): void;

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:1083

Given a callback, iterates over each of the relationships in the model, invoking the callback with the name of each relationship and its relationship descriptor.

Type Parameters ​

T ​

T

Schema ​

Schema extends Model

Parameters ​

callback ​

(this, key, relationship) => void

the callback to invoke

binding? ​

T

the value to which the callback's this should be bound

Returns ​

void

eachTransformedAttribute() ​

ts
static eachTransformedAttribute<T, Schema>(callback, binding?): void;

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:1261

Iterates through the transformedAttributes of the model, calling the passed function on each attribute. Note the callback will not be called for any attributes that do not have an transformation type.

The callback method you provide should have the following signature (all parameters are optional):

javascript
function(name, type);
  • name the name of the current property in the iteration
  • type a string containing the name of the type of transformed applied to the attribute

Note that in addition to a callback, you can also pass an optional target object that will be set as this on the context.

Example

javascript
import { Model, attr } from '@warp-drive/legacy/model';

let Person = Model.extend({
   firstName: attr(),
   lastName: attr('string'),
   birthday: attr('date')
 });

Person.eachTransformedAttribute(function(name, type) {
   // do thing
 });

// prints:
// lastName string
// birthday date

Type Parameters ​

T ​

T

Schema ​

Schema extends Model

Parameters ​

callback ​

(this, key, type) => void

The callback to execute

binding? ​

T

the value to which the callback's this should be bound

Returns ​

void

inverseFor() ​

ts
static inverseFor(name, store): 
  | null
  | LegacyRelationshipField;

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:889

Find the relationship which is the inverse of the one asked for.

For example, if you define models like this:

app/models/post.js
js
import { Model, hasMany } from '@warp-drive/legacy/model';

export default class PostModel extends Model {
   @hasMany('message') comments;
 }
app/models/message.js
js
import { Model, belongsTo } from '@warp-drive/legacy/model';

export default class MessageModel extends Model {
   @belongsTo('post') owner;
 }
js
store.modelFor('post').inverseFor('comments', store) // { type: 'message', name: 'owner', kind: 'belongsTo' }
store.modelFor('message').inverseFor('owner', store) // { type: 'post', name: 'comments', kind: 'hasMany' }

Parameters ​

name ​

string

the name of the relationship

store ​

default

Returns ​

| null | LegacyRelationshipField

the inverse relationship, or null

toString() ​

ts
static toString(): string;

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:1267

Returns the name of the model class.

Returns ​

string

typeForRelationship() ​

ts
static typeForRelationship(name, store): 
  | undefined
| ModelSchema<unknown>;

Defined in: warp-drive-packages/legacy/declarations/model/-private/model.d.ts:856

For a given relationship name, returns the model type of the relationship.

For example, if you define a model like this:

app/models/post.js
js
import { Model, hasMany } from '@warp-drive/legacy/model';

export default class PostModel extends Model {
  @hasMany('comment') comments;
}

Calling store.modelFor('post').typeForRelationship('comments', store) will return Comment.

Parameters ​

name ​

string

the name of the relationship

store ​

default

an instance of Store

Returns ​

| undefined | ModelSchema<unknown>

the type of the relationship, or undefined

Released under the MIT License.

Copyright © 2025 Ember.js and Contributors