@warp-drive/core 5.7.0-alpha.0 → 5.7.0-alpha.2

package/dist/{request-state-CjLph1LP.js → request-state-CejVJgdj.js}

@@ -1139,6 +1139,7 @@ function gate(_target, key, desc) {
   const getter = desc.get;
   // eslint-disable-next-line @typescript-eslint/unbound-method
   const setter = desc.set;
+  const isLocal = desc.isLocal;
   desc.get = function () {
     const signals = withSignalStore(this);
     let signal = peekInternalSignal(signals, key);
@@ -1165,6 +1166,11 @@ function gate(_target, key, desc) {
       setter.call(this, v);
       // when a gate is set, we do not notify the signal
       // as its update is controlled externally.
+      // unless it specifically sets itself to be locally managed
+      if (isLocal) {
+        signal.isStale = true;
+        notifyInternalSignal(signal);
+      }
     };
   }
   return desc;
@@ -1557,185 +1563,6 @@ function _log(scope, prefix, subScop1, subScop2, subScop3, subScop4) {
   }
   return [];
 }
-
-/**
-   A `RecordReference` is a low-level API that allows users and
-   addon authors to perform meta-operations on a record.
-
-   @hideconstructor
-   @public
-*/
-class RecordReference {
-  // unsubscribe token given to us by the notification manager
-
-  constructor(store, identifier) {
-    this.store = store;
-    this.___identifier = identifier;
-    this.___token = store.notifications.subscribe(identifier, (_, bucket, notifiedKey) => {
-      if (bucket === 'identity' || bucket === 'attributes' && notifiedKey === 'id') {
-        this._ref++;
-      }
-    });
-  }
-
-  /** @internal */
-  destroy() {
-    this.store.notifications.unsubscribe(this.___token);
-  }
-  get type() {
-    return this.identifier().type;
-  }
-
-  /**
-     The `id` of the record that this reference refers to.
-      Together, the `type` and `id` properties form a composite key for
-     the identity map.
-      Example
-      ```javascript
-     let userRef = store.getReference('user', 1);
-      userRef.id(); // '1'
-     ```
-     @public
-  */
-  id() {
-    // eslint-disable-next-line @typescript-eslint/no-unused-expressions
-    this._ref; // consume the tracked prop
-    return this.___identifier.id;
-  }
-
-  /**
-     The `identifier` of the record that this reference refers to.
-      Together, the `type` and `id` properties form a composite key for
-     the identity map.
-      Example
-      ```javascript
-     let userRef = store.getReference('user', 1);
-      userRef.identifier(); // '1'
-     ```
-     @public
-  */
-  identifier() {
-    return this.___identifier;
-  }
-
-  /**
-     How the reference will be looked up when it is loaded. Currently
-     this always returns `identity` to signify that a record will be
-     loaded by its `type` and `id`.
-      Example
-      ```javascript
-     const userRef = store.getReference('user', 1);
-      userRef.remoteType(); // 'identity'
-     ```
-      @public
-  */
-  remoteType() {
-    return 'identity';
-  }
-
-  /**
-    This API allows you to provide a reference with new data. The
-    simplest usage of this API is similar to `store.push`: you provide a
-    normalized hash of data and the object represented by the reference
-    will update.
-     If you pass a promise to `push`, Ember Data will not ask the adapter
-    for the data if another attempt to fetch it is made in the
-    interim. When the promise resolves, the underlying object is updated
-    with the new data, and the promise returned by *this function* is resolved
-    with that object.
-     For example, `recordReference.push(promise)` will be resolved with a
-    record.
-      Example
-      ```javascript
-     let userRef = store.getReference('user', 1);
-      // provide data for reference
-     userRef.push({
-       data: {
-         id: "1",
-         type: "user",
-         attributes: {
-           username: "@user"
-         }
-       }
-     }).then(function(user) {
-       userRef.value() === user;
-     });
-     ```
-     @public
-    @param objectOrPromise a JSON:API ResourceDocument or a promise resolving to one
-    @return a promise for the value (record or relationship)
-  */
-  push(objectOrPromise) {
-    // TODO @deprecate pushing unresolved payloads
-    return Promise.resolve(objectOrPromise).then(data => {
-      return this.store.push(data);
-    });
-  }
-
-  /**
-    If the entity referred to by the reference is already loaded, it is
-    present as `reference.value`. Otherwise the value returned by this function
-    is `null`.
-      Example
-      ```javascript
-     let userRef = store.getReference('user', 1);
-      userRef.value(); // user
-     ```
-     @public
-  */
-  value() {
-    return this.store.peekRecord(this.___identifier);
-  }
-
-  /**
-     Triggers a fetch for the backing entity based on its `remoteType`
-     (see `remoteType` definitions per reference type).
-      Example
-      ```javascript
-     let userRef = store.getReference('user', 1);
-      // load user (via store.find)
-     userRef.load().then(...)
-     ```
-     @public
-  */
-  load() {
-    const id = this.id();
-    if (id !== null) {
-      return this.store.findRecord(this.type, id);
-    }
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      {
-        throw new Error(`Unable to fetch record of type ${this.type} without an id`);
-      }
-    })() : {};
-  }
-
-  /**
-     Reloads the record if it is already loaded. If the record is not
-     loaded it will load the record via `store.findRecord`
-      Example
-      ```javascript
-     let userRef = store.getReference('user', 1);
-      // or trigger a reload
-     userRef.reload().then(...)
-     ```
-     @public
-  */
-  reload() {
-    const id = this.id();
-    if (id !== null) {
-      return this.store.findRecord(this.type, id, {
-        reload: true
-      });
-    }
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      {
-        throw new Error(`Unable to fetch record of type ${this.type} without an id`);
-      }
-    })() : {};
-  }
-}
-defineSignal(RecordReference.prototype, '_ref');
 class CacheCapabilitiesManager {
   constructor(_store) {
     this._store = _store;
@@ -1921,7 +1748,6 @@ class InstanceCache {
     this.store = store;
     this.__instances = {
       record: new Map(),
-      reference: new WeakMap(),
       document: new Map()
     };
     this._storeWrapper = new CacheCapabilitiesManager(this.store);
@@ -2015,15 +1841,6 @@ class InstanceCache {
     }
     return record;
   }
-  getReference(identifier) {
-    const cache = this.__instances.reference;
-    let reference = cache.get(identifier);
-    if (!reference) {
-      reference = new RecordReference(this.store, identifier);
-      cache.set(identifier, reference);
-    }
-    return reference;
-  }
   recordIsLoaded(identifier, filterDeleted = false) {
     const cache = this.cache;
     if (!cache) {
@@ -2201,208 +2018,39 @@ class InstanceCache {
     this.store.notifications.notify(identifier, 'identity');
   }
 }
-function _resourceIsFullDeleted(identifier, cache) {
-  return cache.isDeletionCommitted(identifier) || cache.isNew(identifier) && cache.isDeleted(identifier);
-}
-function resourceIsFullyDeleted(instanceCache, identifier) {
-  const cache = instanceCache.cache;
-  return !cache || _resourceIsFullDeleted(identifier, cache);
+function _clearCaches() {
+  RecordCache.clear();
+  StoreMap.clear();
+  CacheForIdentifierCache.clear();
 }
 
-/*
-    When a find request is triggered on the store, the user can optionally pass in
-    attributes and relationships to be preloaded. These are meant to behave as if they
-    came back from the server, except the user obtained them out of band and is informing
-    the store of their existence. The most common use case is for supporting client side
-    nested URLs, such as `/posts/1/comments/2` so the user can do
-    `store.findRecord('comment', 2, { preload: { post: 1 } })` without having to fetch the post.
+/**
+ * The CacheManager wraps a Cache enforcing that only
+ * the public API surface area is exposed.
+ *
+ * Hence, it is the value of `Store.cache`, wrapping
+ * the cache instance returned by `Store.createCache`.
+ *
+ * It handles translating between cache versions when
+ * necessary, for instance when a Store is configured
+ * to use both a v1 and a v2 cache depending on some
+ * heuristic.
+ *
+ * Starting with the v2 spec, the cache is designed such
+ * that it must be implemented as a singleton.
+ *
+ * @class CacheManager
+ * @public
+ */
+class CacheManager {
+  version = '2';
+  #cache;
+  constructor(cache) {
+    this.#cache = cache;
+  }
 
-    Preloaded data can be attributes and relationships passed in either as IDs or as actual
-    models.
-  */
-
-function preloadData(store, identifier, preload) {
-  const jsonPayload = {};
-  //TODO(Igor) consider the polymorphic case
-  const schemas = store.schema;
-  const fields = schemas.fields(identifier);
-  Object.keys(preload).forEach(key => {
-    const preloadValue = preload[key];
-    const field = fields.get(key);
-    if (field && (field.kind === 'hasMany' || field.kind === 'belongsTo')) {
-      if (!jsonPayload.relationships) {
-        jsonPayload.relationships = {};
-      }
-      jsonPayload.relationships[key] = preloadRelationship(field, preloadValue);
-    } else {
-      if (!jsonPayload.attributes) {
-        jsonPayload.attributes = {};
-      }
-      jsonPayload.attributes[key] = preloadValue;
-    }
-  });
-  const cache = store.cache;
-  const hasRecord = Boolean(store._instanceCache.peek(identifier));
-  cache.upsert(identifier, jsonPayload, hasRecord);
-}
-function preloadRelationship(schema, preloadValue) {
-  const relatedType = schema.type;
-  if (schema.kind === 'hasMany') {
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error('You need to pass in an array to set a hasMany property on a record');
-      }
-    })(Array.isArray(preloadValue)) : {};
-    return {
-      data: preloadValue.map(value => _convertPreloadRelationshipToJSON(value, relatedType))
-    };
-  }
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-    if (!test) {
-      throw new Error('You should not pass in an array to set a belongsTo property on a record');
-    }
-  })(!Array.isArray(preloadValue)) : {};
-  return {
-    data: preloadValue ? _convertPreloadRelationshipToJSON(preloadValue, relatedType) : null
-  };
-}
-
-/*
-  findRecord('user', '1', { preload: { friends: ['1'] }});
-  findRecord('user', '1', { preload: { friends: [record] }});
-*/
-function _convertPreloadRelationshipToJSON(value, type) {
-  if (typeof value === 'string' || typeof value === 'number') {
-    return {
-      type,
-      id: ensureStringId(value)
-    };
-  }
-  // TODO if not a record instance assert it's an identifier
-  // and allow identifiers to be used
-  return recordIdentifierFor(value);
-}
-function _clearCaches() {
-  RecordCache.clear();
-  StoreMap.clear();
-  CacheForIdentifierCache.clear();
-}
-
-// if modelFor turns out to be a bottleneck we should replace with a Map
-// and clear it during store teardown.
-const AvailableShims = getOrSetGlobal('AvailableShims', new WeakMap());
-function getShimClass(store, modelName) {
-  let shims = AvailableShims.get(store);
-  if (!shims) {
-    shims = Object.create(null);
-    AvailableShims.set(store, shims);
-  }
-  let shim = shims[modelName];
-  if (shim === undefined) {
-    shim = shims[modelName] = new ShimModelClass(store, modelName);
-  }
-  return shim;
-}
-
-// Mimics the static apis of @ember-data/model
-class ShimModelClass {
-  constructor(store, modelName) {
-    this.__store = store;
-    this.modelName = modelName;
-  }
-  get fields() {
-    const fields = new Map();
-    const fieldSchemas = this.__store.schema.fields({
-      type: this.modelName
-    });
-    fieldSchemas.forEach((schema, key) => {
-      if (schema.kind === 'attribute' || schema.kind === 'belongsTo' || schema.kind === 'hasMany') {
-        fields.set(key, schema.kind);
-      }
-    });
-    return fields;
-  }
-  get attributes() {
-    const attrs = new Map();
-    const fields = this.__store.schema.fields({
-      type: this.modelName
-    });
-    fields.forEach((schema, key) => {
-      if (schema.kind === 'attribute') {
-        attrs.set(key, schema);
-      }
-    });
-    return attrs;
-  }
-  get relationshipsByName() {
-    const rels = new Map();
-    const fields = this.__store.schema.fields({
-      type: this.modelName
-    });
-    fields.forEach((schema, key) => {
-      if (schema.kind === 'belongsTo' || schema.kind === 'hasMany') {
-        rels.set(key, schema);
-      }
-    });
-    return rels;
-  }
-  eachAttribute(callback, binding) {
-    this.__store.schema.fields({
-      type: this.modelName
-    }).forEach((schema, key) => {
-      if (schema.kind === 'attribute') {
-        callback.call(binding, key, schema);
-      }
-    });
-  }
-  eachRelationship(callback, binding) {
-    this.__store.schema.fields({
-      type: this.modelName
-    }).forEach((schema, key) => {
-      if (schema.kind === 'belongsTo' || schema.kind === 'hasMany') {
-        callback.call(binding, key, schema);
-      }
-    });
-  }
-  eachTransformedAttribute(callback, binding) {
-    this.__store.schema.fields({
-      type: this.modelName
-    }).forEach((schema, key) => {
-      if (schema.kind === 'attribute') {
-        const type = schema.type;
-        if (type) callback.call(binding, key, type);
-      }
-    });
-  }
-}
-
-/**
- * The CacheManager wraps a Cache enforcing that only
- * the public API surface area is exposed.
- *
- * Hence, it is the value of `Store.cache`, wrapping
- * the cache instance returned by `Store.createCache`.
- *
- * It handles translating between cache versions when
- * necessary, for instance when a Store is configured
- * to use both a v1 and a v2 cache depending on some
- * heuristic.
- *
- * Starting with the v2 spec, the cache is designed such
- * that it must be implemented as a singleton.
- *
- * @class CacheManager
- * @public
- */
-class CacheManager {
-  version = '2';
-  #cache;
-  constructor(cache) {
-    this.#cache = cache;
-  }
-
-  // Cache Management
-  // ================
+  // Cache Management
+  // ================
 
   /**
    * Cache the response to a request
@@ -4426,57 +4074,6 @@ class RequestStateService {
     return null;
   }
 }
-function isNonEmptyString(str) {
-  return Boolean(str && typeof str === 'string');
-}
-function constructResource(type, id, lid) {
-  if (typeof type === 'object' && type !== null) {
-    const resource = type;
-    if (isStableIdentifier(resource)) {
-      return resource;
-    }
-    if ('id' in resource) {
-      resource.id = coerceId(resource.id);
-    }
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error('Expected either id or lid to be a valid string');
-      }
-    })('id' in resource && isNonEmptyString(resource.id) || isNonEmptyString(resource.lid)) : {};
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error('if id is present, the type must be a string');
-      }
-    })(!('id' in resource) || typeof resource.type === 'string') : {};
-    return resource;
-  } else {
-    const trueId = coerceId(id);
-    if (!isNonEmptyString(trueId)) {
-      if (isNonEmptyString(lid)) {
-        return {
-          lid
-        };
-      }
-      throw new Error('Expected either id or lid to be a valid string');
-    }
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error('type must be a string');
-      }
-    })(typeof type === 'string') : {};
-    if (isNonEmptyString(lid)) {
-      return {
-        type,
-        id: trueId,
-        lid
-      };
-    }
-    return {
-      type,
-      id: trueId
-    };
-  }
-}
 
 // this import location is deprecated but breaks in 4.8 and older
 // @ts-expect-error adding to globalThis
@@ -5023,46 +4620,6 @@ class Store extends BaseClass {
     return future;
   }
 
-  /**
-    Returns the schema for a particular resource type (modelName).
-     When used with Model from @ember-data/model the return is the model class,
-    but this is not guaranteed.
-     If looking to query attribute or relationship information it is
-    recommended to use `getSchemaDefinitionService` instead. This method
-    should be considered legacy and exists primarily to continue to support
-    Adapter/Serializer APIs which expect it's return value in their method
-    signatures.
-     The class of a model might be useful if you want to get a list of all the
-    relationship names of the model, see
-    [`relationshipNames`](/ember-data/release/classes/Model?anchor=relationshipNames)
-    for example.
-     @public
-    @deprecated
-    @param {String} type
-    @return {ModelSchema}
-    */
-
-  modelFor(type) {
-    // FIXME add deprecation and deprecation stripping
-    // FIXME/TODO update RFC to remove this method
-    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
-      assertDestroyedStoreOnly(this, 'modelFor');
-    }
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`You need to pass <type> to the store's modelFor method`);
-      }
-    })(typeof type === 'string' && type.length) : {};
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`No model was found for '${type}' and no schema handles the type`);
-      }
-    })(this.schema.hasResource({
-      type
-    })) : {};
-    return getShimClass(this, type);
-  }
-
   /**
     Create a new record in the current store. The properties passed
     to this method are set on the newly created record.
@@ -5203,403 +4760,27 @@ class Store extends BaseClass {
   }
 
   /**
-    This method returns a record for a given identifier or type and id combination.
-     The `findRecord` method will always resolve its promise with the same
-    object for a given identifier or type and `id`.
-     The `findRecord` method will always return a **promise** that will be
-    resolved with the record.
+    Get a record by a given type and ID without triggering a fetch.
+     This method will synchronously return the record if it is available in the store,
+    otherwise it will return `null`. A record is available if it has been fetched earlier, or
+    pushed manually into the store.
+     See [findRecord](../methods/findRecord?anchor=findRecord) if you would like to request this record from the backend.
+     _Note: This is a synchronous method and does not return a promise._
      **Example 1**
-     ```js [app/routes/post.js]
-    export default class PostRoute extends Route {
-      model({ post_id }) {
-        return this.store.findRecord('post', post_id);
-      }
-    }
+     ```js
+    let post = store.peekRecord('post', '1');
+     post.id; // '1'
     ```
-     **Example 2**
-     `findRecord` can be called with a single identifier argument instead of the combination
+     `peekRecord` can be called with a single identifier argument instead of the combination
     of `type` (modelName) and `id` as separate arguments. You may recognize this combo as
     the typical pairing from [JSON:API](https://jsonapi.org/format/#document-resource-object-identification)
-     ```js [app/routes/post.js]
-    export default class PostRoute extends Route {
-      model({ post_id: id }) {
-        return this.store.findRecord({ type: 'post', id });
-      }
-    }
+     **Example 2**
+     ```js
+    let post = store.peekRecord({ type: 'post', id });
+    post.id; // '1'
     ```
-     **Example 3**
-     If you have previously received an lid via an Identifier for this record, and the record
-    has already been assigned an id, you can find the record again using just the lid.
-     ```js [app/routes/post.js]
-    store.findRecord({ lid });
-    ```
-     If the record is not yet available, the store will ask the adapter's `findRecord`
-    method to retrieve and supply the necessary data. If the record is already present
-    in the store, it depends on the reload behavior _when_ the returned promise
-    resolves.
-     ### Preloading
-     You can optionally `preload` specific attributes and relationships that you know of
-    by passing them via the passed `options`.
-     For example, if your Ember route looks like `/posts/1/comments/2` and your API route
-    for the comment also looks like `/posts/1/comments/2` if you want to fetch the comment
-    without also fetching the post you can pass in the post to the `findRecord` call:
-     ```js [app/routes/post-comments.js]
-    export default class PostRoute extends Route {
-      model({ post_id, comment_id: id }) {
-        return this.store.findRecord({ type: 'comment', id, { preload: { post: post_id }} });
-      }
-    }
-    ```
-     In your adapter you can then access this id without triggering a network request via the
-    snapshot:
-     ```js [app/adapters/application.js]
-    export default class Adapter {
-       findRecord(store, schema, id, snapshot) {
-        let type = schema.modelName;
-         if (type === 'comment')
-          let postId = snapshot.belongsTo('post', { id: true });
-           return fetch(`./posts/${postId}/comments/${id}`)
-            .then(response => response.json())
-        }
-      }
-       static create() {
-        return new this();
-      }
-    }
-    ```
-     This could also be achieved by supplying the post id to the adapter via the adapterOptions
-    property on the options hash.
-     ```js [app/routes/post-comments.js]
-    export default class PostRoute extends Route {
-      model({ post_id, comment_id: id }) {
-        return this.store.findRecord({ type: 'comment', id, { adapterOptions: { post: post_id }} });
-      }
-    }
-    ```
-     ```js [app/adapters/application.js]
-    export default class Adapter {
-      findRecord(store, schema, id, snapshot) {
-        let type = schema.modelName;
-         if (type === 'comment')
-          let postId = snapshot.adapterOptions.post;
-           return fetch(`./posts/${postId}/comments/${id}`)
-            .then(response => response.json())
-        }
-      }
-       static create() {
-        return new this();
-      }
-    }
-    ```
-     If you have access to the post model you can also pass the model itself to preload:
-     ```javascript
-    let post = await store.findRecord('post', '1');
-    let comment = await store.findRecord('comment', '2', { post: myPostModel });
-    ```
-     ### Reloading
-     The reload behavior is configured either via the passed `options` hash or
-    the result of the adapter's `shouldReloadRecord`.
-     If `{ reload: true }` is passed or `adapter.shouldReloadRecord` evaluates
-    to `true`, then the returned promise resolves once the adapter returns
-    data, regardless if the requested record is already in the store:
-     ```js
-    store.push({
-      data: {
-        id: 1,
-        type: 'post',
-        revision: 1
-      }
-    });
-     // adapter#findRecord resolves with
-    // [
-    //   {
-    //     id: 1,
-    //     type: 'post',
-    //     revision: 2
-    //   }
-    // ]
-    store.findRecord('post', '1', { reload: true }).then(function(post) {
-      post.revision; // 2
-    });
-    ```
-     If no reload is indicated via the above mentioned ways, then the promise
-    immediately resolves with the cached version in the store.
-     ### Background Reloading
-     Optionally, if `adapter.shouldBackgroundReloadRecord` evaluates to `true`,
-    then a background reload is started, which updates the records' data, once
-    it is available:
-     ```js
-    // app/adapters/post.js
-    import ApplicationAdapter from "./application";
-     export default class PostAdapter extends ApplicationAdapter {
-      shouldReloadRecord(store, snapshot) {
-        return false;
-      },
-       shouldBackgroundReloadRecord(store, snapshot) {
-        return true;
-      }
-    });
-     // ...
-     store.push({
-      data: {
-        id: 1,
-        type: 'post',
-        revision: 1
-      }
-    });
-     let blogPost = store.findRecord('post', '1').then(function(post) {
-      post.revision; // 1
-    });
-     // later, once adapter#findRecord resolved with
-    // [
-    //   {
-    //     id: 1,
-    //     type: 'post',
-    //     revision: 2
-    //   }
-    // ]
-     blogPost.revision; // 2
-    ```
-     If you would like to force or prevent background reloading, you can set a
-    boolean value for `backgroundReload` in the options object for
-    `findRecord`.
-     ```js [app/routes/post/edit.js]
-    export default class PostEditRoute extends Route {
-      model(params) {
-        return this.store.findRecord('post', params.post_id, { backgroundReload: false });
-      }
-    }
-    ```
-     If you pass an object on the `adapterOptions` property of the options
-    argument it will be passed to your adapter via the snapshot
-     ```js [app/routes/post/edit.js]
-    export default class PostEditRoute extends Route {
-      model(params) {
-        return this.store.findRecord('post', params.post_id, {
-          adapterOptions: { subscribe: false }
-        });
-      }
-    }
-    ```
-     ```js [app/adapters/post.js]
-    import MyCustomAdapter from './custom-adapter';
-     export default class PostAdapter extends MyCustomAdapter {
-      findRecord(store, type, id, snapshot) {
-        if (snapshot.adapterOptions.subscribe) {
-          // ...
-        }
-        // ...
-      }
-    }
-    ```
-     See [peekRecord](../methods/peekRecord?anchor=peekRecord) to get the cached version of a record.
-     ### Retrieving Related Model Records
-     If you use an adapter such as Ember's default
-    [`JSONAPIAdapter`](/ember-data/release/classes/JSONAPIAdapter)
-    that supports the [JSON API specification](http://jsonapi.org/) and if your server
-    endpoint supports the use of an
-    ['include' query parameter](http://jsonapi.org/format/#fetching-includes),
-    you can use `findRecord()` or `findAll()` to automatically retrieve additional records related to
-    the one you request by supplying an `include` parameter in the `options` object.
-     For example, given a `post` model that has a `hasMany` relationship with a `comment`
-    model, when we retrieve a specific post we can have the server also return that post's
-    comments in the same request:
-     ```js [app/routes/post.js]
-    export default class PostRoute extends Route {
-      model(params) {
-        return this.store.findRecord('post', params.post_id, { include: ['comments'] });
-      }
-    }
-    ```
-     ```js [app/adapters/application.js]
-    export default class Adapter {
-      findRecord(store, schema, id, snapshot) {
-        let type = schema.modelName;
-         if (type === 'post')
-          let includes = snapshot.adapterOptions.include;
-           return fetch(`./posts/${postId}?include=${includes}`)
-            .then(response => response.json())
-        }
-      }
-       static create() {
-        return new this();
-      }
-    }
-    ```
-     In this case, the post's comments would then be available in your template as
-    `model.comments`.
-     Multiple relationships can be requested using an `include` parameter consisting of a
-    list of relationship names, while nested relationships can be specified
-    using a dot-separated sequence of relationship names. So to request both the post's
-    comments and the authors of those comments the request would look like this:
-     ```js [app/routes/post.js]
-    export default class PostRoute extends Route {
-      model(params) {
-        return this.store.findRecord('post', params.post_id, { include: ['comments','comments.author'] });
-      }
-    }
-    ```
-     ### Retrieving Specific Fields by Type
-     If your server endpoint supports the use of a ['fields' query parameter](https://jsonapi.org/format/#fetching-sparse-fieldsets),
-    you can use pass those fields through to your server.  At this point in time, this requires a few manual steps on your part.
-     1. Implement `buildQuery` in your adapter.
-     ```js [app/adapters/application.js]
-    buildQuery(snapshot) {
-      let query = super.buildQuery(...arguments);
-       let { fields } = snapshot.adapterOptions;
-       if (fields) {
-        query.fields = fields;
-      }
-       return query;
-    }
-    ```
-     2. Then pass through the applicable fields to your `findRecord` request.
-     Given a `post` model with attributes body, title, publishDate and meta, you can retrieve a filtered list of attributes.
-     ```js [app/routes/post.js]
-    export default class extends Route {
-      model(params) {
-        return this.store.findRecord('post', params.post_id, { adapterOptions: { fields: { post: 'body,title' } });
-      }
-    }
-    ```
-     Moreover, you can filter attributes on related models as well. If a `post` has a `belongsTo` relationship to a user,
-    just include the relationship key and attributes.
-     ```js [app/routes/post.js]
-    export default class extends Route {
-      model(params) {
-        return this.store.findRecord('post', params.post_id, { adapterOptions: { fields: { post: 'body,title', user: 'name,email' } });
-      }
-    }
-    ```
-     @since 1.13.0
-    @public
-    @param {String|object} type - either a string representing the name of the resource or a ResourceIdentifier object containing both the type (a string) and the id (a string) for the record or an lid (a string) of an existing record
-    @param {(String|Integer|Object)} id - optional object with options for the request only if the first param is a ResourceIdentifier, else the string id of the record to be retrieved
-    @param {Object} [options] - if the first param is a string this will be the optional options for the request. See examples for available options.
-    @return {Promise} promise
-  */
-
-  findRecord(resource, id, options) {
-    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
-      assertDestroyingStore(this, 'findRecord');
-    }
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`You need to pass a modelName or resource identifier as the first argument to the store's findRecord method`);
-      }
-    })(resource) : {};
-    if (isMaybeIdentifier(resource)) {
-      options = id;
-    } else {
-      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-        if (!test) {
-          throw new Error(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${resource}`);
-        }
-      })(typeof resource === 'string') : {};
-      const type = normalizeModelName(resource);
-      const normalizedId = ensureStringId(id);
-      resource = constructResource(type, normalizedId);
-    }
-    const identifier = this.identifierCache.getOrCreateRecordIdentifier(resource);
-    options = options || {};
-    if (options.preload) {
-      // force reload if we preload to ensure we don't resolve the promise
-      // until we are complete, else we will end up background-reloading
-      // even for initial load.
-      if (!this._instanceCache.recordIsLoaded(identifier)) {
-        options.reload = true;
-      }
-      this._join(() => {
-        preloadData(this, identifier, options.preload);
-      });
-    }
-    const promise = this.request({
-      op: 'findRecord',
-      data: {
-        record: identifier,
-        options
-      },
-      cacheOptions: {
-        [SkipCache]: true
-      }
-    });
-    return promise.then(document => {
-      return document.content;
-    });
-  }
-
-  /**
-    Get the reference for the specified record.
-     Example
-     ```javascript
-    let userRef = store.getReference('user', '1');
-     // check if the user is loaded
-    let isLoaded = userRef.value() !== null;
-     // get the record of the reference (null if not yet available)
-    let user = userRef.value();
-     // get the identifier of the reference
-    if (userRef.remoteType() === 'id') {
-    let id = userRef.id();
-    }
-     // load user (via store.find)
-    userRef.load().then(...)
-     // or trigger a reload
-    userRef.reload().then(...)
-     // provide data for reference
-    userRef.push({ id: 1, username: '@user' }).then(function(user) {
-      userRef.value() === user;
-    });
-    ```
-     @public
-    @param {String|object} resource - modelName (string) or Identifier (object)
-    @param {String|Integer} id
-    @since 2.5.0
-    @return {RecordReference}
-  */
-  // TODO @deprecate getReference (and references generally)
-  getReference(resource, id) {
-    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
-      assertDestroyingStore(this, 'getReference');
-    }
-    let resourceIdentifier;
-    if (arguments.length === 1 && isMaybeIdentifier(resource)) {
-      resourceIdentifier = resource;
-    } else {
-      const type = normalizeModelName(resource);
-      const normalizedId = ensureStringId(id);
-      resourceIdentifier = constructResource(type, normalizedId);
-    }
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error('getReference expected to receive either a resource identifier or type and id as arguments');
-      }
-    })(isMaybeIdentifier(resourceIdentifier)) : {};
-    const identifier = this.identifierCache.getOrCreateRecordIdentifier(resourceIdentifier);
-    return this._instanceCache.getReference(identifier);
-  }
-
-  /**
-    Get a record by a given type and ID without triggering a fetch.
-     This method will synchronously return the record if it is available in the store,
-    otherwise it will return `null`. A record is available if it has been fetched earlier, or
-    pushed manually into the store.
-     See [findRecord](../methods/findRecord?anchor=findRecord) if you would like to request this record from the backend.
-     _Note: This is a synchronous method and does not return a promise._
-     **Example 1**
-     ```js
-    let post = store.peekRecord('post', '1');
-     post.id; // '1'
-    ```
-     `peekRecord` can be called with a single identifier argument instead of the combination
-    of `type` (modelName) and `id` as separate arguments. You may recognize this combo as
-    the typical pairing from [JSON:API](https://jsonapi.org/format/#document-resource-object-identification)
-     **Example 2**
-     ```js
-    let post = store.peekRecord({ type: 'post', id });
-    post.id; // '1'
-    ```
-     If you have previously received an lid from an Identifier for this record, you can lookup the record again using
-    just the lid.
+     If you have previously received an lid from an Identifier for this record, you can lookup the record again using
+    just the lid.
      **Example 3**
      ```js
     let post = store.peekRecord({ lid });
@@ -5645,430 +4826,73 @@ class Store extends BaseClass {
   }
 
   /**
-    This method delegates a query to the adapter. This is the one place where
-    adapter-level semantics are exposed to the application.
-     Each time this method is called a new request is made through the adapter.
-     Exposing queries this way seems preferable to creating an abstract query
-    language for all server-side queries, and then require all adapters to
-    implement them.
-     ---
-     If you do something like this:
-     ```javascript
-    store.query('person', { page: 1 });
-    ```
-     The request made to the server will look something like this:
-     ```
-    GET "/api/v1/person?page=1"
-    ```
-     ---
-     If you do something like this:
+    This method returns a filtered array that contains all of the
+    known records for a given type in the store.
+     Note that because it's just a filter, the result will contain any
+    locally created records of the type, however, it will not make a
+    request to the backend to retrieve additional records. If you
+    would like to request all the records from the backend please use
+    [store.findAll](../methods/findAll?anchor=findAll).
+     Also note that multiple calls to `peekAll` for a given type will always
+    return the same `RecordArray`.
+     Example
      ```javascript
-    store.query('person', { ids: ['1', '2', '3'] });
-    ```
-     The request made to the server will look something like this:
-     ```
-    GET "/api/v1/person?ids%5B%5D=1&ids%5B%5D=2&ids%5B%5D=3"
-    decoded: "/api/v1/person?ids[]=1&ids[]=2&ids[]=3"
+    let localPosts = store.peekAll('post');
     ```
-     This method returns a promise, which is resolved with a
-    [`Collection`](/ember-data/release/classes/Collection)
-    once the server returns.
      @since 1.13.0
     @public
     @param {String} type the name of the resource
-    @param {Object} query a query to be used by the adapter
-    @param {Object} options optional, may include `adapterOptions` hash which will be passed to adapter.query
-    @return {Promise} promise
+    @return {RecordArray}
   */
 
-  query(type, query, options = {}) {
+  peekAll(type) {
     if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
-      assertDestroyingStore(this, 'query');
+      assertDestroyingStore(this, 'peekAll');
     }
     macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
       if (!test) {
-        throw new Error(`You need to pass a model name to the store's query method`);
+        throw new Error(`You need to pass a model name to the store's peekAll method`);
       }
     })(type) : {};
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`You need to pass a query hash to the store's query method`);
-      }
-    })(query) : {};
     macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
       if (!test) {
         throw new Error(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${type}`);
       }
     })(typeof type === 'string') : {};
-    const promise = this.request({
-      op: 'query',
-      data: {
-        type: normalizeModelName(type),
-        query,
-        options: options
-      },
-      cacheOptions: {
-        [SkipCache]: true
-      }
-    });
-    return promise.then(document => document.content);
+    return this.recordArrayManager.liveArrayFor(normalizeModelName(type));
   }
 
   /**
-    This method makes a request for one record, where the `id` is not known
-    beforehand (if the `id` is known, use [`findRecord`](../methods/findRecord?anchor=findRecord)
-    instead).
-     This method can be used when it is certain that the server will return a
-    single object for the primary data.
-     Each time this method is called a new request is made through the adapter.
-     Let's assume our API provides an endpoint for the currently logged in user
-    via:
-     ```
-    // GET /api/current_user
-    {
-      user: {
-        id: 1234,
-        username: 'admin'
-      }
-    }
-    ```
-     Since the specific `id` of the `user` is not known beforehand, we can use
-    `queryRecord` to get the user:
-     ```javascript
-    store.queryRecord('user', {}).then(function(user) {
-      let username = user.username;
-      // do thing
-    });
-    ```
-     The request is made through the adapters' `queryRecord`:
-     ```js [app/adapters/user.js]
-    import Adapter from '@ember-data/adapter';
-    import $ from 'jquery';
-     export default class UserAdapter extends Adapter {
-      queryRecord(modelName, query) {
-        return $.getJSON('/api/current_user');
-      }
-    }
-    ```
-     Note: the primary use case for `store.queryRecord` is when a single record
-    is queried and the `id` is not known beforehand. In all other cases
-    `store.query` and using the first item of the array is likely the preferred
-    way:
-     ```
-    // GET /users?username=unique
-    {
-      data: [{
-        id: 1234,
-        type: 'user',
-        attributes: {
-          username: "unique"
-        }
-      }]
-    }
-    ```
-     ```javascript
-    store.query('user', { username: 'unique' }).then(function(users) {
-      return users.firstObject;
-    }).then(function(user) {
-      let id = user.id;
-    });
-    ```
-     This method returns a promise, which resolves with the found record.
-     If the adapter returns no data for the primary data of the payload, then
-    `queryRecord` resolves with `null`:
-     ```
-    // GET /users?username=unique
-    {
-      data: null
-    }
-    ```
+    This method unloads all records in the store.
+    It schedules unloading to happen during the next run loop.
+     Optionally you can pass a type which unload all records for a given type.
      ```javascript
-    store.queryRecord('user', { username: 'unique' }).then(function(user) {
-       // user is null
-    });
+    store.unloadAll();
+    store.unloadAll('post');
     ```
-     @since 1.13.0
+     @param {String} type the name of the resource
     @public
-    @param {String} type
-    @param {Object} query an opaque query to be used by the adapter
-    @param {Object} options optional, may include `adapterOptions` hash which will be passed to adapter.queryRecord
-    @return {Promise} promise which resolves with the found record or `null`
   */
 
-  queryRecord(type, query, options) {
+  unloadAll(type) {
     if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
-      assertDestroyingStore(this, 'queryRecord');
+      assertDestroyedStoreOnly(this, 'unloadAll');
     }
     macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
       if (!test) {
-        throw new Error(`You need to pass a model name to the store's queryRecord method`);
+        throw new Error(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${String(type)}`);
       }
-    })(type) : {};
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`You need to pass a query hash to the store's queryRecord method`);
-      }
-    })(query) : {};
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${type}`);
-      }
-    })(typeof type === 'string') : {};
-    const promise = this.request({
-      op: 'queryRecord',
-      data: {
-        type: normalizeModelName(type),
-        query,
-        options: options || {}
-      },
-      cacheOptions: {
-        [SkipCache]: true
-      }
-    });
-    return promise.then(document => document.content);
-  }
-
-  /**
-    `findAll` asks the adapter's `findAll` method to find the records for the
-    given type, and returns a promise which will resolve with all records of
-    this type present in the store, even if the adapter only returns a subset
-    of them.
-     ```js [app/routes/authors.js]
-    export default class AuthorsRoute extends Route {
-      model(params) {
-        return this.store.findAll('author');
-      }
-    }
-    ```
-     _When_ the returned promise resolves depends on the reload behavior,
-    configured via the passed `options` hash and the result of the adapter's
-    `shouldReloadAll` method.
-     ### Reloading
-     If `{ reload: true }` is passed or `adapter.shouldReloadAll` evaluates to
-    `true`, then the returned promise resolves once the adapter returns data,
-    regardless if there are already records in the store:
-     ```js
-    store.push({
-      data: {
-        id: 'first',
-        type: 'author'
-      }
-    });
-     // adapter#findAll resolves with
-    // [
-    //   {
-    //     id: 'second',
-    //     type: 'author'
-    //   }
-    // ]
-    store.findAll('author', { reload: true }).then(function(authors) {
-      authors.getEach('id'); // ['first', 'second']
-    });
-    ```
-     If no reload is indicated via the above mentioned ways, then the promise
-    immediately resolves with all the records currently loaded in the store.
-     ### Background Reloading
-     Optionally, if `adapter.shouldBackgroundReloadAll` evaluates to `true`,
-    then a background reload is started. Once this resolves, the array with
-    which the promise resolves, is updated automatically so it contains all the
-    records in the store:
-     ```js [app/adapters/application.js]
-    import Adapter from '@ember-data/adapter';
-     export default class ApplicationAdapter extends Adapter {
-      shouldReloadAll(store, snapshotsArray) {
-        return false;
-      },
-       shouldBackgroundReloadAll(store, snapshotsArray) {
-        return true;
-      }
-    });
-     // ...
-     store.push({
-      data: {
-        id: 'first',
-        type: 'author'
-      }
-    });
-     let allAuthors;
-    store.findAll('author').then(function(authors) {
-      authors.getEach('id'); // ['first']
-       allAuthors = authors;
-    });
-     // later, once adapter#findAll resolved with
-    // [
-    //   {
-    //     id: 'second',
-    //     type: 'author'
-    //   }
-    // ]
-     allAuthors.getEach('id'); // ['first', 'second']
-    ```
-     If you would like to force or prevent background reloading, you can set a
-    boolean value for `backgroundReload` in the options object for
-    `findAll`.
-     ```js [app/routes/post/edit.js]
-    export default class PostEditRoute extends Route {
-      model() {
-        return this.store.findAll('post', { backgroundReload: false });
-      }
-    }
-    ```
-     If you pass an object on the `adapterOptions` property of the options
-    argument it will be passed to you adapter via the `snapshotRecordArray`
-     ```js [app/routes/posts.js]
-    export default class PostsRoute extends Route {
-      model(params) {
-        return this.store.findAll('post', {
-          adapterOptions: { subscribe: false }
-        });
-      }
-    }
-    ```
-     ```js [app/adapters/post.js]
-    import MyCustomAdapter from './custom-adapter';
-     export default class UserAdapter extends MyCustomAdapter {
-      findAll(store, type, sinceToken, snapshotRecordArray) {
-        if (snapshotRecordArray.adapterOptions.subscribe) {
-          // ...
-        }
-        // ...
-      }
-    }
-    ```
-     See [peekAll](../methods/peekAll?anchor=peekAll) to get an array of current records in the
-    store, without waiting until a reload is finished.
-     ### Retrieving Related Model Records
-     If you use an adapter such as Ember's default
-    [`JSONAPIAdapter`](/ember-data/release/classes/JSONAPIAdapter)
-    that supports the [JSON API specification](http://jsonapi.org/) and if your server
-    endpoint supports the use of an
-    ['include' query parameter](http://jsonapi.org/format/#fetching-includes),
-    you can use `findAll()` to automatically retrieve additional records related to
-    those requested by supplying an `include` parameter in the `options` object.
-     For example, given a `post` model that has a `hasMany` relationship with a `comment`
-    model, when we retrieve all of the post records we can have the server also return
-    all of the posts' comments in the same request:
-     ```js [app/routes/posts.js]
-    export default class PostsRoute extends Route {
-      model() {
-        return this.store.findAll('post', { include: ['comments'] });
-      }
-    }
-    ```
-    Multiple relationships can be requested using an `include` parameter consisting of a
-    list or relationship names, while nested relationships can be specified
-    using a dot-separated sequence of relationship names. So to request both the posts'
-    comments and the authors of those comments the request would look like this:
-     ```js [app/routes/posts.js]
-    export default class PostsRoute extends Route {
-      model() {
-        return this.store.findAll('post', { include: ['comments','comments.author'] });
-      }
-    }
-    ```
-     See [query](../methods/query?anchor=query) to only get a subset of records from the server.
-     @since 1.13.0
-    @public
-    @param {String} type the name of the resource
-    @param {Object} options
-    @return {Promise} promise
-  */
-
-  findAll(type, options = {}) {
-    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
-      assertDestroyingStore(this, 'findAll');
-    }
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`You need to pass a model name to the store's findAll method`);
-      }
-    })(type) : {};
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${type}`);
-      }
-    })(typeof type === 'string') : {};
-    const promise = this.request({
-      op: 'findAll',
-      data: {
-        type: normalizeModelName(type),
-        options: options || {}
-      },
-      cacheOptions: {
-        [SkipCache]: true
-      }
-    });
-    return promise.then(document => document.content);
-  }
-
-  /**
-    This method returns a filtered array that contains all of the
-    known records for a given type in the store.
-     Note that because it's just a filter, the result will contain any
-    locally created records of the type, however, it will not make a
-    request to the backend to retrieve additional records. If you
-    would like to request all the records from the backend please use
-    [store.findAll](../methods/findAll?anchor=findAll).
-     Also note that multiple calls to `peekAll` for a given type will always
-    return the same `RecordArray`.
-     Example
-     ```javascript
-    let localPosts = store.peekAll('post');
-    ```
-     @since 1.13.0
-    @public
-    @param {String} type the name of the resource
-    @return {RecordArray}
-  */
-
-  peekAll(type) {
-    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
-      assertDestroyingStore(this, 'peekAll');
-    }
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`You need to pass a model name to the store's peekAll method`);
-      }
-    })(type) : {};
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${type}`);
-      }
-    })(typeof type === 'string') : {};
-    return this.recordArrayManager.liveArrayFor(normalizeModelName(type));
-  }
-
-  /**
-    This method unloads all records in the store.
-    It schedules unloading to happen during the next run loop.
-     Optionally you can pass a type which unload all records for a given type.
-     ```javascript
-    store.unloadAll();
-    store.unloadAll('post');
-    ```
-     @param {String} type the name of the resource
-    @public
-  */
-
-  unloadAll(type) {
-    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
-      assertDestroyedStoreOnly(this, 'unloadAll');
-    }
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${String(type)}`);
-      }
-    })(!type || typeof type === 'string') : {};
-    this._join(() => {
-      if (type === undefined) {
-        // destroy the graph before unloadAll
-        // since then we avoid churning relationships
-        // during unload
-        this._graph?.identifiers.clear();
-        this.recordArrayManager.clear();
-        this._instanceCache.clear();
-      } else {
-        this._instanceCache.clear(normalizeModelName(type));
+    })(!type || typeof type === 'string') : {};
+    this._join(() => {
+      if (type === undefined) {
+        // destroy the graph before unloadAll
+        // since then we avoid churning relationships
+        // during unload
+        this._graph?.identifiers.clear();
+        this.recordArrayManager.clear();
+        this._instanceCache.clear();
+      } else {
+        this._instanceCache.clear(normalizeModelName(type));
       }
     });
   }
