@ember-data/legacy-compat 4.12.7 → 4.13.0-alpha.1

package/{addon/fetch-manager-025964e9.js → dist/-private-BJlhRRce.js}

@@ -1,11 +1,17 @@
-import { macroCondition, getOwnConfig, importSync } from '@embroider/macros';
-import { deprecate, assert, warn } from '@ember/debug';
+import { deprecate, warn } from '@ember/debug';
 import { SOURCE, coerceId } from '@ember-data/store/-private';
+import { macroCondition, getGlobalConfig, dependencySatisfies, importSync } from '@embroider/macros';
 import { createDeferred } from '@ember-data/request';
+import { getOrSetGlobal } from '@warp-drive/core-types/-private';
+
+/**
+  @module @ember-data/legacy-compat
+*/
+
 /**
   SnapshotRecordArray is not directly instantiable.
   Instances are provided to consuming application's
-  adapters for certain requests.
+  adapters for certain `findAll` requests.
 
   @class SnapshotRecordArray
   @public
@@ -135,6 +141,7 @@ class SnapshotRecordArray {
     if (this._snapshots !== null) {
       return this._snapshots;
     }
+    upgradeStore(this.__store);
     const {
       _fetchManager
     } = this.__store;
@@ -142,7 +149,7 @@ class SnapshotRecordArray {
     return this._snapshots;
   }
 }
-if (macroCondition(getOwnConfig().deprecations.DEPRECATE_SNAPSHOT_MODEL_CLASS_ACCESS)) {
+if (macroCondition(getGlobalConfig().WarpDrive.deprecations.DEPRECATE_SNAPSHOT_MODEL_CLASS_ACCESS)) {
   /**
     The type of the underlying records for the snapshots in the array, as a Model
      @deprecated
@@ -161,53 +168,22 @@ if (macroCondition(getOwnConfig().deprecations.DEPRECATE_SNAPSHOT_MODEL_CLASS_AC
           enabled: '4.5.0'
         }
       });
-      // @ts-expect-error
       return this._recordArray.type;
     }
   });
 }
-function _bind(fn, ...args) {
-  return function () {
-    return fn.apply(undefined, args);
-  };
-}
-function _guard(promise, test) {
-  let guarded = promise.finally(() => {
-    if (!test()) {
-      guarded._subscribers ? guarded._subscribers.length = 0 : null;
-    }
-  });
-  return guarded;
-}
-function _objectIsAlive(object) {
-  return !(object.isDestroyed || object.isDestroying);
-}
-function guardDestroyedStore(promise, store) {
-  return promise.then(_v => {
-    if (!_objectIsAlive(store)) {
-      if (macroCondition(getOwnConfig().deprecations.DEPRECATE_RSVP_PROMISE)) {
-        deprecate(`A Promise did not resolve by the time the store was destroyed. This will error in a future release.`, false, {
-          id: 'ember-data:rsvp-unresolved-async',
-          until: '5.0',
-          for: '@ember-data/store',
-          since: {
-            available: '4.5',
-            enabled: '4.5'
-          }
-        });
-      }
-    }
-    return _v;
-  });
-}
 function assertIdentifierHasId(identifier) {
-  assert(`Attempted to schedule a fetch for a record without an id.`, identifier.id !== null);
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Attempted to schedule a fetch for a record without an id.`);
+    }
+  })(identifier && identifier.id !== null) : {};
 }
 function iterateData(data, fn) {
   if (Array.isArray(data)) {
     return data.map(fn);
   } else {
-    return fn(data);
+    return fn(data, 0);
   }
 }
 function payloadIsNotBlank(adapterPayload) {
@@ -227,8 +203,8 @@ function payloadIsNotBlank(adapterPayload) {
   @internal
 */
 function validateDocumentStructure(doc) {
-  if (macroCondition(getOwnConfig().env.DEBUG)) {
-    let errors = [];
+  if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+    const errors = [];
     if (!doc || typeof doc !== 'object') {
       errors.push('Top level of a JSON API document must be an object');
     } else {
@@ -270,11 +246,15 @@ function validateDocumentStructure(doc) {
         }
       }
     }
-    assert(`Response must be normalized to a valid JSON API document:\n\t* ${errors.join('\n\t* ')}`, errors.length === 0);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Response must be normalized to a valid JSON API document:\n\t* ${errors.join('\n\t* ')}`);
+      }
+    })(errors.length === 0) : {};
   }
 }
 function normalizeResponseHelper(serializer, store, modelClass, payload, id, requestType) {
-  let normalizedResponse = serializer ? serializer.normalizeResponse(store, modelClass, payload, id, requestType) : payload;
+  const normalizedResponse = serializer ? serializer.normalizeResponse(store, modelClass, payload, id, requestType) : payload;
   validateDocumentStructure(normalizedResponse);
   return normalizedResponse;
 }
@@ -294,6 +274,14 @@ function normalizeResponseHelper(serializer, store, modelClass, payload, id, req
   @public
 */
 class Snapshot {
+  /**
+   The type of the underlying record for this snapshot, as a Model.
+    @property type
+    @public
+    @deprecated
+   @type {Model}
+   */
+
   /**
    * @method constructor
    * @constructor
@@ -309,10 +297,7 @@ class Snapshot {
     this._belongsToIds = Object.create(null);
     this._hasManyRelationships = Object.create(null);
     this._hasManyIds = Object.create(null);
-    const hasRecord = !!store._instanceCache.peek({
-      identifier,
-      bucket: 'record'
-    });
+    const hasRecord = !!store._instanceCache.peek(identifier);
     this.modelName = identifier.type;
 
     /**
@@ -331,6 +316,7 @@ class Snapshot {
       the values.
      */
     if (hasRecord) {
+      // eslint-disable-next-line @typescript-eslint/no-unused-expressions
       this._attributes;
     }
 
@@ -372,7 +358,7 @@ class Snapshot {
      */
     this.modelName = identifier.type;
     if (hasRecord) {
-      const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? this._store._instanceCache.getResourceCache(identifier) : this._store.cache;
+      const cache = this._store.cache;
       this._changedAttributes = cache.changedAttrs(identifier);
     }
   }
@@ -390,7 +376,11 @@ class Snapshot {
    */
   get record() {
     const record = this._store.peekRecord(this.identifier);
-    assert(`Record ${this.identifier.type} ${String(this.identifier.id)} (${this.identifier.lid}) is not yet loaded and thus cannot be accessed from the Snapshot during serialization`, record !== null);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Record ${this.identifier.type} ${this.identifier.id} (${this.identifier.lid}) is not yet loaded and thus cannot be accessed from the Snapshot during serialization`);
+      }
+    })(record !== null) : {};
     return record;
   }
   get _attributes() {
@@ -401,27 +391,17 @@ class Snapshot {
     const {
       identifier
     } = this;
-    const attrs = Object.keys(this._store.getSchemaDefinitionService().attributesDefinitionFor(identifier));
-    const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? this._store._instanceCache.getResourceCache(identifier) : this._store.cache;
-    attrs.forEach(keyName => {
-      attributes[keyName] = cache.getAttr(identifier, keyName);
+    const attrs = this._store.schema.fields(identifier);
+    const cache = this._store.cache;
+    attrs.forEach((field, keyName) => {
+      if (field.kind === 'attribute') {
+        attributes[keyName] = cache.getAttr(identifier, keyName);
+      }
     });
     return attributes;
   }
-
-  /**
-   The type of the underlying record for this snapshot, as a Model.
-    @property type
-    @public
-    @deprecated
-   @type {Model}
-   */
-
   get isNew() {
-    const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? this._store._instanceCache.peek({
-      identifier: this.identifier,
-      bucket: 'resourceCache'
-    }) : this._store.cache;
+    const cache = this._store.cache;
     return cache?.isNew(this.identifier) || false;
   }
 
@@ -443,7 +423,11 @@ class Snapshot {
     if (keyName in this._attributes) {
       return this._attributes[keyName];
     }
-    assert(`Model '${this.identifier.lid}' has no attribute named '${keyName}' defined.`, false);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      {
+        throw new Error(`Model '${this.identifier.lid}' has no attribute named '${keyName}' defined.`);
+      }
+    })() : {};
   }
 
   /**
@@ -476,13 +460,13 @@ class Snapshot {
    @public
    */
   changedAttributes() {
-    let changedAttributes = Object.create(null);
+    const changedAttributes = Object.create(null);
     if (!this._changedAttributes) {
       return changedAttributes;
     }
-    let changedAttributeKeys = Object.keys(this._changedAttributes);
+    const changedAttributeKeys = Object.keys(this._changedAttributes);
     for (let i = 0, length = changedAttributeKeys.length; i < length; i++) {
-      let key = changedAttributeKeys[i];
+      const key = changedAttributeKeys[i];
       changedAttributes[key] = this._changedAttributes[key].slice();
     }
     return changedAttributes;
@@ -517,40 +501,50 @@ class Snapshot {
    will be returned if the contents of the relationship is unknown.
    */
   belongsTo(keyName, options) {
-    let returnModeIsId = !!(options && options.id);
+    const returnModeIsId = !!(options && options.id);
     let result;
-    let store = this._store;
+    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];
     }
-    let relationshipMeta = store.getSchemaDefinitionService().relationshipsDefinitionFor({
+    const relationshipMeta = store.schema.fields({
       type: this.modelName
-    })[keyName];
-    assert(`Model '${this.identifier.lid}' has no belongsTo relationship named '${keyName}' defined.`, relationshipMeta && relationshipMeta.kind === 'belongsTo');
-
-    // TODO @runspired it seems this code branch would not work with CUSTOM_MODEL_CLASSes
-    // this check is not a regression in behavior because relationships don't currently
-    // function without access to intimate API contracts between RecordData and Model.
-    // This is a requirement we should fix as soon as the relationship layer does not require
-    // this intimate API usage.
-    if (macroCondition(!getOwnConfig().packages.HAS_JSON_API_PACKAGE)) {
-      assert(`snapshot.belongsTo only supported when using the package @ember-data/json-api`);
-    }
+    }).get(keyName);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Model '${this.identifier.lid}' has no belongsTo relationship named '${keyName}' defined.`);
+      }
+    })(relationshipMeta && relationshipMeta.kind === 'belongsTo') : {};
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`snapshot.belongsTo only supported when using the package @ember-data/graph`);
+      }
+    })(dependencySatisfies('@ember-data/graph', '*')) : {};
     const graphFor = importSync('@ember-data/graph/-private').graphFor;
     const {
       identifier
     } = this;
-    const relationship = graphFor(this._store).get(identifier, keyName);
-    assert(`You looked up the ${keyName} belongsTo relationship for { type: ${identifier.type}, id: ${identifier.id || ''}, lid: ${identifier.lid} but no such relationship was found.`, relationship);
-    assert(`You looked up the ${keyName} belongsTo relationship for { type: ${identifier.type}, id: ${identifier.id || ''}, lid: ${identifier.lid} but that relationship is a hasMany.`, relationship.definition.kind === 'belongsTo');
-    let value = relationship.getData();
-    let data = value && value.data;
-    let inverseIdentifier = data ? store.identifierCache.getOrCreateRecordIdentifier(data) : null;
+    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+      const relationship = graphFor(this._store).get(identifier, keyName);
+      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        if (!test) {
+          throw new Error(`You looked up the ${keyName} belongsTo relationship for { type: ${identifier.type}, id: ${identifier.id || ''}, lid: ${identifier.lid} but no such relationship was found.`);
+        }
+      })(relationship) : {};
+      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        if (!test) {
+          throw new Error(`You looked up the ${keyName} belongsTo relationship for { type: ${identifier.type}, id: ${identifier.id || ''}, lid: ${identifier.lid} but that relationship is a hasMany.`);
+        }
+      })(relationship.definition.kind === 'belongsTo') : {};
+    }
+    const value = graphFor(this._store).getData(identifier, keyName);
+    const data = value && value.data;
+    const inverseIdentifier = data ? store.identifierCache.getOrCreateRecordIdentifier(data) : null;
     if (value && value.data !== undefined) {
-      const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? inverseIdentifier && store._instanceCache.getResourceCache(inverseIdentifier) : store.cache;
+      const cache = store.cache;
       if (inverseIdentifier && !cache.isDeleted(inverseIdentifier)) {
         if (returnModeIsId) {
           result = inverseIdentifier.id;
@@ -593,43 +587,59 @@ class Snapshot {
    undefined will be returned if the contents of the relationship is unknown.
    */
   hasMany(keyName, options) {
-    let returnModeIsIds = !!(options && options.ids);
+    const returnModeIsIds = !!(options && options.ids);
     let results;
-    let cachedIds = this._hasManyIds[keyName];
-    let cachedSnapshots = this._hasManyRelationships[keyName];
+    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;
     }
-    let store = this._store;
-    let relationshipMeta = store.getSchemaDefinitionService().relationshipsDefinitionFor({
+    const store = this._store;
+    const relationshipMeta = store.schema.fields({
       type: this.modelName
-    })[keyName];
-    assert(`Model '${this.identifier.lid}' has no hasMany relationship named '${keyName}' defined.`, relationshipMeta && relationshipMeta.kind === 'hasMany');
+    }).get(keyName);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Model '${this.identifier.lid}' has no hasMany relationship named '${keyName}' defined.`);
+      }
+    })(relationshipMeta && relationshipMeta.kind === 'hasMany') : {};
 
     // TODO @runspired it seems this code branch would not work with CUSTOM_MODEL_CLASSes
     // this check is not a regression in behavior because relationships don't currently
     // function without access to intimate API contracts between RecordData and Model.
     // This is a requirement we should fix as soon as the relationship layer does not require
     // this intimate API usage.
-    if (macroCondition(!getOwnConfig().packages.HAS_JSON_API_PACKAGE)) {
-      assert(`snapshot.hasMany only supported when using the package @ember-data/json-api`);
-    }
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`snapshot.hasMany only supported when using the package @ember-data/graph`);
+      }
+    })(dependencySatisfies('@ember-data/graph', '*')) : {};
     const graphFor = importSync('@ember-data/graph/-private').graphFor;
     const {
       identifier
     } = this;
