@warp-drive/core 5.7.0-alpha.14 → 5.7.0-alpha.16

package/dist/graph/-private.js

@@ -117,11 +117,11 @@ function inspect(value) {
   }
   return 'object';
 }
-function checkIfNew(store, identifier) {
-  if (!identifier.id) {
+function checkIfNew(store, resourceKey) {
+  if (!resourceKey.id) {
     return true;
   }
-  return store.cache.isNew(identifier);
+  return store.cache.isNew(resourceKey);
 }
 function isBelongsTo(relationship) {
   return relationship.definition.kind === 'belongsTo';
@@ -208,13 +208,13 @@ function notifyChange(graph, relationship) {
   if (!relationship.accessed) {
     return;
   }
-  const identifier = relationship.identifier;
+  const resourceKey = relationship.identifier;
   const key = relationship.definition.key;
-  if (identifier === graph._removing) {
+  if (resourceKey === graph._removing) {
     if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_GRAPH)) {
       if (getGlobalConfig().WarpDrive.debug.LOG_GRAPH || globalThis.getWarpDriveRuntimeConfig().debug.LOG_GRAPH) {
         // eslint-disable-next-line no-console
-        console.log(`Graph: ignoring relationship change for removed identifier ${String(identifier)} ${key}`);
+        console.log(`Graph: ignoring relationship change for removed identifier ${String(resourceKey)} ${key}`);
       }
     }
     return;
@@ -222,37 +222,37 @@ function notifyChange(graph, relationship) {
   if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_GRAPH)) {
     if (getGlobalConfig().WarpDrive.debug.LOG_GRAPH || globalThis.getWarpDriveRuntimeConfig().debug.LOG_GRAPH) {
       // eslint-disable-next-line no-console
-      console.log(`Graph: notifying relationship change for ${String(identifier)} ${key}`);
+      console.log(`Graph: notifying relationship change for ${String(resourceKey)} ${key}`);
     }
   }
-  graph.store.notifyChange(identifier, 'relationships', key);
+  graph.store.notifyChange(resourceKey, 'relationships', key);
 }
-function assertRelationshipData(store, identifier, data, meta) {
+function assertRelationshipData(store, resourceKey, data, meta) {
   macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
     if (!test) {
-      throw new Error(`A ${identifier.type} record was pushed into the store with the value of ${meta.key} being '${JSON.stringify(data)}', but ${meta.key} is a belongsTo relationship so the value must not be an array. You should probably check your data payload or serializer.`);
+      throw new Error(`A ${resourceKey.type} record was pushed into the store with the value of ${meta.key} being '${JSON.stringify(data)}', but ${meta.key} is a belongsTo relationship so the value must not be an array. You should probably check your data payload or serializer.`);
     }
   })(!Array.isArray(data)) : {};
   macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
     if (!test) {
-      throw new Error(`Encountered a relationship identifier without a type for the ${meta.kind} relationship '${meta.key}' on <${identifier.type}:${String(identifier.id)}>, expected an identifier with type '${meta.type}' but found\n\n'${JSON.stringify(data, null, 2)}'\n\nPlease check your serializer and make sure it is serializing the relationship payload into a JSON API format.`);
+      throw new Error(`Encountered a relationship identifier without a type for the ${meta.kind} relationship '${meta.key}' on <${resourceKey.type}:${String(resourceKey.id)}>, expected an identifier with type '${meta.type}' but found\n\n'${JSON.stringify(data, null, 2)}'\n\nPlease check your serializer and make sure it is serializing the relationship payload into a JSON API format.`);
     }
   })(data === null || 'type' in data && typeof data.type === 'string' && data.type.length) : {};
   macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
     if (!test) {
-      throw new Error(`Encountered a relationship identifier without an id for the ${meta.kind} relationship '${meta.key}' on <${identifier.type}:${String(identifier.id)}>, expected an identifier but found\n\n'${JSON.stringify(data, null, 2)}'\n\nPlease check your serializer and make sure it is serializing the relationship payload into a JSON API format.`);
+      throw new Error(`Encountered a relationship identifier without an id for the ${meta.kind} relationship '${meta.key}' on <${resourceKey.type}:${String(resourceKey.id)}>, expected an identifier but found\n\n'${JSON.stringify(data, null, 2)}'\n\nPlease check your serializer and make sure it is serializing the relationship payload into a JSON API format.`);
     }
   })(data === null || !!coerceId(data.id)) : {};
   if (data?.type === meta.type) {
     macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
       if (!test) {
-        throw new Error(`Missing Schema: Encountered a relationship identifier { type: '${data.type}', id: '${String(data.id)}' } for the '${identifier.type}.${meta.key}' ${meta.kind} relationship on <${identifier.type}:${String(identifier.id)}>, but no schema exists for that type.`);
+        throw new Error(`Missing Schema: Encountered a relationship identifier { type: '${data.type}', id: '${String(data.id)}' } for the '${resourceKey.type}.${meta.key}' ${meta.kind} relationship on <${resourceKey.type}:${String(resourceKey.id)}>, but no schema exists for that type.`);
       }
     })(store.schema.hasResource(data)) : {};
   } else {
     macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
       if (!test) {
-        throw new Error(`Missing Schema: Encountered a relationship identifier with type '${data.type}' for the ${meta.kind} relationship '${meta.key}' on <${identifier.type}:${String(identifier.id)}>, Expected an identifier with type '${meta.type}'. No schema was found for '${data.type}'.`);
+        throw new Error(`Missing Schema: Encountered a relationship identifier with type '${data.type}' for the ${meta.kind} relationship '${meta.key}' on <${resourceKey.type}:${String(resourceKey.id)}>, Expected an identifier with type '${meta.type}'. No schema was found for '${data.type}'.`);
       }
     })(data === null || !data.type || store.schema.hasResource(data)) : {};
   }