@@ -6241,81 +5065,10 @@ class Store extends BaseClass {
     return 'data' in ret ? ret.data : null;
   }
 
-  /**
-   * Trigger a save for a Record.
-   *
-   * Returns a promise resolving with the same record when the save is complete.
-   *
-   * @public
-   * @param {unknown} record
-   * @param options
-   * @return {Promise<record>}
-   */
-  saveRecord(record, options = {}) {
-    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
-      assertDestroyingStore(this, 'saveRecord');
-    }
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`Unable to initiate save for a record in a disconnected state`);
-      }
-    })(storeFor(record)) : {};
-    const identifier = recordIdentifierFor(record);
-    const cache = this.cache;
-    if (!identifier) {
-      // this commonly means we're disconnected
-      // but just in case we reject here to prevent bad things.
-      return Promise.reject(new Error(`Record Is Disconnected`));
-    }
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`Cannot initiate a save request for an unloaded record: ${identifier.lid}`);
-      }
-    })(this._instanceCache.recordIsLoaded(identifier)) : {};
-    if (resourceIsFullyDeleted(this._instanceCache, identifier)) {
-      return Promise.resolve(record);
-    }
-    if (!options) {
-      options = {};
-    }
-    let operation = 'updateRecord';
-    if (cache.isNew(identifier)) {
-      operation = 'createRecord';
-    } else if (cache.isDeleted(identifier)) {
-      operation = 'deleteRecord';
-    }
-    const request = {
-      op: operation,
-      data: {
-        options,
-        record: identifier
-      },
-      records: [identifier],
-      cacheOptions: {
-        [SkipCache]: true
-      }
-    };
-    return this.request(request).then(document => document.content);
-  }
-
-  /**
-   * Instantiation hook allowing applications or addons to configure the store
-   * to utilize a custom Cache implementation.
-   *
-   * This hook should not be called directly by consuming applications or libraries.
-   * Use `Store.cache` to access the Cache instance.
-   *
-   * @public
-   * @param storeWrapper
-   * @return {Cache}
-   */
-
   /**
    * Returns the cache instance associated to this Store, instantiates the Cache
    * if necessary via `Store.createCache`
    *
-   * @property cache
-   * @type {Cache}
    * @public
    */
   get cache() {
@@ -6330,6 +5083,8 @@ class Store extends BaseClass {
     }
     return cache;
   }
