@ember-data/legacy-compat 4.12.0-alpha.10

package/addon/fetch-manager-2716abb1.js

@@ -0,0 +1,703 @@
+import { macroCondition, getOwnConfig, isDevelopingApp, importSync } from '@embroider/macros';
+import { deprecate, assert, warn } from '@ember/debug';
+import { SOURCE, coerceId } from '@ember-data/store/-private';
+import { _backburner } from '@ember/runloop';
+import RSVP, { resolve } from 'rsvp';
+/**
+  SnapshotRecordArray is not directly instantiable.
+  Instances are provided to consuming application's
+  adapters for certain requests.
+
+  @class SnapshotRecordArray
+  @public
+*/
+class SnapshotRecordArray {
+  /**
+    SnapshotRecordArray is not directly instantiable.
+    Instances are provided to consuming application's
+    adapters and serializers for certain requests.
+     @method constructor
+    @private
+    @constructor
+    @param {Store} store
+    @param {string} type
+    @param options
+   */
+  constructor(store, type, options = {}) {
+    this.__store = store;
+    /**
+      An array of snapshots
+      @private
+      @property _snapshots
+      @type {Array}
+    */
+    this._snapshots = null;
+
+    /**
+    The modelName of the underlying records for the snapshots in the array, as a Model
+    @property modelName
+    @public
+    @type {Model}
+    */
+    this.modelName = type;
+
+    /**
+      A hash of adapter options passed into the store method for this request.
+       Example
+       ```app/adapters/post.js
+      import MyCustomAdapter from './custom-adapter';
+       export default class PostAdapter extends MyCustomAdapter {
+        findAll(store, type, sinceToken, snapshotRecordArray) {
+          if (snapshotRecordArray.adapterOptions.subscribe) {
+            // ...
+          }
+          // ...
+        }
+      }
+      ```
+       @property adapterOptions
+      @public
+      @type {Object}
+    */
+    this.adapterOptions = options.adapterOptions;
+
+    /**
+      The relationships to include for this request.
+       Example
+       ```app/adapters/application.js
+      import Adapter from '@ember-data/adapter';
+       export default class ApplicationAdapter extends Adapter {
+        findAll(store, type, snapshotRecordArray) {
+          let url = `/${type.modelName}?include=${encodeURIComponent(snapshotRecordArray.include)}`;
+           return fetch(url).then((response) => response.json())
+        }
+      }
+      ```
+       @property include
+      @public
+      @type {String|Array}
+    */
+    this.include = options.include;
+  }
+
+  /**
+    An array of records
+     @property _recordArray
+    @private
+    @type {Array}
+  */
+  get _recordArray() {
+    return this.__store.peekAll(this.modelName);
+  }
+
+  /**
+      Number of records in the array
+       Example
+       ```app/adapters/post.js
+      import JSONAPIAdapter from '@ember-data/adapter/json-api';
+       export default class PostAdapter extends JSONAPIAdapter {
+        shouldReloadAll(store, snapshotRecordArray) {
+          return !snapshotRecordArray.length;
+        }
+      });
+      ```
+       @property length
+      @public
+      @type {Number}
+    */
+  get length() {
+    return this._recordArray.length;
+  }
+
+  /**
+    Get snapshots of the underlying record array
+     Example
+     ```app/adapters/post.js
+    import JSONAPIAdapter from '@ember-data/adapter/json-api';
+     export default class PostAdapter extends JSONAPIAdapter {
+      shouldReloadAll(store, snapshotArray) {
+        let snapshots = snapshotArray.snapshots();
+         return snapshots.any(function(ticketSnapshot) {
+          let timeDiff = moment().diff(ticketSnapshot.attr('lastAccessedAt'), 'minutes');
+          if (timeDiff > 20) {
+            return true;
+          } else {
+            return false;
+          }
+        });
+      }
+    }
+    ```
+     @method snapshots
+    @public
+    @return {Array} Array of snapshots
+  */
+  snapshots() {
+    if (this._snapshots !== null) {
+      return this._snapshots;
+    }
+    const {
+      _instanceCache
+    } = this.__store;
+    this._snapshots = this._recordArray[SOURCE].map(identifier => _instanceCache.createSnapshot(identifier));
+    return this._snapshots;
+  }
+}
+if (macroCondition(getOwnConfig().deprecations.DEPRECATE_SNAPSHOT_MODEL_CLASS_ACCESS)) {
+  /**
+    The type of the underlying records for the snapshots in the array, as a Model
+     @deprecated
+    @property type
+    @public
+    @type {Model}
+  */
+  Object.defineProperty(SnapshotRecordArray.prototype, 'type', {
+    get() {
+      deprecate(`Using SnapshotRecordArray.type to access the ModelClass for a record is deprecated. Use store.modelFor(<modelName>) instead.`, false, {
+        id: 'ember-data:deprecate-snapshot-model-class-access',
+        until: '5.0',
+        for: 'ember-data',
+        since: {
+          available: '4.5.0',
+          enabled: '4.5.0'
+        }
+      });
+      // @ts-expect-error
+      return this._recordArray.type;
+    }
+  });
+}
+function _bind(fn, ...args) {
+  return function () {
+    return fn.apply(undefined, args);
+  };
+}
+function _guard(promise, test) {
+  let guarded = promise.finally(() => {
+    if (!test()) {
+      guarded._subscribers.length = 0;
+    }
+  });
+  return guarded;
+}
+function _objectIsAlive(object) {
+  return !(object.isDestroyed || object.isDestroying);
+}
+function guardDestroyedStore(promise, store, label) {
+  let token;
+  if (isDevelopingApp()) {
+    token = store._trackAsyncRequestStart(label);
+  }
+  let wrapperPromise = resolve(promise, label).then(_v => {
+    if (!_objectIsAlive(store)) {
+      if (macroCondition(getOwnConfig().deprecations.DEPRECATE_RSVP_PROMISE)) {
+        deprecate(`A Promise did not resolve by the time the store was destroyed. This will error in a future release.`, false, {
+          id: 'ember-data:rsvp-unresolved-async',
+          until: '5.0',
+          for: '@ember-data/store',
+          since: {
+            available: '4.5',
+            enabled: '4.5'
+          }
+        });
+      }
+    }
+    return promise;
+  });
+  return _guard(wrapperPromise, () => {
+    if (isDevelopingApp()) {
+      store._trackAsyncRequestEnd(token);
+    }
+    return _objectIsAlive(store);
+  });
+}
+function assertIdentifierHasId(identifier) {
+  assert(`Attempted to schedule a fetch for a record without an id.`, identifier.id !== null);
+}
+
+/**
+  This is a helper method that validates a JSON API top-level document
+
+  The format of a document is described here:
+  http://jsonapi.org/format/#document-top-level
+
+  @internal
+*/
+function validateDocumentStructure(doc) {
+  if (isDevelopingApp()) {
+    let errors = [];
+    if (!doc || typeof doc !== 'object') {
+      errors.push('Top level of a JSON API document must be an object');
+    } else {
+      if (!('data' in doc) && !('errors' in doc) && !('meta' in doc)) {
+        errors.push('One or more of the following keys must be present: "data", "errors", "meta".');
+      } else {
+        if ('data' in doc && 'errors' in doc) {
+          errors.push('Top level keys "errors" and "data" cannot both be present in a JSON API document');
+        }
+      }
+      if ('data' in doc) {
+        if (!(doc.data === null || Array.isArray(doc.data) || typeof doc.data === 'object')) {
+          errors.push('data must be null, an object, or an array');
+        }
+      }
+      if ('meta' in doc) {
+        if (typeof doc.meta !== 'object') {
+          errors.push('meta must be an object');
+        }
+      }
+      if ('errors' in doc) {
+        if (!Array.isArray(doc.errors)) {
+          errors.push('errors must be an array');
+        }
+      }
+      if ('links' in doc) {
+        if (typeof doc.links !== 'object') {
+          errors.push('links must be an object');
+        }
+      }
+      if ('jsonapi' in doc) {
+        if (typeof doc.jsonapi !== 'object') {
+          errors.push('jsonapi must be an object');
+        }
+      }
+      if ('included' in doc) {
+        if (typeof doc.included !== 'object') {
+          errors.push('included must be an array');
+        }
+      }
+    }
+    assert(`Response must be normalized to a valid JSON API document:\n\t* ${errors.join('\n\t* ')}`, errors.length === 0);
+  }
+}
+function normalizeResponseHelper(serializer, store, modelClass, payload, id, requestType) {
+  let normalizedResponse = serializer ? serializer.normalizeResponse(store, modelClass, payload, id, requestType) : payload;
+  validateDocumentStructure(normalizedResponse);
+  return normalizedResponse;
+}
+function payloadIsNotBlank(adapterPayload) {
+  if (Array.isArray(adapterPayload)) {
+    return true;
+  } else {
+    return Object.keys(adapterPayload || {}).length !== 0;
+  }
+}
+const SaveOp = Symbol('SaveOp');
+class FetchManager {
+  // saves which are pending in the runloop
+
+  // fetches pending in the runloop, waiting to be coalesced
+
+  constructor(store) {
+    this._store = store;
+    // used to keep track of all the find requests that need to be coalesced
+    this._pendingFetch = new Map();
+    this._pendingSave = [];
+    this.requestCache = store.getRequestStateService();
+    this.isDestroyed = false;
+  }
+  _createSnapshot(identifier, options) {
+    return this._store._instanceCache.createSnapshot(identifier, options);
+  }
+
+  /**
+    This method is called by `record.save`, and gets passed a
+    resolver for the promise that `record.save` returns.
+     It schedules saving to happen at the end of the run loop.
+     @internal
+  */
+  scheduleSave(identifier, options) {
+    let resolver = RSVP.defer(isDevelopingApp() ? `DS: Model#save ${identifier.lid}` : '');
+    let query = {
+      op: 'saveRecord',
+      recordIdentifier: identifier,
+      options
+    };
+    let queryRequest = {
+      data: [query]
+    };
+    const snapshot = this._createSnapshot(identifier, options);
+    const pendingSaveItem = {
+      snapshot: snapshot,
+      resolver: resolver,
+      identifier,
+      options,
+      queryRequest
+    };
+    this._pendingSave.push(pendingSaveItem);
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    _backburner.scheduleOnce('actions', this, this._flushPendingSaves);
+    this.requestCache.enqueue(resolver.promise, pendingSaveItem.queryRequest);
+    return resolver.promise;
+  }
+
+  /**
+    This method is called at the end of the run loop, and
+    flushes any records passed into `scheduleSave`
+     @internal
+  */
+  _flushPendingSaves() {
+    const store = this._store;
+    let pending = this._pendingSave.slice();
+    this._pendingSave = [];
+    for (let i = 0, j = pending.length; i < j; i++) {
+      let pendingItem = pending[i];
+      _flushPendingSave(store, pendingItem);
+    }
+  }
+  scheduleFetch(identifier, options) {
+    // TODO Probably the store should pass in the query object
+    let shouldTrace = isDevelopingApp() && this._store.generateStackTracesForTrackedRequests;
+    let query = {
+      op: 'findRecord',
+      recordIdentifier: identifier,
+      options
+    };
+    let queryRequest = {
+      data: [query]
+    };
+    let pendingFetch = this.getPendingFetch(identifier, options);
+    if (pendingFetch) {
+      return pendingFetch;
+    }
+    let id = identifier.id;
+    let modelName = identifier.type;
+    let resolver = RSVP.defer(`Fetching ${modelName}' with id: ${id}`);
+    let pendingFetchItem = {
+      identifier,
+      resolver,
+      options,
+      queryRequest
+    };
+    if (isDevelopingApp()) {
+      if (shouldTrace) {
+        let trace;
+        try {
+          throw new Error(`Trace Origin for scheduled fetch for ${modelName}:${id}.`);
+        } catch (e) {
+          trace = e;
+        }
+
+        // enable folks to discover the origin of this findRecord call when
+        // debugging. Ideally we would have a tracked queue for requests with
+        // labels or local IDs that could be used to merge this trace with
+        // the trace made available when we detect an async leak
+        pendingFetchItem.trace = trace;
+      }
+    }
+    let resolverPromise = resolver.promise;
+    const store = this._store;
+    const isLoading = !store._instanceCache.recordIsLoaded(identifier); // we don't use isLoading directly because we are the request
+
+    const promise = resolverPromise.then(payload => {
+      // ensure that regardless of id returned we assign to the correct record
+      if (payload.data && !Array.isArray(payload.data)) {
+        payload.data.lid = identifier.lid;
+      }
+
+      // additional data received in the payload
+      // may result in the merging of identifiers (and thus records)
+      let potentiallyNewIm = store._push(payload);
+      if (potentiallyNewIm && !Array.isArray(potentiallyNewIm)) {
+        return potentiallyNewIm;
+      }
+      return identifier;
+    }, error => {
+      const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? store._instanceCache.peek({
+        identifier,
+        bucket: 'resourceCache'
+      }) : store.cache;
+      if (!cache || cache.isEmpty(identifier) || isLoading) {
+        let isReleasable = true;
+        if (macroCondition(getOwnConfig().packages.HAS_GRAPH_PACKAGE)) {
+          if (!cache) {
+            const graphFor = importSync('@ember-data/graph/-private').graphFor;
+            const graph = graphFor(store);
+            isReleasable = graph.isReleasable(identifier);
+            if (!isReleasable) {
+              graph.unload(identifier, true);
+            }
+          }
+        }
+        if (cache || isReleasable) {
+          store._instanceCache.unloadRecord(identifier);
+        }
+      }
+      throw error;
+    });
+    if (this._pendingFetch.size === 0) {
+      // eslint-disable-next-line @typescript-eslint/unbound-method
+      _backburner.schedule('actions', this, this.flushAllPendingFetches);
+    }
+    let fetches = this._pendingFetch;
+    if (!fetches.has(modelName)) {
+      fetches.set(modelName, []);
+    }
+    fetches.get(modelName).push(pendingFetchItem);
+    pendingFetchItem.promise = promise;
+    this.requestCache.enqueue(resolverPromise, pendingFetchItem.queryRequest);
+    return promise;
+  }
+  getPendingFetch(identifier, options) {
+    let pendingFetches = this._pendingFetch.get(identifier.type);
+
+    // We already have a pending fetch for this
+    if (pendingFetches) {
+      let matchingPendingFetch = pendingFetches.find(fetch => fetch.identifier === identifier && isSameRequest(options, fetch.options));
+      if (matchingPendingFetch) {
+        return matchingPendingFetch.promise;
+      }
+    }
+  }
+  flushAllPendingFetches() {
+    if (this.isDestroyed) {
+      return;
+    }
+    const store = this._store;
+    this._pendingFetch.forEach((fetchItem, type) => _flushPendingFetchForType(store, fetchItem, type));
+    this._pendingFetch.clear();
+  }
+  fetchDataIfNeededForIdentifier(identifier, options = {}) {
+    // pre-loading will change the isEmpty value
+    const isEmpty = _isEmpty(this._store._instanceCache, identifier);
+    const isLoading = _isLoading(this._store._instanceCache, identifier);
+    let promise;
+    if (isEmpty) {
+      assertIdentifierHasId(identifier);
+      promise = this.scheduleFetch(identifier, options);
+    } else if (isLoading) {
+      promise = this.getPendingFetch(identifier, options);
+      assert(`Expected to find a pending request for a record in the loading state, but found none`, promise);
+    } else {
+      promise = resolve(identifier);
+    }
+    return promise;
+  }
+  destroy() {
+    this.isDestroyed = true;
+  }
+}
+function _isEmpty(instanceCache, identifier) {
+  const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? instanceCache.__instances.resourceCache.get(identifier) : instanceCache.cache;
+  if (!cache) {
+    return true;
+  }
+  const isNew = cache.isNew(identifier);
+  const isDeleted = cache.isDeleted(identifier);
+  const isEmpty = cache.isEmpty(identifier);
+  return (!isNew || isDeleted) && isEmpty;
+}
+function _isLoading(cache, identifier) {
+  const req = cache.store.getRequestStateService();
+  // const fulfilled = req.getLastRequestForRecord(identifier);
+  const isLoaded = cache.recordIsLoaded(identifier);
+  return !isLoaded &&
+  // fulfilled === null &&
+  req.getPendingRequestsForRecord(identifier).some(req => req.type === 'query');
+}
+
+// this function helps resolve whether we have a pending request that we should use instead
+function isSameRequest(options = {}, existingOptions = {}) {
+  let includedMatches = !options.include || options.include === existingOptions.include;
+  let adapterOptionsMatches = options.adapterOptions === existingOptions.adapterOptions;
+  return includedMatches && adapterOptionsMatches;
+}
+function _findMany(store, adapter, modelName, snapshots) {
+  let modelClass = store.modelFor(modelName); // `adapter.findMany` gets the modelClass still
+  const ids = snapshots.map(s => s.id);
+  assert(`Cannot fetch a record without an id`, ids.every(v => v !== null));
+  // eslint-disable-next-line @typescript-eslint/unbound-method
+  assert(`Expected this adapter to implement findMany for coalescing`, adapter.findMany);
+  let promise = adapter.findMany(store, modelClass, ids, snapshots);
+  let label = `DS: Handle Adapter#findMany of '${modelName}'`;
+  if (promise === undefined) {
+    throw new Error('adapter.findMany returned undefined, this was very likely a mistake');
+  }
+  promise = guardDestroyedStore(promise, store, label);
+  return promise.then(adapterPayload => {
+    assert(`You made a 'findMany' request for '${modelName}' records with ids '[${ids.join(',')}]', but the adapter's response did not have any data`, !!payloadIsNotBlank(adapterPayload));
+    let serializer = store.serializerFor(modelName);
+    let payload = normalizeResponseHelper(serializer, store, modelClass, adapterPayload, null, 'findMany');
+    return payload;
+  });
+}
+function rejectFetchedItems(fetchMap, snapshots, error) {
+  for (let i = 0, l = snapshots.length; i < l; i++) {
+    let snapshot = snapshots[i];
+    let pair = fetchMap.get(snapshot);
+    if (pair) {
+      pair.resolver.reject(error || new Error(`Expected: '<${snapshot.modelName}:${snapshot.id}>' to be present in the adapter provided payload, but it was not found.`));
+    }
+  }
+}
+function handleFoundRecords(store, fetchMap, snapshots, coalescedPayload) {
+  /*
+    It is possible that the same ID is included multiple times
+    via multiple snapshots. This happens when more than one
+    options hash was supplied, each of which must be uniquely
+    accounted for.
+     However, since we can't map from response to a specific
+    options object, we resolve all snapshots by id with
+    the first response we see.
+  */
+  let snapshotsById = new Map();
+  for (let i = 0; i < snapshots.length; i++) {
+    let id = snapshots[i].id;
+    let snapshotGroup = snapshotsById.get(id);
+    if (!snapshotGroup) {
+      snapshotGroup = [];
+      snapshotsById.set(id, snapshotGroup);
+    }
+    snapshotGroup.push(snapshots[i]);
+  }
+  const included = Array.isArray(coalescedPayload.included) ? coalescedPayload.included : [];
+
+  // resolve found records
+  let resources = coalescedPayload.data;
+  for (let i = 0, l = resources.length; i < l; i++) {
+    let resource = resources[i];
+    let snapshotGroup = snapshotsById.get(resource.id);
+    snapshotsById.delete(resource.id);
+    if (!snapshotGroup) {
+      // TODO consider whether this should be a deprecation/assertion
+      included.push(resource);
+    } else {
+      snapshotGroup.forEach(snapshot => {
+        let pair = fetchMap.get(snapshot);
+        let resolver = pair.resolver;
+        resolver.resolve({
+          data: resource
+        });
+      });
+    }
+  }
+  if (included.length > 0) {
+    store._push({
+      data: null,
+      included
+    });
+  }
+  if (snapshotsById.size === 0) {
+    return;
+  }
+
+  // reject missing records
+  let rejected = [];
+  snapshotsById.forEach(snapshots => {
+    rejected.push(...snapshots);
+  });
+  warn('Ember Data expected to find records with the following ids in the adapter response from findMany but they were missing: [ "' + [...snapshotsById.values()].map(r => r[0].id).join('", "') + '" ]', {
+    id: 'ds.store.missing-records-from-adapter'
+  });
+  rejectFetchedItems(fetchMap, rejected);
+}
+function _fetchRecord(store, fetchItem) {
+  let identifier = fetchItem.identifier;
+  let modelName = identifier.type;
+  let adapter = store.adapterFor(modelName);
+  assert(`You tried to find a record but you have no adapter (for ${modelName})`, adapter);
+  assert(`You tried to find a record but your adapter (for ${modelName}) does not implement 'findRecord'`, typeof adapter.findRecord === 'function');
+  let snapshot = store._instanceCache.createSnapshot(identifier, fetchItem.options);
+  let klass = store.modelFor(identifier.type);
+  let id = identifier.id;
+  let label = `DS: Handle Adapter#findRecord of '${modelName}' with id: '${id}'`;
+  let promise = guardDestroyedStore(resolve().then(() => {
+    return adapter.findRecord(store, klass, identifier.id, snapshot);
+  }), store, label);
+  promise = promise.then(adapterPayload => {
+    assert(`You made a 'findRecord' request for a '${modelName}' with id '${id}', but the adapter's response did not have any data`, !!payloadIsNotBlank(adapterPayload));
+    let serializer = store.serializerFor(modelName);
+    let payload = normalizeResponseHelper(serializer, store, klass, adapterPayload, id, 'findRecord');
+    assert(`Ember Data expected the primary data returned from a 'findRecord' response to be an object but instead it found an array.`, !Array.isArray(payload.data));
+    assert(`The 'findRecord' request for ${modelName}:${id} resolved indicating success but contained no primary data. To indicate a 404 not found you should either reject the promise returned by the adapter's findRecord method or throw a NotFoundError.`, 'data' in payload && payload.data !== null && typeof payload.data === 'object');
+    warn(`You requested a record of type '${modelName}' with id '${id}' but the adapter returned a payload with primary data having an id of '${payload.data.id}'. Use 'store.findRecord()' when the requested id is the same as the one returned by the adapter. In other cases use 'store.queryRecord()' instead.`, coerceId(payload.data.id) === coerceId(id), {
+      id: 'ds.store.findRecord.id-mismatch'
+    });
+    return payload;
+  });
+  fetchItem.resolver.resolve(promise);
+}
+function _processCoalescedGroup(store, fetchMap, group, adapter, modelName) {
+  if (group.length > 1) {
+    _findMany(store, adapter, modelName, group).then(payloads => {
+      handleFoundRecords(store, fetchMap, group, payloads);
+    }).catch(error => {
+      rejectFetchedItems(fetchMap, group, error);
+    });
+  } else if (group.length === 1) {
+    _fetchRecord(store, fetchMap.get(group[0]));
+  } else {
+    assert("You cannot return an empty array from adapter's method groupRecordsForFindMany", false);
+  }
+}
+function _flushPendingFetchForType(store, pendingFetchItems, modelName) {
+  let adapter = store.adapterFor(modelName);
+  let shouldCoalesce = !!adapter.findMany && adapter.coalesceFindRequests;
+  let totalItems = pendingFetchItems.length;
+  if (shouldCoalesce) {
+    let snapshots = new Array(totalItems);
+    let fetchMap = new Map();
+    for (let i = 0; i < totalItems; i++) {
+      let fetchItem = pendingFetchItems[i];
+      snapshots[i] = store._instanceCache.createSnapshot(fetchItem.identifier, fetchItem.options);
+      fetchMap.set(snapshots[i], fetchItem);
+    }
+    let groups;
+    if (adapter.groupRecordsForFindMany) {
+      groups = adapter.groupRecordsForFindMany(store, snapshots);
+    } else {
+      groups = [snapshots];
+    }
+    for (let i = 0, l = groups.length; i < l; i++) {
+      _processCoalescedGroup(store, fetchMap, groups[i], adapter, modelName);
+    }
+  } else {
+    for (let i = 0; i < totalItems; i++) {
+      _fetchRecord(store, pendingFetchItems[i]);
+    }
+  }
+}
+function _flushPendingSave(store, pending) {
+  const {
+    snapshot,
+    resolver,
+    identifier,
+    options
+  } = pending;
+  const adapter = store.adapterFor(identifier.type);
+  const operation = options[SaveOp];
+  let modelName = snapshot.modelName;
+  let modelClass = store.modelFor(modelName);
+  const record = store._instanceCache.getRecord(identifier);
+  assert(`You tried to update a record but you have no adapter (for ${modelName})`, adapter);
+  assert(`You tried to update a record but your adapter (for ${modelName}) does not implement '${operation}'`, typeof adapter[operation] === 'function');
+  let promise = resolve().then(() => adapter[operation](store, modelClass, snapshot));
+  let serializer = store.serializerFor(modelName);
+  assert(`Your adapter's '${operation}' method must return a value, but it returned 'undefined'`, promise !== undefined);
+
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+  promise = _guard(guardDestroyedStore(promise, store, isDevelopingApp() ? `DS: Extract and notify about ${operation} completion of ${identifier.lid}` : ''),
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+  _bind(_objectIsAlive, record));
+  promise = promise.then(adapterPayload => {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+    if (!_objectIsAlive(record)) {
+      if (macroCondition(getOwnConfig().deprecations.DEPRECATE_RSVP_PROMISE)) {
+        deprecate(`A Promise while saving ${modelName} did not resolve by the time your model was destroyed. This will error in a future release.`, false, {
+          id: 'ember-data:rsvp-unresolved-async',
+          until: '5.0',
+          for: '@ember-data/store',
+          since: {
+            available: '4.5',
+            enabled: '4.5'
+          }
+        });
+      }
+    }
+    if (adapterPayload) {
+      return normalizeResponseHelper(serializer, store, modelClass, adapterPayload, snapshot.id, operation);
+    }
+  });
+  resolver.resolve(promise);
+}
+export { FetchManager as F, SnapshotRecordArray as S, SaveOp as a, assertIdentifierHasId as b, guardDestroyedStore as g, normalizeResponseHelper as n };