ember-data

What is ember-data?

Ember Data is a library for robustly managing model data in Ember.js applications. It provides a consistent way to interact with a backend data store, manage relationships between models, and handle data persistence.

What are ember-data's main functionalities?

Defining Models

Ember Data allows you to define models with attributes and relationships. In this example, a `Post` model is defined with attributes `title` and `publishedAt`, and relationships to `author` and `comments`.

import Model, { attr, belongsTo, hasMany } from '@ember-data/model';

export default class Post extends Model {
  @attr('string') title;
  @attr('date') publishedAt;
  @belongsTo('author') author;
  @hasMany('comment') comments;
}

Fetching Records

You can fetch records from the backend using the `store` service. This example demonstrates how to fetch a `post` record by its ID in a route.

import Route from '@ember/routing/route';

export default class PostRoute extends Route {
  async model(params) {
    return this.store.findRecord('post', params.post_id);
  }
}

Saving Records

Ember Data provides methods to save records back to the backend. This example shows how to save a `post` record.

import Controller from '@ember/controller';

export default class PostController extends Controller {
  async savePost(post) {
    await post.save();
  }
}

Handling Relationships

Ember Data makes it easy to handle relationships between models. This example demonstrates fetching a `post` along with its related `comments`.

import Route from '@ember/routing/route';

export default class PostRoute extends Route {
  async model(params) {
    let post = await this.store.findRecord('post', params.post_id);
    let comments = await post.comments;
    return { post, comments };
  }
}

Other packages similar to ember-data

redux

Redux is a predictable state container for JavaScript apps. It is often used with React but can be used with any JavaScript framework. Unlike Ember Data, which is tightly integrated with Ember.js, Redux is framework-agnostic and provides a more manual approach to state management.

mobx

MobX is a simple, scalable state management library. It uses reactive programming to automatically update the UI when the state changes. MobX is more flexible and less opinionated compared to Ember Data, making it suitable for a variety of use cases.

vuex

Vuex is a state management pattern + library for Vue.js applications. It serves as a centralized store for all the components in an application, with rules ensuring that the state can only be mutated in a predictable fashion. Vuex is to Vue.js what Ember Data is to Ember.js, providing a structured way to manage state.

README

The lightweight reactive data library for JavaScript applications

---

Wrangle your application's data management with scalable patterns for developer productivity.

• ⚡️ Committed to Best-In-Class Performance
• 🌲 Focused on being as svelte as possible
• 🚀 SSR Ready
• 🔜 Typescript Support
• 🐹 Built with ♥️ by Ember
• ⚛️ Supports any API: GraphQL JSON:API REST tRPC ...bespoke or a mix

Tagged Releases

• 
• 
• 
• 
• 

📖 On This Page

• Overview
  • Architecture
  • Basic Installation
  • Advanced Installation
• Configuration
  • Deprecation Stripping
  • randomUUID polyfill
  • Removing inspector support in production
  • Debugging
• Contributing

Overview

EmberData is a lightweight reactive data library for JavaScript applications that provides composable primitives for ordering query/mutation/peek flows, managing network and cache, and reducing data for presentation.

• API Documentation
• Community & Help
• Contributing Guide
• Usage Guide
• RFCs
• Team
• Blog

🪜 Architecture

EmberData is both resource centric and document centric in it's approach to caching, requesting and presenting data. Your application's configuration and usage drives which is important and when.

The Store is a coordinator. When using a Store you configure what cache to use, how cache data should be presented to the UI, and where it should look for requested data when it is not available in the cache.

This coordination is handled opaquely to the nature of the requests issued and the format of the data being handled. This approach gives applications broad flexibility to configure EmberData to best suite their needs. This makes EmberData a powerful solution for applications regardless of their size and complexity.

EmberData is designed to scale, with a religious focus on performance and asset-size to keep its footprint small but speedy while still being able to handle large complex APIs in huge data-driven applications with no additional code and no added application complexity. It's goal is to prevent applications from writing code to manage data that is difficult to maintain or reason about.