-    const relationship = graphFor(this._store).get(identifier, keyName);
-    assert(`You looked up the ${keyName} hasMany relationship for { type: ${identifier.type}, id: ${identifier.id || ''}, lid: ${identifier.lid} but no such relationship was found.`, relationship);
-    assert(`You looked up the ${keyName} hasMany relationship for { type: ${identifier.type}, id: ${identifier.id || ''}, lid: ${identifier.lid} but that relationship is a belongsTo.`, relationship.definition.kind === 'hasMany');
-    let value = relationship.getData();
+    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+      const relationship = graphFor(this._store).get(identifier, keyName);
+      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        if (!test) {
+          throw new Error(`You looked up the ${keyName} hasMany relationship for { type: ${identifier.type}, id: ${identifier.id || ''}, lid: ${identifier.lid} but no such relationship was found.`);
+        }
+      })(relationship) : {};
+      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        if (!test) {
+          throw new Error(`You looked up the ${keyName} hasMany relationship for { type: ${identifier.type}, id: ${identifier.id || ''}, lid: ${identifier.lid} but that relationship is a belongsTo.`);
+        }
+      })(relationship.definition.kind === 'hasMany') : {};
+    }
+    const value = graphFor(this._store).getData(identifier, keyName);
     if (value.data) {
       results = [];
       value.data.forEach(member => {
-        let inverseIdentifier = store.identifierCache.getOrCreateRecordIdentifier(member);
-        const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? store._instanceCache.getResourceCache(inverseIdentifier) : store.cache;
+        const inverseIdentifier = store.identifierCache.getOrCreateRecordIdentifier(member);
+        const cache = store.cache;
         if (!cache.isDeleted(inverseIdentifier)) {
           if (returnModeIsIds) {
             results.push(inverseIdentifier.id);
@@ -665,9 +675,11 @@ class Snapshot {
     @public
   */
   eachAttribute(callback, binding) {
-    let attrDefs = this._store.getSchemaDefinitionService().attributesDefinitionFor(this.identifier);
-    Object.keys(attrDefs).forEach(key => {
-      callback.call(binding, key, attrDefs[key]);
+    const fields = this._store.schema.fields(this.identifier);
+    fields.forEach((field, key) => {
+      if (field.kind === 'attribute') {
+        callback.call(binding, key, field);
+      }
     });
   }
 
@@ -686,9 +698,11 @@ class Snapshot {
     @public
   */
   eachRelationship(callback, binding) {
-    let relationshipDefs = this._store.getSchemaDefinitionService().relationshipsDefinitionFor(this.identifier);
-    Object.keys(relationshipDefs).forEach(key => {
-      callback.call(binding, key, relationshipDefs[key]);
+    const fields = this._store.schema.fields(this.identifier);
+    fields.forEach((field, key) => {
+      if (field.kind === 'belongsTo' || field.kind === 'hasMany') {
+        callback.call(binding, key, field);
+      }
     });
   }
 
@@ -714,12 +728,17 @@ class Snapshot {
     @public
    */
   serialize(options) {
+    upgradeStore(this._store);
     const serializer = this._store.serializerFor(this.modelName);
-    assert(`Cannot serialize record, no serializer found`, serializer);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Cannot serialize record, no serializer found`);
+      }
+    })(serializer) : {};
     return serializer.serialize(this, options);
   }
 }
-if (macroCondition(getOwnConfig().deprecations.DEPRECATE_SNAPSHOT_MODEL_CLASS_ACCESS)) {
+if (macroCondition(getGlobalConfig().WarpDrive.deprecations.DEPRECATE_SNAPSHOT_MODEL_CLASS_ACCESS)) {
   Object.defineProperty(Snapshot.prototype, 'type', {
     get() {
       deprecate(`Using Snapshot.type to access the ModelClass for a record is deprecated. Use store.modelFor(<modelName>) instead.`, false, {
@@ -735,7 +754,47 @@ if (macroCondition(getOwnConfig().deprecations.DEPRECATE_SNAPSHOT_MODEL_CLASS_AC
     }
   });
 }
-const SaveOp = Symbol('SaveOp');
+function isObject(value) {
+  return value !== null && typeof value === 'object';
+}
+function _objectIsAlive(object) {
+  return isObject(object) ? !(object.isDestroyed || object.isDestroying) : false;
+}
+function guardDestroyedStore(promise, store) {
+  return promise.then(_v => {
+    if (!_objectIsAlive(store)) {
+      if (macroCondition(getGlobalConfig().WarpDrive.deprecations.DEPRECATE_RSVP_PROMISE)) {
+        deprecate(`A Promise did not resolve by the time the store was destroyed. This will error in a future release.`, false, {
+          id: 'ember-data:rsvp-unresolved-async',
+          until: '5.0',
+          for: '@ember-data/store',
+          since: {
+            available: '4.5',
+            enabled: '4.5'
+          }
+        });
+      }
+    }
+    return _v;
+  });
+}
+function _bind(fn, ...args) {
+  return function () {
+    // eslint-disable-next-line prefer-spread
+    return fn.apply(undefined, args);
+  };
+}
+function _guard(promise, test) {
+  const guarded = promise.finally(() => {
+    if (!test()) {
+      // @ts-expect-error this is a private RSVPPromise API that won't always be there
+      // eslint-disable-next-line @typescript-eslint/no-unused-expressions, @typescript-eslint/no-unsafe-member-access
+      guarded._subscribers ? guarded._subscribers.length = 0 : null;
+    }
+  });
+  return guarded;
+}
+const SaveOp = getOrSetGlobal('SaveOp', Symbol('SaveOp'));
 class FetchManager {
   // fetches pending in the runloop, waiting to be coalesced
 
@@ -757,13 +816,13 @@ class FetchManager {
      @internal
   */
   scheduleSave(identifier, options) {
-    let resolver = createDeferred();
-    let query = {
+    const resolver = createDeferred();
+    const query = {
       op: 'saveRecord',
       recordIdentifier: identifier,
       options
     };
-    let queryRequest = {
+    const queryRequest = {
       data: [query]
     };
     const snapshot = this.createSnapshot(identifier, options);
@@ -779,19 +838,19 @@ class FetchManager {
     return monitored;
   }
   scheduleFetch(identifier, options, request) {
-    let query = {
+    const query = {
       op: 'findRecord',
       recordIdentifier: identifier,
       options
     };
-    let queryRequest = {
+    const queryRequest = {
       data: [query]
     };
-    let pendingFetch = this.getPendingFetch(identifier, options);
+    const pendingFetch = this.getPendingFetch(identifier, options);
     if (pendingFetch) {
       return pendingFetch;
     }
-    let modelName = identifier.type;
+    const modelName = identifier.type;
     const resolver = createDeferred();
     const pendingFetchItem = {
       identifier,
@@ -799,7 +858,7 @@ class FetchManager {
       options,
       queryRequest
     };
-    let resolverPromise = resolver.promise;
+    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
 
@@ -812,20 +871,21 @@ class FetchManager {
 
       // additional data received in the payload
       // may result in the merging of identifiers (and thus records)
-      let potentiallyNewIm = store._push(payload, options.reload);
+      const potentiallyNewIm = store._push(payload, options.reload);
       if (potentiallyNewIm && !Array.isArray(potentiallyNewIm)) {
         return potentiallyNewIm;
       }
       return identifier;
     }, error => {
-      assert(`Async Leak Detected: Expected the store to not be destroyed`, !store.isDestroyed);
-      const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? store._instanceCache.peek({
-        identifier,
-        bucket: 'resourceCache'
-      }) : store.cache;
+      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        if (!test) {
+          throw new Error(`Async Leak Detected: Expected the store to not be destroyed`);
+        }
+      })(!store.isDestroyed) : {};
+      const cache = store.cache;
       if (!cache || cache.isEmpty(identifier) || isInitialLoad) {
         let isReleasable = true;
-        if (macroCondition(getOwnConfig().packages.HAS_GRAPH_PACKAGE)) {
+        if (macroCondition(dependencySatisfies('@ember-data/graph', '*'))) {
           if (!cache) {
             const graphFor = importSync('@ember-data/graph/-private').graphFor;
             const graph = graphFor(store);
@@ -848,7 +908,7 @@ class FetchManager {
         this.flushAllPendingFetches();
       });
     }
-    let fetchesByType = this._pendingFetch;
+    const fetchesByType = this._pendingFetch;
     let fetchesById = fetchesByType.get(modelName);
     if (!fetchesById) {
       fetchesById = new Map();
@@ -860,7 +920,7 @@ class FetchManager {
       fetchesById.set(identifier, requestsForIdentifier);
     }
     requestsForIdentifier.push(pendingFetchItem);
-    if (macroCondition(getOwnConfig().env.TESTING)) {
+    if (macroCondition(getGlobalConfig().WarpDrive.env.TESTING)) {
       if (!request.disableTestWaiter) {
         const {
           waitForPromise
@@ -872,11 +932,11 @@ class FetchManager {
     return promise;
   }
   getPendingFetch(identifier, options) {
-    let pendingFetches = this._pendingFetch.get(identifier.type)?.get(identifier);
+    const pendingFetches = this._pendingFetch.get(identifier.type)?.get(identifier);
 
     // We already have a pending fetch for this
     if (pendingFetches) {
-      let matchingPendingFetch = pendingFetches.find(fetch => isSameRequest(options, fetch.options));
+      const matchingPendingFetch = pendingFetches.find(fetch => isSameRequest(options, fetch.options));
       if (matchingPendingFetch) {
         return matchingPendingFetch.promise;
       }
@@ -897,7 +957,7 @@ class FetchManager {
     let promise;
     if (isEmpty) {
       assertIdentifierHasId(identifier);
-      if (macroCondition(getOwnConfig().env.DEBUG)) {
+      if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
         promise = this.scheduleFetch(identifier, Object.assign({}, options, {
           reload: true
         }), request);
@@ -907,7 +967,11 @@ class FetchManager {
       }
     } else if (isLoading) {
       promise = this.getPendingFetch(identifier, options);
-      assert(`Expected to find a pending request for a record in the loading state, but found none`, promise);
+      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        if (!test) {
+          throw new Error(`Expected to find a pending request for a record in the loading state, but found none`);
+        }
+      })(promise) : {};
     } else {
       promise = Promise.resolve(identifier);
     }
@@ -918,7 +982,7 @@ class FetchManager {
   }
 }
 function _isEmpty(instanceCache, identifier) {
-  const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? instanceCache.__instances.resourceCache.get(identifier) : instanceCache.cache;
+  const cache = instanceCache.cache;
   if (!cache) {
     return true;
   }
@@ -933,7 +997,7 @@ function _isLoading(cache, identifier) {
   const isLoaded = cache.recordIsLoaded(identifier);
   return !isLoaded &&
   // fulfilled === null &&
-  req.getPendingRequestsForRecord(identifier).some(req => req.type === 'query');
+  req.getPendingRequestsForRecord(identifier).some(r => r.type === 'query');
 }
 function includesSatisfies(current, existing) {
   // if we have no includes we are good
@@ -972,28 +1036,43 @@ function isSameRequest(options = {}, existingOptions = {}) {
   return optionsSatisfies(options.adapterOptions, existingOptions.adapterOptions) && includesSatisfies(options.include, existingOptions.include);
 }
 function _findMany(store, adapter, modelName, snapshots) {
-  let modelClass = store.modelFor(modelName); // `adapter.findMany` gets the modelClass still
-  let promise = Promise.resolve().then(() => {
+  const modelClass = store.modelFor(modelName); // `adapter.findMany` gets the modelClass still
+  const promise = Promise.resolve().then(() => {
     const ids = snapshots.map(s => s.id);
-    assert(`Cannot fetch a record without an id`, ids.every(v => v !== null));
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Cannot fetch a record without an id`);
+      }
+    })(ids.every(v => v !== null)) : {};
     // eslint-disable-next-line @typescript-eslint/unbound-method
-    assert(`Expected this adapter to implement findMany for coalescing`, adapter.findMany);
-    let ret = adapter.findMany(store, modelClass, ids, snapshots);
-    assert('adapter.findMany returned undefined, this was very likely a mistake', ret !== undefined);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Expected this adapter to implement findMany for coalescing`);
+      }
+    })(adapter.findMany) : {};
+    const ret = adapter.findMany(store, modelClass, ids, snapshots);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error('adapter.findMany returned undefined, this was very likely a mistake');
+      }
+    })(ret !== undefined) : {};
     return ret;
   });
-  promise = guardDestroyedStore(promise, store);
   return promise.then(adapterPayload => {
-    assert(`You made a 'findMany' request for '${modelName}' records with ids '[${snapshots.map(s => s.id).join(',')}]', but the adapter's response did not have any data`, !!payloadIsNotBlank(adapterPayload));
-    let serializer = store.serializerFor(modelName);
-    let payload = normalizeResponseHelper(serializer, store, modelClass, adapterPayload, null, 'findMany');
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`You made a 'findMany' request for '${modelName}' records with ids '[${snapshots.map(s => s.id).join(',')}]', but the adapter's response did not have any data`);
+      }
+    })(!!payloadIsNotBlank(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++) {
-    let snapshot = snapshots[i];
-    let pair = fetchMap.get(snapshot);
+    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.`));
     }
@@ -1009,9 +1088,9 @@ function handleFoundRecords(store, fetchMap, snapshots, coalescedPayload) {
     options object, we resolve all snapshots by id with
     the first response we see.
   */
-  let snapshotsById = new Map();
+  const snapshotsById = new Map();
   for (let i = 0; i < snapshots.length; i++) {
-    let id = snapshots[i].id;
+    const id = snapshots[i].id;
     let snapshotGroup = snapshotsById.get(id);
     if (!snapshotGroup) {
       snapshotGroup = [];
@@ -1022,18 +1101,18 @@ function handleFoundRecords(store, fetchMap, snapshots, coalescedPayload) {
   const included = Array.isArray(coalescedPayload.included) ? coalescedPayload.included : [];
 
   // resolve found records
-  let resources = coalescedPayload.data;
+  const resources = coalescedPayload.data;
   for (let i = 0, l = resources.length; i < l; i++) {
-    let resource = resources[i];
-    let snapshotGroup = snapshotsById.get(resource.id);
+    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 => {
-        let pair = fetchMap.get(snapshot);
-        let resolver = pair.resolver;
+        const pair = fetchMap.get(snapshot);
+        const resolver = pair.resolver;
         resolver.resolve({
           data: resource
         });
@@ -1051,9 +1130,9 @@ function handleFoundRecords(store, fetchMap, snapshots, coalescedPayload) {
   }
 
   // reject missing records
-  let rejected = [];
-  snapshotsById.forEach(snapshots => {
-    rejected.push(...snapshots);
+  const rejected = [];
+  snapshotsById.forEach(snapshotArray => {
+    rejected.push(...snapshotArray);
   });
   warn('Ember Data expected to find records with the following ids in the adapter response from findMany but they were missing: [ "' + [...snapshotsById.values()].map(r => r[0].id).join('", "') + '" ]', {
     id: 'ds.store.missing-records-from-adapter'
@@ -1061,23 +1140,47 @@ function handleFoundRecords(store, fetchMap, snapshots, coalescedPayload) {
   rejectFetchedItems(fetchMap, rejected);
 }
 function _fetchRecord(store, adapter, fetchItem) {
-  let identifier = fetchItem.identifier;
-  let modelName = identifier.type;
-  assert(`You tried to find a record but you have no adapter (for ${modelName})`, adapter);
-  assert(`You tried to find a record but your adapter (for ${modelName}) does not implement 'findRecord'`, typeof adapter.findRecord === 'function');
-  let snapshot = store._fetchManager.createSnapshot(identifier, fetchItem.options);
-  let klass = store.modelFor(identifier.type);
-  let id = identifier.id;
+  const identifier = fetchItem.identifier;
+  const modelName = identifier.type;
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`You tried to find a record but you have no adapter (for ${modelName})`);
+    }
+  })(adapter) : {};
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`You tried to find a record but your adapter (for ${modelName}) does not implement 'findRecord'`);
+    }
+  })(typeof adapter.findRecord === 'function') : {};
+  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 => {
-    assert(`Async Leak Detected: Expected the store to not be destroyed`, _objectIsAlive(store));
-    assert(`You made a 'findRecord' request for a '${modelName}' with id '${id}', but the adapter's response did not have any data`, !!payloadIsNotBlank(adapterPayload));
-    let serializer = store.serializerFor(modelName);
-    let payload = normalizeResponseHelper(serializer, store, klass, adapterPayload, id, 'findRecord');
-    assert(`Ember Data expected the primary data returned from a 'findRecord' response to be an object but instead it found an array.`, !Array.isArray(payload.data));
-    assert(`The 'findRecord' request for ${modelName}:${id} resolved indicating success but contained no primary data. To indicate a 404 not found you should either reject the promise returned by the adapter's findRecord method or throw a NotFoundError.`, 'data' in payload && payload.data !== null && typeof payload.data === 'object');
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Async Leak Detected: Expected the store to not be destroyed`);
+      }
+    })(!(store.isDestroyed || store.isDestroying)) : {};
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`You made a 'findRecord' request for a '${modelName}' with id '${id}', but the adapter's response did not have any data`);
+      }
+    })(!!payloadIsNotBlank(adapterPayload)) : {};
+    const serializer = store.serializerFor(modelName);
+    const payload = normalizeResponseHelper(serializer, store, klass, adapterPayload, id, 'findRecord');
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Ember Data expected the primary data returned from a 'findRecord' response to be an object but instead it found an array.`);
+      }
+    })(!Array.isArray(payload.data)) : {};
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`The 'findRecord' request for ${modelName}:${id} resolved indicating success but contained no primary data. To indicate a 404 not found you should either reject the promise returned by the adapter's findRecord method or throw a NotFoundError.`);
+      }
+    })('data' in payload && payload.data !== null && typeof payload.data === 'object') : {};
     warn(`You requested a record of type '${modelName}' with id '${id}' but the adapter returned a payload with primary data having an id of '${payload.data.id}'. Use 'store.findRecord()' when the requested id is the same as the one returned by the adapter. In other cases use 'store.queryRecord()' instead.`, coerceId(payload.data.id) === coerceId(id), {
       id: 'ds.store.findRecord.id-mismatch'
     });
@@ -1095,12 +1198,16 @@ function _processCoalescedGroup(store, fetchMap, group, adapter, modelName) {
   } else if (group.length === 1) {
     _fetchRecord(store, adapter, fetchMap.get(group[0]));
   } else {
-    assert("You cannot return an empty array from adapter's method groupRecordsForFindMany", false);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      {
+        throw new Error("You cannot return an empty array from adapter's method groupRecordsForFindMany");
+      }
+    })() : {};
   }
 }
 function _flushPendingFetchForType(store, pendingFetchMap, modelName) {
-  let adapter = store.adapterFor(modelName);
-  let shouldCoalesce = !!adapter.findMany && adapter.coalesceFindRequests;
+  const adapter = store.adapterFor(modelName);
+  const shouldCoalesce = !!adapter.findMany && adapter.coalesceFindRequests;
   if (shouldCoalesce) {
     const pendingFetchItems = [];
     pendingFetchMap.forEach((requestsForIdentifier, identifier) => {
@@ -1112,12 +1219,12 @@ function _flushPendingFetchForType(store, pendingFetchMap, modelName) {
       pendingFetchMap.delete(identifier);
       pendingFetchItems.push(requestsForIdentifier[0]);
     });
-    let totalItems = pendingFetchItems.length;
+    const totalItems = pendingFetchItems.length;
     if (totalItems > 1) {
-      let snapshots = new Array(totalItems);
-      let fetchMap = new Map();
+      const snapshots = new Array(totalItems);
+      const fetchMap = new Map();
       for (let i = 0; i < totalItems; i++) {
-        let fetchItem = pendingFetchItems[i];
+        const fetchItem = pendingFetchItems[i];
         snapshots[i] = store._fetchManager.createSnapshot(fetchItem.identifier, fetchItem.options);
         fetchMap.set(snapshots[i], fetchItem);
       }
@@ -1131,12 +1238,12 @@ function _flushPendingFetchForType(store, pendingFetchMap, modelName) {
         _processCoalescedGroup(store, fetchMap, groups[i], adapter, modelName);
       }
     } else if (totalItems === 1) {
-      void _fetchRecord(store, adapter, pendingFetchItems[0]);
+      _fetchRecord(store, adapter, pendingFetchItems[0]);
     }
   }
   pendingFetchMap.forEach(pendingFetchItems => {
     pendingFetchItems.forEach(pendingFetchItem => {
-      void _fetchRecord(store, adapter, pendingFetchItem);
+      _fetchRecord(store, adapter, pendingFetchItem);
     });
   });
 }
@@ -1149,18 +1256,29 @@ function _flushPendingSave(store, pending) {
   } = pending;
   const adapter = store.adapterFor(identifier.type);
   const operation = options[SaveOp];
-  let modelName = snapshot.modelName;
-  let modelClass = store.modelFor(modelName);
+  const modelName = snapshot.modelName;
+  const modelClass = store.modelFor(modelName);
   const record = store._instanceCache.getRecord(identifier);
-  assert(`You tried to update a record but you have no adapter (for ${modelName})`, adapter);
-  assert(`You tried to update a record but your adapter (for ${modelName}) does not implement '${operation}'`, typeof adapter[operation] === 'function');
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`You tried to update a record but you have no adapter (for ${modelName})`);
+    }
+  })(adapter) : {};
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`You tried to update a record but your adapter (for ${modelName}) does not implement '${operation}'`);
+    }
+  })(typeof adapter[operation] === 'function') : {};
   let promise = Promise.resolve().then(() => adapter[operation](store, modelClass, snapshot));
