@ember-data/legacy-compat 4.12.0-alpha.11 → 4.12.0-alpha.13

package/addon/index.js

@@ -1,7 +1,274 @@
-import { macroCondition, getOwnConfig, isDevelopingApp } from '@embroider/macros';
-import { assert } from '@ember/debug';
-import { resolve, Promise as Promise$1 } from 'rsvp';
-import { F as FetchManager, a as SaveOp, b as assertIdentifierHasId, S as SnapshotRecordArray, g as guardDestroyedStore, n as normalizeResponseHelper } from "./fetch-manager-2716abb1";
+import { deprecate, assert } from '@ember/debug';
+import { macroCondition, getOwnConfig, importSync } from '@embroider/macros';
+import { g as guardDestroyedStore, _ as _objectIsAlive, p as payloadIsNotBlank, n as normalizeResponseHelper, c as _guard, i as iterateData, d as _bind, F as FetchManager, e as assertIdentifierHasId, a as SaveOp, S as SnapshotRecordArray } from "./fetch-manager-1067c70f";
+function _findHasMany(adapter, store, identifier, link, relationship, options) {
+  let promise = Promise.resolve().then(() => {
+    const snapshot = store._fetchManager.createSnapshot(identifier, options);
+    let useLink = !link || typeof link === 'string';
+    let relatedLink = useLink ? link : link.href;
+    return adapter.findHasMany(store, snapshot, relatedLink, relationship);
+  });
+  promise = guardDestroyedStore(promise, store);
+  promise = promise.then(adapterPayload => {
+    const record = store._instanceCache.getRecord(identifier);
+    if (!_objectIsAlive(record)) {
+      if (macroCondition(getOwnConfig().deprecations.DEPRECATE_RSVP_PROMISE)) {
+        deprecate(`A Promise for fetching ${relationship.type} 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',
+          for: '@ember-data/store',
+          since: {
+            available: '4.5',
+            enabled: '4.5'
+          }
+        });
+      }
+    }
+    assert(`You made a 'findHasMany' request for a ${identifier.type}'s '${relationship.key}' relationship, using link '${link}' , but the adapter's response did not have any data`, payloadIsNotBlank(adapterPayload));
+    const modelClass = store.modelFor(relationship.type);
+    let serializer = store.serializerFor(relationship.type);
+    let payload = normalizeResponseHelper(serializer, store, modelClass, adapterPayload, null, 'findHasMany');
+    assert(`fetched the hasMany relationship '${relationship.name}' for ${identifier.type}:${identifier.id} with link '${link}', but no data member is present in the response. If no data exists, the response should set { data: [] }`, 'data' in payload && Array.isArray(payload.data));
+    payload = syncRelationshipDataFromLink(store, payload, identifier, relationship);
+    return store._push(payload, true);
+  }, null, `DS: Extract payload of '${identifier.type}' : hasMany '${relationship.type}'`);
+  if (macroCondition(getOwnConfig().deprecations.DEPRECATE_RSVP_PROMISE)) {
+    const record = store._instanceCache.getRecord(identifier);
+    promise = _guard(promise, _bind(_objectIsAlive, record));
+  }
+  return promise;
+}
+function _findBelongsTo(store, identifier, link, relationship, options) {
+  let promise = Promise.resolve().then(() => {
+    let adapter = store.adapterFor(identifier.type);
+    assert(`You tried to load a belongsTo relationship but you have no adapter (for ${identifier.type})`, adapter);
+    assert(`You tried to load a belongsTo relationship from a specified 'link' in the original payload but your adapter does not implement 'findBelongsTo'`, typeof adapter.findBelongsTo === 'function');
+    let snapshot = store._fetchManager.createSnapshot(identifier, options);
+    let useLink = !link || typeof link === 'string';
+    let relatedLink = useLink ? link : link.href;
+    return adapter.findBelongsTo(store, snapshot, relatedLink, relationship);
+  });
+  if (macroCondition(getOwnConfig().deprecations.DEPRECATE_RSVP_PROMISE)) {
+    const record = store._instanceCache.getRecord(identifier);
+    promise = guardDestroyedStore(promise, store);
+    promise = _guard(promise, _bind(_objectIsAlive, record));
+  }
+  promise = promise.then(adapterPayload => {
+    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_RSVP_PROMISE)) {
+      const record = store._instanceCache.getRecord(identifier);
+      if (!_objectIsAlive(record)) {
+        deprecate(`A Promise for fetching ${relationship.type} 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',
+          for: '@ember-data/store',
+          since: {
+            available: '4.5',
+            enabled: '4.5'
+          }
+        });
+      }
+    }
+    let modelClass = store.modelFor(relationship.type);
+    let serializer = store.serializerFor(relationship.type);
+    let payload = normalizeResponseHelper(serializer, store, modelClass, adapterPayload, null, 'findBelongsTo');
+    assert(`fetched the belongsTo relationship '${relationship.name}' for ${identifier.type}:${identifier.id} with link '${link}', but no data member is present in the response. If no data exists, the response should set { data: null }`, 'data' in payload && (payload.data === null || typeof payload.data === 'object' && !Array.isArray(payload.data)));
+    if (!payload.data && !payload.links && !payload.meta) {
+      return null;
+    }
+    payload = syncRelationshipDataFromLink(store, payload, identifier, relationship);
+    return store._push(payload, true);
+  }, null, `DS: Extract payload of ${identifier.type} : ${relationship.type}`);
+  return promise;
+}
+
+// sync
+// iterate over records in payload.data
+// for each record
+//   assert that record.relationships[inverse] is either undefined (so we can fix it)
+//     or provide a data: {id, type} that matches the record that requested it
+//   return the relationship data for the parent
+function syncRelationshipDataFromLink(store, payload, parentIdentifier, relationship) {
+  // ensure the right hand side (incoming payload) points to the parent record that
+  // requested this relationship
+  let relationshipData = payload.data ? iterateData(payload.data, (data, index) => {
+    const {
+      id,
+      type
+    } = data;
+    ensureRelationshipIsSetToParent(data, parentIdentifier, store, relationship, index);
+    return {
+      id,
+      type
+    };
+  }) : null;
+  const relatedDataHash = {};
+  if ('meta' in payload) {
+    relatedDataHash.meta = payload.meta;
+  }
+  if ('links' in payload) {
+    relatedDataHash.links = payload.links;
+  }
+  if ('data' in payload) {
+    relatedDataHash.data = relationshipData;
+  }
+
+  // now, push the left hand side (the parent record) to ensure things are in sync, since
+  // the payload will be pushed with store._push
+  const parentPayload = {
+    id: parentIdentifier.id,
+    type: parentIdentifier.type,
+    relationships: {
+      [relationship.key]: relatedDataHash
+    }
+  };
+  if (!Array.isArray(payload.included)) {
+    payload.included = [];
+  }
+  payload.included.push(parentPayload);
+  return payload;
+}
+function ensureRelationshipIsSetToParent(payload, parentIdentifier, store, parentRelationship, index) {
+  let {
+    id,
+    type
+  } = payload;
+  if (!payload.relationships) {
+    payload.relationships = {};
+  }
+  let {
+    relationships
+  } = payload;
+  let inverse = getInverse(store, parentIdentifier, parentRelationship, type);
+  if (inverse) {
+    let {
+      inverseKey,
+      kind
+    } = inverse;
+    let relationshipData = relationships[inverseKey] && relationships[inverseKey].data;
+    if (macroCondition(getOwnConfig().env.DEBUG)) {
+      if (typeof relationshipData !== 'undefined' && !relationshipDataPointsToParent(relationshipData, parentIdentifier)) {
+        let inspect = function inspect(thing) {
+          return `'${JSON.stringify(thing)}'`;
+        };
+        let quotedType = inspect(type);
+        let quotedInverse = inspect(inverseKey);
+        let expected = inspect({
+          id: parentIdentifier.id,
+          type: parentIdentifier.type
+        });
+        let expectedModel = `${parentIdentifier.type}:${parentIdentifier.id}`;
+        let got = inspect(relationshipData);
+        let prefix = typeof index === 'number' ? `data[${index}]` : `data`;
+        let path = `${prefix}.relationships.${inverseKey}.data`;
+        let other = relationshipData ? `<${relationshipData.type}:${relationshipData.id}>` : null;
+        let relationshipFetched = `${expectedModel}.${parentRelationship.kind}("${parentRelationship.name}")`;
+        let includedRecord = `<${type}:${id}>`;
+        let message = [`Encountered mismatched relationship: Ember Data expected ${path} in the payload from ${relationshipFetched} to include ${expected} but got ${got} instead.\n`, `The ${includedRecord} record loaded at ${prefix} in the payload specified ${other} as its ${quotedInverse}, but should have specified ${expectedModel} (the record the relationship is being loaded from) as its ${quotedInverse} instead.`, `This could mean that the response for ${relationshipFetched} may have accidentally returned ${quotedType} records that aren't related to ${expectedModel} and could be related to a different ${parentIdentifier.type} record instead.`, `Ember Data has corrected the ${includedRecord} record's ${quotedInverse} relationship to ${expectedModel} so that ${relationshipFetched} will include ${includedRecord}.`, `Please update the response from the server or change your serializer to either ensure that the response for only includes ${quotedType} records that specify ${expectedModel} as their ${quotedInverse}, or omit the ${quotedInverse} relationship from the response.`].join('\n');
+        assert(message);
+      }
+    }
+    if (kind !== 'hasMany' || typeof relationshipData !== 'undefined') {
+      relationships[inverseKey] = relationships[inverseKey] || {};
+      relationships[inverseKey].data = fixRelationshipData(relationshipData, kind, parentIdentifier);
+    }
+  }
+}
+function metaIsRelationshipDefinition(meta) {
+  return typeof meta._inverseKey === 'function';
+}
+function inverseForRelationship(store, identifier, key) {
+  const definition = store.getSchemaDefinitionService().relationshipsDefinitionFor(identifier)[key];
+  if (!definition) {
+    return null;
+  }
+  if (macroCondition(getOwnConfig().deprecations.DEPRECATE_RELATIONSHIPS_WITHOUT_INVERSE)) {
+    if (metaIsRelationshipDefinition(definition)) {
+      const modelClass = store.modelFor(identifier.type);
+      return definition._inverseKey(store, modelClass);
+    }
+  }
+  assert(`Expected the relationship defintion to specify the inverse type or null.`, definition.options?.inverse === null || typeof definition.options?.inverse === 'string' && definition.options.inverse.length > 0);
+  return definition.options.inverse;
+}
+function getInverse(store, parentIdentifier, parentRelationship, type) {
+  let {
+    name: lhs_relationshipName
+  } = parentRelationship;
+  let {
+    type: parentType
+  } = parentIdentifier;
+  let inverseKey = inverseForRelationship(store, {
+    type: parentType
+  }, lhs_relationshipName);
+  if (inverseKey) {
+    const definition = store.getSchemaDefinitionService().relationshipsDefinitionFor({
+      type
+    });
+    let {
+      kind
+    } = definition[inverseKey];
+    return {
+      inverseKey,
+      kind
+    };
+  }
+}
+function relationshipDataPointsToParent(relationshipData, identifier) {
+  if (relationshipData === null) {
+    return false;
+  }
+  if (Array.isArray(relationshipData)) {
+    if (relationshipData.length === 0) {
+      return false;
+    }
+    for (let i = 0; i < relationshipData.length; i++) {
+      let entry = relationshipData[i];
+      if (validateRelationshipEntry(entry, identifier)) {
+        return true;
+      }
+    }
+  } else {
+    return validateRelationshipEntry(relationshipData, identifier);
+  }
+  return false;
+}
+function fixRelationshipData(relationshipData, relationshipKind, {
+  id,
+  type
+}) {
+  let parentRelationshipData = {
+    id,
+    type
+  };
+  let payload;
+  if (relationshipKind === 'hasMany') {
+    payload = relationshipData || [];
+    if (relationshipData) {
+      // these arrays could be massive so this is better than filter
+      // Note: this is potentially problematic if type/id are not in the
+      // same state of normalization.
+      let found = relationshipData.find(v => {
+        return v.type === parentRelationshipData.type && v.id === parentRelationshipData.id;
+      });
+      if (!found) {
+        payload.push(parentRelationshipData);
+      }
+    } else {
+      payload.push(parentRelationshipData);
+    }
+  } else {
+    payload = relationshipData || {};
+    Object.assign(payload, parentRelationshipData);
+  }
+  return payload;
+}
+function validateRelationshipEntry({
+  id
+}, {
+  id: parentModelID
+}) {
+  return id && id.toString() === parentModelID;
+}
 const LegacyNetworkHandler = {
   request(context, next) {
     // if we are not a legacy request, move on
@@ -15,25 +282,100 @@ const LegacyNetworkHandler = {
       store._fetchManager = new FetchManager(store);
     }
     switch (context.request.op) {
-      case 'updateRecord':
-        return saveRecord(context);
-      case 'deleteRecord':
-        return saveRecord(context);
-      case 'createRecord':
-        return saveRecord(context);
       case 'findRecord':
         return findRecord(context);
       case 'findAll':
         return findAll(context);
-      case 'queryRecord':
-        return queryRecord(context);
       case 'query':
         return query(context);
+      case 'queryRecord':
+        return queryRecord(context);
+      case 'findBelongsTo':
+        return findBelongsTo(context);
+      case 'findHasMany':
+        return findHasMany(context);
+      case 'updateRecord':
+        return saveRecord(context);
+      case 'createRecord':
+        return saveRecord(context);
+      case 'deleteRecord':
+        return saveRecord(context);
       default:
         return next(context.request);
     }
   }
 };
