chore: refactor implicit edge to match resource and collection pattern

packages/graph/src/-private/-utils.ts

@@ -11,8 +11,9 @@ import { UpgradedMeta } from './-edge-definition';
 import type { UpdateRelationshipOperation } from './-operations';
 import { coerceId } from './coerce-id';
 import type { CollectionEdge } from './edges/collection';
+import type { ImplicitEdge } from './edges/implicit';
 import type { ResourceEdge } from './edges/resource';
-import type { Graph, GraphEdge, ImplicitRelationship } from './graph';
+import type { Graph, GraphEdge } from './graph';
 
 export function getStore(wrapper: CacheCapabilitiesManager | { _store: Store }): Store {
   assert(`expected a private _store property`, '_store' in wrapper);
@@ -83,7 +84,7 @@ export function isBelongsTo(relationship: GraphEdge): relationship is ResourceEd
   return relationship.definition.kind === 'belongsTo';
 }
 
-export function isImplicit(relationship: GraphEdge): relationship is ImplicitRelationship {
+export function isImplicit(relationship: GraphEdge): relationship is ImplicitEdge {
   return relationship.definition.isImplicit;
 }
 

packages/graph/src/-private/edges/collection.ts

@@ -31,6 +31,7 @@ export function createCollectionEdge(definition: UpgradedMeta, identifier: Stabl
     definition,
     identifier,
     state: createState(),
+    transactionRef: 0,
 
     localMembers: new Set(),
     remoteMembers: new Set(),
@@ -40,7 +41,6 @@ export function createCollectionEdge(definition: UpgradedMeta, identifier: Stabl
 
     meta: null,
     links: null,
-    transactionRef: 0,
   };
 }
 

packages/graph/src/-private/edges/implicit.ts

@@ -0,0 +1,21 @@
+import type { StableRecordIdentifier } from '@ember-data/types/q/identifier';
+
+import type { UpgradedMeta } from '../-edge-definition';
+
+export type ImplicitMeta = UpgradedMeta & { kind: 'implicit'; isImplicit: true };
+
+export interface ImplicitEdge {
+  definition: ImplicitMeta;
+  identifier: StableRecordIdentifier;
+  localMembers: Set<StableRecordIdentifier>;
+  remoteMembers: Set<StableRecordIdentifier>;
+}
+
+export function createImplicitEdge(definition: ImplicitMeta, identifier: StableRecordIdentifier): ImplicitEdge {
+  return {
+    definition,
+    identifier,
+    localMembers: new Set(),
+    remoteMembers: new Set(),
+  };
+}

packages/graph/src/-private/graph.ts

@@ -7,7 +7,7 @@ import type { CacheCapabilitiesManager } from '@ember-data/types/q/cache-store-w
 import { CollectionResourceRelationship, SingleResourceRelationship } from '@ember-data/types/q/ember-data-json-api';
 import type { StableRecordIdentifier } from '@ember-data/types/q/identifier';
 
-import type { EdgeCache, UpgradedMeta } from './-edge-definition';
+import type { EdgeCache } from './-edge-definition';
 import { isLHS, upgradeDefinition } from './-edge-definition';
 import type {
   DeleteRecordOperation,
@@ -27,6 +27,7 @@ import {
   removeIdentifierCompletelyFromRelationship,
 } from './-utils';
 import { type CollectionEdge, createCollectionEdge, legacyGetCollectionRelationshipData } from './edges/collection';
+import { createImplicitEdge, ImplicitEdge, ImplicitMeta } from './edges/implicit';
 import { createResourceEdge, legacyGetResourceRelationshipData, type ResourceEdge } from './edges/resource';
 import addToRelatedRecords from './operations/add-to-related-records';
 import { mergeIdentifier } from './operations/merge-identifier';
@@ -35,14 +36,7 @@ import replaceRelatedRecord from './operations/replace-related-record';
 import replaceRelatedRecords, { syncRemoteToLocal } from './operations/replace-related-records';
 import updateRelationshipOperation from './operations/update-relationship';
 
-export interface ImplicitRelationship {
-  definition: UpgradedMeta & { kind: 'implicit'; isImplicit: true };
-  identifier: StableRecordIdentifier;
-  localMembers: Set<StableRecordIdentifier>;
-  remoteMembers: Set<StableRecordIdentifier>;
-}
-
-export type GraphEdge = ImplicitRelationship | CollectionEdge | ResourceEdge;
+export type GraphEdge = ImplicitEdge | CollectionEdge | ResourceEdge;
 
 export const Graphs = new Map<CacheCapabilitiesManager, Graph>();
 
@@ -133,12 +127,7 @@ export class Graph {
         relationship = relationships[propertyName] = createCollectionEdge(meta, identifier);
       } else {
         assert(`Expected kind to be implicit`, meta.kind === 'implicit' && meta.isImplicit === true);
-        relationship = relationships[propertyName] = {
-          definition: meta,
-          identifier,
-          localMembers: new Set(),
-          remoteMembers: new Set(),
-        } as ImplicitRelationship;
+        relationship = relationships[propertyName] = createImplicitEdge(meta as ImplicitMeta, identifier);
       }
     }
 

packages/graph/src/-private/operations/merge-identifier.ts

@@ -2,8 +2,9 @@ import type { MergeOperation } from '@ember-data/types/q/cache';
 
 import { forAllRelatedIdentifiers, isBelongsTo, isHasMany, notifyChange } from '../-utils';
 import type { CollectionEdge } from '../edges/collection';
+import type { ImplicitEdge } from '../edges/implicit';
 import type { ResourceEdge } from '../edges/resource';
-import type { Graph, GraphEdge, ImplicitRelationship } from '../graph';
+import type { Graph, GraphEdge } from '../graph';
 
 export function mergeIdentifier(graph: Graph, op: MergeOperation, relationships: Record<string, GraphEdge>) {
   Object.keys(relationships).forEach((key) => {
@@ -59,7 +60,7 @@ function mergeHasMany(graph: Graph, rel: CollectionEdge, op: MergeOperation): vo
   }
 }
 
-function mergeImplicit(graph: Graph, rel: ImplicitRelationship, op: MergeOperation): void {
+function mergeImplicit(graph: Graph, rel: ImplicitEdge, op: MergeOperation): void {
   if (rel.remoteMembers.has(op.record)) {
     rel.remoteMembers.delete(op.record);
     rel.remoteMembers.add(op.value);

packages/json-api/src/-private/cache.ts

@@ -9,8 +9,9 @@ import { DEBUG } from '@ember-data/env';
 import { graphFor, peekGraph } from '@ember-data/graph/-private';
 import type { LocalRelationshipOperation } from '@ember-data/graph/-private/-operations';
 import type { CollectionEdge } from '@ember-data/graph/-private/edges/collection';
+import type { ImplicitEdge } from '@ember-data/graph/-private/edges/implicit';
 import type { ResourceEdge } from '@ember-data/graph/-private/edges/resource';
-import type { Graph, GraphEdge, ImplicitRelationship } from '@ember-data/graph/-private/graph';
+import type { Graph, GraphEdge } from '@ember-data/graph/-private/graph';
 import { StructuredErrorDocument } from '@ember-data/request/-private/types';
 import { StoreRequestInfo } from '@ember-data/store/-private/cache-handler';
 import type { IdentifierCache } from '@ember-data/store/-private/caches/identifier-cache';
@@ -39,7 +40,7 @@ import type { StableExistingRecordIdentifier, StableRecordIdentifier } from '@em
 import type { AttributesHash, JsonApiError, JsonApiResource } from '@ember-data/types/q/record-data-json-api';
 import type { AttributeSchema, RelationshipSchema } from '@ember-data/types/q/record-data-schemas';
 
-function isImplicit(relationship: GraphEdge): relationship is ImplicitRelationship {
+function isImplicit(relationship: GraphEdge): relationship is ImplicitEdge {
   return relationship.definition.isImplicit;
 }
 

tests/graph/tests/integration/graph/edge-removal/helpers.ts

@@ -1,6 +1,6 @@
 import { settled } from '@ember/test-helpers';
 
-import type { ImplicitRelationship } from '@ember-data/graph/-private/graph';
+import type { ImplicitEdge } from '@ember-data/graph/-private/edges/implicit';
 import Model, { attr, belongsTo, hasMany } from '@ember-data/model';
 import { recordIdentifierFor } from '@ember-data/store';
 import type { StableRecordIdentifier } from '@ember-data/types/q/identifier';
@@ -186,8 +186,8 @@ export async function setInitialState(context: Context, config: TestConfig, asse
 
     assert.strictEqual(Object.keys(chrisImplicits).length, 1, 'PreCond: Chris has one implicit relationship');
 
-    const chrisImplicitFriend = chrisImplicits[chrisBestFriend.definition.inverseKey] as ImplicitRelationship;
-    const johnImplicitFriend = johnImplicits[johnBestFriend.definition.inverseKey] as ImplicitRelationship;
+    const chrisImplicitFriend = chrisImplicits[chrisBestFriend.definition.inverseKey] as ImplicitEdge;
+    const johnImplicitFriend = johnImplicits[johnBestFriend.definition.inverseKey] as ImplicitEdge;
 
     assert.ok(chrisImplicitFriend, 'PreCond: Chris has an implicit best friend');
 
@@ -346,7 +346,7 @@ export async function testFinalState(
 
     assert.strictEqual(Object.keys(chrisImplicits).length, 1, 'Result: Chris has one implicit relationship key');
 
-    const chrisImplicitFriend = chrisImplicits[testState.chrisInverseKey] as ImplicitRelationship;
+    const chrisImplicitFriend = chrisImplicits[testState.chrisInverseKey] as ImplicitEdge;
 
     assert.ok(chrisImplicitFriend, 'Result: Chris has an implicit relationship for best friend');
     const chrisImplicitState = stateOf(chrisImplicitFriend);
@@ -370,7 +370,7 @@ export async function testFinalState(
       assert.false(graph.implicit.has(johnIdentifier), 'implicit cache for john has been removed');
     } else {
       const johnImplicits = graph.getImplicit(johnIdentifier);
-      const johnImplicitFriend = johnImplicits[testState.johnInverseKey] as ImplicitRelationship;
+      const johnImplicitFriend = johnImplicits[testState.johnInverseKey] as ImplicitEdge;
       assert.strictEqual(
         Object.keys(johnImplicits).length,
         1,

tests/graph/tests/integration/graph/edge-removal/setup.ts

@@ -2,8 +2,9 @@ import { setupTest } from 'ember-qunit';
 
 import { graphFor } from '@ember-data/graph/-private';
 import type { CollectionEdge } from '@ember-data/graph/-private/edges/collection';
+import type { ImplicitEdge } from '@ember-data/graph/-private/edges/implicit';
 import type { ResourceEdge } from '@ember-data/graph/-private/edges/resource';
-import type { GraphEdge, ImplicitRelationship } from '@ember-data/graph/-private/graph';
+import type { GraphEdge } from '@ember-data/graph/-private/graph';
 import type Model from '@ember-data/model';
 import type Store from '@ember-data/store';
 import type {
@@ -45,7 +46,7 @@ class AbstractGraph {
     return graphFor(this.store).get(identifier, propertyName);
   }
 
-  getImplicit(identifier: StableRecordIdentifier): Record<string, ImplicitRelationship> {
+  getImplicit(identifier: StableRecordIdentifier): Record<string, ImplicitEdge> {
     const rels = graphFor(this.store).identifiers.get(identifier);
     let implicits = Object.create(null);
     if (rels) {
@@ -68,7 +69,7 @@ export function isBelongsTo(relationship: GraphEdge): relationship is ResourceEd
   return relationship.definition.kind === 'belongsTo';
 }
 
-export function isImplicit(relationship: GraphEdge): relationship is ImplicitRelationship {
+export function isImplicit(relationship: GraphEdge): relationship is ImplicitEdge {
   return relationship.definition.isImplicit;
 }
 

tests/main/tests/helpers/accessors.ts

@@ -1,5 +1,6 @@
 import { graphFor } from '@ember-data/graph/-private';
-import type { GraphEdge, ImplicitRelationship } from '@ember-data/graph/-private/graph';
+import type { ImplicitEdge } from '@ember-data/graph/-private/edges/implicit';
+import type { GraphEdge } from '@ember-data/graph/-private/graph';
 import type Store from '@ember-data/store';
 import { recordIdentifierFor } from '@ember-data/store';
 import type { CacheCapabilitiesManager } from '@ember-data/types/q/cache-store-wrapper';
@@ -24,7 +25,7 @@ export function hasRelationshipForRecord(
 export function implicitRelationshipsFor(
   storeWrapper: CacheCapabilitiesManager,
   identifier: StableRecordIdentifier
-): { [key: string]: ImplicitRelationship } {
+): { [key: string]: ImplicitEdge } {
   const rels = graphFor(storeWrapper).identifiers.get(identifier);
   if (!rels) {
     throw new Error(`Expected at least one relationship to be populated`);