#

API Docs for: v3.8.1
Show: Inherited Protected Private Deprecated

# DS Class

Defined in: `addon/-private/core.js:9`
Module: ember-data

All Ember Data classes, methods and functions are defined inside of this namespace.

- Index
- Methods
- Properties

## Item Index

### Methods

- attr
- belongsTo
- errorsArrayToHash
- errorsHashToArray
- hasMany
- normalizeModelName

### Properties

- VERSION static

## Methods

### `attr`

(

- `type`
- `options`

)
Attribute

Defined in `addon/-private/attr.ts:30`

`DS.attr` defines an attribute on a DS.Model. By default, attributes are passed through as-is, however you can specify an optional type to have the value automatically transformed. Ember Data ships with four basic transform types: `string`, `number`, `boolean` and `date`. You can define your own transforms by subclassing DS.Transform.

Note that you cannot use `attr` to define an attribute of `id`.

`DS.attr` takes an optional hash as a second parameter, currently supported options are:

- `defaultValue`: Pass a string or a function to be called to set the attribute to a default value if none is supplied.

Example

    import DS from 'ember-data';

    export default DS.Model.extend({
      username: DS.attr('string'),
      email: DS.attr('string'),
      verified: DS.attr('boolean', { defaultValue: false })
    });

Default value can also be a function. This is useful it you want to return a new object for each attribute.

    import DS from 'ember-data';

    export default DS.Model.extend({
      username: DS.attr('string'),
      email: DS.attr('string'),
      settings: DS.attr({
        defaultValue() {
          return {};
        }
      })
    });

The `options` hash is passed as second argument to a transforms' `serialize` and `deserialize` method. This allows to configure a transformation and adapt the corresponding value, based on the config:

    import DS from 'ember-data';

    export default DS.Model.extend({
      text: DS.attr('text', {
        uppercase: true
      })
    });

    import DS from 'ember-data';

    export default DS.Transform.extend({
      serialize(value, options) {
        if (options.uppercase) {
          return value.toUpperCase();
        }

        return value;
      },

      deserialize(value) {
        return value;
      }
    })

#### Parameters:

- `type` String | Object

  the attribute type

- `options` Object

  a hash of options

#### Returns:

Attribute:

### `belongsTo`

(

- `modelName`
- `options`

)
Ember.computed

Defined in `addon/-private/system/relationships/belongs-to.js:6`

`DS.belongsTo` is used to define One-To-One and One-To-Many relationships on a DS.Model.

`DS.belongsTo` takes an optional hash as a second parameter, currently supported options are:

- `async`: A boolean value used to explicitly declare this to be an async relationship. The default is true.
- `inverse`: A string used to identify the inverse property on a related model in a One-To-Many relationship. See Explicit Inverses

#### One-To-One

To declare a one-to-one relationship between two models, use `DS.belongsTo`:

    import DS from 'ember-data';

    export default DS.Model.extend({
      profile: DS.belongsTo('profile')
    });

    import DS from 'ember-data';

    export default DS.Model.extend({
      user: DS.belongsTo('user')
    });

#### One-To-Many

To declare a one-to-many relationship between two models, use `DS.belongsTo` in combination with `DS.hasMany`, like this:

    import DS from 'ember-data';

    export default DS.Model.extend({
      comments: DS.hasMany('comment')
    });

    import DS from 'ember-data';

    export default DS.Model.extend({
      post: DS.belongsTo('post')
    });

You can avoid passing a string as the first parameter. In that case Ember Data will infer the type from the key name.

    import DS from 'ember-data';

    export default DS.Model.extend({
      post: DS.belongsTo()
    });

will lookup for a Post type.

#### Sync relationships

Ember Data resolves sync relationships with the related resources available in its local store, hence it is expected these resources to be loaded before or along-side the primary resource.

    import DS from 'ember-data';

    export default DS.Model.extend({
      post: DS.belongsTo('post', {
        async: false
      })
    });

In contrast to async relationship, accessing a sync relationship will always return the record (Model instance) for the existing local resource, or null. But it will error on access when a related resource is known to exist and it has not been loaded.

    let post = comment.get('post');

#### Parameters:

- `modelName` String

  (optional) type of the relationship

- `options` Object

  (optional) a hash of options

#### Returns:

Ember.computed:

relationship

### `errorsArrayToHash`

(

- `errors`

)
Object public

Defined in `addon/-private/adapters/errors.js:422`

Convert an array of errors in JSON-API format into an object.

    import DS from 'ember-data';

    const { errorsArrayToHash } = DS;

    let errorsArray = [
      {
        title: 'Invalid Attribute',
        detail: 'Must be present',
        source: { pointer: '/data/attributes/name' }
      },
      {
        title: 'Invalid Attribute',
        detail: 'Must be present',
        source: { pointer: '/data/attributes/age' }
      },
      {
        title: 'Invalid Attribute',
        detail: 'Must be a number',
        source: { pointer: '/data/attributes/age' }
      }
    ];

    let errors = errorsArrayToHash(errorsArray);
    // {
    //   "name": ["Must be present"],
    //   "age":  ["Must be present", "must be a number"]
    // }