@@ -485,13 +485,13 @@ function isLHS(info, type, key) {
   }
   return false;
 }
-function upgradeDefinition(graph, identifier, propertyName, isImplicit = false) {
+function upgradeDefinition(graph, key, propertyName, isImplicit = false) {
   const cache = graph._definitionCache;
   const storeWrapper = graph.store;
   const polymorphicLookup = graph._potentialPolymorphicTypes;
   const {
     type
-  } = identifier;
+  } = key;
   let cached = /*#__NOINLINE__*/expandingGet(cache, type, propertyName);
 
   // CASE: We have a cached resolution (null if no relationship exists)
@@ -503,7 +503,7 @@ function upgradeDefinition(graph, identifier, propertyName, isImplicit = false)
       throw new Error(`Expected to find relationship definition in the cache for the implicit relationship ${propertyName}`);
     }
   })(!isImplicit) : {};
-  const relationships = storeWrapper.schema.fields(identifier);
+  const relationships = storeWrapper.schema.fields(key);
   macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
     if (!test) {
       throw new Error(`Expected to have a relationship definition for ${type} but none was found.`);
@@ -555,7 +555,7 @@ function upgradeDefinition(graph, identifier, propertyName, isImplicit = false)
     })(getStore(storeWrapper).modelFor(inverseType)) : {};
     inverseDefinition = null;
   } else {
-    inverseKey = /*#__NOINLINE__*/inverseForRelationship(getStore(storeWrapper), identifier, propertyName);
+    inverseKey = /*#__NOINLINE__*/inverseForRelationship(getStore(storeWrapper), key, propertyName);
 
     // CASE: If we are polymorphic, and we declared an inverse that is non-null
     // we must assume that the lack of inverseKey means that there is no
@@ -711,8 +711,8 @@ function upgradeDefinition(graph, identifier, propertyName, isImplicit = false)
   expandingSet(cache, inverseType, inverseKey, info);
   return info;
 }
