As we saw in the section, Understanding the Ember Data identity map – DS.Store, all interactions with the server are handled by the adapter. Adapter in ember-data understands how to connect to the server, in order to fetch and save the records from/to the server. Similarly, serializer, as the name implies, is responsible for serializing or converting the response received from the server to DS.Model objects.

By default in ember-data, the store will use the DS.RESTAdapter and DS.RESTSerializer. As the name implies, the DS.RESTAdapter is based on the REST (Representational State Transfer) principles to load or save a record from/to the server. The DS.RESTAdapter communicates with the HTTP server by sending and receiving JSON (JavaScript Object Notation) data, via AJAX requests. If the server with which the Ember.js application talks with, understands and follows the URL conventions according to REST principles, then your ember-data communication will work flawlessly without any customization to the adapter or serializer.

Let us see what the URL endpoints for our book model (chapter-6/example1/app/models/book.js) discussed when used with different actions:

As you can see, the DS.RESTAdapter uses plural form of the model name to create the URLs, hence the URL for the book model becomes /books/. Another important thing to note here is the use of HTTP verbs while making calls to the server. To fetch a record or records from the server, the adapter uses GET verb or action; to create a new record, the POST verb is used; to update an existing record, the PUT verb is used; and to delete a record, the DELETE verb is used.

Now that we have understood how the adapter creates the URLs to communicate with the server, let's understand how we need to send the JSON response back from the server, in order for it to be compliant with the DS.RESTAdapter and DS.RESTSerializer.

In order to understand the JSON response from the server, let us take the look at the book model:

import DS from "ember-data";

export default DS.Model.extend({
  title: DS.attr('string'),
  isbn: DS.attr('string'),
  pages: DS.attr('number'),
  description: DS.attr('string'),
  authors: DS.hasMany('author',{ async: true }),
  publisher: DS.belongsTo('publisher',{ async: true }),
  reviews: DS.hasMany("review",{ async: true })
});

Here, you can see that the book model contains both attributes and relationships. When we make a call to fetch a particular book from the server using store.find("book",1), this gets translated to GET /books/1 that should return a JSON response, which can be de-serialized into book model object. The JSON response returned from the server should be of the following structure:

{
  "book": {
    "id":1
    "title": "Ember.js Essentials",
    "isbn": "ISBN1",
    "pages": 180,
    "description": "Ember.js essentials to master",
    "authors": [1],
    "publisher": 1,
    "reviews": [1,2,3]
  }
}

Here, you can see that we return a JSON response that has a top-level key that is the same as the name of the model, book in our case. This is followed by the attributes and their values. One important thing to note is that it is mandatory to send the ID of the object with the JSON response, the ID attribute is defined automatically on every DS.Model object and is used by the store to uniquely identify the records.

Let's look at relationships now. The book record has three relationships, namely authors, publisher, and reviews. The relationships of DS.hasMany type use the plural form of the model and expect the relationship IDs in an array.

The relationship response "reviews": [1,2,3] tells the serializer that this book object has three reviews, whose IDs are 1, 2, and 3. Similarly, the "publisher": 1 tells the adapter and serializer that a book has one publisher with ID 1.

Now, as we used {async:true} in defining our relationships of the book model, the DS.RESTAdapter and DS.RESTSerializer that the JSON response of the book object will only contain the IDs of the relationships in proper format. These relationship objects (authors, publisher and reviews) should be fetched separately only when they are referred to by the application code. When such references to the relationships are encountered, a call store.find('reviews',1) or GET /reviews/1 is sent for each object present in the "reviews": [1,2,3] array.

The async property is very helpful in cases where an object has a lot of relationships, but initially only the details of the objects are visible on the screen as the relationships are fetched lazily when required by the application.

import DS from "ember-data";
export default DS.Model.extend({
  title: DS.attr('string'),
  isbn: DS.attr('string'),
  pages: DS.attr('number'),
  description: DS.attr('string'),
  authors: DS.hasMany('author'),
  publisher: DS.belongsTo('publisher'),
  reviews: DS.hasMany("review")
});

{
  "book": {
    "id":1,
    "title": "Ember.js Essentials",
    "isbn": "ISBN1",
    "pages": 180,
    "description": "Ember.js essentials to master",
    "authors": [1],
    "publisher": 1,
    "reviews": [1,2,3]
  },

  "publisher": {
    "id": 1,
    "name": "Packt Publishing",
    "organizationName": "Pact",
    "address":"Packt Publishing London",
    "book":1
  },

  "authors": [{
    "id": 1,
    "firstName": "firstName1",
    "lastName" : "LastName1",
    "bio": "Great Guy",
    "book":[1]
  }],
  "reviews": [{
    "id": 1
    "name": "Reviewer 1",
    "comment": "comment 1",
    "book":1
  },{
    "id": 2
    "name": "Reviewer 2",
    "comment": "comment 2",
    "book":1
  },
  {
    "id": 3
    "name": "Reviewer 3",
    "comment": "comment 3",
    "book":1
  }]
}

import DS from 'ember-data';
export default DS.RESTAdapter.extend({
  namespace: 'api'
});

import DS from 'ember-data';
export default DS.RESTAdapter.extend({
  host: 'http://api.someotherdomain.com/'
});