@ember-data/legacy-compat 5.4.0-alpha.4 → 5.4.0-alpha.41

package/addon/index.js

@@ -1,46 +1,50 @@
+import { getOwner } from '@ember/application';
 import { assert } from '@ember/debug';
+import { recordIdentifierFor } from '@ember-data/store';
+import { _deprecatingNormalize } from '@ember-data/store/-private';
+import { p as payloadIsNotBlank, n as normalizeResponseHelper, i as iterateData, F as FetchManager, a as assertIdentifierHasId, S as SaveOp, b as SnapshotRecordArray } from "./-private-DmhhlB_x";
 import { macroCondition, getOwnConfig, importSync } from '@embroider/macros';
-import { p as payloadIsNotBlank, n as normalizeResponseHelper, i as iterateData, F as FetchManager, c as assertIdentifierHasId, a as SaveOp, S as SnapshotRecordArray } from "./fetch-manager-0744e8e9";
 function _findHasMany(adapter, store, identifier, link, relationship, options) {
-  let promise = Promise.resolve().then(() => {
+  const promise = Promise.resolve().then(() => {
     const snapshot = store._fetchManager.createSnapshot(identifier, options);
-    let useLink = !link || typeof link === 'string';
-    let relatedLink = useLink ? link : link.href;
+    const useLink = !link || typeof link === 'string';
+    const relatedLink = useLink ? link : link.href;
+    assert(`Attempted to load a hasMany relationship from a specified 'link' in the original payload, but the specified link is empty. You must provide a valid 'link' in the original payload to use 'findHasMany'`, relatedLink);
+    assert(`Expected the adapter to implement 'findHasMany' but it does not`, typeof adapter.findHasMany === 'function');
     return adapter.findHasMany(store, snapshot, relatedLink, relationship);
   });
-  promise = promise.then(adapterPayload => {
-    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));
+  return promise.then(adapterPayload => {
+    assert(`You made a 'findHasMany' request for a ${identifier.type}'s '${relationship.name}' relationship, using link '${JSON.stringify(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);
+    const 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));
+    assert(`fetched the hasMany relationship '${relationship.name}' for ${identifier.type}:${identifier.id} with link '${JSON.stringify(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}'`);
-  return promise;
+  }, null);
 }
 function _findBelongsTo(store, identifier, link, relationship, options) {
-  let promise = Promise.resolve().then(() => {
-    let adapter = store.adapterFor(identifier.type);
+  const promise = Promise.resolve().then(() => {
+    const 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;
+    const snapshot = store._fetchManager.createSnapshot(identifier, options);
+    const useLink = !link || typeof link === 'string';
+    const relatedLink = useLink ? link : link.href;
+    assert(`Attempted to load a belongsTo relationship from a specified 'link' in the original payload, but the specified link is empty. You must provide a valid 'link' in the original payload to use 'findBelongsTo'`, relatedLink);
     return adapter.findBelongsTo(store, snapshot, relatedLink, relationship);
   });
-  promise = promise.then(adapterPayload => {
-    let modelClass = store.modelFor(relationship.type);
-    let serializer = store.serializerFor(relationship.type);
+  return promise.then(adapterPayload => {
+    const modelClass = store.modelFor(relationship.type);
+    const 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)));
+    assert(`fetched the belongsTo relationship '${relationship.name}' for ${identifier.type}:${identifier.id} with link '${JSON.stringify(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;
+  }, null);
 }
 
 // sync
@@ -52,7 +56,7 @@ function _findBelongsTo(store, identifier, link, relationship, options) {
 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 relationshipData = payload.data ? iterateData(payload.data, (data, index) => {
     const {
       id,
       type
@@ -80,7 +84,7 @@ function syncRelationshipDataFromLink(store, payload, parentIdentifier, relation
     id: parentIdentifier.id,
     type: parentIdentifier.type,
     relationships: {
-      [relationship.key]: relatedDataHash
+      [relationship.name]: relatedDataHash
     }
   };
   if (!Array.isArray(payload.included)) {
@@ -90,48 +94,49 @@ function syncRelationshipDataFromLink(store, payload, parentIdentifier, relation
   return payload;
 }
 function ensureRelationshipIsSetToParent(payload, parentIdentifier, store, parentRelationship, index) {
-  let {
+  const {
     id,
     type
   } = payload;
   if (!payload.relationships) {
     payload.relationships = {};
   }
-  let {
+  const {
     relationships
   } = payload;
-  let inverse = getInverse(store, parentIdentifier, parentRelationship, type);
+  const inverse = getInverse(store, parentIdentifier, parentRelationship, type);
   if (inverse) {
-    let {
+    const {
       inverseKey,
       kind
     } = inverse;
-    let relationshipData = relationships[inverseKey] && relationships[inverseKey].data;
+    const relationshipData = relationships[inverseKey]?.data;
     if (macroCondition(getOwnConfig().env.DEBUG)) {
       if (typeof relationshipData !== 'undefined' && !relationshipDataPointsToParent(relationshipData, parentIdentifier)) {
-        let inspect = function inspect(thing) {
+        const inspect = function inspect(thing) {
           return `'${JSON.stringify(thing)}'`;
         };
-        let quotedType = inspect(type);
-        let quotedInverse = inspect(inverseKey);
-        let expected = inspect({
+        const quotedType = inspect(type);
+        const quotedInverse = inspect(inverseKey);
+        const 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');
+        const expectedModel = `${parentIdentifier.type}:${parentIdentifier.id}`;
+        const got = inspect(relationshipData);
+        const prefix = typeof index === 'number' ? `data[${index}]` : `data`;
+        const path = `${prefix}.relationships.${inverseKey}.data`;
+        const data = Array.isArray(relationshipData) ? relationshipData[0] : relationshipData;
+        const other = data ? `<${data.type}:${data.id}>` : null;
+        const relationshipFetched = `${expectedModel}.${parentRelationship.kind}("${parentRelationship.name}")`;
+        const includedRecord = `<${type}:${id}>`;
+        const 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);
+      relationships[inverseKey].data = fixRelationshipData(relationshipData ?? null, kind, parentIdentifier);
     }
   }
 }
@@ -144,20 +149,20 @@ function inverseForRelationship(store, identifier, key) {
   return definition.options.inverse;
 }
 function getInverse(store, parentIdentifier, parentRelationship, type) {
-  let {
+  const {
     name: lhs_relationshipName
   } = parentRelationship;
-  let {
+  const {
     type: parentType
   } = parentIdentifier;
-  let inverseKey = inverseForRelationship(store, {
+  const inverseKey = inverseForRelationship(store, {
     type: parentType
   }, lhs_relationshipName);
   if (inverseKey) {
     const definition = store.getSchemaDefinitionService().relationshipsDefinitionFor({
       type
     });
-    let {
+    const {
       kind
     } = definition[inverseKey];
     return {
@@ -175,7 +180,7 @@ function relationshipDataPointsToParent(relationshipData, identifier) {
       return false;
     }
     for (let i = 0; i < relationshipData.length; i++) {
-      let entry = relationshipData[i];
+      const entry = relationshipData[i];
       if (validateRelationshipEntry(entry, identifier)) {
         return true;
       }
@@ -189,29 +194,32 @@ function fixRelationshipData(relationshipData, relationshipKind, {
   id,
   type
 }) {
-  let parentRelationshipData = {
+  const parentRelationshipData = {
     id,
     type
   };
-  let payload;
+  let payload = null;
   if (relationshipKind === 'hasMany') {
-    payload = relationshipData || [];
+    const relData = relationshipData || [];
     if (relationshipData) {
+      assert('expected the relationship data to be an array', Array.isArray(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 => {
+      const found = relationshipData.find(v => {
         return v.type === parentRelationshipData.type && v.id === parentRelationshipData.id;
       });
       if (!found) {
-        payload.push(parentRelationshipData);
+        relData.push(parentRelationshipData);
       }
     } else {
-      payload.push(parentRelationshipData);
+      relData.push(parentRelationshipData);
     }
+    payload = relData;
   } else {
-    payload = relationshipData || {};
-    Object.assign(payload, parentRelationshipData);
+    const relData = relationshipData || {};
+    Object.assign(relData, parentRelationshipData);
+    payload = relData;
   }
   return payload;
 }
@@ -220,7 +228,7 @@ function validateRelationshipEntry({
 }, {
   id: parentModelID
 }) {
-  return id && id.toString() === parentModelID;
+  return !!id && id.toString() === parentModelID;
 }
 const PotentialLegacyOperations = new Set(['findRecord', 'findAll', 'query', 'queryRecord', 'findBelongsTo', 'findHasMany', 'updateRecord', 'createRecord', 'deleteRecord']);
 const LegacyNetworkHandler = {
@@ -275,11 +283,12 @@ function findBelongsTo(context) {
   const identifier = identifiers?.[0];
 
   // short circuit if we are already loading
-  let pendingRequest = identifier && store._fetchManager.getPendingFetch(identifier, options);
+  const pendingRequest = identifier && store._fetchManager.getPendingFetch(identifier, options);
   if (pendingRequest) {
     return pendingRequest;
   }
   if (useLink) {
+    assert(`Expected a related link when calling store.findBelongsTo, found ${String(links)}`, links && links.related);
     return _findBelongsTo(store, record, links.related, field, options);
   }
   assert(`Expected an identifier`, Array.isArray(identifiers) && identifiers.length === 1);
@@ -315,15 +324,16 @@ function findHasMany(context) {
     */
     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');
+    assert(`Expected a related link when calling store.findhasMany, found ${String(links)}`, links && links.related);
     return _findHasMany(adapter, store, record, links.related, field, options);
   }
 
   // identifiers case
-
+  assert(`Expected an array of identifiers to fetch`, Array.isArray(identifiers));
   const fetches = new Array(identifiers.length);
   const manager = store._fetchManager;
   for (let i = 0; i < identifiers.length; i++) {
-    let identifier = identifiers[i];
+    const 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);
@@ -347,7 +357,7 @@ function saveRecord(context) {
   return fetchManagerPromise.then(payload => {
     if (macroCondition(getOwnConfig().debug.LOG_PAYLOADS)) {
       try {
-        let payloadCopy = payload ? JSON.parse(JSON.stringify(payload)) : payload;
+        const payloadCopy = payload ? JSON.parse(JSON.stringify(payload)) : payload;
         // eslint-disable-next-line no-console
         console.log(`EmberData | Payload - ${operation}`, payloadCopy);
       } catch (e) {
@@ -356,22 +366,22 @@ function saveRecord(context) {
       }
     }
     let result;
-    /*
-    // TODO @runspired re-evaluate the below claim now that
-    // the save request pipeline is more streamlined.
-     Note to future spelunkers hoping to optimize.
-    We rely on this `run` to create a run loop if needed
-    that `store._push` and `store.saveRecord` will both share.
-     We use `join` because it is often the case that we
-    have an outer run loop available still from the first
-    call to `store._push`;
-    */
     store._join(() => {
+      // @ts-expect-error we don't have access to a response in legacy
       result = store.cache.didCommit(identifier, {
         request: context.request,
         content: payload
       });
     });
+
+    // blatantly lie if we were a createRecord request
+    // to give some semblance of cache-control to the
+    // lifetimes service while legacy is still around
+    if (store.lifetimes?.didRequest && operation === 'createRecord') {
+      store.lifetimes.didRequest(context.request, {
+        status: 201
+      }, null, store);
+    }
     return store.peekRecord(result.data);
   }).catch(e => {
     let err = e;
@@ -386,12 +396,12 @@ function saveRecord(context) {
 }
 function adapterDidInvalidate(store, identifier, error) {
   if (error && error.isAdapterError === true && error.code === 'InvalidError') {
-    let serializer = store.serializerFor(identifier.type);
+    const serializer = store.serializerFor(identifier.type);
 
     // TODO @deprecate extractErrors being called
     // TODO remove extractErrors from the default serializers.
     if (serializer && typeof serializer.extractErrors === 'function') {
-      let errorsHash = serializer.extractErrors(store, store.modelFor(identifier.type), error, identifier.id);
+      const errorsHash = serializer.extractErrors(store, store.modelFor(identifier.type), error, identifier.id);
       error.errors = errorsHashToArray(errorsHash);
     }
   }
@@ -421,7 +431,7 @@ function errorsHashToArray(errors) {
   const out = [];
   if (errors) {
     Object.keys(errors).forEach(key => {
-      let messages = makeArray(errors[key]);
+      const messages = makeArray(errors[key]);
       for (let i = 0; i < messages.length; i++) {
         let title = 'Invalid Attribute';
         let pointer = `/data/attributes/${key}`;
@@ -462,7 +472,7 @@ function findRecord(context) {
     promise = store._fetchManager.scheduleFetch(identifier, options, context.request);
   } else {
     let snapshot = null;
-    let adapter = store.adapterFor(identifier.type);
+    const 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._fetchManager.createSnapshot(identifier, options))) {
@@ -577,7 +587,7 @@ function query(context) {
     delete options._recordArray;
   }
   const schema = store.modelFor(type);
-  let promise = Promise.resolve().then(() => adapter.query(store, schema, query, recordArray, options));
+  const promise = Promise.resolve().then(() => adapter.query(store, schema, query, recordArray, options));
   return promise.then(adapterPayload => {
     const serializer = store.serializerFor(type);
     const payload = normalizeResponseHelper(serializer, store, schema, adapterPayload, null, 'query');
@@ -605,7 +615,7 @@ 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.resolve().then(() => adapter.queryRecord(store, schema, query, options));
+  const promise = Promise.resolve().then(() => adapter.queryRecord(store, schema, query, options));
   return promise.then(adapterPayload => {
     const serializer = store.serializerFor(type);
     const payload = normalizeResponseHelper(serializer, store, schema, adapterPayload, null, 'queryRecord');
@@ -614,4 +624,227 @@ function queryRecord(context) {
     return identifier ? store.peekRecord(identifier) : null;
   });
 }
-export { LegacyNetworkHandler };
+
+/**
+ * @module @ember-data/store
+ * @class Store
+ */
+
+/**
+    Returns an instance of the adapter for a given type. For
+    example, `adapterFor('person')` will return an instance of
+    the adapter located at `app/adapters/person.js`
+
+    If no `person` adapter is found, this method will look
+    for an `application` adapter (the default adapter for
+    your entire application).
+
+    @method adapterFor
+    @public
+    @param {String} modelName
+    @return Adapter
+  */
+
+function adapterFor(modelName, _allowMissing) {
+  assert(`Attempted to call store.adapterFor(), but the store instance has already been destroyed.`, !(this.isDestroying || this.isDestroyed));
+  assert(`You need to pass a model name to the store's adapterFor method`, modelName);
+  assert(`Passing classes to store.adapterFor has been removed. Please pass a dasherized string instead of ${modelName}`, typeof modelName === 'string');
+  this._adapterCache = this._adapterCache || Object.create(null);
+  const normalizedModelName = _deprecatingNormalize(modelName);
+  const {
+    _adapterCache
+  } = this;
+  let adapter = _adapterCache[normalizedModelName];
+  if (adapter) {
+    return adapter;
+  }
+  const owner = getOwner(this);
+
+  // name specific adapter
+  adapter = owner.lookup(`adapter:${normalizedModelName}`);
+  if (adapter !== undefined) {
+    _adapterCache[normalizedModelName] = adapter;
+    return adapter;
+  }
+
+  // no adapter found for the specific name, fallback and check for application adapter
+  adapter = _adapterCache.application || owner.lookup('adapter:application');
+  if (adapter !== undefined) {
+    _adapterCache[normalizedModelName] = adapter;
+    _adapterCache.application = adapter;
+    return adapter;
+  }
+  assert(`No adapter was found for '${modelName}' and no 'application' adapter was found as a fallback.`, _allowMissing);
+}
+
+/**
+    Returns an instance of the serializer for a given type. For
+    example, `serializerFor('person')` will return an instance of
+    `App.PersonSerializer`.
+
+    If no `App.PersonSerializer` is found, this method will look
+    for an `App.ApplicationSerializer` (the default serializer for
+    your entire application).
+
+    If a serializer cannot be found on the adapter, it will fall back
+    to an instance of `JSONSerializer`.
+
+    @method serializerFor
+    @public
+    @param {String} modelName the record to serialize
+    @return {Serializer}
+  */
+function serializerFor(modelName) {
+  assert(`Attempted to call store.serializerFor(), but the store instance has already been destroyed.`, !(this.isDestroying || this.isDestroyed));
+  assert(`You need to pass a model name to the store's serializerFor method`, modelName);
+  assert(`Passing classes to store.serializerFor has been removed. Please pass a dasherized string instead of ${modelName}`, typeof modelName === 'string');
+  this._serializerCache = this._serializerCache || Object.create(null);
+  const normalizedModelName = _deprecatingNormalize(modelName);
+  const {
+    _serializerCache
+  } = this;
+  let serializer = _serializerCache[normalizedModelName];
+  if (serializer) {
+    return serializer;
+  }
+
+  // by name
+  const owner = getOwner(this);
+  serializer = owner.lookup(`serializer:${normalizedModelName}`);
+  if (serializer !== undefined) {
+    _serializerCache[normalizedModelName] = serializer;
+    return serializer;
+  }
+
+  // no serializer found for the specific model, fallback and check for application serializer
+  serializer = _serializerCache.application || owner.lookup('serializer:application');
+  if (serializer !== undefined) {
+    _serializerCache[normalizedModelName] = serializer;
+    _serializerCache.application = serializer;
+    return serializer;
+  }
+  return null;
+}
+
+/**
+    `normalize` converts a json payload into the normalized form that
+    [push](../methods/push?anchor=push) expects.
+
+    Example
+
+    ```js
+    socket.on('message', function(message) {
+      let modelName = message.model;
+      let data = message.data;
+      store.push(store.normalize(modelName, data));
+    });
+    ```
+
+    @method normalize
+    @public
+    @param {String} modelName The name of the model type for this payload
+    @param {Object} payload
+    @return {Object} The normalized payload
+  */
+// TODO @runspired @deprecate users should call normalize on the associated serializer directly
+function normalize(modelName, payload) {
+  assert(`Attempted to call store.normalize(), but the store instance has already been destroyed.`, !(this.isDestroying || this.isDestroyed));
+  assert(`You need to pass a model name to the store's normalize method`, modelName);
+  assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${typeof modelName}`, typeof modelName === 'string');
+  const normalizedModelName = _deprecatingNormalize(modelName);
+  const serializer = this.serializerFor(normalizedModelName);
+  const schema = this.modelFor(normalizedModelName);
+  assert(`You must define a normalize method in your serializer in order to call store.normalize`, typeof serializer?.normalize === 'function');
+  return serializer.normalize(schema, payload);
+}
+
+/**
+    Push some raw data into the store.
+
+    This method can be used both to push in brand new
+    records, as well as to update existing records. You
+    can push in more than one type of object at once.
+    All objects should be in the format expected by the
+    serializer.
+
+    ```app/serializers/application.js
+    import RESTSerializer from '@ember-data/serializer/rest';
+
+    export default class ApplicationSerializer extends RESTSerializer;
+    ```
+
+    ```js
+    let pushData = {
+      posts: [
+        { id: 1, postTitle: "Great post", commentIds: [2] }
+      ],
+      comments: [
+        { id: 2, commentBody: "Insightful comment" }
+      ]
+    }
+
+    store.pushPayload(pushData);
+    ```
+
+    By default, the data will be deserialized using a default
+    serializer (the application serializer if it exists).
+
+    Alternatively, `pushPayload` will accept a model type which
+    will determine which serializer will process the payload.
+
+    ```app/serializers/application.js
+    import RESTSerializer from '@ember-data/serializer/rest';
+
+     export default class ApplicationSerializer extends RESTSerializer;
+    ```
+
+    ```app/serializers/post.js
+    import JSONSerializer from '@ember-data/serializer/json';
+
+    export default JSONSerializer;
+    ```
+
+    ```js
+    store.pushPayload(pushData); // Will use the application serializer
+    store.pushPayload('post', pushData); // Will use the post serializer
+    ```
+
+    @method pushPayload
+    @public
+    @param {String} modelName Optionally, a model type used to determine which serializer will be used
+    @param {Object} inputPayload
+  */
+// TODO @runspired @deprecate pushPayload in favor of looking up the serializer
+function pushPayload(modelName, inputPayload) {
+  assert(`Attempted to call store.pushPayload(), but the store instance has already been destroyed.`, !(this.isDestroying || this.isDestroyed));
+  const payload = inputPayload || modelName;
+  const normalizedModelName = inputPayload ? _deprecatingNormalize(modelName) : 'application';
+  const serializer = this.serializerFor(normalizedModelName);
+  assert(`You cannot use 'store.pushPayload(<type>, <payload>)' unless the serializer for '${normalizedModelName}' defines 'pushPayload'`, serializer && typeof serializer.pushPayload === 'function');
+  serializer.pushPayload(this, payload);
+}
+
+// TODO @runspired @deprecate records should implement their own serialization if desired
+function serializeRecord(record, options) {
+  // TODO we used to check if the record was destroyed here
+  if (!this._fetchManager) {
+    this._fetchManager = new FetchManager(this);
+  }
+  return this._fetchManager.createSnapshot(recordIdentifierFor(record)).serialize(options);
+}
+function cleanup() {
+  // enqueue destruction of any adapters/serializers we have created
+  for (const adapterName in this._adapterCache) {
+    const adapter = this._adapterCache[adapterName];
+    if (typeof adapter.destroy === 'function') {
+      adapter.destroy();
+    }
+  }
+  for (const serializerName in this._serializerCache) {
+    const serializer = this._serializerCache[serializerName];
+    if (typeof serializer.destroy === 'function') {
+      serializer.destroy();
+    }
+  }
+}
+export { LegacyNetworkHandler, adapterFor, cleanup, normalize, pushPayload, serializeRecord, serializerFor };