@ember-data/store 4.12.6 → 4.12.8

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

package/addon/{index-ecc2c2e5.js → index-cc461d33.js}

@@ -164,6 +164,23 @@ async function _request2(link, options = {}) {
   }));
   return response.content;
 }
+
+/**
+ * A service which an application may provide to the store via
+ * the store's `lifetimes` property to configure the behavior
+ * of the CacheHandler.
+ *
+ * The default behavior for request lifetimes is to never expire
+ * unless manually refreshed via `cacheOptions.reload` or `cacheOptions.backgroundReload`.
+ *
+ * Implementing this service allows you to programatically define
+ * when a request should be considered expired.
+ *
+ * @class <Interface> LifetimesService
+ * @public
+ */
+
+const MUTATION_OPS = new Set(['createRecord', 'updateRecord', 'deleteRecord']);
 function isErrorDocument(document) {
   return 'errors' in document;
 }
@@ -171,6 +188,10 @@ function maybeUpdateUiObjects(store, request, options, document, isFromCache) {
   const {
     identifier
   } = options;
+  if (!document) {
+    assert(`The CacheHandler expected response content but none was found`, !options.shouldHydrate);
+    return document;
+  }
   if (isErrorDocument(document)) {
     if (!identifier && !options.shouldHydrate) {
       return document;
@@ -262,25 +283,54 @@ function calcShouldFetch(store, request, hasCachedValue, identifier) {
   const {
     cacheOptions
   } = request;
-  return cacheOptions?.reload || !hasCachedValue || (store.lifetimes && identifier ? store.lifetimes.isHardExpired(identifier) : false);
+  return request.op && MUTATION_OPS.has(request.op) || cacheOptions?.reload || !hasCachedValue || (store.lifetimes && identifier ? store.lifetimes.isHardExpired(identifier, store) : false);
 }
 function calcShouldBackgroundFetch(store, request, willFetch, identifier) {
   const {
     cacheOptions
   } = request;
-  return !willFetch && (cacheOptions?.backgroundReload || (store.lifetimes && identifier ? store.lifetimes.isSoftExpired(identifier) : false));
+  return !willFetch && (cacheOptions?.backgroundReload || (store.lifetimes && identifier ? store.lifetimes.isSoftExpired(identifier, store) : false));
+}
+function isMutation(request) {
+  return Boolean(request.op && MUTATION_OPS.has(request.op));
 }
 function fetchContentAndHydrate(next, context, identifier, shouldFetch, shouldBackgroundFetch) {
   const {
     store
   } = context.request;
-  const shouldHydrate = context.request[Symbol.for('ember-data:enable-hydration')] || false;
-  return next(context.request).then(document => {
+  const shouldHydrate = context.request[EnableHydration] || false;
+  let isMut = false;
+  if (isMutation(context.request)) {
+    isMut = true;
+    // TODO should we handle multiple records in request.records by iteratively calling willCommit for each
+    const record = context.request.data?.record || context.request.records?.[0];
+    assert(`Expected to receive a list of records included in the ${context.request.op} request`, record || !shouldHydrate);
+    if (record) {
+      store.cache.willCommit(record, context);
+    }
+  }
+  if (store.lifetimes?.willRequest) {
+    store.lifetimes.willRequest(context.request, identifier, store);
+  }
+  const promise = next(context.request).then(document => {
     store.requestManager._pending.delete(context.id);
     store._enableAsyncFlush = true;
     let response;
     store._join(() => {
-      response = store.cache.put(document);
+      if (isMutation(context.request)) {
+        const record = context.request.data?.record || context.request.records?.[0];
+        if (record) {
+          response = store.cache.didCommit(record, document);
+
+          // a mutation combined with a 204 has no cache impact when no known records were involved
+          // a createRecord with a 201 with an empty response and no known records should similarly
+          // have no cache impact
+        } else if (isCacheAffecting(document)) {
+          response = store.cache.put(document);
+        }
+      } else {
+        response = store.cache.put(document);
+      }
       response = maybeUpdateUiObjects(store, context.request, {
         shouldHydrate,
         shouldFetch,
@@ -289,6 +339,9 @@ function fetchContentAndHydrate(next, context, identifier, shouldFetch, shouldBa
       }, response, false);
     });
     store._enableAsyncFlush = null;
+    if (store.lifetimes?.didRequest) {
+      store.lifetimes.didRequest(context.request, document.response, identifier, store);
+    }
     if (shouldFetch) {
       return response;
     } else if (shouldBackgroundFetch) {
@@ -303,15 +356,28 @@ function fetchContentAndHydrate(next, context, identifier, shouldFetch, shouldBa
     store._enableAsyncFlush = true;
     let response;
     store._join(() => {
-      response = store.cache.put(error);
-      response = maybeUpdateUiObjects(store, context.request, {
-        shouldHydrate,
-        shouldFetch,
-        shouldBackgroundFetch,
-        identifier
-      }, response, false);
+      if (isMutation(context.request)) {
+        // TODO similar to didCommit we should spec this to be similar to cache.put for handling full response
+        // currently we let the response remain undefiend.
+        const errors = error && error.content && typeof error.content === 'object' && 'errors' in error.content && Array.isArray(error.content.errors) ? error.content.errors : undefined;
+        const record = context.request.data?.record || context.request.records?.[0];
+        store.cache.commitWasRejected(record, errors);
+        // re-throw the original error to preserve `errors` property.
+        throw error;
+      } else {
+        response = store.cache.put(error);
+        response = maybeUpdateUiObjects(store, context.request, {
+          shouldHydrate,
+          shouldFetch,
+          shouldBackgroundFetch,
+          identifier
+        }, response, false);
+      }
     });
     store._enableAsyncFlush = null;
+    if (identifier && store.lifetimes?.didRequest) {
+      store.lifetimes.didRequest(context.request, error.response, identifier, store);
+    }
     if (!shouldBackgroundFetch) {
       const newError = cloneError(error);
       newError.content = response;
@@ -320,15 +386,82 @@ function fetchContentAndHydrate(next, context, identifier, shouldFetch, shouldBa
       store.notifications._flush();
     }
   });
+  if (!isMut) {
+    return promise;
+  }
+  assert(`Expected a mutation`, isMutation(context.request));
+
+  // for mutations we need to enqueue the promise with the requestStateService
+  // TODO should we enque a request per record in records?
+  const record = context.request.data?.record || context.request.records?.[0];
+  return store._requestCache._enqueue(promise, {
+    data: [{
+      op: 'saveRecord',
+      recordIdentifier: record,
+      options: undefined
+    }]
+  });
+}
+function isAggregateError(error) {
+  return error instanceof AggregateError || error.name === 'AggregateError' && Array.isArray(error.errors);
 }
+// TODO @runspired, consider if we should deep freeze errors (potentially only in debug) vs cloning them
 function cloneError(error) {
-  const cloned = new Error(error.message);
+  const isAggregate = isAggregateError(error);
+  const cloned = isAggregate ?
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+  new AggregateError(structuredClone(error.errors), error.message) : new Error(error.message);
   cloned.stack = error.stack;
   cloned.error = error.error;
+
+  // copy over enumerable properties
+  Object.assign(cloned, error);
   return cloned;
 }
 const SkipCache = Symbol.for('ember-data:skip-cache');
 const EnableHydration = Symbol.for('ember-data:enable-hydration');
+
+/**
+ * A CacheHandler that adds support for using an EmberData Cache with a RequestManager.
+ *
+ * This handler will only run when a request has supplied a `store` instance. Requests
+ * issued by the store via `store.request()` will automatically have the `store` instance
+ * attached to the request.
+ *
+ * ```ts
+ * requestManager.request({
+ *   store: store,
+ *   url: '/api/posts',
+ *   method: 'GET'
+ * });
+ * ```
+ *
+ * When this handler elects to handle a request, it will return the raw `StructuredDocument`
+ * unless the request has `[EnableHydration]` set to `true`. In this case, the handler will
+ * return a `Document` instance that will automatically update the UI when the cache is updated
+ * in the future and will hydrate any identifiers in the StructuredDocument into Record instances.
+ *
+ * When issuing a request via the store, [EnableHydration] is automatically set to `true`. This
+ * means that if desired you can issue requests that utilize the cache without needing to also
+ * utilize Record instances if desired.
+ *
+ * Said differently, you could elect to issue all requests via a RequestManager, without ever using
+ * the store directly, by setting [EnableHydration] to `true` and providing a store instance. Not
+ * necessarily the most useful thing, but the decoupled nature of the RequestManager and incremental-feature
+ * approach of EmberData allows for this flexibility.
+ *
+ * ```ts
+ * import { EnableHydration } from '@warp-drive/core-types/request';
+ *
+ * requestManager.request({
+ *   store: store,
+ *   url: '/api/posts',
+ *   method: 'GET',
+ *   [EnableHydration]: true
+ * });
+ *
+ * @typedoc
+ */
 const CacheHandler = {
   request(context, next) {
     // if we have no cache or no cache-key skip cache handling
@@ -348,7 +481,7 @@ const CacheHandler = {
 
     // if we have not skipped cache, determine if we should update behind the scenes
     if (calcShouldBackgroundFetch(store, context.request, false, identifier)) {
-      let promise = fetchContentAndHydrate(next, context, identifier, false, true);
+      const promise = fetchContentAndHydrate(next, context, identifier, false, true);
       store.requestManager._pending.set(context.id, promise);
     }
     const shouldHydrate = context.request[EnableHydration] || false;
@@ -361,10 +494,11 @@ const CacheHandler = {
       newError.content = content;
       throw newError;
     }
-    return Promise.resolve(shouldHydrate ? maybeUpdateUiObjects(store, context.request, {
+    const result = shouldHydrate ? maybeUpdateUiObjects(store, context.request, {
       shouldHydrate,
       identifier
-    }, peeked.content, true) : peeked.content);
+    }, peeked.content, true) : peeked.content;
+    return result;
   }
 };
 function copyDocumentProperties(target, source) {
@@ -378,6 +512,19 @@ function copyDocumentProperties(target, source) {
     target.errors = source.errors;
   }
 }
+function isCacheAffecting(document) {
+  if (!isMutation(document.request)) {
+    return true;
+  }
+  // a mutation combined with a 204 has no cache impact when no known records were involved
+  // a createRecord with a 201 with an empty response and no known records should similarly
+  // have no cache impact
+
+  if (document.request.op === 'createRecord' && document.response?.status === 201) {
+    return document.content ? Object.keys(document.content).length > 0 : false;
+  }
+  return document.response?.status !== 204;
+}
 
 /*
  * Returns the Cache instance associated with a given
@@ -7132,11 +7279,6 @@ class Store extends EmberObject {
         [SkipCache]: true
       }
     };
-
-    // we lie here on the type because legacy doesn't have enough context
-    cache.willCommit(identifier, {
-      request
-    });
     return this.request(request).then(document => document.content);
   }
 
@@ -7493,4 +7635,4 @@ function normalizeModelName(modelName) {
   }
   assert(`normalizeModelName support has been removed`);
 }
-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 };
+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, constructResource as e, coerceId as f, ensureStringId as g, Collection as h, isStableIdentifier as i, notifyArray as j, SOURCE as k, IDENTIFIER_ARRAY_TAG as l, fastPush as m, normalizeModelName as n, removeRecordDataFor as o, peekCache as p, recordIdentifierFor as r, storeFor as s };