+function findBelongsTo(context) {
+  const {
+    store,
+    data,
+    records: identifiers
+  } = context.request;
+  const {
+    options,
+    record,
+    links,
+    useLink,
+    field
+  } = data;
+  const identifier = identifiers?.[0];
+
+  // short circuit if we are already loading
+  let pendingRequest = identifier && store._fetchManager.getPendingFetch(identifier, options);
+  if (pendingRequest) {
+    return pendingRequest;
+  }
+  if (useLink) {
+    return _findBelongsTo(store, record, links.related, field, options);
+  }
+  assert(`Expected an identifier`, Array.isArray(identifiers) && identifiers.length === 1);
+  const manager = store._fetchManager;
+  assertIdentifierHasId(identifier);
+  return options.reload ? manager.scheduleFetch(identifier, options, context.request) : manager.fetchDataIfNeededForIdentifier(identifier, options, context.request);
+}
+function findHasMany(context) {
+  const {
+    store,
+    data,
+    records: identifiers
+  } = context.request;
+  const {
+    options,
+    record,
+    links,
+    useLink,
+    field
+  } = data;
+
+  // link case
+  if (useLink) {
+    const adapter = store.adapterFor(record.type);
+    /*
+    If a relationship was originally populated by the adapter as a link
+    (as opposed to a list of IDs), this method is called when the
+    relationship is fetched.
+     The link (which is usually a URL) is passed through unchanged, so the
+    adapter can make whatever request it wants.
+     The usual use-case is for the server to register a URL as a link, and
+    then use that URL in the future to make a request for the relationship.
+    */
+    assert(`You tried to load a hasMany relationship but you have no adapter (for ${record.type})`, adapter);
+    assert(`You tried to load a hasMany relationship from a specified 'link' in the original payload but your adapter does not implement 'findHasMany'`, typeof adapter.findHasMany === 'function');
+    return _findHasMany(adapter, store, record, links.related, field, options);
+  }
+
+  // identifiers case
+
+  const fetches = new Array(identifiers.length);
+  const manager = store._fetchManager;
+  for (let i = 0; i < identifiers.length; i++) {
+    let identifier = identifiers[i];
+    // TODO we probably can be lenient here and return from cache for the isNew case
+    assertIdentifierHasId(identifier);
+    fetches[i] = options.reload ? manager.scheduleFetch(identifier, options, context.request) : manager.fetchDataIfNeededForIdentifier(identifier, options, context.request);
+  }
+  return Promise.all(fetches);
+}
 function saveRecord(context) {
   const {
     store,
@@ -87,7 +429,7 @@ function saveRecord(context) {
         store._push({
           data: null,
           included: payload.included
-        });
+        }, true);
       }
     });
     return store.peekRecord(identifier);
