@warp-drive/legacy 5.8.0-alpha.4 → 5.8.0-alpha.40

package/dist/unpkg/dev-deprecated/compat.js

@@ -0,0 +1,1146 @@
+import { getOwner } from '@ember/application';
+import { recordIdentifierFor } from '@warp-drive/core';
+import { assertPrivateStore, waitFor, _deprecatingNormalize } from '@warp-drive/core/store/-private';
+import '@warp-drive/core/reactive/-private';
+import { p as payloadIsNotBlank, n as normalizeResponseHelper, i as iterateData, F as FetchManager, S as SaveOp, a as assertIdentifierHasId, b as SnapshotRecordArray } from "./-private-DbaSCSym.js";
+function _findHasMany(adapter, store, identifier, link, relationship, options) {
+  const promise = Promise.resolve().then(() => {
+    const snapshot = store._fetchManager.createSnapshot(identifier, options);
+    const useLink = !link || typeof link === 'string';
+    const relatedLink = useLink ? link : link.href;
+    (test => {
+      if (!test) {
+        throw new Error(`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);
+    (test => {
+      if (!test) {
+        throw new Error(`Expected the adapter to implement 'findHasMany' but it does not`);
+      }
+    })(typeof adapter.findHasMany === 'function');
+    return adapter.findHasMany(store, snapshot, relatedLink, relationship);
+  });
+  return promise.then(adapterPayload => {
+    (test => {
+      if (!test) {
+        throw new Error(`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);
+    const serializer = store.serializerFor(relationship.type);
+    let payload = normalizeResponseHelper(serializer, store, modelClass, adapterPayload, null, 'findHasMany');
+    (test => {
+      if (!test) {
+        throw new Error(`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);
+}
+function _findBelongsTo(store, identifier, link, relationship, options) {
+  const promise = Promise.resolve().then(() => {
+    const adapter = store.adapterFor(identifier.type);
+    (test => {
+      if (!test) {
+        throw new Error(`You tried to load a belongsTo relationship but you have no adapter (for ${identifier.type})`);
+      }
+    })(adapter);
+    (test => {
+      if (!test) {
+        throw new Error(`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');
+    const snapshot = store._fetchManager.createSnapshot(identifier, options);
+    const useLink = !link || typeof link === 'string';
+    const relatedLink = useLink ? link : link.href;
+    (test => {
+      if (!test) {
+        throw new Error(`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);
+  });
+  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');
+    (test => {
+      if (!test) {
+        throw new Error(`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);
+}
+
+// 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
+  const 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.name]: relatedDataHash
+    }
+  };
+  if (!Array.isArray(payload.included)) {
+    payload.included = [];
+  }
+  payload.included.push(parentPayload);
+  return payload;
+}
+function ensureRelationshipIsSetToParent(payload, parentIdentifier, store, parentRelationship, index) {
+  const {
+    id,
+    type
+  } = payload;
+  if (!payload.relationships) {
+    payload.relationships = {};
+  }
+  const {
+    relationships
+  } = payload;
+  const inverse = getInverse(store, parentIdentifier, parentRelationship, type);
+  if (inverse) {
+    const {
+      inverseKey,
+      kind
+    } = inverse;
+    const relationshipData = relationships[inverseKey]?.data;
+    {
+      if (typeof relationshipData !== 'undefined' && !relationshipDataPointsToParent(relationshipData, parentIdentifier)) {
+        const inspect = function inspect(thing) {
+          return `'${JSON.stringify(thing)}'`;
+        };
+        const quotedType = inspect(type);
+        const quotedInverse = inspect(inverseKey);
+        const expected = inspect({
+          id: parentIdentifier.id,
+          type: parentIdentifier.type
+        });
+        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');
+        (test => {
+          {
+            throw new Error(message);
+          }
+        })();
+      }
+    }
+    if (kind !== 'hasMany' || typeof relationshipData !== 'undefined') {
+      relationships[inverseKey] = relationships[inverseKey] || {};
+      relationships[inverseKey].data = fixRelationshipData(relationshipData ?? null, kind, parentIdentifier);
+    }
+  }
+}
+function inverseForRelationship(store, identifier, key) {
+  const definition = store.schema.fields(identifier).get(key);
+  if (!definition) {
+    return null;
+  }
+  (test => {
+    if (!test) {
+      throw new Error(`Expected the field definition to be a relationship`);
+    }
+  })(definition.kind === 'hasMany' || definition.kind === 'belongsTo');
+  (test => {
+    if (!test) {
+      throw new Error(`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) {
+  const {
+    name: lhs_relationshipName
+  } = parentRelationship;
+  const {
+    type: parentType
+  } = parentIdentifier;
+  const inverseKey = inverseForRelationship(store, {
+    type: parentType
+  }, lhs_relationshipName);
+  if (inverseKey) {
+    const definition = store.schema.fields({
+      type
+    }).get(inverseKey);
+    (test => {
+      if (!test) {
+        throw new Error(`Expected the field definition to be a relationship`);
+      }
+    })(definition && (definition.kind === 'hasMany' || definition.kind === 'belongsTo'));
+    return {
+      inverseKey,
+      kind: definition.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++) {
+      const entry = relationshipData[i];
+      if (validateRelationshipEntry(entry, identifier)) {
+        return true;
+      }
+    }
+  } else {
+    return validateRelationshipEntry(relationshipData, identifier);
+  }
+  return false;
+}
+function fixRelationshipData(relationshipData, relationshipKind, {
+  id,
+  type
+}) {
+  const parentRelationshipData = {
+    id,
+    type
+  };
+  let payload = null;
+  if (relationshipKind === 'hasMany') {
+    const relData = relationshipData || [];
+    if (relationshipData) {
+      (test => {
+        if (!test) {
+          throw new Error('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.
+      const found = relationshipData.find(v => {
+        return v.type === parentRelationshipData.type && v.id === parentRelationshipData.id;
+      });
+      if (!found) {
+        relData.push(parentRelationshipData);
+      }
+    } else {
+      relData.push(parentRelationshipData);
+    }
+    payload = relData;
+  } else {
+    const relData = relationshipData || {};
+    Object.assign(relData, parentRelationshipData);
+    payload = relData;
+  }
+  return payload;
+}
+function validateRelationshipEntry({
+  id
+}, {
+  id: parentModelID
+}) {
+  return !!id && id.toString() === parentModelID;
+}
+
+/*
+  These are the runtime implementations for the javascript macros that have
+  runtime implementations.
+
+  Not every macro has a runtime implementation, some only make sense in the
+  build and always run there.
+
+  Even when we have runtime implementations, we are still careful to emit static
+  errors during the build wherever possible, and runtime errors when necessary,
+  so that you're not surprised when you switch from runtime-mode to compile-time
+  mode.
+*/
+
+// This is here as a compile target for `getConfig` and `getOwnConfig` when
+// we're in runtime mode. This is not public API to call from your own code.
+function config(packageRoot) {
+  return runtimeConfig.packages[packageRoot];
+}
+function getGlobalConfig() {
+  return runtimeConfig.global;
+}
+const runtimeConfig = initializeRuntimeMacrosConfig();
+
+// this exists to be targeted by our babel plugin
+function initializeRuntimeMacrosConfig() {
+  return {
+    "packages": {},
+    "global": {
+      "@embroider/macros": {
+        "isTesting": false
+      },
+      "WarpDrive": {
+        "debug": {
+          "DEBUG_RELATIONSHIP_NOTIFICATIONS": false,
+          "LOG_CACHE": false,
+          "LOG_CACHE_POLICY": false,
+          "LOG_GRAPH": false,
+          "LOG_IDENTIFIERS": false,
+          "LOG_INSTANCE_CACHE": false,
+          "LOG_METRIC_COUNTS": false,
+          "LOG_MUTATIONS": false,
+          "LOG_NOTIFICATIONS": false,
+          "LOG_OPERATIONS": false,
+          "LOG_PAYLOADS": false,
+          "LOG_REACT_SIGNAL_INTEGRATION": false,
+          "LOG_REQUESTS": false,
+          "LOG_REQUEST_STATUS": false,
+          "__INTERNAL_LOG_NATIVE_MAP_SET_COUNTS": false
+        },
+        "polyfillUUID": false,
+        "includeDataAdapter": true,
+        "compatWith": null,
+        "deprecations": {
+          "DEPRECATE_CATCH_ALL": true,
+          "DEPRECATE_COMPUTED_CHAINS": true,
+          "DEPRECATE_EMBER_INFLECTOR": true,
+          "DEPRECATE_LEGACY_IMPORTS": true,
+          "DEPRECATE_MANY_ARRAY_DUPLICATES": true,
+          "DEPRECATE_NON_STRICT_ID": true,
+          "DEPRECATE_NON_STRICT_TYPES": true,
+          "DEPRECATE_NON_UNIQUE_PAYLOADS": true,
+          "DEPRECATE_RELATIONSHIP_REMOTE_UPDATE_CLEARING_LOCAL_STATE": true,
+          "DEPRECATE_STORE_EXTENDS_EMBER_OBJECT": true,
+          "DEPRECATE_TRACKING_PACKAGE": true,
+          "DISABLE_7X_DEPRECATIONS": true,
+          "ENABLE_LEGACY_REQUEST_METHODS": true,
+          "ENABLE_LEGACY_SCHEMA_SERVICE": true
+        },
+        "features": {
+          "ENFORCE_STRICT_RESOURCE_FINALIZATION": false,
+          "JSON_API_CACHE_VALIDATION_ERRORS": false,
+          "SAMPLE_FEATURE_FLAG": null
+        },
+        "activeLogging": {
+          "DEBUG_RELATIONSHIP_NOTIFICATIONS": true,
+          "LOG_CACHE": true,
+          "LOG_CACHE_POLICY": true,
+          "LOG_GRAPH": true,
+          "LOG_IDENTIFIERS": true,
+          "LOG_INSTANCE_CACHE": true,
+          "LOG_METRIC_COUNTS": true,
+          "LOG_MUTATIONS": true,
+          "LOG_NOTIFICATIONS": true,
+          "LOG_OPERATIONS": true,
+          "LOG_PAYLOADS": true,
+          "LOG_REACT_SIGNAL_INTEGRATION": true,
+          "LOG_REQUESTS": true,
+          "LOG_REQUEST_STATUS": true,
+          "__INTERNAL_LOG_NATIVE_MAP_SET_COUNTS": true
+        },
+        "env": {
+          "TESTING": true,
+          "PRODUCTION": false,
+          "DEBUG": true,
+          "IS_RECORDING": false,
+          "IS_CI": true,
+          "SHOULD_RECORD": false
+        }
+      }
+    }
+  };
+}
+function updaterMethods() {
+  return {
+    config,
+    getGlobalConfig,
+    setConfig(packageRoot, value) {
+      runtimeConfig.packages[packageRoot] = value;
+    },
+    setGlobalConfig(key, value) {
+      runtimeConfig.global[key] = value;
+    }
+  };
+}
+
+// this is how runtime config can get injected at boot. I'm not sure yet if this
+// should be public API, but we certainly need it internally to set things like
+// the global fastboot.isRunning.
+//
+// consumers of this API push a function onto
+// window._embroider_macros_runtime_config. The function is given four methods
+// which allow it to read and write the per-package and global configs. The
+// reason for allowing both read & write is that merging strategies are up to
+// each consumers -- read first, then merge, then write.
+//
+// For an example user of this API, see where we generate
+// embroider_macros_fastboot_init.js' in @embroider/core.
+let updaters = typeof window !== 'undefined' ? window._embroider_macros_runtime_config : undefined;
+if (updaters) {
+  let methods = updaterMethods();
+  for (let updater of updaters) {
+    updater(methods);
+  }
+}
+const PotentialLegacyOperations = new Set(['findRecord', 'findAll', 'query', 'queryRecord', 'findBelongsTo', 'findHasMany', 'updateRecord', 'createRecord', 'deleteRecord']);
+const LegacyNetworkHandler = {
+  request(context, next) {
+    // if we are not a legacy request, move on
+    if (context.request.url || !context.request.op || !PotentialLegacyOperations.has(context.request.op)) {
+      return next(context.request);
+    }
+    const {
+      store
+    } = context.request;
+    if (!store._fetchManager) {
+      store._fetchManager = new FetchManager(store);
+    }
+    switch (context.request.op) {
+      case 'findRecord':
+        return findRecord(context);
+      case 'findAll':
+        return findAll(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
+  const pendingRequest = identifier && store._fetchManager.getPendingFetch(identifier, options);
+  if (pendingRequest) {
+    return pendingRequest;
+  }
+  if (useLink) {
+    (test => {
+      if (!test) {
+        throw new Error(`Expected a related link when calling store.findBelongsTo, found ${String(links)}`);
+      }
+    })(links && links.related);
+    return _findBelongsTo(store, record, links.related, field, options);
+  }
+  (test => {
+    if (!test) {
+      throw new Error(`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.
+    */
+    (test => {
+      if (!test) {
+        throw new Error(`You tried to load a hasMany relationship but you have no adapter (for ${record.type})`);
+      }
+    })(adapter);
+    (test => {
+      if (!test) {
+        throw new Error(`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');
+    (test => {
+      if (!test) {
+        throw new Error(`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
+  (test => {
+    if (!test) {
+      throw new Error(`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++) {
+    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);
+  }
+  return Promise.all(fetches);
+}
+function saveRecord(context) {
+  const {
+    store,
+    data,
+    op: operation
+  } = context.request;
+  const {
+    options,
+    record: identifier
+  } = data;
+  assertPrivateStore(store);
+  store.cache.willCommit(identifier, context);
+  const saveOptions = Object.assign({
+    [SaveOp]: operation
+  }, options);
+  const fetchManagerPromise = store._fetchManager.scheduleSave(identifier, saveOptions);
+  return fetchManagerPromise.then(payload => {
+    let result;
+    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
+    // CachePolicy 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;
+    if (!e) {
+      err = new Error(`Unknown Error Occurred During Request`);
+    } else if (typeof e === 'string') {
+      err = new Error(e);
+    }
+    adapterDidInvalidate(store, identifier, err);
+    throw err;
+  });
+}
+function adapterDidInvalidate(store, identifier, error) {
+  if (error && error.isAdapterError === true && error.code === 'InvalidError') {
+    const serializer = store.serializerFor(identifier.type);
+
+    // TODO @deprecate extractErrors being called
+    // TODO remove extractErrors from the default serializers.
+    if (serializer && typeof serializer.extractErrors === 'function') {
+      const errorsHash = serializer.extractErrors(store, store.modelFor(identifier.type), error, identifier.id);
+      error.errors = errorsHashToArray(errorsHash);
+    }
+  }
+  const cache = store.cache;
+  if (error.errors) {
+    (test => {
+      if (!test) {
+        throw new Error(`Expected the cache in use by resource ${String(identifier)} to have a getErrors(identifier) method for retrieving errors.`);
+      }
+    })(typeof cache.getErrors === 'function');
+    let jsonApiErrors = error.errors;
+    if (jsonApiErrors.length === 0) {
+      jsonApiErrors = [{
+        title: 'Invalid Error',
+        detail: '',
+        source: {
+          pointer: '/data'
+        }
+      }];
+    }
+    cache.commitWasRejected(identifier, jsonApiErrors);
+  } else {
+    cache.commitWasRejected(identifier);
+  }
+}
+function makeArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+const PRIMARY_ATTRIBUTE_KEY = 'base';
+function errorsHashToArray(errors) {
+  const out = [];
+  if (errors) {
+    Object.keys(errors).forEach(key => {
+      const messages = makeArray(errors[key]);
+      for (let i = 0; i < messages.length; i++) {
+        let title = 'Invalid Attribute';
+        let pointer = `/data/attributes/${key}`;
+        if (key === PRIMARY_ATTRIBUTE_KEY) {
+          title = 'Invalid Document';
+          pointer = `/data`;
+        }
+        out.push({
+          title: title,
+          detail: messages[i],
+          source: {
+            pointer: pointer
+          }
+        });
+      }
+    });
+  }
+  return out;
+}
+function findRecord(context) {
+  const {
+    store,
+    data
+  } = context.request;
+  const {
+    record: identifier,
+    options
+  } = data;
+  assertPrivateStore(store);
+  let promise;
+
+  // if not loaded start loading
+  if (!store._instanceCache.recordIsLoaded(identifier)) {
+    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, context.request);
+  } else {
+    let snapshot = null;
+    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))) {
+      assertIdentifierHasId(identifier);
+      {
+        promise = store._fetchManager.scheduleFetch(identifier, Object.assign({}, options, {
+          reload: true
+        }), 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._fetchManager.createSnapshot(identifier, options)))) {
+        assertIdentifierHasId(identifier);
+        {
+          void store._fetchManager.scheduleFetch(identifier, Object.assign({}, options, {
+            backgroundReload: true
+          }), context.request);
+        }
+      }
+
+      // Return the cached record
+      promise = Promise.resolve(identifier);
+    }
+  }
+  return promise.then(i => store.peekRecord(i));
+}
+function findAll(context) {
+  const {
+    store,
+    data
+  } = context.request;
+  const {
+    type,
+    options
+  } = data;
+  assertPrivateStore(store);
+  const adapter = store.adapterFor(type);
+  (test => {
+    if (!test) {
+      throw new Error(`You tried to load all records but you have no adapter (for ${type})`);
+    }
+  })(adapter);
+  (test => {
+    if (!test) {
+      throw new Error(`You tried to load all records but your adapter does not implement 'findAll'`);
+    }
+  })(typeof adapter.findAll === 'function');
+
+  // avoid initializing the liveArray just to set `isUpdating`
+  const maybeRecordArray = store.recordArrayManager._live.get(type);
+  const snapshotArray = new SnapshotRecordArray(store, type, options);
+  const shouldReload = options.reload || options.reload !== false && (adapter.shouldReloadAll && adapter.shouldReloadAll(store, snapshotArray) || !adapter.shouldReloadAll && snapshotArray.length === 0);
+  let fetch;
+  if (shouldReload) {
+    // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+    maybeRecordArray && (maybeRecordArray.isUpdating = true);
+    fetch = _findAll(adapter, store, type, snapshotArray, context.request, true);
+  } else {
+    fetch = Promise.resolve(store.peekAll(type));
+    if (options.backgroundReload || options.backgroundReload !== false && (!adapter.shouldBackgroundReloadAll || adapter.shouldBackgroundReloadAll(store, snapshotArray))) {
+      // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+      maybeRecordArray && (maybeRecordArray.isUpdating = true);
+      void _findAll(adapter, store, type, snapshotArray, context.request, false);
+    }
+  }
+  return fetch;
+}
+function _findAll(adapter, store, type, snapshotArray, request, isAsyncFlush) {
+  const schema = store.modelFor(type);
+  let promise = Promise.resolve().then(() => adapter.findAll(store, schema, null, snapshotArray));
+  promise = promise.then(adapterPayload => {
+    (test => {
+      if (!test) {
+        throw new Error(`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, isAsyncFlush);
+    snapshotArray._recordArray.isUpdating = false;
+    {
+      if (getGlobalConfig().WarpDrive.debug.LOG_REQUESTS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_REQUESTS) {
+        // eslint-disable-next-line no-console
+        console.log(`request: findAll<${type}> background reload complete`);
+      }
+    }
+    return snapshotArray._recordArray;
+  });
+  {
+    if (!request.disableTestWaiter) {
+      promise = waitFor(promise);
+    }
+  }
+  return promise;
+}
+function query(context) {
+  const {
+    store,
+    data
+  } = context.request;
+  assertPrivateStore(store);
+  let {
+    options
+  } = data;
+  // eslint-disable-next-line @typescript-eslint/no-shadow
+  const {
+    type,
+    query
+  } = data;
+  const adapter = store.adapterFor(type);
+  (test => {
+    if (!test) {
+      throw new Error(`You tried to make a query but you have no adapter (for ${type})`);
+    }
+  })(adapter);
+  (test => {
+    if (!test) {
+      throw new Error(`You tried to make a query but your adapter does not implement 'query'`);
+    }
+  })(typeof adapter.query === 'function');
+  const recordArray = options._recordArray || store.recordArrayManager.getCollection({
+    type,
+    query
+  });
+  {
+    options = Object.assign({}, options);
+    delete options._recordArray;
+  }
+  const schema = store.modelFor(type);
+  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');
+    const identifiers = store._push(payload, true);
+    (test => {
+      if (!test) {
+        throw new Error('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;
+  });
+}
+function assertSingleResourceDocument(payload) {
+  (test => {
+    if (!test) {
+      throw new Error(`Expected the primary data returned by the serializer for a 'queryRecord' response to be a single object or null but instead it was an array.`);
+    }
+  })(!Array.isArray(payload.data));
+}
+function queryRecord(context) {
+  const {
+    store,
+    data
+  } = context.request;
+  // eslint-disable-next-line @typescript-eslint/no-shadow
+  const {
+    type,
+    query,
+    options
+  } = data;
+  const adapter = store.adapterFor(type);
+  (test => {
+    if (!test) {
+      throw new Error(`You tried to make a query but you have no adapter (for ${type})`);
+    }
+  })(adapter);
+  (test => {
+    if (!test) {
+      throw new Error(`You tried to make a query but your adapter does not implement 'queryRecord'`);
+    }
+  })(typeof adapter.queryRecord === 'function');
+  const schema = store.modelFor(type);
+  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');
+    assertSingleResourceDocument(payload);
+    const identifier = store._push(payload, true);
+    return identifier ? store.peekRecord(identifier) : null;
+  });
+}
+
+/**
+ * Extends the signature of {@link Store} with additional
+ * methods available when using the legacy network layer.
+ *
+ * @public
+ * @noInheritDoc
+ * @legacy
+ */
+
+/**
+ * @deprecated - use {@link LegacyStoreCompat} instead
+ */
+
+/**
+  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).
+
+  @public
+  @param modelName
+*/
+
+function adapterFor(modelName, _allowMissing) {
+  (test => {
+    if (!test) {
+      throw new Error(`Attempted to call store.adapterFor(), but the store instance has already been destroyed.`);
+    }
+  })(!(this.isDestroying || this.isDestroyed));
+  (test => {
+    if (!test) {
+      throw new Error(`You need to pass a model name to the store's adapterFor method`);
+    }
+  })(modelName);
+  (test => {
+    if (!test) {
+      throw new Error(`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;
+  }
+  (test => {
+    if (!test) {
+      throw new Error(`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`.
+
+  @public
+  @param modelName the record to serialize
+  */
+function serializerFor(modelName) {
+  (test => {
+    if (!test) {
+      throw new Error(`Attempted to call store.serializerFor(), but the store instance has already been destroyed.`);
+    }
+  })(!(this.isDestroying || this.isDestroyed));
+  (test => {
+    if (!test) {
+      throw new Error(`You need to pass a model name to the store's serializerFor method`);
+    }
+  })(modelName);
+  (test => {
+    if (!test) {
+      throw new Error(`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 expected by
+  {@link Store.push | push} using the serializer specified by `modelName`
+
+  :::warning
+  Generally it would be better to invoke the serializer yourself directly,
+  or write a more specialized normalization utility.
+  :::
+
+  Example
+
+  ```js
+  socket.on('message', function(message) {
+    let modelName = message.model;
+    let data = message.data;
+    store.push(store.normalize(modelName, data));
+  });
+  ```
+
+  @legacy
+  @public
+  @param modelName The name of the model type for this payload
+  @return The normalized payload
+*/
+// TODO @runspired @deprecate users should call normalize on the associated serializer directly
+function normalize(modelName, payload) {
+  (test => {
+    if (!test) {
+      throw new Error(`Attempted to call store.normalize(), but the store instance has already been destroyed.`);
+    }
+  })(!(this.isDestroying || this.isDestroyed));
+  (test => {
+    if (!test) {
+      throw new Error(`You need to pass a model name to the store's normalize method`);
+    }
+  })(modelName);
+  (test => {
+    if (!test) {
+      throw new Error(`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);
+  (test => {
+    if (!test) {
+      throw new Error(`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.
+
+    ```js [app/serializers/application.js]
+    import RESTSerializer from '@warp-drive/legacy/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.
+
+    ```js [app/serializers/application.js]
+    import RESTSerializer from '@warp-drive/legacy/serializer/rest';
+
+     export default class ApplicationSerializer extends RESTSerializer;
+    ```
+
+    ```js [app/serializers/post.js]
+    import JSONSerializer from '@warp-drive/legacy/serializer/json';
+
+    export default JSONSerializer;
+    ```
+
+    ```js
+    store.pushPayload(pushData); // Will use the application serializer
+    store.pushPayload('post', pushData); // Will use the post serializer
+    ```
+
+    @public
+    @param modelName Optionally, a model type used to determine which serializer will be used
+    @param inputPayload
+  */
+// TODO @runspired @deprecate pushPayload in favor of looking up the serializer
+function pushPayload(modelName, inputPayload) {
+  (test => {
+    if (!test) {
+      throw new Error(`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);
+  (test => {
+    if (!test) {
+      throw new Error(`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 };