@warp-drive-mirror/json-api 5.8.0-alpha.9 → 5.8.0-beta.1

package/dist/unpkg/prod/index.js

@@ -0,0 +1,1884 @@
+import { graphFor, peekGraph, isBelongsTo } from '@warp-drive-mirror/core/graph/-private';
+import { assertPrivateCapabilities, isResourceKey, isRequestKey } from '@warp-drive-mirror/core/store/-private';
+import 'fuse.js';
+import 'json-to-ast';
+
+function isMetaDocument(doc) {
+  return !(doc instanceof Error) && doc.content && !('data' in doc.content) && !('included' in doc.content) && 'meta' in doc.content;
+}
+function isErrorDocument(doc) {
+  return doc instanceof Error;
+}
+
+function isImplicit(relationship) {
+  return relationship.definition.isImplicit;
+}
+const EMPTY_ITERATOR = {
+  iterator() {
+    return {
+      next() {
+        return {
+          done: true,
+          value: undefined
+        };
+      }
+    };
+  }
+};
+function makeCache() {
+  return {
+    id: null,
+    remoteAttrs: null,
+    localAttrs: null,
+    defaultAttrs: null,
+    inflightAttrs: null,
+    changes: null,
+    errors: null,
+    isNew: false,
+    isDeleted: false,
+    isDeletionCommitted: false
+  };
+}
+
+/**
+ * ```ts
+ * import { JSONAPICache } from '@warp-drive-mirror/json-api';
+ * ```
+ *
+ * A {@link Cache} implementation tuned for [{json:api}](https://jsonapi.org/)
+ *
+ * @categoryDescription Cache Management
+ * APIs for primary cache management functionality
+ * @categoryDescription Cache Forking
+ * APIs that support Cache Forking
+ * @categoryDescription SSR Support
+ * APIs that support SSR functionality
+ * @categoryDescription Resource Lifecycle
+ * APIs that support management of resource data
+ * @categoryDescription Resource Data
+ * APIs that support granular field level management of resource data
+ * @categoryDescription Resource State
+ * APIs that support managing Resource states
+ *
+ * @public
+ */
+class JSONAPICache {
+  /**
+   * The Cache Version that this implementation implements.
+   *
+   * @public
+   */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  constructor(capabilities) {
+    this.version = '2';
+    this._capabilities = capabilities;
+    this.__cache = new Map();
+    this.__graph = graphFor(capabilities);
+    this.__destroyedCache = new Map();
+    this.__documents = new Map();
+  }
+
+  ////////// ================ //////////
+  ////////// Cache Management //////////
+  ////////// ================ //////////
+
+  /**
+   * Cache the response to a request
+   *
+   * Implements `Cache.put`.
+   *
+   * Expects a StructuredDocument whose `content` member is a JsonApiDocument.
+   *
+   * ```js
+   * cache.put({
+   *   request: { url: 'https://api.example.com/v1/user/1' },
+   *   content: {
+   *     data: {
+   *       type: 'user',
+   *       id: '1',
+   *       attributes: {
+   *         name: 'Chris'
+   *       }
+   *     }
+   *   }
+   * })
+   * ```
+   *
+   * > **Note**
+   * > The nested `content` and `data` members are not a mistake. This is because
+   * > there are two separate concepts involved here, the `StructuredDocument` which contains
+   * > the context of a given Request that has been issued with the returned contents as its
+   * > `content` property, and a `JSON:API Document` which is the json contents returned by
+   * > this endpoint and which uses its `data` property to signify which resources are the
+   * > primary resources associated with the request.
+   *
+   * StructuredDocument's with urls will be cached as full documents with
+   * associated resource membership order and contents preserved but linked
+   * into the cache.
+   *
+   * @category Cache Management
+   * @public
+   */
+
+  put(doc) {
+    if (isErrorDocument(doc)) {
+      return this._putDocument(doc, undefined, undefined);
+    } else if (isMetaDocument(doc)) {
+      return this._putDocument(doc, undefined, undefined);
+    }
+    const jsonApiDoc = doc.content;
+    const included = jsonApiDoc.included;
+    let i, length;
+    const {
+      cacheKeyManager
+    } = this._capabilities;
+    if (included) {
+      for (i = 0, length = included.length; i < length; i++) {
+        included[i] = putOne(this, cacheKeyManager, included[i]);
+      }
+    }
+    if (Array.isArray(jsonApiDoc.data)) {
+      length = jsonApiDoc.data.length;
+      const identifiers = [];
+      for (i = 0; i < length; i++) {
+        identifiers.push(putOne(this, cacheKeyManager, jsonApiDoc.data[i]));
+      }
+      return this._putDocument(doc, identifiers, included);
+    }
+    if (jsonApiDoc.data === null) {
+      return this._putDocument(doc, null, included);
+    }
+    const identifier = putOne(this, cacheKeyManager, jsonApiDoc.data);
+    return this._putDocument(doc, identifier, included);
+  }
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+  _putDocument(doc, data, included) {
+    // @ts-expect-error narrowing within is just horrible  in TS :/
+    const resourceDocument = isErrorDocument(doc) ? fromStructuredError(doc) : fromBaseDocument(doc);
+    if (data !== undefined) {
+      resourceDocument.data = data;
+    }
+    if (included !== undefined) {
+      resourceDocument.included = included;
+    }
+    const request = doc.request;
+    const identifier = request ? this._capabilities.cacheKeyManager.getOrCreateDocumentIdentifier(request) : null;
+    if (identifier) {
+      resourceDocument.lid = identifier.lid;
+
+      // @ts-expect-error
+      doc.content = resourceDocument;
+      const hasExisting = this.__documents.has(identifier.lid);
+      this.__documents.set(identifier.lid, doc);
+      this._capabilities.notifyChange(identifier, hasExisting ? 'updated' : 'added', null);
+    }
+    if (doc.request?.op === 'findHasMany') {
+      const parentIdentifier = doc.request.options?.identifier;
+      const parentField = doc.request.options?.field;
+      if (parentField && parentIdentifier) {
+        this.__graph.push({
+          op: 'updateRelationship',
+          record: parentIdentifier,
+          field: parentField.name,
+          value: resourceDocument
+        });
+      }
+    }
+    return resourceDocument;
+  }
+
+  /**
+   * Update the "remote" or "canonical" (persisted) state of the Cache
+   * by merging new information into the existing state.
+   *
+   * @category Cache Management
+   * @public
+   * @param op the operation or list of operations to perform
+   */
+  patch(op) {
+    if (Array.isArray(op)) {
+      assertPrivateCapabilities(this._capabilities);
+      this._capabilities._store._join(() => {
+        for (const operation of op) {
+          patchCache(this, operation);
+        }
+      });
+    } else {
+      patchCache(this, op);
+    }
+  }
+
+  /**
+   * Update the "local" or "current" (unpersisted) state of the Cache
+   *
+   * @category Cache Management
+   * @public
+   */
+  mutate(mutation) {
+    this.__graph.update(mutation, false);
+  }
+
+  /**
+   * Peek resource data from the Cache.
+   *
+   * In development, if the return value
+   * is JSON the return value
+   * will be deep-cloned and deep-frozen
+   * to prevent mutation thereby enforcing cache
+   * Immutability.
+   *
+   * This form of peek is useful for implementations
+   * that want to feed raw-data from cache to the UI
+   * or which want to interact with a blob of data
+   * directly from the presentation cache.
+   *
+   * An implementation might want to do this because
+   * de-referencing records which read from their own
+   * blob is generally safer because the record does
+   * not require retainining connections to the Store
+   * and Cache to present data on a per-field basis.
+   *
+   * This generally takes the place of `getAttr` as
+   * an API and may even take the place of `getRelationship`
+   * depending on implementation specifics, though this
+   * latter usage is less recommended due to the advantages
+   * of the Graph handling necessary entanglements and
+   * notifications for relational data.
+   *
+   * :::warning
+   * It is not recommended to use the return value as
+   * a serialized representation of the resource both
+   * due to it containing local mutations and because
+   * it may contain additional fields not recognized
+   * by the {json:api} API implementation such as `lid` and
+   * the various internal WarpDrive bookkeeping fields.
+   * :::
+   *
+   * @category Cache Management
+   * @public
+   */
+
+  peek(identifier) {
+    if (isResourceKey(identifier)) {
+      const peeked = this.__safePeek(identifier, false);
+      if (!peeked) {
+        return null;
+      }
+      const {
+        type,
+        id,
+        lid
+      } = identifier;
+      const attributes = structuredClone(Object.assign({}, peeked.remoteAttrs, peeked.inflightAttrs, peeked.localAttrs));
+      const relationships = {};
+      const rels = this.__graph.identifiers.get(identifier);
+      if (rels) {
+        Object.keys(rels).forEach(key => {
+          const rel = rels[key];
+          if (rel.definition.isImplicit) {
+            return;
+          } else {
+            relationships[key] = this.__graph.getData(identifier, key);
+          }
+        });
+      }
+      assertPrivateCapabilities(this._capabilities);
+      const store = this._capabilities._store;
+      const attrs = getCacheFields(this, identifier);
+      attrs.forEach((attr, key) => {
+        if (key in attributes && attributes[key] !== undefined) {
+          return;
+        }
+        const defaultValue = getDefaultValue(attr, identifier, store);
+        if (defaultValue !== undefined) {
+          attributes[key] = defaultValue;
+        }
+      });
+      return {
+        type,
+        id,
+        lid,
+        attributes,
+        relationships
+      };
+    }
+    const document = this.peekRequest(identifier);
+    if (document) {
+      if ('content' in document) return document.content;
+    }
+    return null;
+  }
+
+  /**
+   * Peek the remote resource data from the Cache.
+   *
+   * @category Cache Management
+   * @public
+   */
+
+  peekRemoteState(identifier) {
+    if (isResourceKey(identifier)) {
+      const peeked = this.__safePeek(identifier, false);
+      if (!peeked) {
+        return null;
+      }
+      const {
+        type,
+        id,
+        lid
+      } = identifier;
+      const attributes = structuredClone(peeked.remoteAttrs);
+      const relationships = {};
+      const rels = this.__graph.identifiers.get(identifier);
+      if (rels) {
+        Object.keys(rels).forEach(key => {
+          const rel = rels[key];
+          if (rel.definition.isImplicit) {
+            return;
+          } else {
+            relationships[key] = structuredClone(this.__graph.getData(identifier, key));
+          }
+        });
+      }
+      assertPrivateCapabilities(this._capabilities);
+      const store = this._capabilities._store;
+      const attrs = getCacheFields(this, identifier);
+      attrs.forEach((attr, key) => {
+        if (key in attributes && attributes[key] !== undefined) {
+          return;
+        }
+        const defaultValue = getDefaultValue(attr, identifier, store);
+        if (defaultValue !== undefined) {
+          attributes[key] = defaultValue;
+        }
+      });
+      return {
+        type,
+        id,
+        lid,
+        attributes,
+        relationships
+      };
+    }
+    const document = this.peekRequest(identifier);
+    if (document) {
+      if ('content' in document) return document.content;
+    }
+    return null;
+  }
+
+  /**
+   * Peek the Cache for the existing request data associated with
+   * a cacheable request.
+   *
+   * This is effectively the reverse of `put` for a request in
+   * that it will return the the request, response, and content
+   * whereas `peek` will return just the `content`.
+   *
+   * @category Cache Management
+   * @public
+   */
+  peekRequest(identifier) {
+    return this.__documents.get(identifier.lid) || null;
+  }
+
+  /**
+   * Push resource data from a remote source into the cache for this identifier
+   *
+   * @category Cache Management
+   * @public
+   * @return if `calculateChanges` is true then calculated key changes should be returned
+   */
+  upsert(identifier, data, calculateChanges) {
+    assertPrivateCapabilities(this._capabilities);
+    const store = this._capabilities._store;
+    if (!store._cbs) {
+      let result = undefined;
+      store._run(() => {
+        result = cacheUpsert(this, identifier, data, calculateChanges);
+      });
+      return result;
+    }
+    return cacheUpsert(this, identifier, data, calculateChanges);
+  }
+
+  ////////// ============= //////////
+  ////////// Cache Forking //////////
+  ////////// ============= //////////
+
+  /**
+   * Create a fork of the cache from the current state.
+   *
+   * Applications should typically not call this method themselves,
+   * preferring instead to fork at the Store level, which will
+   * utilize this method to fork the cache.
+   *
+   * @category Cache Forking
+   * @private
+   */
+  fork() {
+    throw new Error(`Not Implemented`);
+  }
+
+  /**
+   * Merge a fork back into a parent Cache.
+   *
+   * Applications should typically not call this method themselves,
+   * preferring instead to merge at the Store level, which will
+   * utilize this method to merge the caches.
+   *
+   * @category Cache Forking
+   * @private
+   */
+  merge(_cache) {
+    throw new Error(`Not Implemented`);
+  }
+
+  /**
+   * Generate the list of changes applied to all
+   * record in the store.
+   *
+   * Each individual resource or document that has
+   * been mutated should be described as an individual
+   * `Change` entry in the returned array.
+   *
+   * A `Change` is described by an object containing up to
+   * three properties: (1) the `identifier` of the entity that
+   * changed; (2) the `op` code of that change being one of
+   * `upsert` or `remove`, and if the op is `upsert` a `patch`
+   * containing the data to merge into the cache for the given
+   * entity.
+   *
+   * This `patch` is opaque to the Store but should be understood
+   * by the Cache and may expect to be utilized by an Adapter
+   * when generating data during a `save` operation.
+   *
+   * It is generally recommended that the `patch` contain only
+   * the updated state, ignoring fields that are unchanged
+   *
+   * ```ts
+   * interface Change {
+   *  identifier: ResourceKey | RequestKey;
+   *  op: 'upsert' | 'remove';
+   *  patch?: unknown;
+   * }
+   * ```
+   *
+   * @category Cache Forking
+   * @private
+   */
+  diff() {
+    throw new Error(`Not Implemented`);
+  }
+
+  ////////// =========== //////////
+  ////////// SSR Support //////////
+  ////////// =========== //////////
+
+  /**
+   * Serialize the entire contents of the Cache into a Stream
+   * which may be fed back into a new instance of the same Cache
+   * via `cache.hydrate`.
+   *
+   * @category SSR Support
+   * @private
+   */
+  dump() {
+    throw new Error(`Not Implemented`);
+  }
+
+  /**
+   * hydrate a Cache from a Stream with content previously serialized
+   * from another instance of the same Cache, resolving when hydration
+   * is complete.
+   *
+   * This method should expect to be called both in the context of restoring
+   * the Cache during application rehydration after SSR **AND** at unknown
+   * times during the lifetime of an already booted application when it is
+   * desired to bulk-load additional information into the cache. This latter
+   * behavior supports optimizing pre/fetching of data for route transitions
+   * via data-only SSR modes.
+   *
+   * @category SSR Support
+   * @private
+   */
+  hydrate(stream) {
+    throw new Error('Not Implemented');
+  }
+
+  ////////// ================== //////////
+  ////////// Resource Lifecycle //////////
+  ////////// ================== //////////
+
+  /**
+   * [LIFECYCLE] Signal to the cache that a new record has been instantiated on the client
+   *
+   * It returns properties from options that should be set on the record during the create
+   * process. This return value behavior is deprecated.
+   *
+   * @category Resource Lifecycle
+   * @public
+   */
+  clientDidCreate(identifier, options) {
+    const cached = this._createCache(identifier);
+    cached.isNew = true;
+    const createOptions = {};
+    if (options !== undefined) {
+      const fields = getCacheFields(this, identifier);
+      const graph = this.__graph;
+      const propertyNames = Object.keys(options);
+      for (let i = 0; i < propertyNames.length; i++) {
+        const name = propertyNames[i];
+        const propertyValue = options[name];
+        if (name === 'id') {
+          continue;
+        }
+        const fieldType = fields.get(name);
+        const kind = fieldType !== undefined ? 'kind' in fieldType ? fieldType.kind : 'attribute' : null;
+        let relationship;
+        switch (kind) {
+          case 'attribute':
+            this.setAttr(identifier, name, propertyValue);
+            createOptions[name] = propertyValue;
+            break;
+          case 'belongsTo':
+            this.mutate({
+              op: 'replaceRelatedRecord',
+              field: name,
+              record: identifier,
+              value: propertyValue
+            });
+            relationship = graph.get(identifier, name);
+            relationship.state.hasReceivedData = true;
+            relationship.state.isEmpty = false;
+            break;
+          case 'hasMany':
+            this.mutate({
+              op: 'replaceRelatedRecords',
+              field: name,
+              record: identifier,
+              value: propertyValue
+            });
+            relationship = graph.get(identifier, name);
+            relationship.state.hasReceivedData = true;
+            relationship.state.isEmpty = false;
+            break;
+          default:
+            // reflect back (pass-thru) unknown properties
+            createOptions[name] = propertyValue;
+        }
+      }
+    }
+    this._capabilities.notifyChange(identifier, 'added', null);
+    return createOptions;
+  }
+
+  /**
+   * [LIFECYCLE] Signals to the cache that a resource
+   * will be part of a save transaction.
+   *
+   * @category Resource Lifecycle
+   * @public
+   */
+  willCommit(identifier, _context) {
+    if (Array.isArray(identifier)) {
+      for (const key of identifier) {
+        willCommit(this, key);
+      }
+    } else {
+      willCommit(this, identifier);
+    }
+  }
+
+  /**
+   * [LIFECYCLE] Signals to the cache that a resource
+   * was successfully updated as part of a save transaction.
+   *
+   * @category Resource Lifecycle
+   * @public
+   */
+
+  didCommit(committedIdentifier, result) {
+    const payload = result ? result.content : null;
+    const operation = result?.request?.op ?? null;
+    const data = payload && payload.data;
+    const responseIsCollection = Array.isArray(data);
+    const hasMultipleIdentifiers = Array.isArray(committedIdentifier) && committedIdentifier.length > 1;
+    if (Array.isArray(committedIdentifier)) {
+      if (responseIsCollection) {
+        for (let i = 0; i < committedIdentifier.length; i++) {
+          const identifier = committedIdentifier[i];
+          didCommit(this, identifier, data[i] ?? null, operation);
+        }
+        // but if we get back no data or a single entry, we apply
+        // the change back to the original identifier
+      } else {
+        for (let i = 0; i < committedIdentifier.length; i++) {
+          const identifier = committedIdentifier[i];
+          didCommit(this, identifier, i === 0 ? data : null, operation);
+        }
+      }
+    } else {
+      didCommit(this, committedIdentifier, data, operation);
+    }
+    const included = payload && payload.included;
+    const {
+      cacheKeyManager
+    } = this._capabilities;
+    if (included) {
+      for (let i = 0, length = included.length; i < length; i++) {
+        putOne(this, cacheKeyManager, included[i]);
+      }
+    }
+    return hasMultipleIdentifiers && responseIsCollection ? {
+      data: committedIdentifier
+    } : {
+      data: Array.isArray(committedIdentifier) ? committedIdentifier[0] : committedIdentifier
+    };
+  }
+
+  /**
+   * [LIFECYCLE] Signals to the cache that a resource
+   * was update via a save transaction failed.
+   *
+   * @category Resource Lifecycle
+   * @public
+   */
+  commitWasRejected(identifier, errors) {
+    if (Array.isArray(identifier)) {
+      for (let i = 0; i < identifier.length; i++) {
+        commitDidError(this, identifier[i], errors && i === 0 ? errors : null);
+      }
+      return;
+    }
+    return commitDidError(this, identifier, errors || null);
+  }
+
+  /**
+   * [LIFECYCLE] Signals to the cache that all data for a resource
+   * should be cleared.
+   *
+   * This method is a candidate to become a mutation
+   *
+   * @category Resource Lifecycle
+   * @public
+   */
+  unloadRecord(identifier) {
+    const storeWrapper = this._capabilities;
+    // TODO this is necessary because
+    // we maintain memebership inside InstanceCache
+    // for peekAll, so even though we haven't created
+    // any data we think this exists.
+    // TODO can we eliminate that membership now?
+    if (!this.__cache.has(identifier)) {
+      // the graph may still need to unload identity
+      peekGraph(storeWrapper)?.unload(identifier);
+      return;
+    }
+    const removeFromRecordArray = !this.isDeletionCommitted(identifier);
+    let removed = false;
+    const cached = this.__peek(identifier, false);
+    if (cached.isNew || cached.isDeletionCommitted) {
+      peekGraph(storeWrapper)?.push({
+        op: 'deleteRecord',
+        record: identifier,
+        isNew: cached.isNew
+      });
+    } else {
+      peekGraph(storeWrapper)?.unload(identifier);
+    }
+
+    // effectively clearing these is ensuring that
+    // we report as `isEmpty` during teardown.
+    cached.localAttrs = null;
+    cached.remoteAttrs = null;
+    cached.defaultAttrs = null;
+    cached.inflightAttrs = null;
+    const relatedIdentifiers = _allRelatedIdentifiers(storeWrapper, identifier);
+    if (areAllModelsUnloaded(storeWrapper, relatedIdentifiers)) {
+      for (let i = 0; i < relatedIdentifiers.length; ++i) {
+        const relatedIdentifier = relatedIdentifiers[i];
+        storeWrapper.notifyChange(relatedIdentifier, 'removed', null);
+        removed = true;
+        storeWrapper.disconnectRecord(relatedIdentifier);
+      }
+    }
+    this.__cache.delete(identifier);
+    this.__destroyedCache.set(identifier, cached);
+
+    /*
+     * The destroy cache is a hack to prevent applications
+     * from blowing up during teardown. Accessing state
+     * on a destroyed record is not safe, but historically
+     * was possible due to a combination of teardown timing
+     * and retention of cached state directly on the
+     * record itself.
+     *
+     * Once we have deprecated accessing state on a destroyed
+     * instance we may remove this. The timing isn't a huge deal
+     * as momentarily retaining the objects outside the bounds
+     * of a test won't cause issues.
+     */
+    if (this.__destroyedCache.size === 1) {
+      // TODO do we still need this?
+      setTimeout(() => {
+        this.__destroyedCache.clear();
+      }, 100);
+    }
+    if (!removed && removeFromRecordArray) {
+      storeWrapper.notifyChange(identifier, 'removed', null);
+    }
+  }
+
+  ////////// ============= //////////
+  ////////// Resource Data //////////
+  ////////// ============= //////////
+
+  /**
+   * Retrieve the data for an attribute from the cache
+   * with local mutations applied.
+   *
+   * @category Resource Data
+   * @public
+   */
+  getAttr(identifier, attr) {
+    const isSimplePath = !Array.isArray(attr) || attr.length === 1;
+    if (Array.isArray(attr) && attr.length === 1) {
+      attr = attr[0];
+    }
+    if (isSimplePath) {
+      const attribute = attr;
+      const cached = this.__peek(identifier, true);
+
+      // in Prod we try to recover when accessing something that
+      // doesn't exist
+      if (!cached) {
+        return undefined;
+      }
+      if (cached.localAttrs && attribute in cached.localAttrs) {
+        return cached.localAttrs[attribute];
+      } else if (cached.inflightAttrs && attribute in cached.inflightAttrs) {
+        return cached.inflightAttrs[attribute];
+      } else if (cached.remoteAttrs && attribute in cached.remoteAttrs) {
+        return cached.remoteAttrs[attribute];
+      } else if (cached.defaultAttrs && attribute in cached.defaultAttrs) {
+        return cached.defaultAttrs[attribute];
+      } else {
+        const attrSchema = getCacheFields(this, identifier).get(attribute);
+        assertPrivateCapabilities(this._capabilities);
+        const defaultValue = getDefaultValue(attrSchema, identifier, this._capabilities._store);
+        if (schemaHasLegacyDefaultValueFn(attrSchema)) {
+          cached.defaultAttrs = cached.defaultAttrs || Object.create(null);
+          cached.defaultAttrs[attribute] = defaultValue;
+        }
+        return defaultValue;
+      }
+    }
+
+    // TODO @runspired consider whether we need a defaultValue cache in ReactiveResource
+    // like we do for the simple case above.
+    const path = attr;
+    const cached = this.__peek(identifier, true);
+    const basePath = path[0];
+    let current = cached.localAttrs && basePath in cached.localAttrs ? cached.localAttrs[basePath] : undefined;
+    if (current === undefined) {
+      current = cached.inflightAttrs && basePath in cached.inflightAttrs ? cached.inflightAttrs[basePath] : undefined;
+    }
+    if (current === undefined) {
+      current = cached.remoteAttrs && basePath in cached.remoteAttrs ? cached.remoteAttrs[basePath] : undefined;
+    }
+    if (current === undefined) {
+      return undefined;
+    }
+    for (let i = 1; i < path.length; i++) {
+      current = current[path[i]];
+      if (current === undefined) {
+        return undefined;
+      }
+    }
+    return current;
+  }
+
+  /**
+   * Retrieve the remote data for an attribute from the cache
+   *
+   * @category Resource Data
+   * @public
+   */
+  getRemoteAttr(identifier, attr) {
+    const isSimplePath = !Array.isArray(attr) || attr.length === 1;
+    if (Array.isArray(attr) && attr.length === 1) {
+      attr = attr[0];
+    }
+    if (isSimplePath) {
+      const attribute = attr;
+      const cached = this.__peek(identifier, true);
+
+      // in Prod we try to recover when accessing something that
+      // doesn't exist
+      if (!cached) {
+        return undefined;
+      }
+      if (cached.remoteAttrs && attribute in cached.remoteAttrs) {
+        return cached.remoteAttrs[attribute];
+
+        // we still show defaultValues in the case of a remoteAttr access
+      } else if (cached.defaultAttrs && attribute in cached.defaultAttrs) {
+        return cached.defaultAttrs[attribute];
+      } else {
+        const attrSchema = getCacheFields(this, identifier).get(attribute);
+        assertPrivateCapabilities(this._capabilities);
+        const defaultValue = getDefaultValue(attrSchema, identifier, this._capabilities._store);
+        if (schemaHasLegacyDefaultValueFn(attrSchema)) {
+          cached.defaultAttrs = cached.defaultAttrs || Object.create(null);
+          cached.defaultAttrs[attribute] = defaultValue;
+        }
+        return defaultValue;
+      }
+    }
+
+    // TODO @runspired consider whether we need a defaultValue cache in ReactiveResource
+    // like we do for the simple case above.
+    const path = attr;
+    const cached = this.__peek(identifier, true);
+    const basePath = path[0];
+    let current = cached.remoteAttrs && basePath in cached.remoteAttrs ? cached.remoteAttrs[basePath] : undefined;
+    if (current === undefined) {
+      return undefined;
+    }
+    for (let i = 1; i < path.length; i++) {
+      current = current[path[i]];
+      if (current === undefined) {
+        return undefined;
+      }
+    }
+    return current;
+  }
+
+  /**
+   * Mutate the data for an attribute in the cache
+   *
+   * This method is a candidate to become a mutation
+   *
+   * @category Resource Data
+   * @public
+   */
+  setAttr(identifier, attr, value) {
+    const isSimplePath = !Array.isArray(attr) || attr.length === 1;
+    if (Array.isArray(attr) && attr.length === 1) {
+      attr = attr[0];
+    }
+    if (isSimplePath) {
+      const cached = this.__peek(identifier, false);
+      const currentAttr = attr;
+      const existing = cached.inflightAttrs && currentAttr in cached.inflightAttrs ? cached.inflightAttrs[currentAttr] : cached.remoteAttrs && currentAttr in cached.remoteAttrs ? cached.remoteAttrs[currentAttr] : undefined;
+      if (existing !== value) {
+        cached.localAttrs = cached.localAttrs || Object.create(null);
+        cached.localAttrs[currentAttr] = value;
+        cached.changes = cached.changes || Object.create(null);
+        cached.changes[currentAttr] = [existing, value];
+      } else if (cached.localAttrs) {
+        delete cached.localAttrs[currentAttr];
+        delete cached.changes[currentAttr];
+      }
+      if (cached.defaultAttrs && currentAttr in cached.defaultAttrs) {
+        delete cached.defaultAttrs[currentAttr];
+      }
+      this._capabilities.notifyChange(identifier, 'attributes', currentAttr);
+      return;
+    }
+
+    // get current value from local else inflight else remote
+    // structuredClone current if not local (or always?)
+    // traverse path, update value at path
+    // notify change at first link in path.
+    // second pass optimization is change notifyChange signature to take an array path
+
+    // guaranteed that we have path of at least 2 in length
+    const path = attr;
+    const cached = this.__peek(identifier, false);
+
+    // get existing cache record for base path
+    const basePath = path[0];
+    const existing = cached.inflightAttrs && basePath in cached.inflightAttrs ? cached.inflightAttrs[basePath] : cached.remoteAttrs && basePath in cached.remoteAttrs ? cached.remoteAttrs[basePath] : undefined;
+    let existingAttr;
+    if (existing) {
+      existingAttr = existing[path[1]];
+      for (let i = 2; i < path.length; i++) {
+        // the specific change we're making is at path[length - 1]
+        existingAttr = existingAttr[path[i]];
+      }
+    }
+    if (existingAttr !== value) {
+      cached.localAttrs = cached.localAttrs || Object.create(null);
+      cached.localAttrs[basePath] = cached.localAttrs[basePath] || structuredClone(existing);
+      cached.changes = cached.changes || Object.create(null);
+      let currentLocal = cached.localAttrs[basePath];
+      let nextLink = 1;
+      while (nextLink < path.length - 1) {
+        currentLocal = currentLocal[path[nextLink++]];
+      }
+      currentLocal[path[nextLink]] = value;
+      cached.changes[basePath] = [existing, cached.localAttrs[basePath]];
+
+      // since we initiaize the value as basePath as a clone of the value at the remote basePath
+      // then in theory we can use JSON.stringify to compare the two values as key insertion order
+      // ought to be consistent.
+      // we try/catch this because users have a habit of doing "Bad Things"TM wherein the cache contains
+      // stateful values that are not JSON serializable correctly such as Dates.
+      // in the case that we error, we fallback to not removing the local value
+      // so that any changes we don't understand are preserved. Thse objects would then sometimes
+      // appear to be dirty unnecessarily, and for folks that open an issue we can guide them
+      // to make their cache data less stateful.
+    } else if (cached.localAttrs) {
+      try {
+        if (!existing) {
+          return;
+        }
+        const existingStr = JSON.stringify(existing);
+        const newStr = JSON.stringify(cached.localAttrs[basePath]);
+        if (existingStr !== newStr) {
+          delete cached.localAttrs[basePath];
+          delete cached.changes[basePath];
+        }
+      } catch {
+        // noop
+      }
+    }
+    this._capabilities.notifyChange(identifier, 'attributes', basePath);
+  }
+
+  /**
+   * Query the cache for the changed attributes of a resource.
+   *
+   * @category Resource Data
+   * @public
+   * @return `{ '<field>': ['<old>', '<new>'] }`
+   */
+  changedAttrs(identifier) {
+    const cached = this.__peek(identifier, false);
+
+    // in Prod we try to recover when accessing something that
+    // doesn't exist
+    if (!cached) {
+      return Object.create(null);
+    }
+
+    // TODO freeze in dev
+    return cached.changes || Object.create(null);
+  }
+
+  /**
+   * Query the cache for whether any mutated attributes exist
+   *
+   * @category Resource Data
+   * @public
+   */
+  hasChangedAttrs(identifier) {
+    const cached = this.__peek(identifier, true);
+
+    // in Prod we try to recover when accessing something that
+    // doesn't exist
+    if (!cached) {
+      return false;
+    }
+    return cached.inflightAttrs !== null && Object.keys(cached.inflightAttrs).length > 0 || cached.localAttrs !== null && Object.keys(cached.localAttrs).length > 0;
+  }
+
+  /**
+   * Tell the cache to discard any uncommitted mutations to attributes
+   *
+   * This method is a candidate to become a mutation
+   *
+   * @category Resource Data
+   * @public
+   * @return the names of fields that were restored
+   */
+  rollbackAttrs(identifier) {
+    const cached = this.__peek(identifier, false);
+    let dirtyKeys;
+    cached.isDeleted = false;
+    if (cached.localAttrs !== null) {
+      dirtyKeys = Object.keys(cached.localAttrs);
+      cached.localAttrs = null;
+      cached.changes = null;
+    }
+    if (cached.isNew) {
+      // > Note: Graph removal handled by unloadRecord
+      cached.isDeletionCommitted = true;
+      cached.isDeleted = true;
+      cached.isNew = false;
+    }
+    cached.inflightAttrs = null;
+    cached.defaultAttrs = null;
+    if (cached.errors) {
+      cached.errors = null;
+      this._capabilities.notifyChange(identifier, 'errors', null);
+    }
+    this._capabilities.notifyChange(identifier, 'state', null);
+    if (dirtyKeys && dirtyKeys.length) {
+      notifyAttributes(this._capabilities, identifier, new Set(dirtyKeys));
+    }
+    return dirtyKeys || [];
+  }
+
+  /**
+   * Query the cache for the changes to relationships of a resource.
+   *
+   * Returns a map of relationship names to RelationshipDiff objects.
+   *
+   * ```ts
+   * type RelationshipDiff =
+     | {
+        kind: 'collection';
+        remoteState: ResourceKey[];
+        additions: Set<ResourceKey>;
+        removals: Set<ResourceKey>;
+        localState: ResourceKey[];
+        reordered: boolean;
+       }
+     | {
+        kind: 'resource';
+        remoteState: ResourceKey | null;
+        localState: ResourceKey | null;
+      };
+      ```
+   *
+   * @category Resource Data
+   * @public
+   */
+  changedRelationships(identifier) {
+    return this.__graph.getChanged(identifier);
+  }
+
+  /**
+   * Query the cache for whether any mutated relationships exist
+   *
+   * @category Resource Data
+   * @public
+   */
+  hasChangedRelationships(identifier) {
+    return this.__graph.hasChanged(identifier);
+  }
+
+  /**
+   * Tell the cache to discard any uncommitted mutations to relationships.
+   *
+   * This will also discard the change on any appropriate inverses.
+   *
+   * This method is a candidate to become a mutation
+   *
+   * @category Resource Data
+   * @public
+   * @return the names of relationships that were restored
+   */
+  rollbackRelationships(identifier) {
+    assertPrivateCapabilities(this._capabilities);
+    let result;
+    this._capabilities._store._join(() => {
+      result = this.__graph.rollback(identifier);
+    });
+    return result;
+  }
+
+  /**
+   * Query the cache for the current state of a relationship property
+   *
+   * @category Resource Data
+   * @public
+   * @return resource relationship object
+   */
+  getRelationship(identifier, field) {
+    return this.__graph.getData(identifier, field);
+  }
+
+  /**
+   * Query the cache for the remote state of a relationship property
+   *
+   * @category Resource Data
+   * @public
+   * @return resource relationship object
+   */
+  getRemoteRelationship(identifier, field) {
+    return this.__graph.getRemoteData(identifier, field);
+  }
+
+  ////////// ============== //////////
+  ////////// Resource State //////////
+  ////////// ============== //////////
+
+  /**
+   * Update the cache state for the given resource to be marked
+   * as locally deleted, or remove such a mark.
+   *
+   * This method is a candidate to become a mutation
+   *
+   * @category Resource State
+   * @public
+   */
+  setIsDeleted(identifier, isDeleted) {
+    const cached = this.__peek(identifier, false);
+    cached.isDeleted = isDeleted;
+    // > Note: Graph removal for isNew handled by unloadRecord
+    this._capabilities.notifyChange(identifier, 'state', null);
+  }
+
+  /**
+   * Query the cache for any validation errors applicable to the given resource.
+   *
+   * @category Resource State
+   * @public
+   */
+  getErrors(identifier) {
+    return this.__peek(identifier, true).errors || [];
+  }
+
+  /**
+   * Query the cache for whether a given resource has any available data
+   *
+   * @category Resource State
+   * @public
+   */
+  isEmpty(identifier) {
+    const cached = this.__safePeek(identifier, true);
+    return cached ? cached.remoteAttrs === null && cached.inflightAttrs === null && cached.localAttrs === null : true;
+  }
+
+  /**
+   * Query the cache for whether a given resource was created locally and not
+   * yet persisted.
+   *
+   * @category Resource State
+   * @public
+   */
+  isNew(identifier) {
+    // TODO can we assert here?
+    return this.__safePeek(identifier, true)?.isNew || false;
+  }
+
+  /**
+   * Query the cache for whether a given resource is marked as deleted (but not
+   * necessarily persisted yet).
+   *
+   * @category Resource State
+   * @public
+   */
+  isDeleted(identifier) {
+    // TODO can we assert here?
+    return this.__safePeek(identifier, true)?.isDeleted || false;
+  }
+
+  /**
+   * Query the cache for whether a given resource has been deleted and that deletion
+   * has also been persisted.
+   *
+   * @category Resource State
+   * @public
+   */
+  isDeletionCommitted(identifier) {
+    // TODO can we assert here?
+    return this.__safePeek(identifier, true)?.isDeletionCommitted || false;
+  }
+
+  /**
+   * Private method used to populate an entry for the identifier
+   *
+   * @internal
+   */
+  _createCache(identifier) {
+    const cache = makeCache();
+    this.__cache.set(identifier, cache);
+    return cache;
+  }
+
+  /**
+   * Peek whether we have cached resource data matching the identifier
+   * without asserting if the resource data is missing.
+   *
+   * @internal
+   */
+  __safePeek(identifier, allowDestroyed) {
+    let resource = this.__cache.get(identifier);
+    if (!resource && allowDestroyed) {
+      resource = this.__destroyedCache.get(identifier);
+    }
+    return resource;
+  }
+
+  /**
+   * Peek whether we have cached resource data matching the identifier
+   * Asserts if the resource data is missing.
+   *
+   * @internal
+   */
+  __peek(identifier, allowDestroyed) {
+    const resource = this.__safePeek(identifier, allowDestroyed);
+    return resource;
+  }
+}
+function addResourceToDocument(cache, op) {
+  const doc = cache.__documents.get(op.record.lid);
+  const {
+    content
+  } = doc;
+  if (op.field === 'data') {
+    let shouldNotify = false;
+
+    // if data is not an array, we set the data property directly
+    if (!Array.isArray(content.data)) {
+      shouldNotify = content.data !== op.value;
+      if (shouldNotify) content.data = op.value;
+    } else {
+      if (Array.isArray(op.value)) {
+        if (op.index !== undefined) {
+          // for collections, because we allow duplicates we are always changed.
+          shouldNotify = true;
+          content.data.splice(op.index, 0, ...op.value);
+        } else {
+          // for collections, because we allow duplicates we are always changed.
+          shouldNotify = true;
+          content.data.push(...op.value);
+        }
+      } else {
+        if (op.index !== undefined) {
+          // for collections, because we allow duplicates we are always changed.
+          shouldNotify = true;
+          content.data.splice(op.index, 0, op.value);
+        } else {
+          // for collections, because we allow duplicates we are always changed.
+          shouldNotify = true;
+          content.data.push(op.value);
+        }
+      }
+    }
+
+    // notify
+    if (shouldNotify) cache._capabilities.notifyChange(op.record, 'updated', null);
+    return;
+  }
+  content.included = content.included || [];
+  if (Array.isArray(op.value)) {
+    content.included = content.included.concat(op.value);
+  } else {
+    content.included.push(op.value);
+  }
+
+  // we don't notify in the included case because this is not reactively
+  // exposed. We should possibly consider doing so though for subscribers
+}
+function removeResourceFromDocument(cache, op) {
+  const doc = cache.__documents.get(op.record.lid);
+  const {
+    content
+  } = doc;
+  if (op.field === 'data') {
+    let shouldNotify = false;
+
+    // if data is not an array, we set the data property directly
+    if (!Array.isArray(content.data)) {
+      shouldNotify = content.data === op.value;
+      // we only remove the value if it was our existing value
+      if (shouldNotify) content.data = null;
+    } else {
+      const toRemove = Array.isArray(op.value) ? op.value : [op.value];
+      for (let i = 0; i < toRemove.length; i++) {
+        const value = toRemove[i];
+        if (op.index !== undefined) {
+          // in production we want to recover gracefully
+          // so we fallback to first-index-of
+          const index = op.index < content.data.length && content.data[op.index] === value ? op.index : content.data.indexOf(value);
+          if (index !== -1) {
+            // we remove the first occurrence of the value
+            shouldNotify = true;
+            content.data.splice(index, 1);
+          }
+        } else {
+          // we remove the first occurrence of the value
+          const index = content.data.indexOf(value);
+          if (index !== -1) {
+            shouldNotify = true;
+            content.data.splice(index, 1);
+          }
+        }
+      }
+    }
+
+    // notify
+    if (shouldNotify) cache._capabilities.notifyChange(op.record, 'updated', null);
+  } else {
+    content.included = content.included || [];
+    const toRemove = Array.isArray(op.value) ? op.value : [op.value];
+    for (const identifier of toRemove) {
+      const index = content.included.indexOf(identifier);
+      if (index !== -1) {
+        content.included.splice(index, 1);
+      }
+    }
+
+    // we don't notify in the included case because this is not reactively
+    // exposed. We should possibly consider doing so though for subscribers
+  }
+}
+function areAllModelsUnloaded(wrapper, identifiers) {
+  for (let i = 0; i < identifiers.length; ++i) {
+    const identifier = identifiers[i];
+    if (wrapper.hasRecord(identifier)) {
+      return false;
+    }
+  }
+  return true;
+}
+function getLocalState(rel) {
+  if (isBelongsTo(rel)) {
+    return rel.localState ? [rel.localState] : [];
+  }
+  return rel.additions ? [...rel.additions] : [];
+}
+function getRemoteState(rel) {
+  if (isBelongsTo(rel)) {
+    return rel.remoteState ? [rel.remoteState] : [];
+  }
+  return rel.remoteState;
+}
+function schemaHasLegacyDefaultValueFn(schema) {
+  if (!schema) return false;
+  return hasLegacyDefaultValueFn(schema.options);
+}
+function hasLegacyDefaultValueFn(options) {
+  return !!options && typeof options.defaultValue === 'function';
+}
+function getDefaultValue(schema, identifier, store) {
+  const options = schema?.options;
+  if (!schema || !options && !schema.type) {
+    return;
+  }
+  if (schema.kind !== 'attribute' && schema.kind !== 'field') {
+    return;
+  }
+
+  // legacy support for defaultValues that are functions
+  if (hasLegacyDefaultValueFn(options)) {
+    // If anyone opens an issue for args not working right, we'll restore + deprecate it via a Proxy
+    // that lazily instantiates the record. We don't want to provide any args here
+    // because in a non @ember-data-mirror/model world they don't make sense.
+    return options.defaultValue();
+    // legacy support for defaultValues that are primitives
+  } else if (options && 'defaultValue' in options) {
+    const defaultValue = options.defaultValue;
+    return defaultValue;
+
+    // new style transforms
+  } else if (schema.kind !== 'attribute' && schema.type) {
+    const transform = store.schema.transformation(schema);
+    if (transform?.defaultValue) {
+      return transform.defaultValue(options || null, identifier);
+    }
+  }
+}
+function notifyAttributes(storeWrapper, identifier, keys) {
+  if (!keys) {
+    storeWrapper.notifyChange(identifier, 'attributes', null);
+    return;
+  }
+  for (const key of keys) {
+    storeWrapper.notifyChange(identifier, 'attributes', key);
+  }
+}
+
+/*
+      TODO @deprecate IGOR DAVID
+      There seems to be a potential bug here, where we will return keys that are not
+      in the schema
+  */
+function calculateChangedKeys(cached, updates, fields) {
+  const changedKeys = new Set();
+  const keys = Object.keys(updates);
+  const length = keys.length;
+  const localAttrs = cached.localAttrs;
+  const original = Object.assign(Object.create(null), cached.remoteAttrs, cached.inflightAttrs);
+  for (let i = 0; i < length; i++) {
+    const key = keys[i];
+    if (!fields.has(key)) {
+      continue;
+    }
+    const value = updates[key];
+
+    // A value in localAttrs means the user has a local change to
+    // this attribute. We never override this value when merging
+    // updates from the backend so we should not sent a change
+    // notification if the server value differs from the original.
+    if (localAttrs && localAttrs[key] !== undefined) {
+      continue;
+    }
+    if (original[key] !== value) {
+      changedKeys.add(key);
+    }
+  }
+  return changedKeys;
+}
+function cacheIsEmpty(cached) {
+  return !cached || cached.remoteAttrs === null && cached.inflightAttrs === null && cached.localAttrs === null;
+}
+function _isEmpty(peeked) {
+  if (!peeked) {
+    return true;
+  }
+  const isNew = peeked.isNew;
+  const isDeleted = peeked.isDeleted;
+  const isEmpty = cacheIsEmpty(peeked);
+  return (!isNew || isDeleted) && isEmpty;
+}
+function recordIsLoaded(cached, filterDeleted = false) {
+  if (!cached) {
+    return false;
+  }
+  const isNew = cached.isNew;
+  const isEmpty = cacheIsEmpty(cached);
+
+  // if we are new we must consider ourselves loaded
+  if (isNew) {
+    return !cached.isDeleted;
+  }
+  // even if we have a past request, if we are now empty we are not loaded
+  // typically this is true after an unloadRecord call
+
+  // if we are not empty, not new && we have a fulfilled request then we are loaded
+  // we should consider allowing for something to be loaded that is simply "not empty".
+  // which is how RecordState currently handles this case; however, RecordState is buggy
+  // in that it does not account for unloading.
+  return filterDeleted && cached.isDeletionCommitted ? false : !isEmpty;
+}
+function _isLoading(peeked, capabilities, identifier) {
+  assertPrivateCapabilities(capabilities);
+  // TODO refactor things such that the cache is not required to know
+  // about isLoading
+  const req = capabilities._store.getRequestStateService();
+  // const fulfilled = req.getLastRequestForRecord(identifier);
+  const isLoaded = recordIsLoaded(peeked);
+  return !isLoaded &&
+  // fulfilled === null &&
+  req.getPendingRequestsForRecord(identifier).some(r => r.type === 'query');
+}
+function setupRelationships(graph, fields, identifier, data) {
+  for (const name in data.relationships) {
+    const relationshipData = data.relationships[name];
+    const field = fields.get(name);
+    // TODO consider asserting if the relationship is not in the schema
+    // we intentionally ignore relationships that are not in the schema
+    if (!relationshipData || !field || !isRelationship(field)) continue;
+    graph.push({
+      op: 'updateRelationship',
+      record: identifier,
+      field: name,
+      value: relationshipData
+    });
+  }
+}
+function isRelationship(field) {
+  const {
+    kind
+  } = field;
+  return kind === 'hasMany' || kind === 'belongsTo' || kind === 'resource' || kind === 'collection';
+}
+function patchLocalAttributes(cached, changedRemoteKeys) {
+  const {
+    localAttrs,
+    remoteAttrs,
+    inflightAttrs,
+    defaultAttrs,
+    changes
+  } = cached;
+  if (!localAttrs) {
+    cached.changes = null;
+    return false;
+  }
+  let hasAppliedPatch = false;
+  const mutatedKeys = Object.keys(localAttrs);
+  for (let i = 0, length = mutatedKeys.length; i < length; i++) {
+    const attr = mutatedKeys[i];
+    const existing = inflightAttrs && attr in inflightAttrs ? inflightAttrs[attr] : remoteAttrs && attr in remoteAttrs ? remoteAttrs[attr] : undefined;
+    if (existing === localAttrs[attr]) {
+      hasAppliedPatch = true;
+
+      // if the local change is committed, then
+      // the remoteKeyChange is no longer relevant
+      changedRemoteKeys?.delete(attr);
+      delete localAttrs[attr];
+      delete changes[attr];
+    }
+    if (defaultAttrs && attr in defaultAttrs) {
+      delete defaultAttrs[attr];
+    }
+  }
+  return hasAppliedPatch;
+}
+function putOne(cache, identifiers, resource) {
+  let identifier = identifiers.peekResourceKey(resource);
+  if (identifier) {
+    identifier = identifiers.updateRecordIdentifier(identifier, resource);
+  } else {
+    identifier = identifiers.getOrCreateRecordIdentifier(resource);
+  }
+  cache.upsert(identifier, resource, cache._capabilities.hasRecord(identifier));
+  // even if the identifier was not "existing" before, it is now
+  return identifier;
+}
+
+/*
+    Iterates over the set of internal models reachable from `this` across exactly one
+    relationship.
+  */
+function _directlyRelatedIdentifiersIterable(storeWrapper, originating) {
+  const graph = peekGraph(storeWrapper);
+  const initializedRelationships = graph?.identifiers.get(originating);
+  if (!initializedRelationships) {
+    return EMPTY_ITERATOR;
+  }
+  const initializedRelationshipsArr = [];
+  Object.keys(initializedRelationships).forEach(key => {
+    const rel = initializedRelationships[key];
+    if (rel && !isImplicit(rel)) {
+      initializedRelationshipsArr.push(rel);
+    }
+  });
+  let i = 0;
+  let j = 0;
+  let k = 0;
+  const findNext = () => {
+    while (i < initializedRelationshipsArr.length) {
+      while (j < 2) {
+        const relatedIdentifiers = j === 0 ? getLocalState(initializedRelationshipsArr[i]) : getRemoteState(initializedRelationshipsArr[i]);
+        while (k < relatedIdentifiers.length) {
+          const relatedIdentifier = relatedIdentifiers[k++];
+          if (relatedIdentifier !== null) {
+            return relatedIdentifier;
+          }
+        }
+        k = 0;
+        j++;
+      }
+      j = 0;
+      i++;
+    }
+    return undefined;
+  };
+  return {
+    iterator() {
+      return {
+        next: () => {
+          const value = findNext();
+          return {
+            value,
+            done: value === undefined
+          };
+        }
+      };
+    }
+  };
+}
+
+/*
+      Computes the set of Identifiers reachable from this Identifier.
+
+      Reachability is determined over the relationship graph (ie a graph where
+      nodes are identifiers and edges are belongs to or has many
+      relationships).
+
+      Returns an array including `this` and all identifiers reachable
+      from `this.identifier`.
+    */
+function _allRelatedIdentifiers(storeWrapper, originating) {
+  const array = [];
+  const queue = [];
+  const seen = new Set();
+  queue.push(originating);
+  while (queue.length > 0) {
+    const identifier = queue.shift();
+    array.push(identifier);
+    seen.add(identifier);
+    const iterator = _directlyRelatedIdentifiersIterable(storeWrapper, originating).iterator();
+    for (let obj = iterator.next(); !obj.done; obj = iterator.next()) {
+      const relatedIdentifier = obj.value;
+      if (relatedIdentifier && !seen.has(relatedIdentifier)) {
+        seen.add(relatedIdentifier);
+        queue.push(relatedIdentifier);
+      }
+    }
+  }
+  return array;
+}
+function fromBaseDocument(doc) {
+  const resourceDocument = {};
+  const jsonApiDoc = doc.content;
+  if (jsonApiDoc) {
+    copyLinksAndMeta(resourceDocument, jsonApiDoc);
+  }
+  return resourceDocument;
+}
+function fromStructuredError(doc) {
+  const errorDoc = {};
+  if (doc.content) {
+    copyLinksAndMeta(errorDoc, doc.content);
+    if ('errors' in doc.content) {
+      errorDoc.errors = doc.content.errors;
+    } else if (typeof doc.error === 'object' && 'errors' in doc.error) {
+      errorDoc.errors = doc.error.errors;
+    } else {
+      errorDoc.errors = [{
+        title: doc.message
+      }];
+    }
+  }
+  return errorDoc;
+}
+function copyLinksAndMeta(target, source) {
+  if ('links' in source) {
+    target.links = source.links;
+  }
+  if ('meta' in source) {
+    target.meta = source.meta;
+  }
+}
+function cacheUpsert(cache, identifier, data, calculateChanges) {
+  let changedKeys;
+  const peeked = cache.__safePeek(identifier, false);
+  const existed = !!peeked;
+  const cached = peeked || cache._createCache(identifier);
+  const isLoading = /*#__NOINLINE__*/_isLoading(peeked, cache._capabilities, identifier) || !recordIsLoaded(peeked);
+  const isUpdate = /*#__NOINLINE__*/!_isEmpty(peeked) && !isLoading;
+  if (cached.isNew) {
+    cached.isNew = false;
+    cache._capabilities.notifyChange(identifier, 'identity', null);
+    cache._capabilities.notifyChange(identifier, 'state', null);
+  }
+  const fields = getCacheFields(cache, identifier);
+
+  // if no cache entry existed, no record exists / property has been accessed
+  // and thus we do not need to notify changes to any properties.
+  if (calculateChanges && existed && data.attributes) {
+    changedKeys = calculateChangedKeys(cached, data.attributes, fields);
+  }
+  cached.remoteAttrs = Object.assign(cached.remoteAttrs || Object.create(null), data.attributes);
+  if (cached.localAttrs) {
+    if (patchLocalAttributes(cached, changedKeys)) {
+      cache._capabilities.notifyChange(identifier, 'state', null);
+    }
+  }
+  if (!isUpdate) {
+    cache._capabilities.notifyChange(identifier, 'added', null);
+  }
+  if (data.id) {
+    cached.id = data.id;
+  }
+  if (data.relationships) {
+    setupRelationships(cache.__graph, fields, identifier, data);
+  }
+  if (changedKeys?.size) {
+    notifyAttributes(cache._capabilities, identifier, changedKeys);
+  }
+  return changedKeys?.size ? Array.from(changedKeys) : undefined;
+}
+function patchCache(Cache, op) {
+  const isRecord = isResourceKey(op.record);
+  !isRecord && isRequestKey(op.record);
+  switch (op.op) {
+    case 'mergeIdentifiers':
+      {
+        const cache = Cache.__cache.get(op.record);
+        if (cache) {
+          Cache.__cache.set(op.value, cache);
+          Cache.__cache.delete(op.record);
+        }
+        Cache.__graph.update(op, true);
+        break;
+      }
+    case 'update':
+      {
+        if (isRecord) {
+          if ('field' in op) {
+            const field = getCacheFields(Cache, op.record).get(op.field);
+            if (isRelationship(field)) {
+              Cache.__graph.push(op);
+            } else {
+              Cache.upsert(op.record, {
+                type: op.record.type,
+                id: op.record.id,
+                attributes: {
+                  [op.field]: op.value
+                }
+              }, Cache._capabilities.hasRecord(op.record));
+            }
+          } else {
+            Cache.upsert(op.record, op.value, Cache._capabilities.hasRecord(op.record));
+          }
+        }
+        break;
+      }
+    case 'add':
+      {
+        if (isRecord) {
+          if ('field' in op) {
+            Cache.__graph.push(op);
+          } else {
+            Cache.upsert(op.record, op.value, Cache._capabilities.hasRecord(op.record));
+          }
+        } else {
+          addResourceToDocument(Cache, op);
+        }
+        break;
+      }
+    case 'remove':
+      {
+        if (isRecord) {
+          if ('field' in op) {
+            Cache.__graph.push(op);
+          } else {
+            const cached = Cache.__safePeek(op.record, false);
+            if (cached) {
+              cached.isDeleted = true;
+              cached.isDeletionCommitted = true;
+              Cache.unloadRecord(op.record);
+            } else {
+              peekGraph(Cache._capabilities)?.push({
+                op: 'deleteRecord',
+                record: op.record,
+                isNew: false
+              });
+            }
+          }
+        } else {
+          if ('field' in op) {
+            removeResourceFromDocument(Cache, op);
+          }
+        }
+        break;
+      }
+  }
+}
+function getCacheFields(cache, identifier) {
+  if (cache._capabilities.schema.cacheFields) {
+    const result = cache._capabilities.schema.cacheFields(identifier);
+    if (result) {
+      return result;
+    }
+  }
+
+  // the model schema service cannot process fields that are not cache fields
+  return cache._capabilities.schema.fields(identifier);
+}
+function commitDidError(cache, identifier, errors) {
+  const cached = cache.__peek(identifier, false);
+  if (cached.inflightAttrs) {
+    const keys = Object.keys(cached.inflightAttrs);
+    if (keys.length > 0) {
+      const attrs = cached.localAttrs = cached.localAttrs || Object.create(null);
+      for (let i = 0; i < keys.length; i++) {
+        if (attrs[keys[i]] === undefined) {
+          attrs[keys[i]] = cached.inflightAttrs[keys[i]];
+        }
+      }
+    }
+    cached.inflightAttrs = null;
+  }
+  if (errors) {
+    cached.errors = errors;
+  }
+  cache._capabilities.notifyChange(identifier, 'errors', null);
+}
+function didCommit(cache, committedIdentifier, data, op) {
+  const {
+    cacheKeyManager
+  } = cache._capabilities;
+  const existingId = committedIdentifier.id;
+  const identifier = op !== 'deleteRecord' && data ? cacheKeyManager.updateRecordIdentifier(committedIdentifier, data) : committedIdentifier;
+  const cached = cache.__peek(identifier, false);
+  if (cached.isDeleted || op === 'deleteRecord') {
+    cache.__graph.push({
+      op: 'deleteRecord',
+      record: identifier,
+      isNew: false
+    });
+    cached.isDeleted = true;
+    cached.isDeletionCommitted = true;
+    cache._capabilities.notifyChange(identifier, 'removed', null);
+    // TODO @runspired should we early exit here?
+  }
+  const fields = getCacheFields(cache, identifier);
+  cached.isNew = false;
+  let newCanonicalAttributes;
+  if (data) {
+    if (data.id && !cached.id) {
+      cached.id = data.id;
+    }
+    if (identifier === committedIdentifier && identifier.id !== existingId) {
+      cache._capabilities.notifyChange(identifier, 'identity', null);
+    }
+    if (data.relationships) {
+      setupRelationships(cache.__graph, fields, identifier, data);
+    }
+    newCanonicalAttributes = data.attributes;
+  }
+  const changedKeys = newCanonicalAttributes && calculateChangedKeys(cached, newCanonicalAttributes, fields);
+  cached.remoteAttrs = Object.assign(cached.remoteAttrs || Object.create(null), cached.inflightAttrs, newCanonicalAttributes);
+  cached.inflightAttrs = null;
+  patchLocalAttributes(cached, changedKeys);
+  if (cached.errors) {
+    cached.errors = null;
+    cache._capabilities.notifyChange(identifier, 'errors', null);
+  }
+  if (changedKeys?.size) notifyAttributes(cache._capabilities, identifier, changedKeys);
+  cache._capabilities.notifyChange(identifier, 'state', null);
+}
+function willCommit(cache, identifier) {
+  const cached = cache.__peek(identifier, false);
+
+  /*
+      if we have multiple saves in flight at once then
+      we have information loss no matter what. This
+      attempts to lose the least information.
+       If we were to clear inflightAttrs, previous requests
+      would not be able to use it during their didCommit.
+       If we upsert inflightattrs, previous requests incorrectly
+      see more recent inflight changes as part of their own and
+      will incorrectly mark the new state as the correct remote state.
+       We choose this latter behavior to avoid accidentally removing
+      earlier changes.
+       If apps do not want this behavior they can either
+      - chain save requests serially vs allowing concurrent saves
+      - move to using a request handler that caches the inflight state
+        on a per-request basis
+      - change their save requests to only send a "PATCH" instead of a "PUT"
+        so that only latest changes are involved in each request, and then also
+        ensure that the API or their handler reflects only those changes back
+        for upsert into the cache.
+    */
+  if (cached.inflightAttrs) {
+    if (cached.localAttrs) {
+      Object.assign(cached.inflightAttrs, cached.localAttrs);
+    }
+  } else {
+    cached.inflightAttrs = cached.localAttrs;
+  }
+  cached.localAttrs = null;
+}
+
+export { JSONAPICache };