EmberData's power comes not from specific features, data formats, or adherence to specific API specs such as JSON:API trpc or GraphQL, but from solid conventions around requesting and mutating data developed over decades of experience scaling developer productivity.

Basic Installation

Install using your javascript package manager of choice. For instance with pnpm

pnpm add ember-data

ember-data is installed by default for new applications generated with ember-cli. You can check what version is installed by looking in the devDependencies hash of your project's package.json file.

If you have generated a new Ember application using ember-cli but do not wish to use ember-data, remove ember-data from your project's package.json file and run your package manager's install command to update your lockfile.

Advanced Installation

EmberData is organized into primitives that compose together via public APIs.

• @ember-data/request provides managed fetch via its RequestManager and can be used without any other parts of EmberData.
• @ember-data/store is the "core" of EmberData and handles coordination between the RequestManager, the Cache, and Presentation Concerns.
• @ember-data/tracking is currently required when using the core and provides tracking primitives for change notification of Tracked properties.
• @ember-data/json-api is a resource cache for JSON:API structured data. It integrates with the store via the hook createCache
• @ember-data/model is a presentation layer, it integrates with the store via the hooks instantiateRecord and teardownRecord.
• @ember-data/debug provides (optional) debugging support for the ember-inspector.

Some EmberData APIs are older than others, and these still interop via well-defined public API boundaries but are no longer the ideal approach.

• @ember-data/legacy-compat provides support for older paradigms that are being phased out
• @ember-data/adapter provides various network API integrations for APIS built over specific REST or JSON:API conventions. It integrates with the Store via store.adapterFor, and with the request pipeline via the LegacyNetworkHandler available via @ember-data/legacy-compat which utilizes the Minimum Adapter Interface.
• @ember-data/serializer pairs with @ember-data/adapter and the LegacyNetworkHandler to normalize and serialize data to and from an API format into the JSON:API format understood by @ember-data/json-api.

And finally:

• ember-data is a "meta" package which bundles all of these together for convenience

The packages interop with each other through well defined public API boundaries. The core of the library is the store provided by @ember-data/store, while each of the other libraries plugs into the store when installed. Because these packages interop via fully public APIs, other libraries or applications may provide their own implementations. For instance, ember-m3 is a commonly used presentation and cache implementation suitable for complex resource objects and graphs.

Configuration

Deprecation Stripping

EmberData allows users to opt-in and remove code that exists to support deprecated behaviors.

If your app has resolved all deprecations present in a given version, you may specify that version as your "compatibility" version to remove the code that supported the deprecated behavior from your app.

let app = new EmberApp(defaults, {
  emberData: {
    compatWith: '4.8',
  },
});

• Full Documentation

randomUUID polyfill

EmberData uses UUID V4 by default to generate identifiers for new data created on the client. Identifier generation is configurable, but we also for convenience will polyfill the necessary feature if your browser support or deployment environment demands it. To activate this polyfill:

let app = new EmberApp(defaults, {
  '@embroider/macros': {
    setConfig: {
      '@ember-data/store': {
        polyfillUUID: true,
      },
    },
  },
});

removing inspector support in production

If you do not want to ship inspector support in your production application, you can specify that all support for it should be stripped from the build.

let app = new EmberApp(defaults, {
  emberData: {
    includeDataAdapterInProduction: false,
  },
});

• Full Documentation

Debugging

Many portions of the internals are helpfully instrumented with logging that can be activated at build time. This instrumentation is always removed from production builds or any builds that has not explicitly activated it. To activate it set the appropriate flag to true.

let app = new EmberApp(defaults, {
  emberData: {
    debug: {
      LOG_PAYLOADS: false, // data store received to update cache with
      LOG_OPERATIONS: false, // updates to cache remote state
      LOG_MUTATIONS: false, // updates to cache local state
      LOG_NOTIFICATIONS: false,
      LOG_REQUESTS: false, // log Requests issued via the request manager
      LOG_REQUEST_STATUS: false,
      LOG_IDENTIFIERS: false,
      LOG_GRAPH: false, // relationship storage
      LOG_INSTANCE_CACHE: false, // instance creation/deletion
    },
  },
});

License

This project is licensed under the MIT License.