@warp-drive/legacy 5.9.0-alpha.21 → 5.9.0-alpha.22

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

@@ -1,744 +1,3 @@
-import { getOwner } from '@ember/application';
-import { recordIdentifierFor } from '@warp-drive/core';
-import { assertPrivateStore, _deprecatingNormalize } from '@warp-drive/core/store/-private';
-import '@warp-drive/core/reactive/-private';
-import { n as normalizeResponseHelper, F as FetchManager, S as SaveOp, a as SnapshotRecordArray } from "./-private-BdyZaGEh.js";
-import '@warp-drive/core/signals/-leaked';
-function iterateData(data, fn) {
-  if (Array.isArray(data)) {
-    return data.map(fn);
-  } else {
-    return fn(data, 0);
-  }
-}
-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;
-    return adapter.findHasMany(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, 'findHasMany');
-    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);
-    const snapshot = store._fetchManager.createSnapshot(identifier, options);
-    const useLink = !link || typeof link === 'string';
-    const relatedLink = useLink ? link : link.href;
-    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');
-    if (!payload.data && !payload.links && !payload.meta) {
-      return null;
-    }
-    payload = syncRelationshipDataFromLink(store, payload, identifier, relationship);
-    return store._push(payload, true);
-  }, null);
-}
+import { a as serializeRecord, i as pushPayload, n as cleanup, o as serializerFor, r as normalize, s as LegacyNetworkHandler, t as adapterFor } from "./compat-CJ87MzDn.js";
 
-// 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);
-    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 (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;
-  }
-  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);
-    return {
-      inverseKey,
-      kind: definition.kind
-    };
-  }
-}
-function fixRelationshipData(relationshipData, relationshipKind, {
-  id,
-  type
-}) {
-  const parentRelationshipData = {
-    id,
-    type
-  };
-  let payload = null;
-  if (relationshipKind === 'hasMany') {
-    const relData = 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.
-      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;
-}
-const PotentialLegacyOperations = new Set(['findRecord', 'findAll', 'query', 'queryRecord', 'findBelongsTo', 'findHasMany', 'updateRecord', 'createRecord', 'deleteRecord']);
-
-/**
- * A {@link Handler} that fulfills legacy `findRecord`/`findAll`/`query`/
- * `queryRecord`/`findBelongsTo`/`findHasMany`/`createRecord`/`updateRecord`/
- * `deleteRecord` requests using the store's configured {@link MinimumAdapterInterface | adapter}
- * and {@link MinimumSerializerInterface | serializer}, passing any other
- * request through to the next handler unchanged.
- */
-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) {
-    return _findBelongsTo(store, record, links.related, field, options);
-  }
-  const manager = store._fetchManager;
-  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);
-    return _findHasMany(adapter, store, record, links.related, field, options);
-  }
-  const fetches = new Array(identifiers.length);
-  const manager = store._fetchManager;
-  for (let i = 0; i < identifiers.length; i++) {
-    const identifier = identifiers[i];
-    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) {
-    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) {
-    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))) {
-      {
-        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._fetchManager.createSnapshot(identifier, options)))) {
-        {
-          options.backgroundReload = true;
-          void store._fetchManager.scheduleFetch(identifier, options, 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);
-
-  // 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 => {
-    const serializer = store.serializerFor(type);
-    const payload = normalizeResponseHelper(serializer, store, schema, adapterPayload, null, 'findAll');
-    store._push(payload, isAsyncFlush);
-    snapshotArray._recordArray.isUpdating = false;
-    return snapshotArray._recordArray;
-  });
-  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);
-  const recordArray = options._recordArray || store.recordArrayManager.getCollection({
-    type,
-    query
-  });
-  {
-    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);
-    store.recordArrayManager.populateManagedArray(recordArray, identifiers, payload);
-    return recordArray;
-  });
-}
-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);
-  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');
-    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) {
-  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;
-  }
-}
-
-/**
-  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) {
-  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) {
-  const normalizedModelName = _deprecatingNormalize(modelName);
-  const serializer = this.serializerFor(normalizedModelName);
-  const schema = this.modelFor(normalizedModelName);
-  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) {
-  const payload = inputPayload || modelName;
-  const normalizedModelName = inputPayload ? _deprecatingNormalize(modelName) : 'application';
-  const serializer = this.serializerFor(normalizedModelName);
-  serializer.pushPayload(this, payload);
-}
-
-/**
- * Serializes a record using the store's legacy network layer, as with
- * {@link LegacyStoreCompat.serializeRecord | store.serializeRecord}.
- */
-// 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);
-}
-
-/**
- * Destroys any adapters/serializers the legacy network layer has created
- * for this store, invoked when the store itself is destroyed.
- */
-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 };