@ember-data/store 4.12.0-alpha.13 → 4.12.0-alpha.15

package/addon/-private.js

@@ -1 +1 @@
-export { C as AdapterPopulatedRecordArray, h as IDENTIFIER_ARRAY_TAG, I as IdentifierArray, M as MUTATE, I as RecordArray, R as RecordArrayManager, g as SOURCE, S as Store, _ as _clearCaches, e as coerceId, j as fastPush, i as isStableIdentifier, n as normalizeModelName, f as notifyArray, p as peekCache, r as recordIdentifierFor, k as removeRecordDataFor, c as setIdentifierForgetMethod, a as setIdentifierGenerationMethod, d as setIdentifierResetMethod, b as setIdentifierUpdateMethod, s as storeFor } from "./index-5cfdce8a";
+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-35424a6b";

package/addon/{index-5cfdce8a.js → index-35424a6b.js}

@@ -35,103 +35,6 @@ import ObjectProxy from '@ember/object/proxy';
 function normalizeModelName$1(modelName) {
   return dasherize(modelName);
 }
-function getHydratedContent(store, request, document) {
-  if (Array.isArray(document.data)) {
-    const {
-      lid
-    } = document;
-    const {
-      recordArrayManager
-    } = store;
-    if (!lid) {
-      return recordArrayManager.createArray({
-        identifiers: document.data,
-        doc: document,
-        query: request
-      });
-    }
-    let managed = recordArrayManager._keyedArrays.get(lid);
-    if (!managed) {
-      managed = recordArrayManager.createArray({
-        identifiers: document.data,
-        doc: document
-      });
-      recordArrayManager._keyedArrays.set(lid, managed);
-    } else {
-      recordArrayManager.populateManagedArray(managed, document.data, document);
-    }
-    return managed;
-  } else {
-    return document.data ? store.peekRecord(document.data) : null;
-  }
-}
-function calcShouldFetch(store, request, hasCachedValue, lid) {
-  const {
-    cacheOptions,
-    url,
-    method
-  } = request;
-  return cacheOptions?.reload || !hasCachedValue || store.lifetimes && lid && url && method ? store.lifetimes.isHardExpired(lid, url, method) : false;
-}
-function calcShouldBackgroundFetch(store, request, willFetch, lid) {
-  const {
-    cacheOptions,
-    url,
-    method
-  } = request;
-  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;
-  return next(context.request).then(document => {
-    const response = store.cache.put(document);
-    if (shouldFetch) {
-      return getHydratedContent(store, context.request, response);
-    }
-  }, error => {
-    store.cache.put(error);
-    // TODO @runspired this is probably not the right thing to throw so make sure we add a test
-    if (!shouldBackgroundFetch) {
-      throw error;
-    }
-  });
-}
-const CacheHandler = {
-  request(context, next) {
-    // if we are a legacy request, skip cache handling
-    if (context.request.op && !context.request.url) {
-      return next(context.request);
-    }
-    const {
-      store
-    } = context.request;
-    const {
-      cacheOptions,
-      url,
-      method
-    } = context.request;
-    const lid = cacheOptions?.key || method === 'GET' && url ? url : null;
-    const peeked = lid ? store.cache.peekRequest({
-      lid
-    }) : null;
-
-    // determine if we should skip cache
-    if (calcShouldFetch(store, context.request, !!peeked, lid)) {
-      return fetchContentAndHydrate(next, context, true, false);
-    }
-
-    // if we have not skipped cache, determine if we should update behind the scenes
-    if (calcShouldBackgroundFetch(store, context.request, false, lid)) {
-      void fetchContentAndHydrate(next, context, false, true);
-    }
-    if ('error' in peeked) {
-      throw peeked.error;
-    }
-    return Promise.resolve(getHydratedContent(store, context.request, peeked.content));
-  }
-};
 
 /*
  * Returns the Cache instance associated with a given
@@ -824,9 +727,9 @@ function _applyDecoratedDescriptor(target, property, decorators, descriptor, con
   return desc;
 }
 let tokenId = 0;
-const CacheOperations = new Set(['added', 'removed', 'state', 'updated']);
+const CacheOperations$1 = new Set(['added', 'removed', 'state', 'updated']);
 function isCacheOperationValue(value) {
-  return CacheOperations.has(value);
+  return CacheOperations$1.has(value);
 }
 function runLoopIsFlushing() {
   //@ts-expect-error
@@ -2923,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;
     }
@@ -4391,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') {
@@ -4828,7 +4732,7 @@ class Store {
    * it as a service or by initializing it.
    *
    * ```ts
-   * import Store from '@ember-data/store';
+   * import Store, { CacheHandler } from '@ember-data/store';
    * import RequestManager from '@ember-data/request';
    * import Fetch from '@ember/data/request/fetch';
    *
@@ -4837,6 +4741,7 @@ class Store {
    *     super(...arguments);
    *     this.requestManager = new RequestManager();
    *     this.requestManager.use([Fetch]);
+   *     this.requestManager.useCache(CacheHandler);
    *   }
    * }
    * ```
@@ -4849,13 +4754,22 @@ class Store {
    * A Property which an App may set to provide a Lifetimes Service
    * to control when a cached request becomes stale.
    *
+   * Note, when defined, these methods will only be invoked if `key` `url` and `method`
+   * are all present.
+   *
+   * `isSoftExpired` will only be invoked if `isHardExpired` returns `false`.
+   *
    * ```ts
    * store.lifetimes = {
    *   // make the request and ignore the current cache state
-   *   isHardExpired() {}
+   *   isHardExpired(key: string, url: string, method?: HTTPMethod): boolean {
+   *     return false;
+   *   }
    *
    *   // make the request in the background if true, return cache state
-   *   isSoftExpired() {}
+   *   isSoftExpired(key: string, url: string, method: HTTPMethod): boolean {
+   *     return false;
+   *   }
    * }
    * ```
    *
@@ -4890,13 +4804,6 @@ class Store {
     this._serializerCache = Object.create(null);
     this._modelFactoryCache = Object.create(null);
   }
-  _registerCacheHandler() {
-    if (this._hasRegisteredCacheHandler) {
-      return;
-    }
-    this.requestManager.useCache(CacheHandler);
-    this._hasRegisteredCacheHandler = true;
-  }
   _run(cb) {
     assert(`EmberData should never encounter a nested run`, !this._cbs);
     const _cbs = this._cbs = {};
@@ -4981,7 +4888,6 @@ 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.
-    this._registerCacheHandler();
     let opts = {
       store: this
     };
@@ -6892,6 +6798,127 @@ function secretInit(record, cache, identifier, store) {
   StoreMap.set(record, store);
   setCacheFor(record, cache);
 }
+const CacheOperations = new Set(['findRecord', 'findAll', 'query', 'queryRecord', 'findBelongsTo', 'findHasMany', 'updateRecord', 'createRecord', 'deleteRecord']);
+function getHydratedContent(store, request, document) {
+  if (!request.op || !CacheOperations.has(request.op)) {
+    return document;
+  }
+  if (Array.isArray(document.data)) {
+    const {
+      lid
+    } = document;
+    const {
+      recordArrayManager
+    } = store;
+    if (!lid) {
+      return recordArrayManager.createArray({
+        identifiers: document.data,
+        doc: document,
+        query: request
+      });
+    }
+    let managed = recordArrayManager._keyedArrays.get(lid);
+    if (!managed) {
+      managed = recordArrayManager.createArray({
+        identifiers: document.data,
+        doc: document
+      });
+      recordArrayManager._keyedArrays.set(lid, managed);
+    } else {
+      recordArrayManager.populateManagedArray(managed, document.data, document);
+    }
+    return managed;
+  } else {
+    switch (request.op) {
+      case 'findBelongsTo':
+      case 'queryRecord':
+      case 'findRecord':
+        return document.data ? store.peekRecord(document.data) : null;
+      default:
+        return document.data;
+    }
+  }
+}
+function calcShouldFetch(store, request, hasCachedValue, lid) {
+  const {
+    cacheOptions,
+    url,
+    method
+  } = request;
+  return cacheOptions?.reload || !hasCachedValue || (store.lifetimes && lid && url && method ? store.lifetimes.isHardExpired(lid, url, method) : false);
+}
+function calcShouldBackgroundFetch(store, request, willFetch, lid) {
+  const {
+    cacheOptions,
+    url,
+    method
+  } = request;
+  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;
+  return next(context.request).then(document => {
+    store._enableAsyncFlush = true;
+    let response;
+    store._join(() => {
+      response = store.cache.put(document);
+      if (shouldFetch) {
+        response = getHydratedContent(store, context.request, response);
+      }
+    });
+    store._enableAsyncFlush = null;
+    if (shouldFetch) {
+      return response;
+    }
+  }, 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;
+    }
+  });
+}
+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 && CacheOperations.has(context.request.op) && !context.request.url) {
+      return next(context.request);
+    }
+    const {
+      store
+    } = context.request;
+    const {
+      cacheOptions,
+      url,
+      method
+    } = context.request;
+    const lid = cacheOptions?.key || method === 'GET' && url ? url : null;
+    const peeked = lid ? store.cache.peekRequest({
+      lid
+    }) : null;
+
+    // determine if we should skip cache
+    if (calcShouldFetch(store, context.request, !!peeked, lid)) {
+      return fetchContentAndHydrate(next, context, true, false);
+    }
+
+    // if we have not skipped cache, determine if we should update behind the scenes
+    if (calcShouldBackgroundFetch(store, context.request, false, lid)) {
+      void fetchContentAndHydrate(next, context, false, true);
+    }
+    if ('error' in peeked) {
+      throw peeked.error;
+    }
+    return Promise.resolve(getHydratedContent(store, context.request, peeked.content));
+  }
+};
 function normalizeModelName(modelName) {
   if (macroCondition(getOwnConfig().deprecations.DEPRECATE_HELPERS)) {
     deprecate(`the helper function normalizeModelName is deprecated. You should use model names that are already normalized, or use string helpers of your own. This function is primarily an alias for dasherize from @ember/string.`, false, {
@@ -6907,4 +6934,4 @@ function normalizeModelName(modelName) {
   }
   assert(`normalizeModelName support has been removed`);
 }
-export { Collection as C, IdentifierArray as I, MUTATE as M, RecordArrayManager as R, Store as S, _clearCaches as _, setIdentifierGenerationMethod as a, setIdentifierUpdateMethod as b, setIdentifierForgetMethod as c, setIdentifierResetMethod as d, coerceId as e, notifyArray as f, SOURCE as g, IDENTIFIER_ARRAY_TAG as h, isStableIdentifier as i, fastPush as j, removeRecordDataFor as k, normalizeModelName as n, peekCache as p, recordIdentifierFor as r, storeFor as s };
+export { CacheHandler as C, IdentifierArray as I, MUTATE as M, RecordArrayManager as R, Store as S, _clearCaches as _, setIdentifierGenerationMethod as a, setIdentifierUpdateMethod as b, setIdentifierForgetMethod as c, setIdentifierResetMethod as d, coerceId as e, Collection as f, notifyArray as g, SOURCE as h, isStableIdentifier as i, IDENTIFIER_ARRAY_TAG as j, fastPush as k, removeRecordDataFor as l, normalizeModelName as n, peekCache as p, recordIdentifierFor as r, storeFor as s };