#### Parameters:

- `errors` Array

  array of errors in JSON-API format

#### Returns:

Object:

### `errorsHashToArray`

(

- `errors`

)
Array public

Defined in `addon/-private/adapters/errors.js:349`

Convert an hash of errors into an array with errors in JSON-API format.

    import DS from 'ember-data';

    const { errorsHashToArray } = DS;

    let errors = {
      base: 'Invalid attributes on saving this record',
      name: 'Must be present',
      age: ['Must be present', 'Must be a number']
    };

    let errorsArray = errorsHashToArray(errors);
    // [
    //   {
    //     title: "Invalid Document",
    //     detail: "Invalid attributes on saving this record",
    //     source: { pointer: "/data" }
    //   },
    //   {
    //     title: "Invalid Attribute",
    //     detail: "Must be present",
    //     source: { pointer: "/data/attributes/name" }
    //   },
    //   {
    //     title: "Invalid Attribute",
    //     detail: "Must be present",
    //     source: { pointer: "/data/attributes/age" }
    //   },
    //   {
    //     title: "Invalid Attribute",
    //     detail: "Must be a number",
    //     source: { pointer: "/data/attributes/age" }
    //   }
    // ]

#### Parameters:

- `errors` Object

  hash with errors as properties

#### Returns:

Array:

array of errors in JSON-API format

### `hasMany`

(

- `type`
- `options`

)
Ember.computed

Defined in `addon/-private/system/relationships/has-many.js:9`

`DS.hasMany` is used to define One-To-Many and Many-To-Many relationships on a DS.Model.

`DS.hasMany` takes an optional hash as a second parameter, currently supported options are:

- `async`: A boolean value used to explicitly declare this to be an async relationship. The default is true.
- `inverse`: A string used to identify the inverse property on a related model.

#### One-To-Many

To declare a one-to-many relationship between two models, use `DS.belongsTo` in combination with `DS.hasMany`, like this:

    import DS from 'ember-data';

    export default DS.Model.extend({
      comments: DS.hasMany('comment')
    });

    import DS from 'ember-data';

    export default DS.Model.extend({
      post: DS.belongsTo('post')
    });

#### Many-To-Many

To declare a many-to-many relationship between two models, use `DS.hasMany`:

    import DS from 'ember-data';

    export default DS.Model.extend({
      tags: DS.hasMany('tag')
    });

    import DS from 'ember-data';

    export default DS.Model.extend({
      posts: DS.hasMany('post')
    });

You can avoid passing a string as the first parameter. In that case Ember Data will infer the type from the singularized key name.

    import DS from 'ember-data';

    export default DS.Model.extend({
      tags: DS.hasMany()
    });

will lookup for a Tag type.

#### Explicit Inverses

Ember Data will do its best to discover which relationships map to one another. In the one-to-many code above, for example, Ember Data can figure out that changing the `comments` relationship should update the `post` relationship on the inverse because post is the only relationship to that model.

However, sometimes you may have multiple `belongsTo`/`hasMany` for the same type. You can specify which property on the related model is the inverse using `DS.hasMany`'s `inverse` option:

    import DS from 'ember-data';

    export default DS.Model.extend({
      onePost: DS.belongsTo('post'),
      twoPost: DS.belongsTo('post'),
      redPost: DS.belongsTo('post'),
      bluePost: DS.belongsTo('post')
    });

    import DS from 'ember-data';

    export default DS.Model.extend({
      comments: DS.hasMany('comment', {
        inverse: 'redPost'
      })
    });

You can also specify an inverse on a `belongsTo`, which works how you'd expect.

#### Sync relationships

Ember Data resolves sync relationships with the related resources available in its local store, hence it is expected these resources to be loaded before or along-side the primary resource.

    import DS from 'ember-data';

    export default DS.Model.extend({
      comments: DS.hasMany('comment', {
        async: false
      })
    });

In contrast to async relationship, accessing a sync relationship will always return a DS.ManyArray instance containing the existing local resources. But it will error on access when any of the known related resources have not been loaded.

    post.get('comments').forEach((comment) => {

    });

If you are using `links` with sync relationships, you have to use `ref.reload` to fetch the resources.

#### Parameters:

- `type` String

  (optional) type of the relationship

- `options` Object

  (optional) a hash of options

#### Returns:

Ember.computed:

relationship

### `normalizeModelName`

(

- `modelName`

)
String public

Defined in `addon/-private/system/normalize-model-name.js:6`

This method normalizes a modelName into the format Ember Data uses internally.

#### Parameters:

- `modelName` String

#### Returns:

String:

normalizedModelName

## Properties

### `VERSION`

String static

Defined in `addon/-private/core.js:16`