-function inverseForRelationship(store, identifier, key) {
-  const definition = store.schema.fields(identifier).get(key);
+function inverseForRelationship(store, resourceKey, key) {
+  const definition = store.schema.fields(resourceKey).get(key);
   if (!definition) {
     return null;
   }
@@ -991,7 +991,7 @@ function replaceRelatedRecords(graph, op, isRemote) {
   }
 }
 function replaceRelatedRecordsLocal(graph, op, isRemote) {
-  const identifiers = op.value;
+  const resourceKeys = op.value;
   const relationship = graph.get(op.record, op.field);
   macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
     if (!test) {
@@ -1017,48 +1017,48 @@ function replaceRelatedRecordsLocal(graph, op, isRemote) {
       count(`replaceRelatedRecordsLocal ${'type' in record ? record.type : '<document>'} ${op.field}`);
     }
   }
-  const onAdd = identifier => {
+  const onAdd = resourceKey => {
     // Since we are diffing against the remote state, we check
-    // if our previous local state did not contain this identifier
-    const removalsHas = removals?.has(identifier);
-    if (removalsHas || !additions?.has(identifier)) {
-      if (type !== identifier.type) {
+    // if our previous local state did not contain this ResourceKey
+    const removalsHas = removals?.has(resourceKey);
+    if (removalsHas || !additions?.has(resourceKey)) {
+      if (type !== resourceKey.type) {
         if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
-          assertPolymorphicType(relationship.identifier, relationship.definition, identifier, graph.store);
+          assertPolymorphicType(relationship.identifier, relationship.definition, resourceKey, graph.store);
         }
-        graph.registerPolymorphicType(type, identifier.type);
+        graph.registerPolymorphicType(type, resourceKey.type);
       }
 
       // we've added a record locally that wasn't in the local state before
       localBecameDirty = true;
-      addToInverse(graph, identifier, inverseKey, op.record, isRemote);
+      addToInverse(graph, resourceKey, inverseKey, op.record, isRemote);
       if (removalsHas) {
-        removals.delete(identifier);
+        removals.delete(resourceKey);
       }
     }
   };
-  const onRemove = identifier => {
+  const onRemove = resourceKey => {
     // Since we are diffing against the remote state, we check
-    // if our previous local state had contained this identifier
-    const additionsHas = additions?.has(identifier);
-    if (additionsHas || !removals?.has(identifier)) {
+    // if our previous local state had contained this ResourceKey
+    const additionsHas = additions?.has(resourceKey);
+    if (additionsHas || !removals?.has(resourceKey)) {
       // we've removed a record locally that was in the local state before
       localBecameDirty = true;
-      removeFromInverse(graph, identifier, inverseKey, record, isRemote);
+      removeFromInverse(graph, resourceKey, inverseKey, record, isRemote);
       if (additionsHas) {
-        additions.delete(identifier);
+        additions.delete(resourceKey);
       }
     }
   };
-  const diff = diffCollection(identifiers, relationship, onAdd, onRemove);
+  const diff = diffCollection(resourceKeys, relationship, onAdd, onRemove);
 
   // any additions no longer in the local state
   // also need to be removed from the inverse
   if (additions && additions.size > 0) {
-    additions.forEach(identifier => {
-      if (!diff.add.has(identifier)) {
+    additions.forEach(resourceKey => {
+      if (!diff.add.has(resourceKey)) {
         localBecameDirty = true;
-        onRemove(identifier);
+        onRemove(resourceKey);
       }
     });
   }
@@ -1066,10 +1066,10 @@ function replaceRelatedRecordsLocal(graph, op, isRemote) {
   // any removals no longer in the local state
   // also need to be added back to the inverse
   if (removals && removals.size > 0) {
-    removals.forEach(identifier => {
-      if (!diff.del.has(identifier)) {
+    removals.forEach(resourceKey => {
+      if (!diff.del.has(resourceKey)) {
         localBecameDirty = true;
-        onAdd(identifier);
+        onAdd(resourceKey);
       }
     });
   }
@@ -1085,7 +1085,7 @@ function replaceRelatedRecordsLocal(graph, op, isRemote) {
   }
 }
 function replaceRelatedRecordsRemote(graph, op, isRemote) {
-  const identifiers = op.value;
+  const resourceKeys = op.value;
   const relationship = graph.get(op.record, op.field);
   if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_METRIC_COUNTS)) {
     if (getGlobalConfig().WarpDrive.debug.LOG_METRIC_COUNTS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_METRIC_COUNTS) {
@@ -1117,18 +1117,18 @@ function replaceRelatedRecordsRemote(graph, op, isRemote) {
   const {
     type
   } = relationship.definition;
-  const diff = diffCollection(identifiers, relationship, identifier => {
-    if (type !== identifier.type) {
+  const diff = diffCollection(resourceKeys, relationship, resourceKey => {
+    if (type !== resourceKey.type) {
       if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
-        assertPolymorphicType(relationship.identifier, relationship.definition, identifier, graph.store);
+        assertPolymorphicType(relationship.identifier, relationship.definition, resourceKey, graph.store);
       }
-      graph.registerPolymorphicType(type, identifier.type);
+      graph.registerPolymorphicType(type, resourceKey.type);
     }
     // commit additions
     // TODO build this into the diff?
     // because we are not dirty if this was a committed local addition
-    if (relationship.additions?.has(identifier)) {
-      relationship.additions.delete(identifier);
+    if (relationship.additions?.has(resourceKey)) {
+      relationship.additions.delete(resourceKey);
     } else {
       if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.DEBUG_RELATIONSHIP_NOTIFICATIONS)) {
         if (getGlobalConfig().WarpDrive.debug.DEBUG_RELATIONSHIP_NOTIFICATIONS || globalThis.getWarpDriveRuntimeConfig().debug.DEBUG_RELATIONSHIP_NOTIFICATIONS) {
@@ -1139,13 +1139,13 @@ function replaceRelatedRecordsRemote(graph, op, isRemote) {
         }
       }
     }
-    addToInverse(graph, identifier, definition.inverseKey, op.record, isRemote);
-  }, identifier => {
+    addToInverse(graph, resourceKey, definition.inverseKey, op.record, isRemote);
+  }, resourceKey => {
     // commit removals
     // TODO build this into the diff?
     // because we are not dirty if this was a committed local addition
-    if (relationship.removals?.has(identifier)) {
-      relationship.removals.delete(identifier);
+    if (relationship.removals?.has(resourceKey)) {
+      relationship.removals.delete(resourceKey);
     } else {
       if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.DEBUG_RELATIONSHIP_NOTIFICATIONS)) {
         if (getGlobalConfig().WarpDrive.debug.DEBUG_RELATIONSHIP_NOTIFICATIONS || globalThis.getWarpDriveRuntimeConfig().debug.DEBUG_RELATIONSHIP_NOTIFICATIONS) {
@@ -1156,7 +1156,7 @@ function replaceRelatedRecordsRemote(graph, op, isRemote) {
         }
       }
     }
-    removeFromInverse(graph, identifier, definition.inverseKey, op.record, isRemote);
+    removeFromInverse(graph, resourceKey, definition.inverseKey, op.record, isRemote);
   });
 
   // replace existing state
@@ -1187,30 +1187,30 @@ function replaceRelatedRecordsRemote(graph, op, isRemote) {
       };
       if (relationship.removals) {
         relationship.isDirty = true;
-        relationship.removals.forEach(identifier => {
+        relationship.removals.forEach(resourceKey => {
           deprecationInfo.triggered = true;
-          deprecationInfo.removals.push(identifier);
+          deprecationInfo.removals.push(resourceKey);
           // reverse the removal
           // if we are still in removals at this point then
           // we were not "committed" which means we are present
           // in the remoteMembers. So we "add back" on the inverse.
-          addToInverse(graph, identifier, definition.inverseKey, op.record, false);
+          addToInverse(graph, resourceKey, definition.inverseKey, op.record, false);
         });
         relationship.removals = null;
       }
       if (relationship.additions) {
-        relationship.additions.forEach(identifier => {
+        relationship.additions.forEach(resourceKey => {
           // reverse the addition
           // if we are still in additions at this point then
           // we were not "committed" which means we are not present
           // in the remoteMembers. So we "remove" from the inverse.
           // however we only do this if we are not a "new" record.
-          if (!checkIfNew(graph._realStore, identifier)) {
+          if (!checkIfNew(graph._realStore, resourceKey)) {
             deprecationInfo.triggered = true;
-            deprecationInfo.additions.push(identifier);
+            deprecationInfo.additions.push(resourceKey);
             relationship.isDirty = true;
-            relationship.additions.delete(identifier);
-            removeFromInverse(graph, identifier, definition.inverseKey, op.record, false);
+            relationship.additions.delete(resourceKey);
+            removeFromInverse(graph, resourceKey, definition.inverseKey, op.record, false);
           }
         });
         if (relationship.additions.size === 0) {
@@ -1235,8 +1235,8 @@ function replaceRelatedRecordsRemote(graph, op, isRemote) {
     flushCanonical(graph, relationship);
   }
 }
-function addToInverse(graph, identifier, key, value, isRemote) {
-  const relationship = graph.get(identifier, key);
+function addToInverse(graph, resourceKey, key, value, isRemote) {
+  const relationship = graph.get(resourceKey, key);
   const {
     type
   } = relationship.definition;
@@ -1252,13 +1252,13 @@ function addToInverse(graph, identifier, key, value, isRemote) {
     if (isRemote) {
       graph._addToTransaction(relationship);
       if (relationship.remoteState !== null) {
-        removeFromInverse(graph, relationship.remoteState, relationship.definition.inverseKey, identifier, isRemote);
+        removeFromInverse(graph, relationship.remoteState, relationship.definition.inverseKey, resourceKey, isRemote);
       }
       relationship.remoteState = value;
     }
     if (relationship.localState !== value) {
       if (!isRemote && relationship.localState) {
-        removeFromInverse(graph, relationship.localState, relationship.definition.inverseKey, identifier, isRemote);
+        removeFromInverse(graph, relationship.localState, relationship.definition.inverseKey, resourceKey, isRemote);
       }
       relationship.localState = value;
       notifyChange(graph, relationship);
@@ -1289,7 +1289,7 @@ function addToInverse(graph, identifier, key, value, isRemote) {
       if (!relationship.isDirty && !relationship.localState) {
         relationship.localState = [];
       }
-      if (_add(graph, identifier, relationship, value, null, isRemote)) {
+      if (_add(graph, resourceKey, relationship, value, null, isRemote)) {
         notifyChange(graph, relationship);
       }
     }
@@ -1306,14 +1306,14 @@ function addToInverse(graph, identifier, key, value, isRemote) {
     }
   }
 }
-function notifyInverseOfPotentialMaterialization(graph, identifier, key, value, isRemote) {
-  const relationship = graph.get(identifier, key);
+function notifyInverseOfPotentialMaterialization(graph, resourceKey, key, value, isRemote) {
+  const relationship = graph.get(resourceKey, key);
   if (isHasMany(relationship) && isRemote && relationship.remoteMembers.has(value)) {
     notifyChange(graph, relationship);
   }
 }
-function removeFromInverse(graph, identifier, key, value, isRemote) {
-  const relationship = graph.get(identifier, key);
+function removeFromInverse(graph, resourceKey, key, value, isRemote) {
+  const relationship = graph.get(resourceKey, key);
   if (isBelongsTo(relationship)) {
     relationship.state.isEmpty = true;
     if (isRemote) {
@@ -2101,18 +2101,18 @@ function _removeRemote(relationship, value) {
   })(relationship.localState || relationship.isDirty) : {};
   return true;
 }
-function rollbackRelationship(graph, identifier, field, relationship) {
+function rollbackRelationship(graph, key, field, relationship) {
   if (isBelongsTo(relationship)) {
     replaceRelatedRecord(graph, {
       op: 'replaceRelatedRecord',
-      record: identifier,
+      record: key,
       field,
       value: relationship.remoteState
     }, false);
   } else {
     replaceRelatedRecords(graph, {
       op: 'replaceRelatedRecords',
-      record: identifier,
+      record: key,
       field,
       value: relationship.remoteState.slice()
     }, false);
@@ -2477,7 +2477,7 @@ function updateRelationshipOperation(graph, op) {
           throw new Error(`Expected an array`);
         }
       })(Array.isArray(payload.data)) : {};
-      const cache = graph.store.identifierCache;
+      const cache = graph.store.cacheKeyManager;
       graph.update({
         op: 'replaceRelatedRecords',
         record: identifier,
@@ -2489,7 +2489,7 @@ function updateRelationshipOperation(graph, op) {
         op: 'replaceRelatedRecord',
         record: identifier,
         field: op.field,
-        value: payload.data ? graph.store.identifierCache.upgradeIdentifier(payload.data) : null
+        value: payload.data ? graph.store.cacheKeyManager.upgradeIdentifier(payload.data) : null
       }, true);
     }
   } else if (definition.isAsync === false && !state.hasReceivedData) {
@@ -2625,21 +2625,21 @@ class Graph {
     this._removing = null;
     this.silenceNotifications = false;
   }
-  has(identifier, propertyName) {
-    const relationships = this.identifiers.get(identifier);
+  has(resourceKey, propertyName) {
+    const relationships = this.identifiers.get(resourceKey);
     if (!relationships) {
       return false;
     }
     return relationships[propertyName] !== undefined;
   }
-  getDefinition(identifier, propertyName) {
-    let defs = this._metaCache[identifier.type];
+  getDefinition(resourceKey, propertyName) {
+    let defs = this._metaCache[resourceKey.type];
     let meta = defs?.[propertyName];
     if (!meta) {
-      const info = /*#__NOINLINE__*/upgradeDefinition(this, identifier, propertyName);
+      const info = /*#__NOINLINE__*/upgradeDefinition(this, resourceKey, propertyName);
       macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
         if (!test) {
-          throw new Error(`Could not determine relationship information for ${identifier.type}.${propertyName}`);
+          throw new Error(`Could not determine relationship information for ${resourceKey.type}.${propertyName}`);
         }
       })(info !== null) : {};
 
@@ -2649,43 +2649,43 @@ class Graph {
       // this.registerPolymorphicType(info.rhs_baseModelName, identifier.type);
       // }
 
-      meta = /*#__NOINLINE__*/isLHS(info, identifier.type, propertyName) ? info.lhs_definition : info.rhs_definition;
-      defs = this._metaCache[identifier.type] = defs || {};
+      meta = /*#__NOINLINE__*/isLHS(info, resourceKey.type, propertyName) ? info.lhs_definition : info.rhs_definition;
+      defs = this._metaCache[resourceKey.type] = defs || {};
       defs[propertyName] = meta;
     }
     return meta;
   }
-  get(identifier, propertyName) {
+  get(resourceKey, propertyName) {
     macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
       if (!test) {
         throw new Error(`expected propertyName`);
       }
     })(propertyName) : {};
-    let relationships = this.identifiers.get(identifier);
+    let relationships = this.identifiers.get(resourceKey);
     if (!relationships) {
       relationships = Object.create(null);
-      this.identifiers.set(identifier, relationships);
+      this.identifiers.set(resourceKey, relationships);
     }
     let relationship = relationships[propertyName];
     if (!relationship) {
-      const meta = this.getDefinition(identifier, propertyName);
+      const meta = this.getDefinition(resourceKey, propertyName);
       if (meta.kind === 'belongsTo') {
-        relationship = relationships[propertyName] = createResourceEdge(meta, identifier);
+        relationship = relationships[propertyName] = createResourceEdge(meta, resourceKey);
       } else if (meta.kind === 'hasMany') {
-        relationship = relationships[propertyName] = createCollectionEdge(meta, identifier);
+        relationship = relationships[propertyName] = createCollectionEdge(meta, resourceKey);
       } else {
         macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
           if (!test) {
             throw new Error(`Expected kind to be implicit`);
           }
         })(meta.kind === 'implicit' && meta.isImplicit === true) : {};
-        relationship = relationships[propertyName] = createImplicitEdge(meta, identifier);
+        relationship = relationships[propertyName] = createImplicitEdge(meta, resourceKey);
       }
     }
     return relationship;
   }
-  getData(identifier, propertyName) {
-    const relationship = this.get(identifier, propertyName);
+  getData(resourceKey, propertyName) {
+    const relationship = this.get(resourceKey, propertyName);
     macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
       if (!test) {
         throw new Error(`Cannot getData() on an implicit relationship`);
@@ -2696,8 +2696,8 @@ class Graph {
     }
     return legacyGetCollectionRelationshipData(relationship, false);
   }
-  getRemoteData(identifier, propertyName) {
-    const relationship = this.get(identifier, propertyName);
+  getRemoteData(resourceKey, propertyName) {
+    const relationship = this.get(resourceKey, propertyName);
     macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
       if (!test) {
         throw new Error(`Cannot getRemoteData() on an implicit relationship`);
@@ -2733,13 +2733,13 @@ class Graph {
     }
     t2[type1] = true;
   }
-  isReleasable(identifier) {
-    const relationships = this.identifiers.get(identifier);
+  isReleasable(resourceKey) {
+    const relationships = this.identifiers.get(resourceKey);
     if (!relationships) {
       if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_GRAPH)) {
         if (getGlobalConfig().WarpDrive.debug.LOG_GRAPH || globalThis.getWarpDriveRuntimeConfig().debug.LOG_GRAPH) {
           // eslint-disable-next-line no-console
-          console.log(`graph: RELEASABLE ${String(identifier)}`);
+          console.log(`graph: RELEASABLE ${String(resourceKey)}`);
         }
       }
       return true;
@@ -2757,11 +2757,11 @@ class Graph {
           throw new Error(`Expected a relationship`);
         }
       })(relationship) : {};
-      if (relationship.definition.inverseIsAsync && !checkIfNew(this._realStore, identifier)) {
+      if (relationship.definition.inverseIsAsync && !checkIfNew(this._realStore, resourceKey)) {
         if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_GRAPH)) {
           if (getGlobalConfig().WarpDrive.debug.LOG_GRAPH || globalThis.getWarpDriveRuntimeConfig().debug.LOG_GRAPH) {
             // eslint-disable-next-line no-console
-            console.log(`graph: <<NOT>> RELEASABLE ${String(identifier)}`);
+            console.log(`graph: <<NOT>> RELEASABLE ${String(resourceKey)}`);
           }
         }
         return false;
@@ -2770,19 +2770,19 @@ class Graph {
     if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_GRAPH)) {
       if (getGlobalConfig().WarpDrive.debug.LOG_GRAPH || globalThis.getWarpDriveRuntimeConfig().debug.LOG_GRAPH) {
         // eslint-disable-next-line no-console
-        console.log(`graph: RELEASABLE ${String(identifier)}`);
+        console.log(`graph: RELEASABLE ${String(resourceKey)}`);
       }
     }
     return true;
   }
-  unload(identifier, silenceNotifications) {
+  unload(resourceKey, silenceNotifications) {
     if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_GRAPH)) {
       if (getGlobalConfig().WarpDrive.debug.LOG_GRAPH || globalThis.getWarpDriveRuntimeConfig().debug.LOG_GRAPH) {
         // eslint-disable-next-line no-console
-        console.log(`graph: unload ${String(identifier)}`);
+        console.log(`graph: unload ${String(resourceKey)}`);
       }
     }
-    const relationships = this.identifiers.get(identifier);
+    const relationships = this.identifiers.get(resourceKey);
     if (relationships) {
       // cleans up the graph but retains some nodes
       // to allow for rematerialization
@@ -2800,8 +2800,8 @@ class Graph {
       });
     }
   }
-  _isDirty(identifier, field) {
-    const relationships = this.identifiers.get(identifier);
+  _isDirty(resourceKey, field) {
+    const relationships = this.identifiers.get(resourceKey);
     if (!relationships) {
       return false;
     }
@@ -2818,8 +2818,8 @@ class Graph {
     }
     return false;
   }
-  getChanged(identifier) {
-    const relationships = this.identifiers.get(identifier);
+  getChanged(resourceKey) {
+    const relationships = this.identifiers.get(resourceKey);
     const changed = new Map();
     if (!relationships) {
       return changed;
@@ -2857,21 +2857,21 @@ class Graph {
     }
     return changed;
   }
-  hasChanged(identifier) {
-    const relationships = this.identifiers.get(identifier);
+  hasChanged(resourceKey) {
+    const relationships = this.identifiers.get(resourceKey);
     if (!relationships) {
       return false;
     }
     const keys = Object.keys(relationships);
     for (let i = 0; i < keys.length; i++) {
-      if (this._isDirty(identifier, keys[i])) {
+      if (this._isDirty(resourceKey, keys[i])) {
         return true;
       }
     }
     return false;
   }
-  rollback(identifier) {
-    const relationships = this.identifiers.get(identifier);
+  rollback(resourceKey) {
+    const relationships = this.identifiers.get(resourceKey);
     const changed = [];
     if (!relationships) {
       return changed;
@@ -2883,28 +2883,28 @@ class Graph {
       if (!relationship) {
         continue;
       }
-      if (this._isDirty(identifier, field)) {
-        rollbackRelationship(this, identifier, field, relationship);
+      if (this._isDirty(resourceKey, field)) {
+        rollbackRelationship(this, resourceKey, field, relationship);
         changed.push(field);
       }
     }
     return changed;
   }
-  remove(identifier) {
+  remove(resourceKey) {
     if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_GRAPH)) {
       if (getGlobalConfig().WarpDrive.debug.LOG_GRAPH || globalThis.getWarpDriveRuntimeConfig().debug.LOG_GRAPH) {
         // eslint-disable-next-line no-console
-        console.log(`graph: remove ${String(identifier)}`);
+        console.log(`graph: remove ${String(resourceKey)}`);
       }
     }
     macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
       if (!test) {
-        throw new Error(`Cannot remove ${String(identifier)} while still removing ${String(this._removing)}`);
+        throw new Error(`Cannot remove ${String(resourceKey)} while still removing ${String(this._removing)}`);
       }
     })(!this._removing) : {};
-    this._removing = identifier;
-    this.unload(identifier);
-    this.identifiers.delete(identifier);
+    this._removing = resourceKey;
+    this.unload(resourceKey);
+    this.identifiers.delete(resourceKey);
     this._removing = null;
   }
 
@@ -3176,7 +3176,7 @@ function destroyRelationship(graph, rel, silenceNotifications) {
     }
   }
 }
-function notifyInverseOfDematerialization(graph, inverseIdentifier, inverseKey, identifier, silenceNotifications) {
+function notifyInverseOfDematerialization(graph, inverseIdentifier, inverseKey, resourceKey, silenceNotifications) {
   if (!graph.has(inverseIdentifier, inverseKey)) {
     return;
   }
@@ -3189,8 +3189,8 @@ function notifyInverseOfDematerialization(graph, inverseIdentifier, inverseKey,
 
   // For remote members, it is possible that inverseRecordData has already been associated to
   // to another record. For such cases, do not dematerialize the inverseRecordData
-  if (!isBelongsTo(relationship) || !relationship.localState || identifier === relationship.localState) {
-    /*#__NOINLINE__*/removeDematerializedInverse(graph, relationship, identifier, silenceNotifications);
+  if (!isBelongsTo(relationship) || !relationship.localState || resourceKey === relationship.localState) {
+    /*#__NOINLINE__*/removeDematerializedInverse(graph, relationship, resourceKey, silenceNotifications);
   }
 }
 function clearRelationship(relationship) {