-  let serializer = store.serializerFor(modelName);
-  assert(`Your adapter's '${operation}' method must return a value, but it returned 'undefined'`, promise !== undefined);
+  const serializer = store.serializerFor(modelName);
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Your adapter's '${operation}' method must return a value, but it returned 'undefined'`);
+    }
+  })(promise !== undefined) : {};
   promise = promise.then(adapterPayload => {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-call
     if (!_objectIsAlive(record)) {
-      if (macroCondition(getOwnConfig().deprecations.DEPRECATE_RSVP_PROMISE)) {
+      if (macroCondition(getGlobalConfig().WarpDrive.deprecations.DEPRECATE_RSVP_PROMISE)) {
         deprecate(`A Promise while saving ${modelName} did not resolve by the time your model was destroyed. This will error in a future release.`, false, {
           id: 'ember-data:rsvp-unresolved-async',
           until: '5.0',
@@ -1178,4 +1296,13 @@ function _flushPendingSave(store, pending) {
   });
   resolver.resolve(promise);
 }
-export { FetchManager as F, SnapshotRecordArray as S, _objectIsAlive as _, SaveOp as a, Snapshot as b, _guard as c, _bind as d, assertIdentifierHasId as e, guardDestroyedStore as g, iterateData as i, normalizeResponseHelper as n, payloadIsNotBlank as p };
+
+/**
+ * Utilities - often temporary - for maintaining backwards compatibility with
+ * older parts of EmberData.
+ *
+  @module @ember-data/legacy-compat
+  @main @ember-data/legacy-compat
+*/
+function upgradeStore(store) {}
+export { FetchManager as F, SaveOp as S, _objectIsAlive as _, _guard as a, _bind as b, assertIdentifierHasId as c, SnapshotRecordArray as d, Snapshot as e, guardDestroyedStore as g, iterateData as i, normalizeResponseHelper as n, payloadIsNotBlank as p, upgradeStore as u };