@warp-drive/legacy 5.8.0-beta.0 → 5.8.0-beta.2

package/dist/unpkg/prod/compat.js

@@ -0,0 +1,727 @@
+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);
+}
+
+// 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']);
+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);
+}
+
+// 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 };