@ember-data/legacy-compat 5.4.0-alpha.8 → 5.4.0-alpha.81

package/{addon/fetch-manager-0744e8e9.js → dist/-private-DVN28hvw.js}

@@ -1,7 +1,8 @@
 import { SOURCE, coerceId } from '@ember-data/store/-private';
-import { assert, warn } from '@ember/debug';
-import { macroCondition, getOwnConfig, importSync } from '@embroider/macros';
+import { warn } from '@ember/debug';
+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
@@ -10,7 +11,7 @@ import { createDeferred } from '@ember-data/request';
 /**
   SnapshotRecordArray is not directly instantiable.
   Instances are provided to consuming application's
-  adapters for certain requests.
+  adapters for certain `findAll` requests.
 
   @class SnapshotRecordArray
   @public
@@ -140,6 +141,7 @@ class SnapshotRecordArray {
     if (this._snapshots !== null) {
       return this._snapshots;
     }
+    upgradeStore(this.__store);
     const {
       _fetchManager
     } = this.__store;
@@ -148,13 +150,17 @@ class SnapshotRecordArray {
   }
 }
 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) {
@@ -174,8 +180,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 {
@@ -217,11 +223,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;
 }
@@ -333,7 +343,13 @@ class Snapshot {
    @public
    */
   get record() {
-    return this._store._instanceCache.getRecord(this.identifier);
+    const record = this._store.peekRecord(this.identifier);
+    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() {
     if (this.__attributes !== null) {
@@ -343,10 +359,12 @@ class Snapshot {
     const {
       identifier
     } = this;
-    const attrs = Object.keys(this._store.getSchemaDefinitionService().attributesDefinitionFor(identifier));
+    const attrs = this._store.schema.fields(identifier);
     const cache = this._store.cache;
-    attrs.forEach(keyName => {
-      attributes[keyName] = cache.getAttr(identifier, keyName);
+    attrs.forEach((field, keyName) => {
+      if (field.kind === 'attribute') {
+        attributes[keyName] = cache.getAttr(identifier, keyName);
+      }
     });
     return attributes;
   }
@@ -373,7 +391,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.`);
+      }
+    })() : {};
   }
 
   /**
@@ -406,13 +428,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;
@@ -447,40 +469,48 @@ 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;
-    if (macroCondition(getOwnConfig().env.DEBUG)) {
+    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
       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');
+      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') : {};
     }
-    let value = graphFor(this._store).getData(identifier, keyName);
-    let data = value && value.data;
-    let inverseIdentifier = data ? store.identifierCache.getOrCreateRecordIdentifier(data) : null;
+    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 = store.cache;
       if (inverseIdentifier && !cache.isDeleted(inverseIdentifier)) {
@@ -525,44 +555,58 @@ 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;
-    if (macroCondition(getOwnConfig().env.DEBUG)) {
+    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
       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');
+      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') : {};
     }
-    let value = graphFor(this._store).getData(identifier, keyName);
+    const value = graphFor(this._store).getData(identifier, keyName);
     if (value.data) {
       results = [];
       value.data.forEach(member => {
-        let inverseIdentifier = store.identifierCache.getOrCreateRecordIdentifier(member);
+        const inverseIdentifier = store.identifierCache.getOrCreateRecordIdentifier(member);
         const cache = store.cache;
         if (!cache.isDeleted(inverseIdentifier)) {
           if (returnModeIsIds) {
@@ -599,9 +643,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);
+      }
     });
   }
 
@@ -620,9 +666,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);
+      }
     });
   }
 
@@ -648,12 +696,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);
   }
 }
-const SaveOp = Symbol('SaveOp');
+const SaveOp = getOrSetGlobal('SaveOp', Symbol('SaveOp'));
 class FetchManager {
   // fetches pending in the runloop, waiting to be coalesced
 
@@ -675,13 +728,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);
@@ -697,19 +750,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,
@@ -717,7 +770,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
 
@@ -730,17 +783,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);
+      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);
@@ -763,7 +820,7 @@ class FetchManager {
         this.flushAllPendingFetches();
       });
     }
-    let fetchesByType = this._pendingFetch;
+    const fetchesByType = this._pendingFetch;
     let fetchesById = fetchesByType.get(modelName);
     if (!fetchesById) {
       fetchesById = new Map();
@@ -775,7 +832,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
@@ -787,11 +844,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;
       }
@@ -812,7 +869,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);
@@ -822,7 +879,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);
     }
@@ -887,27 +948,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;
   });
   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.`));
     }
@@ -923,9 +1000,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 = [];
@@ -936,18 +1013,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
         });
@@ -965,7 +1042,7 @@ function handleFoundRecords(store, fetchMap, snapshots, coalescedPayload) {
   }
 
   // reject missing records
-  let rejected = [];
+  const rejected = [];
   snapshotsById.forEach(snapshotArray => {
     rejected.push(...snapshotArray);
   });
@@ -975,23 +1052,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`, !(store.isDestroyed || store.isDestroying));
-    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'
     });
@@ -1009,12 +1110,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) => {
@@ -1026,12 +1131,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);
       }
@@ -1045,12 +1150,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);
     });
   });
 }
@@ -1063,13 +1168,25 @@ function _flushPendingSave(store, pending) {
   } = pending;
   const adapter = store.adapterFor(identifier.type);
   const operation = options[SaveOp];
-  let modelName = snapshot.modelName;
-  let modelClass = store.modelFor(modelName);
-  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');
+  const modelName = snapshot.modelName;
+  const modelClass = store.modelFor(modelName);
+  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 => {
     if (adapterPayload) {
       return normalizeResponseHelper(serializer, store, modelClass, adapterPayload, snapshot.id, operation);
@@ -1077,4 +1194,13 @@ function _flushPendingSave(store, pending) {
   });
   resolver.resolve(promise);
 }
-export { FetchManager as F, SnapshotRecordArray as S, SaveOp as a, Snapshot as b, assertIdentifierHasId as c, 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, assertIdentifierHasId as a, SnapshotRecordArray as b, Snapshot as c, iterateData as i, normalizeResponseHelper as n, payloadIsNotBlank as p, upgradeStore as u };