+
+  /** @internal */
   destroy() {
     if (this.isDestroyed) {
       // @ember/test-helpers will call destroy multiple times
@@ -6344,6 +5099,12 @@ class Store extends BaseClass {
     this.unloadAll();
     this.isDestroyed = true;
   }
+
+  /**
+   * This method
+   *
+   * @private
+   */
   static create(args) {
     return new this(args);
   }
@@ -6487,6 +5248,748 @@ function extractIdentifierFromRecord$1(recordOrPromiseRecord) {
   const extract = recordIdentifierFor;
   return extract(recordOrPromiseRecord);
 }
+
+/*
+    When a find request is triggered on the store, the user can optionally pass in
+    attributes and relationships to be preloaded. These are meant to behave as if they
+    came back from the server, except the user obtained them out of band and is informing
+    the store of their existence. The most common use case is for supporting client side
+    nested URLs, such as `/posts/1/comments/2` so the user can do
+    `store.findRecord('comment', 2, { preload: { post: 1 } })` without having to fetch the post.
+
+    Preloaded data can be attributes and relationships passed in either as IDs or as actual
+    models.
+  */
+function preloadData(store, identifier, preload) {
+  const jsonPayload = {};
+  //TODO(Igor) consider the polymorphic case
+  const schemas = store.schema;
+  const fields = schemas.fields(identifier);
+  Object.keys(preload).forEach(key => {
+    const preloadValue = preload[key];
+    const field = fields.get(key);
+    if (field && (field.kind === 'hasMany' || field.kind === 'belongsTo')) {
+      if (!jsonPayload.relationships) {
+        jsonPayload.relationships = {};
+      }
+      jsonPayload.relationships[key] = preloadRelationship(field, preloadValue);
+    } else {
+      if (!jsonPayload.attributes) {
+        jsonPayload.attributes = {};
+      }
+      jsonPayload.attributes[key] = preloadValue;
+    }
+  });
+  const cache = store.cache;
+  const hasRecord = Boolean(store._instanceCache.peek(identifier));
+  cache.upsert(identifier, jsonPayload, hasRecord);
+}
+function preloadRelationship(schema, preloadValue) {
+  const relatedType = schema.type;
+  if (schema.kind === 'hasMany') {
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error('You need to pass in an array to set a hasMany property on a record');
+      }
+    })(Array.isArray(preloadValue)) : {};
+    return {
+      data: preloadValue.map(value => _convertPreloadRelationshipToJSON(value, relatedType))
+    };
+  }
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error('You should not pass in an array to set a belongsTo property on a record');
+    }
+  })(!Array.isArray(preloadValue)) : {};
+  return {
+    data: preloadValue ? _convertPreloadRelationshipToJSON(preloadValue, relatedType) : null
+  };
+}
+
+/*
+  findRecord('user', '1', { preload: { friends: ['1'] }});
+  findRecord('user', '1', { preload: { friends: [record] }});
+*/
+function _convertPreloadRelationshipToJSON(value, type) {
+  if (typeof value === 'string' || typeof value === 'number') {
+    return {
+      type,
+      id: ensureStringId(value)
+    };
+  }
+  // TODO if not a record instance assert it's an identifier
+  // and allow identifiers to be used
+  return recordIdentifierFor(value);
+}
+
+/**
+ * Minimum subset of static schema methods and properties on the
+ * "model" class.
+ *
+ * Only used when using the legacy schema-service implementation
+ * for @ember-data/model or when wrapping schema for legacy
+ * Adapters/Serializers.
+ *
+ */
+
+function _resourceIsFullDeleted(identifier, cache) {
+  return cache.isDeletionCommitted(identifier) || cache.isNew(identifier) && cache.isDeleted(identifier);
+}
+function resourceIsFullyDeleted(instanceCache, identifier) {
+  const cache = instanceCache.cache;
+  return !cache || _resourceIsFullDeleted(identifier, cache);
+}
+
+/**
+   A `RecordReference` is a low-level API that allows users and
+   addon authors to perform meta-operations on a record.
+
+   @hideconstructor
+   @public
+*/
+class RecordReference {
+  /** @internal */
+
+  // unsubscribe token given to us by the notification manager
+  /** @internal */
+  ___token;
+  /** @internal */
+  ___identifier;
+  /** @internal */
+
+  constructor(store, identifier) {
+    this.store = store;
+    this.___identifier = identifier;
+    this.___token = store.notifications.subscribe(identifier, (_, bucket, notifiedKey) => {
+      if (bucket === 'identity' || bucket === 'attributes' && notifiedKey === 'id') {
+        this._ref++;
+      }
+    });
+  }
+
+  /** @internal */
+  destroy() {
+    this.store.notifications.unsubscribe(this.___token);
+  }
+  get type() {
+    return this.identifier().type;
+  }
+
+  /**
+     The `id` of the record that this reference refers to.
+      Together, the `type` and `id` properties form a composite key for
+     the identity map.
+      Example
+      ```javascript
+     let userRef = store.getReference('user', 1);
+      userRef.id(); // '1'
+     ```
+     @public
+    @return The id of the record.
+  */
+  id() {
+    // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+    this._ref; // consume the tracked prop
+    return this.___identifier.id;
+  }
+
+  /**
+     The `identifier` of the record that this reference refers to.
+      Together, the `type` and `id` properties form a composite key for
+     the identity map.
+      Example
+      ```javascript
+     let userRef = store.getReference('user', 1);
+      userRef.identifier(); // '1'
+     ```
+     @public
+    @return The identifier of the record.
+  */
+  identifier() {
+    return this.___identifier;
+  }
+
+  /**
+     How the reference will be looked up when it is loaded. Currently
+     this always returns `identity` to signify that a record will be
+     loaded by its `type` and `id`.
+      Example
+      ```javascript
+     const userRef = store.getReference('user', 1);
+      userRef.remoteType(); // 'identity'
+     ```
+      @public
+  */
+  remoteType() {
+    return 'identity';
+  }
+
+  /**
+    This API allows you to provide a reference with new data. The
+    simplest usage of this API is similar to `store.push`: you provide a
+    normalized hash of data and the object represented by the reference
+    will update.
+     If you pass a promise to `push`, Ember Data will not ask the adapter
+    for the data if another attempt to fetch it is made in the
+    interim. When the promise resolves, the underlying object is updated
+    with the new data, and the promise returned by *this function* is resolved
+    with that object.
+     For example, `recordReference.push(promise)` will be resolved with a
+    record.
+      Example
+      ```javascript
+     let userRef = store.getReference('user', 1);
+      // provide data for reference
+     userRef.push({
+       data: {
+         id: "1",
+         type: "user",
+         attributes: {
+           username: "@user"
+         }
+       }
+     }).then(function(user) {
+       userRef.value() === user;
+     });
+     ```
+     @public
+    @param objectOrPromise a JSON:API ResourceDocument or a promise resolving to one
+    @return a promise for the value (record or relationship)
+  */
+  push(objectOrPromise) {
+    // TODO @deprecate pushing unresolved payloads
+    return Promise.resolve(objectOrPromise).then(data => {
+      return this.store.push(data);
+    });
+  }
+
+  /**
+    If the entity referred to by the reference is already loaded, it is
+    present as `reference.value`. Otherwise the value returned by this function
+    is `null`.
+      Example
+      ```javascript
+     let userRef = store.getReference('user', 1);
+      userRef.value(); // user
+     ```
+     @public
+    @return the record for this RecordReference
+  */
+  value() {
+    return this.store.peekRecord(this.___identifier);
+  }
+
+  /**
+     Triggers a fetch for the backing entity based on its `remoteType`
+     (see `remoteType` definitions per reference type).
+      Example
+      ```javascript
+     let userRef = store.getReference('user', 1);
+      // load user (via store.find)
+     userRef.load().then(...)
+     ```
+     @public
+    @return the record for this RecordReference
+  */
+  load() {
+    const id = this.id();
+    if (id !== null) {
+      return this.store.findRecord(this.type, id);
+    }
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      {
+        throw new Error(`Unable to fetch record of type ${this.type} without an id`);
+      }
+    })() : {};
+  }
+
+  /**
+     Reloads the record if it is already loaded. If the record is not
+     loaded it will load the record via `store.findRecord`
+      Example
+      ```javascript
+     let userRef = store.getReference('user', 1);
+      // or trigger a reload
+     userRef.reload().then(...)
+     ```
+     @public
+    @return the record for this RecordReference
+  */
+  reload() {
+    const id = this.id();
+    if (id !== null) {
+      return this.store.findRecord(this.type, id, {
+        reload: true
+      });
+    }
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      {
+        throw new Error(`Unable to fetch record of type ${this.type} without an id`);
+      }
+    })() : {};
+  }
+}
+defineSignal(RecordReference.prototype, '_ref');
+
+// if modelFor turns out to be a bottleneck we should replace with a Map
+// and clear it during store teardown.
+const AvailableShims = getOrSetGlobal('AvailableShims', new WeakMap());
+function getShimClass(store, modelName) {
+  let shims = AvailableShims.get(store);
+  if (!shims) {
+    shims = Object.create(null);
+    AvailableShims.set(store, shims);
+  }
+  let shim = shims[modelName];
+  if (shim === undefined) {
+    shim = shims[modelName] = new ShimModelClass(store, modelName);
+  }
+  return shim;
+}
+
+// Mimics the static apis of @ember-data/model
+class ShimModelClass {
+  constructor(store, modelName) {
+    this.__store = store;
+    this.modelName = modelName;
+  }
+  get fields() {
+    const fields = new Map();
+    const fieldSchemas = this.__store.schema.fields({
+      type: this.modelName
+    });
+    fieldSchemas.forEach((schema, key) => {
+      if (schema.kind === 'attribute' || schema.kind === 'belongsTo' || schema.kind === 'hasMany') {
+        fields.set(key, schema.kind);
+      }
+    });
+    return fields;
+  }
+  get attributes() {
+    const attrs = new Map();
+    const fields = this.__store.schema.fields({
+      type: this.modelName
+    });
+    fields.forEach((schema, key) => {
+      if (schema.kind === 'attribute') {
+        attrs.set(key, schema);
+      }
+    });
+    return attrs;
+  }
+  get relationshipsByName() {
+    const rels = new Map();
+    const fields = this.__store.schema.fields({
+      type: this.modelName
+    });
+    fields.forEach((schema, key) => {
+      if (schema.kind === 'belongsTo' || schema.kind === 'hasMany') {
+        rels.set(key, schema);
+      }
+    });
+    return rels;
+  }
+  eachAttribute(callback, binding) {
+    this.__store.schema.fields({
+      type: this.modelName
+    }).forEach((schema, key) => {
+      if (schema.kind === 'attribute') {
+        callback.call(binding, key, schema);
+      }
+    });
+  }
+  eachRelationship(callback, binding) {
+    this.__store.schema.fields({
+      type: this.modelName
+    }).forEach((schema, key) => {
+      if (schema.kind === 'belongsTo' || schema.kind === 'hasMany') {
+        callback.call(binding, key, schema);
+      }
+    });
+  }
+  eachTransformedAttribute(callback, binding) {
+    this.__store.schema.fields({
+      type: this.modelName
+    }).forEach((schema, key) => {
+      if (schema.kind === 'attribute') {
+        const type = schema.type;
+        if (type) callback.call(binding, key, type);
+      }
+    });
+  }
+}
+if (macroCondition(getGlobalConfig().WarpDrive.deprecations.ENABLE_LEGACY_REQUEST_METHODS)) {
+  Store.prototype.findRecord = function (resource, id, options) {
+    deprecate(`store.findRecord is deprecated. Use store.request instead.`, false, {
+      id: 'warp-drive:deprecate-legacy-request-methods',
+      until: '6.0',
+      for: '@warp-drive/core',
+      url: 'https://docs.warp-drive.io/api/@warp-drive/core/build-config/deprecations/variables/ENABLE_LEGACY_REQUEST_METHODS',
+      since: {
+        enabled: '5.7',
+        available: '5.7'
+      }
+    });
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Attempted to call store.findRecord(), but the store instance has already been destroyed.`);
+      }
+    })(!(this.isDestroying || this.isDestroyed)) : {};
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`You need to pass a modelName or resource identifier as the first argument to the store's findRecord method`);
+      }
+    })(resource) : {};
+    if (isMaybeIdentifier(resource)) {
+      options = id;
+    } else {
+      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        if (!test) {
+          throw new Error(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${resource}`);
+        }
+      })(typeof resource === 'string') : {};
+      const type = normalizeModelName(resource);
+      const normalizedId = ensureStringId(id);
+      resource = constructResource(type, normalizedId);
+    }
+    const identifier = this.identifierCache.getOrCreateRecordIdentifier(resource);
+    options = options || {};
+    if (options.preload) {
+      // force reload if we preload to ensure we don't resolve the promise
+      // until we are complete, else we will end up background-reloading
+      // even for initial load.
+      if (!this._instanceCache.recordIsLoaded(identifier)) {
+        options.reload = true;
+      }
+      this._join(() => {
+        preloadData(this, identifier, options.preload);
+      });
+    }
+    const promise = this.request({
+      op: 'findRecord',
+      data: {
+        record: identifier,
+        options
+      },
+      cacheOptions: {
+        [SkipCache]: true
+      }
+    });
+    return promise.then(document => {
+      return document.content;
+    });
+  };
+  Store.prototype.findAll = function (type, options = {}) {
+    deprecate(`store.findAll is deprecated. Use store.request instead.`, false, {
+      id: 'warp-drive:deprecate-legacy-request-methods',
+      until: '6.0',
+      for: '@warp-drive/core',
+      url: 'https://docs.warp-drive.io/api/@warp-drive/core/build-config/deprecations/variables/ENABLE_LEGACY_REQUEST_METHODS',
+      since: {
+        enabled: '5.7',
+        available: '5.7'
+      }
+    });
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Attempted to call store.findAll(), but the store instance has already been destroyed.`);
+      }
+    })(!(this.isDestroying || this.isDestroyed)) : {};
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`You need to pass a model name to the store's findAll method`);
+      }
+    })(type) : {};
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${type}`);
+      }
+    })(typeof type === 'string') : {};
+    const promise = this.request({
+      op: 'findAll',
+      data: {
+        type: normalizeModelName(type),
+        options: options || {}
+      },
+      cacheOptions: {
+        [SkipCache]: true
+      }
+    });
+    return promise.then(document => document.content);
+  };
+  Store.prototype.query = function (type, query, options = {}) {
+    deprecate(`store.query is deprecated. Use store.request instead.`, false, {
+      id: 'warp-drive:deprecate-legacy-request-methods',
+      until: '6.0',
+      for: '@warp-drive/core',
+      url: 'https://docs.warp-drive.io/api/@warp-drive/core/build-config/deprecations/variables/ENABLE_LEGACY_REQUEST_METHODS',
+      since: {
+        enabled: '5.7',
+        available: '5.7'
+      }
+    });
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Attempted to call store.query(), but the store instance has already been destroyed.`);
+      }
+    })(!(this.isDestroying || this.isDestroyed)) : {};
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`You need to pass a model name to the store's query method`);
+      }
+    })(type) : {};
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`You need to pass a query hash to the store's query method`);
+      }
+    })(query) : {};
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${type}`);
+      }
+    })(typeof type === 'string') : {};
+    const promise = this.request({
+      op: 'query',
+      data: {
+        type: normalizeModelName(type),
+        query,
+        options: options
+      },
+      cacheOptions: {
+        [SkipCache]: true
+      }
+    });
+    return promise.then(document => document.content);
+  };
+  Store.prototype.queryRecord = function (type, query, options) {
+    deprecate(`store.queryRecord is deprecated. Use store.request instead.`, false, {
+      id: 'warp-drive:deprecate-legacy-request-methods',
+      until: '6.0',
+      for: '@warp-drive/core',
+      url: 'https://docs.warp-drive.io/api/@warp-drive/core/build-config/deprecations/variables/ENABLE_LEGACY_REQUEST_METHODS',
+      since: {
+        enabled: '5.7',
+        available: '5.7'
+      }
+    });
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Attempted to call store.queryRecord(), but the store instance has already been destroyed.`);
+      }
+    })(!(this.isDestroying || this.isDestroyed)) : {};
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`You need to pass a model name to the store's queryRecord method`);
+      }
+    })(type) : {};
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`You need to pass a query hash to the store's queryRecord method`);
+      }
+    })(query) : {};
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${type}`);
+      }
+    })(typeof type === 'string') : {};
+    const promise = this.request({
+      op: 'queryRecord',
+      data: {
+        type: normalizeModelName(type),
+        query,
+        options: options || {}
+      },
+      cacheOptions: {
+        [SkipCache]: true
+      }
+    });
+    return promise.then(document => document.content);
+  };
+  Store.prototype.getReference = function (resource, id) {
+    deprecate(`store.getReference is deprecated. There is no direct replacement. For working with the cache and relationships, use the cache with the appropriate identifiers. To load, use store.request.`, false, {
+      id: 'warp-drive:deprecate-legacy-request-methods',
+      until: '6.0',
+      for: '@warp-drive/core',
+      url: 'https://docs.warp-drive.io/api/@warp-drive/core/build-config/deprecations/variables/ENABLE_LEGACY_REQUEST_METHODS',
+      since: {
+        enabled: '5.7',
+        available: '5.7'
+      }
+    });
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Attempted to call store.getReference(), but the store instance has already been destroyed.`);
+      }
+    })(!(this.isDestroying || this.isDestroyed)) : {};
+    let resourceIdentifier;
+    if (arguments.length === 1 && isMaybeIdentifier(resource)) {
+      resourceIdentifier = resource;
+    } else {
+      const type = normalizeModelName(resource);
+      const normalizedId = ensureStringId(id);
+      resourceIdentifier = constructResource(type, normalizedId);
+    }
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error('getReference expected to receive either a resource identifier or type and id as arguments');
+      }
+    })(isMaybeIdentifier(resourceIdentifier)) : {};
+    const identifier = this.identifierCache.getOrCreateRecordIdentifier(resourceIdentifier);
+    const cache = upgradeInstanceCaches(this._instanceCache.__instances).reference;
+    let reference = cache.get(identifier);
+    if (!reference) {
+      reference = new RecordReference(this, identifier);
+      cache.set(identifier, reference);
+    }
+    return reference;
+  };
+  Store.prototype.modelFor = function (type) {
+    deprecate(`store.modelFor is deprecated, please use store.schema.fields({ type: '${type}' }) to access schema information instead.`, false, {
+      id: 'warp-drive:deprecate-legacy-request-methods',
+      until: '6.0',
+      for: '@warp-drive/core',
+      url: 'https://docs.warp-drive.io/api/@warp-drive/core/build-config/deprecations/variables/ENABLE_LEGACY_REQUEST_METHODS',
+      since: {
+        enabled: '5.7',
+        available: '5.7'
+      }
+    });
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Attempted to call store.modelFor(), but the store instance has already been destroyed.`);
+      }
+    })(!this.isDestroyed) : {};
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`You need to pass <type> to the store's modelFor method`);
+      }
+    })(typeof type === 'string' && type.length) : {};
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`No model was found for '${type}' and no schema handles the type`);
+      }
+    })(this.schema.hasResource({
+      type
+    })) : {};
+    return getShimClass(this, type);
+  };
+  Store.prototype.saveRecord = function (record, options = {}) {
+    deprecate(`store.saveRecord is deprecated, please use store.request to initiate a save request instead.`, false, {
+      id: 'warp-drive:deprecate-legacy-request-methods',
+      until: '6.0',
+      for: '@warp-drive/core',
+      url: 'https://docs.warp-drive.io/api/@warp-drive/core/build-config/deprecations/variables/ENABLE_LEGACY_REQUEST_METHODS',
+      since: {
+        enabled: '5.7',
+        available: '5.7'
+      }
+    });
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Attempted to call store.saveRecord(), but the store instance has already been destroyed.`);
+      }
+    })(!(this.isDestroying || this.isDestroyed)) : {};
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Unable to initiate save for a record in a disconnected state`);
+      }
+    })(storeFor(record)) : {};
+    const identifier = recordIdentifierFor(record);
+    const cache = this.cache;
+    if (!identifier) {
+      // this commonly means we're disconnected
+      // but just in case we reject here to prevent bad things.
+      return Promise.reject(new Error(`Record Is Disconnected`));
+    }
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Cannot initiate a save request for an unloaded record: ${identifier.lid}`);
+      }
+    })(this._instanceCache.recordIsLoaded(identifier)) : {};
+    if (resourceIsFullyDeleted(this._instanceCache, identifier)) {
+      return Promise.resolve(record);
+    }
+    if (!options) {
+      options = {};
+    }
+    let operation = 'updateRecord';
+    if (cache.isNew(identifier)) {
+      operation = 'createRecord';
+    } else if (cache.isDeleted(identifier)) {
+      operation = 'deleteRecord';
+    }
+    const request = {
+      op: operation,
+      data: {
+        options,
+        record: identifier
+      },
+      records: [identifier],
+      cacheOptions: {
+        [SkipCache]: true
+      }
+    };
+    return this.request(request).then(document => document.content);
+  };
+}
+function upgradeInstanceCaches(cache) {
+  const withReferences = cache;
+  if (!withReferences.reference) {
+    withReferences.reference = new WeakMap();
+  }
+  return withReferences;
+}
+function isNonEmptyString(str) {
+  return Boolean(str && typeof str === 'string');
+}
+function constructResource(type, id, lid) {
+  if (typeof type === 'object' && type !== null) {
+    const resource = type;
+    if (isStableIdentifier(resource)) {
+      return resource;
+    }
+    if ('id' in resource) {
+      resource.id = coerceId(resource.id);
+    }
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error('Expected either id or lid to be a valid string');
+      }
+    })('id' in resource && isNonEmptyString(resource.id) || isNonEmptyString(resource.lid)) : {};
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error('if id is present, the type must be a string');
+      }
+    })(!('id' in resource) || typeof resource.type === 'string') : {};
+    return resource;
+  } else {
+    const trueId = coerceId(id);
+    if (!isNonEmptyString(trueId)) {
+      if (isNonEmptyString(lid)) {
+        return {
+          lid
+        };
+      }
+      throw new Error('Expected either id or lid to be a valid string');
+    }
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error('type must be a string');
+      }
+    })(typeof type === 'string') : {};
+    if (isNonEmptyString(lid)) {
+      return {
+        type,
+        id: trueId,
+        lid
+      };
+    }
+    return {
+      type,
+      id: trueId
+    };
+  }
+}
 function _MUTATE(target, receiver, prop, args, _SIGNAL) {
   const collection = receiver;
   switch (prop) {
@@ -8136,4 +7639,4 @@ function getRequestState(future) {
   }
   return state;
 }
-export { Signals as A, peekInternalSignal as B, Collection as C, DISPOSE as D, withSignalStore as E, notifyInternalSignal as F, consumeInternalSignal as G, getOrCreateInternalSignal as H, IdentifierArray as I, ReactiveDocument as J, setIdentifierGenerationMethod as K, setIdentifierUpdateMethod as L, MUTATE as M, setIdentifierForgetMethod as N, setIdentifierResetMethod as O, setKeyInfoForResource as P, isExtensionProp as Q, RecordArrayManager as R, Store as S, performExtensionSet as T, performArrayExtensionGet as U, performObjectExtensionGet as V, _clearCaches as _, isDocumentIdentifier as a, coerceId as b, constructResource as c, SOURCE as d, ensureStringId as e, fastPush as f, removeRecordDataFor as g, setRecordIdentifier as h, isStableIdentifier as i, StoreMap as j, setCacheFor as k, RelatedCollection as l, log as m, normalizeModelName as n, logGroup as o, peekCache as p, getPromiseState as q, recordIdentifierFor as r, storeFor as s, createRequestSubscription as t, getRequestState as u, memoized as v, gate as w, entangleSignal as x, defineSignal as y, defineNonEnumerableSignal as z };
+export { defineNonEnumerableSignal as A, Signals as B, Collection as C, DISPOSE as D, peekInternalSignal as E, withSignalStore as F, notifyInternalSignal as G, consumeInternalSignal as H, IdentifierArray as I, getOrCreateInternalSignal as J, ReactiveDocument as K, setIdentifierGenerationMethod as L, MUTATE as M, setIdentifierUpdateMethod as N, setIdentifierForgetMethod as O, setIdentifierResetMethod as P, setKeyInfoForResource as Q, RecordArrayManager as R, Store as S, isExtensionProp as T, performExtensionSet as U, performArrayExtensionGet as V, performObjectExtensionGet as W, _clearCaches as _, isDocumentIdentifier as a, coerceId as b, constructResource as c, SOURCE as d, ensureStringId as e, fastPush as f, removeRecordDataFor as g, setRecordIdentifier as h, isStableIdentifier as i, StoreMap as j, setCacheFor as k, RelatedCollection as l, log as m, normalizeModelName as n, logGroup as o, peekCache as p, getPromiseState as q, recordIdentifierFor as r, storeFor as s, createRequestSubscription as t, getRequestState as u, memoized as v, gate as w, entangleSignal as x, defineSignal as y, defineGate as z };