@ember-data/store 4.12.0-beta.5 → 4.12.0-beta.7

package/README.md

@@ -80,66 +80,64 @@ class extends Store {
 
 Now that we have a `cache` let's setup something to handle fetching and saving data via our API.
 
-> Note: [1] the cache from `@ember-data/json-api` is a special cache: if the package is present the `createCache` hook will automatically do the above wiring if the hook is not implemented. We still recommend implementing the hook.
+> **Note** [1] the cache from `@ember-data/json-api` is a special cache: if the package is present the `createCache` hook will automatically do the above wiring if the hook is not implemented. We still recommend implementing the hook.
 >
-> Note: [2] The `ember-data` package automatically includes the `@ember-data/json-api` cache for you.
+> **Note** [2] The `ember-data` package automatically includes the `@ember-data/json-api` cache for you.
 
-### Adding An Adapter
+### Handling Requests
 
-When *Ember***Data** needs to fetch or save data it will pass that request to your application's `Adapter` for fulfillment. How this fulfillment occurs (in-memory, device storage, via single or multiple API requests, etc.) is up to that Adapter.
+When *Ember***Data** needs to fetch or save data it will pass that request to your application's `RequestManager` for fulfillment. How this fulfillment occurs (in-memory, device storage, via single or multiple API requests, etc.) is then up to the registered request handlers.
 
-To start, let's install a `JSON:API` adapter. If your app uses `GraphQL` or `REST` other adapters may better fit your data. You can author your own adapter by creating one that conforms to the [spec]().
+To start, let's install the `FetchManager` from `@ember-data/request` and the basic `Fetch` handler from ``@ember-data/request/fetch`.
 
-The package `@ember-data/adapter` provides a `JSON:API` adapter we can use. After installing it, we can configure the store to use this adapter.
+> **Note** If your app uses `GraphQL`, `REST` or different conventions for `JSON:API` than your cache expects, other handlers may better fit your data. You can author your own handler by creating one that conforms to the [handler interface](https://github.com/emberjs/data/tree/main/packages/request#handling-requests).
 
-```js
+```ts
 import Store from '@ember-data/store';
-import Adapter from '@ember-data/adapter/json-api';
-
-class extends Store {
-  #adapter = new Adapter();
-
-  adapterFor() {
-    return this.#adapter;
+import RequestManager from '@ember-data/request';
+import Fetch from '@ember-data/request/fetch';
+
+export default class extends Store {
+  constructor() {
+    super(...arguments);
+    this.requestManager = new RequestManager();
+    this.requestManager.use([Fetch]);
   }
 }
 ```
 
-If you want to know more about using Adapters with Ember read the next section, else lets skip to [Presenting Data from the Cache](#presenting-data-from-the-cache) to configure how our application will interact with our data. 
+**Using RequestManager as a Service**
 
-#### Using with Ember
+Alternatively if you have configured the `RequestManager` to be a service you may re-use it.
 
-Note: If you are using Ember and would like to make use of `service` injections in your adapter, you will want to additionally `setOwner` for the Adapter.
-
-```js
-import Store from '@ember-data/store';
-import Adapter from '@ember-data/adapter/json-api';
-import { getOwner, setOwner } from '@ember/application';
+*app/services/request.js*
+```ts
+import RequestManager from '@ember-data/request';
+import Fetch from '@ember-data/request/fetch';
 
-class extends Store {
-  #adapter = null;
-
-  adapterFor() {
-    let adapter = this.#adapter;
-    if (!adapter) {
-      const owner = getOwner(this);
-      adapter = new Adapter();
-      setOwner(adapter, owner);
-      this.#adapter = adapter;
-    }
-
-    return adapter;
+export default class extends RequestManager {
+  constructor(createArgs) {
+    super(createArgs);
+    this.use([Fetch]);
   }
 }
 ```
 
-By default when using with Ember you only need to implement this hook if you want your adapter usage to be statically analyzeable. *Ember***Data** will attempt to resolve adapters using Ember's resolver. To provide a single Adapter for your application like the above you would provide it as the default export of the file `app/adapters/application.{js/ts}`
+*app/services/store.js*
+```ts
+import Store from '@ember-data/store';
+import { service } from '@ember/service';
+
+export default class extends Store {
+  @service('request') requestManager
+}
+```
 
 ### Presenting Data from the Cache
 
 Now that we have a source and a cach for our data, we need to configure how the Store delivers that data back to our application. We do this via the hook `instantiateRecord`, which allows us to transform the data for a resource before handing it to the application.
 
-A naive way to present the data would be to return it as JSON. Typically instead this hook will be used to add reactivity and make each uniue resource a singleton, ensuring that if the cache updates our presented data will reflect the new state.
+A naive way to present the data would be to return it as JSON. Typically instead this hook will be used to add reactivity and make each unique resource a singleton, ensuring that if the cache updates our presented data will reflect the new state.
 
 Below is an example of using the hooks `instantiateRecord` and a `teardownRecord` to provide minimal read-only reactive state for simple resources.
 
@@ -156,25 +154,34 @@ class extends Store {
     record.type = identifier.type;
     record.id = identifier.id;
     
-    notifications.subscribe(identifier, (_, change) => {
+    // update the TrackedObject whenever attributes change
+    const token = notifications.subscribe(identifier, (_, change) => {
       if (change === 'attributes') {
         Object.assign(record, cache.peek(identifier));
       }
     });
 
+    record.destroy = () => {
+      this.notifications.unsubscribe(token);
+    };
+
     return record;
   }
+
+  teardownRecord(record: FakeRecord) {
+    record.destroy();
+  }
 }
 ```
 
 Because `instantiateRecord` is opaque to the nature of the record, an implementation can be anything from a fairly simple object to a robust proxy that intelligently links together associated records through relationships.
 
-This also enables creating a record that separates `edit` flows from `create` flows entirely. A record class might choose to implement a `checkout`method that gives access to an editable instance while the primary record continues to be read-only and reflect only persisted (non-mutated) state.
+This also enables creating a record that separates `edit` flows from `create` flows entirely. A record class might choose to implement a `checkout` method that gives access to an editable instance while the primary record continues to be read-only and reflect only persisted (non-mutated) state.
 
 Typically you will choose an existing record implementation such as `@ember-data/model` for your application.
 
 Because of the boundaries around instantiation and the cache, record implementations should be capable of interop both with each other and with any `Cache`. Due to this, if needed an application can utilize multiple record implementations and multiple cache implementations either to support enhanced features for only a subset of records or to be able to incrementally migrate from one record/cache to another record or cache.
 
-> Note: [1] `@ember-data/model` is a special record implementation: if the package is present the `instantiateRecord` hook will automatically do the above wiring if the hook is not implemented. Due to the complexity of this legacy package's use of Ember's resolver, we do not recommend wiring this package manually.
+> Note: [1] `@ember-data/model` is a special record implementation: currently, if the package is present the `instantiateRecord` hook will automatically do the above wiring if the hook is not implemented.
 >
 > Note: [2] The `ember-data` package automatically includes the `@ember-data/model` implementation for you.

package/addon/-private.js

@@ -1 +1 @@
-export { f as AdapterPopulatedRecordArray, C as CacheHandler, j as IDENTIFIER_ARRAY_TAG, I as IdentifierArray, M as MUTATE, I as RecordArray, R as RecordArrayManager, h as SOURCE, S as Store, _ as _clearCaches, e as coerceId, k as fastPush, i as isStableIdentifier, n as normalizeModelName, g as notifyArray, p as peekCache, r as recordIdentifierFor, l as removeRecordDataFor, c as setIdentifierForgetMethod, a as setIdentifierGenerationMethod, d as setIdentifierResetMethod, b as setIdentifierUpdateMethod, s as storeFor } from "./index-123f3e7e";
+export { f as AdapterPopulatedRecordArray, C as CacheHandler, j as IDENTIFIER_ARRAY_TAG, I as IdentifierArray, M as MUTATE, I as RecordArray, R as RecordArrayManager, h as SOURCE, S as Store, _ as _clearCaches, e as coerceId, k as fastPush, i as isStableIdentifier, n as normalizeModelName, g as notifyArray, p as peekCache, r as recordIdentifierFor, l as removeRecordDataFor, c as setIdentifierForgetMethod, a as setIdentifierGenerationMethod, d as setIdentifierResetMethod, b as setIdentifierUpdateMethod, s as storeFor } from "./index-f7d3d5e5";

package/addon/{index-123f3e7e.js → index-f7d3d5e5.js}

@@ -2826,7 +2826,7 @@ class InstanceCache {
     return reference;
   }
   recordIsLoaded(identifier, filterDeleted = false) {
-    const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? this.__instances.resourceCache.get(identifier) : this.cache;
+    const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? this.__instances.resourceCache.get(identifier) || this.cache : this.cache;
     if (!cache) {
       return false;
     }
@@ -4294,6 +4294,7 @@ class RecordArrayManager {
     this._managed = new Set();
     this._pending = new Map();
     this._staged = new Map();
+    this._keyedArrays = new Map();
     this._identifiers = RecordArraysCache;
     this._subscription = this.store.notifications.subscribe('resource', (identifier, type) => {
       if (type === 'added') {
@@ -4887,8 +4888,10 @@ class Store {
     // we lazily set the cache handler when we issue the first request
     // because constructor doesn't allow for this to run after
     // the user has had the chance to set the prop.
+    const storeSymbol = Symbol.for('ember-data:enable-hydration');
     let opts = {
-      store: this
+      store: this,
+      [storeSymbol]: true
     };
     if (macroCondition(getOwnConfig().env.TESTING)) {
       if (this.DISABLE_WAITER) {
@@ -6824,7 +6827,9 @@ function getHydratedContent(store, request, document) {
     }
     return managed;
   } else {
-    return document.data ? store.peekRecord(document.data) : null;
+    return Object.assign({}, document, {
+      data: document.data ? store.peekRecord(document.data) : null
+    });
   }
 }
 function calcShouldFetch(store, request, hasCachedValue, lid) {
@@ -6833,7 +6838,7 @@ function calcShouldFetch(store, request, hasCachedValue, lid) {
     url,
     method
   } = request;
-  return cacheOptions?.reload || !hasCachedValue || store.lifetimes && lid && url && method ? store.lifetimes.isHardExpired(lid, url, method) : false;
+  return cacheOptions?.reload || !hasCachedValue || (store.lifetimes && lid && url && method ? store.lifetimes.isHardExpired(lid, url, method) : false);
 }
 function calcShouldBackgroundFetch(store, request, willFetch, lid) {
   const {
@@ -6841,19 +6846,33 @@ function calcShouldBackgroundFetch(store, request, willFetch, lid) {
     url,
     method
   } = request;
-  return !willFetch && (cacheOptions?.backgroundReload || store.lifetimes && lid && url && method ? store.lifetimes.isSoftExpired(lid, url, method) : false);
+  return !willFetch && (cacheOptions?.backgroundReload || (store.lifetimes && lid && url && method ? store.lifetimes.isSoftExpired(lid, url, method) : false));
 }
 function fetchContentAndHydrate(next, context, shouldFetch, shouldBackgroundFetch) {
   const {
     store
   } = context.request;
+  const shouldHydrate = context.request[Symbol.for('ember-data:enable-hydration')] || false;
   return next(context.request).then(document => {
-    const response = store.cache.put(document);
+    store._enableAsyncFlush = true;
+    let response;
+    store._join(() => {
+      response = store.cache.put(document);
+      if (shouldFetch && shouldHydrate) {
+        response = getHydratedContent(store, context.request, response);
+      }
+    });
+    store._enableAsyncFlush = null;
     if (shouldFetch) {
-      return getHydratedContent(store, context.request, response);
+      return response;
     }
   }, error => {
-    store.cache.put(error);
+    store._enableAsyncFlush = true;
+    store._join(() => {
+      store.cache.put(error);
+    });
+    store._enableAsyncFlush = null;
+
     // TODO @runspired this is probably not the right thing to throw so make sure we add a test
     if (!shouldBackgroundFetch) {
       throw error;
@@ -6862,8 +6881,8 @@ function fetchContentAndHydrate(next, context, shouldFetch, shouldBackgroundFetc
 }
 const CacheHandler = {
   request(context, next) {
-    // if we are a legacy request or did not originate from the store, skip cache handling
-    if (!context.request.store || context.request.op && !context.request.url) {
+    // if we have no cache or no cache-key skip cache handling
+    if (!context.request.store || !(context.request.cacheOptions?.key || context.request.url)) {
       return next(context.request);
     }
     const {
@@ -6891,7 +6910,8 @@ const CacheHandler = {
     if ('error' in peeked) {
       throw peeked.error;
     }
-    return Promise.resolve(getHydratedContent(store, context.request, peeked.content));
+    const shouldHydrate = context.request[Symbol.for('ember-data:enable-hydration')] || false;
+    return Promise.resolve(shouldHydrate ? getHydratedContent(store, context.request, peeked.content) : peeked.content);
   }
 };
 function normalizeModelName(modelName) {