Product
Introducing License Enforcement in Socket
Ensure open-source compliance with Socket’s License Enforcement Beta. Set up your License Policy and secure your software!
ember-data
Advanced tools
Ember Data is a library for robustly managing model data in your Ember.js applications.
Ember Data is a library for robustly managing model data in your Ember.js applications.
Ember Data is designed to be agnostic to the underlying persistence mechanism, so it works just as well with JSON APIs over HTTP as it does with streaming WebSockets or local IndexedDB storage.
It provides many of the facilities you'd find in server-side ORMs like ActiveRecord, but is designed specifically for the unique environment of JavaScript in the browser.
In particular, Ember Data uses Promises/A+-compatible promises from the ground up to manage loading and saving records, so integrating with other JavaScript APIs is easy.
bower install ember-data --save
The latest passing build from the "master" branch is available on http://emberjs.com/builds/#/canary.
Similarly, the latest passing build from the "beta" branch can be found on http://emberjs.com/builds/#/beta
Or build ember-data.js yourself. Clone the repository and run npm run dist
after setup. You'll find ember-data.js in the dist
directory.
If you need to support Internet Explorer, you will need to use es5-shim.js and es5-sham.js from es5-shim.
In Ember Data, the store is responsible for managing the lifecycle of your models. Every time you need a model or a collection of models, you'll ask the store for it.
To create a store, you don't need to do anything. Just by loading the
Ember Data library, all of the routes and controllers in your
application will get a new store
property. This property is an
instance of DS.Store
that will be shared across all of the routes and
controllers in your app.
First thing's first: tell Ember Data about the models in your application. For example, imagine we're writing a blog reader app. Here's what your model definition would look like if you're using globals (that is, not something like Ember App Kit or ember-cli):
var attr = DS.attr,
hasMany = DS.hasMany,
belongsTo = DS.belongsTo;
App.BlogPost = DS.Model.extend({
title: attr(),
createdAt: attr('date'),
comments: hasMany('comment')
});
App.Comment = DS.Model.extend({
body: attr(),
username: attr(),
post: belongsTo('blogPost')
});
If you're using ES6 modules (via Ember App Kit or ember-cli), your models would look like this:
// app/models/blog-post.js
var attr = DS.attr,
hasMany = DS.hasMany;
export default DS.Model.extend({
title: attr(),
createdAt: attr('date'),
comments: hasMany('comment')
});
// app/models/comment.js
var attr = DS.attr,
belongsTo = DS.belongsTo;
export default DS.Model.extend({
body: attr(),
username: attr(),
post: belongsTo('blogPost')
});
Without immediately diving in to the depths of the architecture, one thing you should know is that Ember Data uses an object called an adapter to know how to talk to your server.
An adapter is just an object that knows how to translate requests from
Ember Data into requests on your server. For example, if I ask the Ember
Data store for a record of type person
with an ID of 123
, the
adapter translates that into an XHR request to (for example)
api.example.com/v3/person/123.json
.
By default, Ember Data will use the RESTAdapter
, which adheres to a
set of RESTful JSON conventions.
Ember Data also ships with the FixtureAdapter
, useful for testing and
prototyping before you have a server, and the ActiveModelAdapter
,
which is designed to work out-of-the-box with the
ActiveModel::Serializers
gem for Rails.
To learn more about adapters, including what conventions the
RESTAdapter
follows and how to build your own, see the Ember.js
Guides: Connecting to an HTTP
Server.
From your route or controller:
this.store.find('blogPost');
This returns a promise that resolves to the collection of records.
this.store.find('blogPost', 123);
This returns a promise that resolves to the requested record. If the record can't be found or there was an error during the request, the promise will be rejected.
For much more detail on how to use Ember Data, see the Ember.js Guides on models.
Ember Data is still under active development and is currently beta quality. That being said, the API has largely stabilized and many companies are using it in production.
For details on anticipated changes before the 1.0 release, see the blog post The Road to Ember Data 1.0.
npm install
to ensure the required dependencies are installed.npm run dist
to build Ember Data. The builds will be placed in the dist/
directory.See CONTRIBUTING.md
Install Node.js from http://nodejs.org or your favorite package manager.
Install Ember CLI and bower. npm install -g ember-cli bower
Run npm install
inside the project root to install the JS dependencies.
To start the development server, run npm start
.
Visit http://localhost:4200
Install phantomjs from http://phantomjs.org
Run npm test
Ember Data 1.0.0-beta.14.1 (December 31, 2014)
<%= versionStamp %>
with actual version stamp. Thanks
@tricknotes!FAQs
The lightweight reactive data library for JavaScript applications
The npm package ember-data receives a total of 55,777 weekly downloads. As such, ember-data popularity was classified as popular.
We found that ember-data demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 0 open source maintainers collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Product
Ensure open-source compliance with Socket’s License Enforcement Beta. Set up your License Policy and secure your software!
Product
We're launching a new set of license analysis and compliance features for analyzing, managing, and complying with licenses across a range of supported languages and ecosystems.
Product
We're excited to introduce Socket Optimize, a powerful CLI command to secure open source dependencies with tested, optimized package overrides.