@@ -172,29 +514,43 @@ function findRecord(context) {
 
   // if not loaded start loading
   if (!store._instanceCache.recordIsLoaded(identifier)) {
-    promise = store._fetchManager.fetchDataIfNeededForIdentifier(identifier, options);
+    promise = store._fetchManager.fetchDataIfNeededForIdentifier(identifier, options, context.request);
 
     // Refetch if the reload option is passed
   } else if (options.reload) {
     assertIdentifierHasId(identifier);
-    promise = store._fetchManager.scheduleFetch(identifier, options);
+    promise = store._fetchManager.scheduleFetch(identifier, options, context.request);
   } else {
     let snapshot = null;
     let adapter = store.adapterFor(identifier.type);
 
     // Refetch the record if the adapter thinks the record is stale
-    if (typeof options.reload === 'undefined' && adapter.shouldReloadRecord && adapter.shouldReloadRecord(store, snapshot = store._instanceCache.createSnapshot(identifier, options))) {
+    if (typeof options.reload === 'undefined' && adapter.shouldReloadRecord && adapter.shouldReloadRecord(store, snapshot = store._fetchManager.createSnapshot(identifier, options))) {
       assertIdentifierHasId(identifier);
-      promise = store._fetchManager.scheduleFetch(identifier, options);
+      if (macroCondition(getOwnConfig().env.DEBUG)) {
+        promise = store._fetchManager.scheduleFetch(identifier, Object.assign({}, options, {
+          reload: true
+        }), context.request);
+      } else {
+        options.reload = true;
+        promise = store._fetchManager.scheduleFetch(identifier, options, context.request);
+      }
     } else {
       // Trigger the background refetch if backgroundReload option is passed
-      if (options.backgroundReload !== false && (options.backgroundReload || !adapter.shouldBackgroundReloadRecord || adapter.shouldBackgroundReloadRecord(store, snapshot = snapshot || store._instanceCache.createSnapshot(identifier, options)))) {
+      if (options.backgroundReload !== false && (options.backgroundReload || !adapter.shouldBackgroundReloadRecord || adapter.shouldBackgroundReloadRecord(store, snapshot = snapshot || store._fetchManager.createSnapshot(identifier, options)))) {
         assertIdentifierHasId(identifier);
-        void store._fetchManager.scheduleFetch(identifier, options);
+        if (macroCondition(getOwnConfig().env.DEBUG)) {
+          void store._fetchManager.scheduleFetch(identifier, Object.assign({}, options, {
+            backgroundReload: true
+          }), context.request);
+        } else {
+          options.backgroundReload = true;
+          void store._fetchManager.scheduleFetch(identifier, options, context.request);
+        }
       }
 
       // Return the cached record
-      promise = resolve(identifier);
+      promise = Promise.resolve(identifier);
     }
   }
   return promise.then(identifier => store.peekRecord(identifier));
@@ -219,35 +575,41 @@ function findAll(context) {
   let fetch;
   if (shouldReload) {
     maybeRecordArray && (maybeRecordArray.isUpdating = true);
-    fetch = _findAll(adapter, store, type, snapshotArray);
+    fetch = _findAll(adapter, store, type, snapshotArray, context.request, true);
   } else {
-    fetch = Promise$1.resolve(store.peekAll(type));
+    fetch = Promise.resolve(store.peekAll(type));
     if (options.backgroundReload || options.backgroundReload !== false && (!adapter.shouldBackgroundReloadAll || adapter.shouldBackgroundReloadAll(store, snapshotArray))) {
       maybeRecordArray && (maybeRecordArray.isUpdating = true);
-      void _findAll(adapter, store, type, snapshotArray);
+      void _findAll(adapter, store, type, snapshotArray, context.request, false);
     }
   }
   return fetch;
 }
-function payloadIsNotBlank(adapterPayload) {
-  if (Array.isArray(adapterPayload)) {
-    return true;
-  } else {
-    return Object.keys(adapterPayload || {}).length;
-  }
-}
-function _findAll(adapter, store, type, snapshotArray) {
+function _findAll(adapter, store, type, snapshotArray, request, isAsyncFlush) {
   const schema = store.modelFor(type);
-  let promise = Promise$1.resolve().then(() => adapter.findAll(store, schema, null, snapshotArray));
-  promise = guardDestroyedStore(promise, store, isDevelopingApp() ? `DS: Handle Adapter#findAll of ${type}` : '');
-  return promise.then(adapterPayload => {
+  let promise = Promise.resolve().then(() => adapter.findAll(store, schema, null, snapshotArray));
+  promise = guardDestroyedStore(promise, store);
+  promise = promise.then(adapterPayload => {
     assert(`You made a 'findAll' request for '${type}' records, but the adapter's response did not have any data`, payloadIsNotBlank(adapterPayload));
     const serializer = store.serializerFor(type);
     const payload = normalizeResponseHelper(serializer, store, schema, adapterPayload, null, 'findAll');
-    store._push(payload);
+    store._push(payload, isAsyncFlush);
     snapshotArray._recordArray.isUpdating = false;
+    if (macroCondition(getOwnConfig().debug.LOG_PAYLOADS)) {
+      // eslint-disable-next-line no-console
+      console.log(`request: findAll<${type}> background reload complete`);
+    }
     return snapshotArray._recordArray;
   });
+  if (macroCondition(getOwnConfig().env.TESTING)) {
+    if (!request.disableTestWaiter) {
+      const {
+        waitForPromise
+      } = importSync('@ember/test-waiters');
+      promise = waitForPromise(promise);
+    }
+  }
+  return promise;
 }
 function query(context) {
   const {
@@ -268,19 +630,19 @@ function query(context) {
     type,
     query
   });
-  if (isDevelopingApp()) {
+  if (macroCondition(getOwnConfig().env.DEBUG)) {
     options = Object.assign({}, options);
     delete options._recordArray;
   } else {
     delete options._recordArray;
   }
   const schema = store.modelFor(type);
-  let promise = Promise$1.resolve().then(() => adapter.query(store, schema, query, recordArray, options));
-  promise = guardDestroyedStore(promise, store, isDevelopingApp() ? `DS: Handle Adapter#query of ${type}` : ``);
+  let promise = Promise.resolve().then(() => adapter.query(store, schema, query, recordArray, options));
+  promise = guardDestroyedStore(promise, store);
   return promise.then(adapterPayload => {
     const serializer = store.serializerFor(type);
     const payload = normalizeResponseHelper(serializer, store, schema, adapterPayload, null, 'query');
-    const identifiers = store._push(payload);
+    const identifiers = store._push(payload, true);
     assert('The response to store.query is expected to be an array but it was a single record. Please wrap your response in an array or use `store.queryRecord` to query for a single record.', Array.isArray(identifiers));
     store.recordArrayManager.populateManagedArray(recordArray, identifiers, payload);
     return recordArray;
@@ -303,13 +665,14 @@ function queryRecord(context) {
   assert(`You tried to make a query but you have no adapter (for ${type})`, adapter);
   assert(`You tried to make a query but your adapter does not implement 'queryRecord'`, typeof adapter.queryRecord === 'function');
   const schema = store.modelFor(type);
-  let promise = Promise$1.resolve().then(() => adapter.queryRecord(store, schema, query, options));
-  promise = guardDestroyedStore(promise, store, isDevelopingApp() ? `DS: Handle Adapter#queryRecord of ${type}` : ``);
+  let promise = Promise.resolve().then(() => adapter.queryRecord(store, schema, query, options));
+  promise = guardDestroyedStore(promise, store);
   return promise.then(adapterPayload => {
     const serializer = store.serializerFor(type);
     const payload = normalizeResponseHelper(serializer, store, schema, adapterPayload, null, 'queryRecord');
     assertSingleResourceDocument(payload);
-    return store.push(payload);
+    const identifier = store._push(payload, true);
+    return identifier ? store.peekRecord(identifier) : null;
   });
 }
 export { LegacyNetworkHandler };