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

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

@@ -1,971 +0,0 @@
-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 };