@warp-drive/legacy 5.8.0-beta.0 → 5.8.0-beta.2

package/dist/unpkg/prod-deprecated/-private-BdyZaGEh.js

@@ -0,0 +1,971 @@
+import { Context } from '@warp-drive/core/reactive/-private';
+import { createDeferred } from '@warp-drive/core/request';
+import '@warp-drive/core/signals/-leaked';
+import { assertPrivateStore } from '@warp-drive/core/store/-private';
+import { getOrSetGlobal } from '@warp-drive/core/types/-private';
+
+/**
+  SnapshotRecordArray is not directly instantiable.
+  Instances are provided to consuming application's
+  adapters for certain `findAll` requests.
+
+  @hideconstructor
+  @public
+*/
+class SnapshotRecordArray {
+  /**
+   * An array of snapshots
+   *
+   * @internal
+   */
+
+  /** @internal */
+
+  /**
+   * The ResourceType of the underlying records for the {@link Snapshot | Snapshots} in the array
+   */
+
+  /** @internal */
+
+  /**
+   *  A hash of adapter options passed into the store method for this request.
+       Example
+       ```js [app/adapters/post.js]
+      import MyCustomAdapter from './custom-adapter';
+       export default class PostAdapter extends MyCustomAdapter {
+        findAll(store, type, sinceToken, snapshotRecordArray) {
+          if (snapshotRecordArray.adapterOptions.subscribe) {
+            // ...
+          }
+          // ...
+        }
+      }
+      ```
+   */
+
+  /**
+   * The relationships to include for this request.
+       Example
+       ```js [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())
+        }
+      }
+      ```
+   */
+
+  /**
+    SnapshotRecordArray is not directly instantiable.
+    Instances are provided to consuming application's
+    adapters and serializers for certain requests.
+     @private
+    @constructor
+    @param {Store} store
+    @param {String} type
+    @param options
+   */
+  constructor(store, type, options = {}) {
+    this.__store = store;
+    this._snapshots = null;
+    this.modelName = type;
+    this.adapterOptions = options.adapterOptions;
+    this.include = options.include;
+  }
+
+  /**
+    An array of records
+     @internal
+  */
+  get _recordArray() {
+    return this.__store.peekAll(this.modelName);
+  }
+
+  /**
+      Number of records in the array
+       Example
+       ```js [app/adapters/post.js]
+      import JSONAPIAdapter from '@ember-data/adapter/json-api';
+       export default class PostAdapter extends JSONAPIAdapter {
+        shouldReloadAll(store, snapshotRecordArray) {
+          return !snapshotRecordArray.length;
+        }
+      });
+      ```
+    */
+  get length() {
+    return this._recordArray.length;
+  }
+
+  /**
+    Get snapshots of the underlying record array
+     Example
+     ```js [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;
+          }
+        });
+      }
+    }
+    ```
+     @public
+    @return Array of snapshots
+  */
+  snapshots() {
+    if (this._snapshots !== null) {
+      return this._snapshots;
+    }
+    upgradeStore(this.__store);
+    const {
+      _fetchManager
+    } = this.__store;
+    const LiveArrayContext = this._recordArray[Context];
+    this._snapshots = LiveArrayContext.source.map(identifier => _fetchManager.createSnapshot(identifier));
+    return this._snapshots;
+  }
+}
+
+/**
+  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 normalizeResponseHelper(serializer, store, modelClass, payload, id, requestType) {
+  const normalizedResponse = serializer ? serializer.normalizeResponse(store, modelClass, payload, id, requestType) : payload;
+  return normalizedResponse;
+}
+
+/**
+  Snapshot is not directly instantiable.
+  Instances are provided to a consuming application's
+  adapters and serializers for certain requests.
+
+  Snapshots are only available when using `@ember-data/legacy-compat`
+  for legacy compatibility with adapters and serializers.
+
+  For serialization of records in modern paradigms, request data from
+  the cache or off the record directly.
+
+  @hideconstructor
+  @public
+*/
+class Snapshot {
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /**
+    The unique ResourceKey associated with this Snapshot.
+     @public
+  */
+
+  /**
+   The ResourceType of the underlying record for this Snapshot, as a string.
+     @public
+  */
+
+  /**
+   The id of the snapshot's underlying record
+     Example
+     ```js
+    // store.push('post', { id: 1, author: 'Tomster', title: 'Ember.js rocks' });
+    postSnapshot.id; // => '1'
+    ```
+     @public
+  */
+
+  /**
+   If `include` was passed to the options for the request, the value
+   would be available here.
+    @public
+  */
+
+  /**
+   The adapterOptions passed to the request which generated this Snapshot, if any
+    @public
+  */
+
+  constructor(options, identifier, store) {
+    this._store = store;
+    this.__attributes = null;
+    this._belongsToRelationships = Object.create(null);
+    this._belongsToIds = Object.create(null);
+    this._hasManyRelationships = Object.create(null);
+    this._hasManyIds = Object.create(null);
+    assertPrivateStore(store);
+    const hasRecord = !!store._instanceCache.peek(identifier);
+    this.modelName = identifier.type;
+    this.identifier = identifier;
+
+    /*
+      If the we do not yet have a record, then we are
+      likely a snapshot being provided to a find request, so we
+      populate __attributes lazily. Else, to preserve the "moment
+      in time" in which a snapshot is created, we greedily grab
+      the values.
+     */
+    if (hasRecord) {
+      // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+      this._attributes;
+    }
+    this.id = identifier.id;
+    this.adapterOptions = options.adapterOptions;
+    this.include = options.include;
+    this.modelName = identifier.type;
+    if (hasRecord) {
+      const cache = this._store.cache;
+      this._changedAttributes = cache.changedAttrs(identifier);
+    }
+  }
+
+  /**
+   The underlying record for this snapshot. Can be used to access methods and
+   properties defined on the record.
+    ```js
+   const someValue = snapshot.record.someProp;
+   ```
+    @property record
+   @public
+   */
+  get record() {
+    const record = this._store.peekRecord(this.identifier);
+    return record;
+  }
+
+  /** @internal */
+  get _attributes() {
+    if (this.__attributes !== null) {
+      return this.__attributes;
+    }
+    const attributes = this.__attributes = Object.create(null);
+    const {
+      identifier
+    } = this;
+    const cache = this._store.cache;
+    this.eachAttribute((key, meta) => {
+      attributes[key] = cache.getAttr(identifier, key);
+    });
+    return attributes;
+  }
+  get isNew() {
+    const cache = this._store.cache;
+    return cache?.isNew(this.identifier) || false;
+  }
+
+  /**
+   Returns the value of an attribute.
+    Example
+    ```javascript
+   // store.push('post', { id: 1, author: 'Tomster', title: 'Ember.js rocks' });
+   postSnapshot.attr('author'); // => 'Tomster'
+   postSnapshot.attr('title'); // => 'Ember.js rocks'
+   ```
+    Note: Values are loaded eagerly and cached when the snapshot is created.
+    @return The attribute value or undefined
+   @public
+   */
+  attr(keyName) {
+    if (keyName in this._attributes) {
+      return this._attributes[keyName];
+    }
+  }
+
+  /**
+   Returns all attributes and their corresponding values.
+    ::: warning ⚠️ WARNING
+   Attributes are SHALLOW copied from the cache.
+   Because they are NOT deep copied from the cache, mutating
+   any object or array fields will cause unintended side-effects
+   and bugs.
+   :::
+    Example
+    ```js
+   // store.push('post', { id: 1, author: 'Tomster', title: 'Ember.js rocks' });
+   postSnapshot.attributes(); // => { author: 'Tomster', title: 'Ember.js rocks' }
+   ```
+    @return All attributes of the current snapshot
+   @public
+   */
+  attributes() {
+    return {
+      ...this._attributes
+    };
+  }
+
+  /**
+   Returns all changed attributes and their old and new values.
+    Example
+    ```js
+   // store.push('post', { id: 1, author: 'Tomster', title: 'Ember.js rocks' });
+   postModel.set('title', 'Ember.js rocks!');
+   postSnapshot.changedAttributes(); // => { title: ['Ember.js rocks', 'Ember.js rocks!'] }
+   ```
+    @return All changed attributes of the current snapshot
+   @public
+   */
+  changedAttributes() {
+    const changedAttributes = Object.create(null);
+    if (!this._changedAttributes) {
+      return changedAttributes;
+    }
+    const changedAttributeKeys = Object.keys(this._changedAttributes);
+    for (let i = 0, length = changedAttributeKeys.length; i < length; i++) {
+      const key = changedAttributeKeys[i];
+      changedAttributes[key] = this._changedAttributes[key].slice();
+    }
+    return changedAttributes;
+  }
+
+  /**
+   Returns the current value of a belongsTo relationship.
+    `belongsTo` takes an optional hash of options as a second parameter,
+   currently supported options are:
+    - `id`: set to `true` if you only want the ID of the related record to be
+   returned.
+    Example
+    ```js
+   // store.push('post', { id: 1, title: 'Hello World' });
+   // store.createRecord('comment', { body: 'Lorem ipsum', post: post });
+   commentSnapshot.belongsTo('post'); // => Snapshot
+   commentSnapshot.belongsTo('post', { id: true }); // => '1'
+    // store.push('comment', { id: 1, body: 'Lorem ipsum' });
+   commentSnapshot.belongsTo('post'); // => undefined
+   ```
+    Calling `belongsTo` will return a new Snapshot as long as there's any known
+   data for the relationship available, such as an ID. If the relationship is
+   known but unset, `belongsTo` will return `null`. If the contents of the
+   relationship is unknown `belongsTo` will return `undefined`.
+    Note: Relationships are loaded lazily and cached upon first access.
+    @public
+   @return A snapshot or ID of a known relationship or null if the
+   relationship is known but unset. undefined will be returned if the
+   contents of the relationship are unknown.
+   */
+  belongsTo(keyName, options) {
+    const returnModeIsId = !!(options && options.id);
+    let result;
+    const store = this._store;
+    if (returnModeIsId === true && keyName in this._belongsToIds) {
+      return this._belongsToIds[keyName];
+    }
+    if (returnModeIsId === false && keyName in this._belongsToRelationships) {
+      return this._belongsToRelationships[keyName];
+    }
+    store.schema.fields({
+      type: this.modelName
+    }).get(keyName);
+    const {
+      identifier
+    } = this;
+    const value = this._store.cache.getRelationship(identifier, keyName);
+    const data = value && value.data;
+    const inverseIdentifier = data ? store.cacheKeyManager.getOrCreateRecordIdentifier(data) : null;
+    if (value && value.data !== undefined) {
+      const cache = store.cache;
+      if (inverseIdentifier && !cache.isDeleted(inverseIdentifier)) {
+        if (returnModeIsId) {
+          result = inverseIdentifier.id;
+        } else {
+          result = store._fetchManager.createSnapshot(inverseIdentifier);
+        }
+      } else {
+        result = null;
+      }
+    }
+    if (returnModeIsId) {
+      this._belongsToIds[keyName] = result;
+    } else {
+      this._belongsToRelationships[keyName] = result;
+    }
+    return result;
+  }
+
+  /**
+   Returns the current value of a hasMany relationship.
+    `hasMany` takes an optional hash of options as a second parameter,
+   currently supported options are:
+    - `ids`: set to `true` if you only want the IDs of the related records to be
+   returned.
+    Example
+    ```javascript
+   // store.push('post', { id: 1, title: 'Hello World', comments: [2, 3] });
+   postSnapshot.hasMany('comments'); // => [Snapshot, Snapshot]
+   postSnapshot.hasMany('comments', { ids: true }); // => ['2', '3']
+    // store.push('post', { id: 1, title: 'Hello World' });
+   postSnapshot.hasMany('comments'); // => undefined
+   ```
+    Note: Relationships are loaded lazily and cached upon first access.
+    @public
+   @return An array of snapshots or IDs of a known
+   relationship or an empty array if the relationship is known but unset.
+   undefined will be returned if the contents of the relationship is unknown.
+   */
+  hasMany(keyName, options) {
+    const returnModeIsIds = !!(options && options.ids);
+    let results;
+    const cachedIds = this._hasManyIds[keyName];
+    const cachedSnapshots = this._hasManyRelationships[keyName];
+    if (returnModeIsIds === true && keyName in this._hasManyIds) {
+      return cachedIds;
+    }
+    if (returnModeIsIds === false && keyName in this._hasManyRelationships) {
+      return cachedSnapshots;
+    }
+    const store = this._store;
+    store.schema.fields({
+      type: this.modelName
+    }).get(keyName);
+    const {
+      identifier
+    } = this;
+    const value = this._store.cache.getRelationship(identifier, keyName);
+    if (value.data) {
+      results = [];
+      value.data.forEach(member => {
+        const inverseIdentifier = store.cacheKeyManager.getOrCreateRecordIdentifier(member);
+        const cache = store.cache;
+        if (!cache.isDeleted(inverseIdentifier)) {
+          if (returnModeIsIds) {
+            results.push(inverseIdentifier.id);
+          } else {
+            results.push(store._fetchManager.createSnapshot(inverseIdentifier));
+          }
+        }
+      });
+    }
+
+    // we assign even if `undefined` so that we don't reprocess the relationship
+    // on next access. This works with the `keyName in` checks above.
+    if (returnModeIsIds) {
+      this._hasManyIds[keyName] = results;
+    } else {
+      this._hasManyRelationships[keyName] = results;
+    }
+    return results;
+  }
+
+  /**
+    Iterates through all the attributes of the model, calling the passed
+    function on each attribute.
+     Example
+     ```javascript
+    snapshot.eachAttribute(function(name, meta) {
+      // ...
+    });
+    ```
+     @param callback the callback to execute
+    @param binding the optional value to which the callback's `this` should be bound
+    @public
+  */
+  eachAttribute(callback, binding) {
+    // if the store has a modelFor implementation, we use it to iterate attributes. This allows
+    // a custom "ModelSchema" class for legacy serializers to adapt to new fields if desired.
+    if (typeof this._store.modelFor === 'function') {
+      const modelSchema = this._store.modelFor(this.identifier.type);
+      modelSchema.eachAttribute(callback, binding);
+    } else {
+      const fields = this._store.schema.fields(this.identifier);
+      fields.forEach((field, key) => {
+        if (field.kind === 'attribute') {
+          callback.call(binding, key, field);
+        }
+      });
+    }
+  }
+
+  /**
+    Iterates through all the relationships of the model, calling the passed
+    function on each relationship.
+     Example
+     ```javascript
+    snapshot.eachRelationship(function(name, relationship) {
+      // ...
+    });
+    ```
+     @param callback the callback to execute
+    @param binding the optional value to which the callback's `this` should be bound
+    @public
+  */
+  eachRelationship(callback, binding) {
+    // if the store has a modelFor implementation, we use it to iterate relationships. This allows
+    // a custom "ModelSchema" class for legacy serializers to adapt to new fields if desired.
+    if (typeof this._store.modelFor === 'function') {
+      const modelSchema = this._store.modelFor(this.identifier.type);
+      modelSchema.eachRelationship(callback, binding);
+    } else {
+      const fields = this._store.schema.fields(this.identifier);
+      fields.forEach((field, key) => {
+        if (field.kind === 'belongsTo' || field.kind === 'hasMany') {
+          callback.call(binding, key, field);
+        }
+      });
+    }
+  }
+
+  /**
+    Serializes the snapshot using the serializer for the model.
+     Example
+     ```js [app/adapters/application.js]
+    import Adapter from '@ember-data/adapter';
+     export default Adapter.extend({
+      createRecord(store, type, snapshot) {
+        let data = snapshot.serialize({ includeId: true });
+        let url = `/${type.modelName}`;
+         return fetch(url, {
+          method: 'POST',
+          body: data,
+        }).then((response) => response.json())
+      }
+    });
+    ```
+     @return an object whose values are primitive JSON values only
+    @public
+   */
+  serialize(options) {
+    upgradeStore(this._store);
+    const serializer = this._store.serializerFor(this.modelName);
+    return serializer.serialize(this, options);
+  }
+}
+const SaveOp = getOrSetGlobal('SaveOp', Symbol('SaveOp'));
+/**
+ * @private
+ */
+class FetchManager {
+  /**
+   * @internal
+   */
+
+  /** @internal */
+
+  // fetches pending in the runloop, waiting to be coalesced
+  /**
+   * @internal
+   */
+
+  /** @internal */
+
+  constructor(store) {
+    assertPrivateStore(store);
+    this._store = store;
+    // used to keep track of all the find requests that need to be coalesced
+    this._pendingFetch = new Map();
+    this.requestCache = store.getRequestStateService();
+    this.isDestroyed = false;
+  }
+  createSnapshot(identifier, options = {}) {
+    return new Snapshot(options, identifier, this._store);
+  }
+
+  /**
+    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.
+     @private
+  */
+  scheduleSave(identifier, options) {
+    const resolver = createDeferred();
+    const query = {
+      op: 'saveRecord',
+      recordIdentifier: identifier,
+      options
+    };
+    const queryRequest = {
+      data: [query]
+    };
+    const snapshot = this.createSnapshot(identifier, options);
+    const pendingSaveItem = {
+      snapshot: snapshot,
+      resolver: resolver,
+      identifier,
+      options,
+      queryRequest
+    };
+    const monitored = this.requestCache._enqueue(resolver.promise, pendingSaveItem.queryRequest);
+    _flushPendingSave(this._store, pendingSaveItem);
+    return monitored;
+  }
+  scheduleFetch(identifier, options, request) {
+    const query = {
+      op: 'findRecord',
+      recordIdentifier: identifier,
+      options
+    };
+    const queryRequest = {
+      data: [query]
+    };
+    const pendingFetch = this.getPendingFetch(identifier, options);
+    if (pendingFetch) {
+      return pendingFetch;
+    }
+    const modelName = identifier.type;
+    const resolver = createDeferred();
+    const pendingFetchItem = {
+      identifier,
+      resolver,
+      options,
+      queryRequest
+    };
+    const resolverPromise = resolver.promise;
+    const store = this._store;
+    const isInitialLoad = !store._instanceCache.recordIsLoaded(identifier); // we don't use isLoading directly because we are the request
+
+    const monitored = this.requestCache._enqueue(resolverPromise, pendingFetchItem.queryRequest);
+    let promise = monitored.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)
+      const potentiallyNewIm = store._push(payload, options.reload);
+      if (potentiallyNewIm && !Array.isArray(potentiallyNewIm)) {
+        return potentiallyNewIm;
+      }
+      return identifier;
+    }, error => {
+      const cache = store.cache;
+      if (!cache || cache.isEmpty(identifier) || isInitialLoad) {
+        let isReleasable = true;
+        if (store._graph) {
+          const graph = store._graph;
+          if (!cache) {
+            isReleasable = graph.isReleasable(identifier);
+            if (!isReleasable) {
+              graph.unload(identifier, true);
+            }
+          }
+        }
+        if (cache || isReleasable) {
+          store._enableAsyncFlush = true;
+          store._instanceCache.unloadRecord(identifier);
+          store._enableAsyncFlush = null;
+        }
+      }
+      throw error;
+    });
+    if (this._pendingFetch.size === 0) {
+      void new Promise(resolve => setTimeout(resolve, 0)).then(() => {
+        this.flushAllPendingFetches();
+      });
+    }
+    const fetchesByType = this._pendingFetch;
+    let fetchesById = fetchesByType.get(modelName);
+    if (!fetchesById) {
+      fetchesById = new Map();
+      fetchesByType.set(modelName, fetchesById);
+    }
+    let requestsForIdentifier = fetchesById.get(identifier);
+    if (!requestsForIdentifier) {
+      requestsForIdentifier = [];
+      fetchesById.set(identifier, requestsForIdentifier);
+    }
+    requestsForIdentifier.push(pendingFetchItem);
+    pendingFetchItem.promise = promise;
+    return promise;
+  }
+  getPendingFetch(identifier, options) {
+    const pendingFetches = this._pendingFetch.get(identifier.type)?.get(identifier);
+
+    // We already have a pending fetch for this
+    if (pendingFetches) {
+      const matchingPendingFetch = pendingFetches.find(fetch => 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 = {}, request) {
+    // 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) {
+      {
+        options.reload = true;
+        promise = this.scheduleFetch(identifier, options, request);
+      }
+    } else if (isLoading) {
+      promise = this.getPendingFetch(identifier, options);
+    } else {
+      promise = Promise.resolve(identifier);
+    }
+    return promise;
+  }
+  destroy() {
+    this.isDestroyed = true;
+  }
+}
+
+/**
+ * This type exists for internal use only for
+ * where intimate contracts still exist either for
+ * the Test Suite or for Legacy code.
+ *
+ * @private
+ */
+
+function _isEmpty(instanceCache, identifier) {
+  const cache = 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(r => r.type === 'query');
+}
+function includesSatisfies(current, existing) {
+  // if we have no includes we are good
+  if (!current?.length) {
+    return true;
+  }
+
+  // if we are here we have includes,
+  // and if existing has no includes then we will need a new request
+  if (!existing?.length) {
+    return false;
+  }
+  const arrCurrent = (Array.isArray(current) ? current : current.split(',')).sort();
+  const arrExisting = (Array.isArray(existing) ? existing : existing.split(',')).sort();
+
+  // includes are identical
+  if (arrCurrent.join(',') === arrExisting.join(',')) {
+    return true;
+  }
+
+  // if all of current includes are in existing includes then we are good
+  // so if we find one that is not in existing then we need a new request
+  for (let i = 0; i < arrCurrent.length; i++) {
+    if (!arrExisting.includes(arrCurrent[i])) {
+      return false;
+    }
+  }
+  return true;
+}
+function optionsSatisfies(current, existing) {
+  return !current || current === existing || Object.keys(current).length === 0;
+}
+
+// this function helps resolve whether we have a pending request that we should use instead
+function isSameRequest(options = {}, existingOptions = {}) {
+  return optionsSatisfies(options.adapterOptions, existingOptions.adapterOptions) && includesSatisfies(options.include, existingOptions.include);
+}
+function _findMany(store, adapter, modelName, snapshots) {
+  const modelClass = store.modelFor(modelName); // `adapter.findMany` gets the modelClass still
+  const promise = Promise.resolve().then(() => {
+    const ids = snapshots.map(s => s.id);
+    const ret = adapter.findMany(store, modelClass, ids, snapshots);
+    return ret;
+  });
+  return promise.then(adapterPayload => {
+    const serializer = store.serializerFor(modelName);
+    const 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++) {
+    const snapshot = snapshots[i];
+    const 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.
+  */
+  const snapshotsById = new Map();
+  for (let i = 0; i < snapshots.length; i++) {
+    const 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
+  const resources = coalescedPayload.data;
+  for (let i = 0, l = resources.length; i < l; i++) {
+    const resource = resources[i];
+    const 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 => {
+        const pair = fetchMap.get(snapshot);
+        const resolver = pair.resolver;
+        resolver.resolve({
+          data: resource
+        });
+      });
+    }
+  }
+  if (included.length > 0) {
+    store._push({
+      data: null,
+      included
+    }, true);
+  }
+  if (snapshotsById.size === 0) {
+    return;
+  }
+
+  // reject missing records
+  const rejected = [];
+  snapshotsById.forEach(snapshotArray => {
+    rejected.push(...snapshotArray);
+  });
+  rejectFetchedItems(fetchMap, rejected);
+}
+function _fetchRecord(store, adapter, fetchItem) {
+  const identifier = fetchItem.identifier;
+  const modelName = identifier.type;
+  const snapshot = store._fetchManager.createSnapshot(identifier, fetchItem.options);
+  const klass = store.modelFor(identifier.type);
+  const id = identifier.id;
+  let promise = Promise.resolve().then(() => {
+    return adapter.findRecord(store, klass, identifier.id, snapshot);
+  });
+  promise = promise.then(adapterPayload => {
+    const serializer = store.serializerFor(modelName);
+    const payload = normalizeResponseHelper(serializer, store, klass, adapterPayload, id, 'findRecord');
+    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, adapter, fetchMap.get(group[0]));
+  } else ;
+}
+function _flushPendingFetchForType(store, pendingFetchMap, modelName) {
+  const adapter = store.adapterFor(modelName);
+  const shouldCoalesce = !!adapter.findMany && adapter.coalesceFindRequests;
+  if (shouldCoalesce) {
+    const pendingFetchItems = [];
+    pendingFetchMap.forEach((requestsForIdentifier, identifier) => {
+      if (requestsForIdentifier.length > 1) {
+        return;
+      }
+
+      // remove this entry from the map so it's not processed again
+      pendingFetchMap.delete(identifier);
+      pendingFetchItems.push(requestsForIdentifier[0]);
+    });
+    const totalItems = pendingFetchItems.length;
+    if (totalItems > 1) {
+      const snapshots = new Array(totalItems);
+      const fetchMap = new Map();
+      for (let i = 0; i < totalItems; i++) {
+        const fetchItem = pendingFetchItems[i];
+        snapshots[i] = store._fetchManager.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 if (totalItems === 1) {
+      _fetchRecord(store, adapter, pendingFetchItems[0]);
+    }
+  }
+  pendingFetchMap.forEach(pendingFetchItems => {
+    pendingFetchItems.forEach(pendingFetchItem => {
+      _fetchRecord(store, adapter, pendingFetchItem);
+    });
+  });
+}
+function _flushPendingSave(store, pending) {
+  const {
+    snapshot,
+    resolver,
+    identifier,
+    options
+  } = pending;
+  const adapter = store.adapterFor(identifier.type);
+  const operation = options[SaveOp];
+  const modelName = snapshot.modelName;
+  const modelClass = store.modelFor(modelName);
+  let promise = Promise.resolve().then(() => adapter[operation](store, modelClass, snapshot));
+  const serializer = store.serializerFor(modelName);
+  promise = promise.then(adapterPayload => {
+    if (adapterPayload) {
+      return normalizeResponseHelper(serializer, store, modelClass, adapterPayload, snapshot.id, operation);
+    }
+  });
+  resolver.resolve(promise);
+}
+
+/**
+ * Utilities - often temporary - for maintaining backwards compatibility with
+ * older parts of WarpDrive.
+ *
+  @module
+*/
+function upgradeStore(store) {}
+export { FetchManager as F, SaveOp as S, SnapshotRecordArray as a, Snapshot as b, normalizeResponseHelper as n, upgradeStore as u };