@warp-drive/core 5.6.0-alpha.17 → 5.6.0-alpha.5

package/declarations/graph/-private/-edge-definition.d.ts

@@ -1,148 +0,0 @@
-import type { StableRecordIdentifier } from "../../types.js";
-import type { CollectionField, FieldSchema, LegacyBelongsToField, LegacyHasManyField, ResourceField } from "../../types/schema/fields.js";
-import type { Graph } from "./graph.js";
-export type EdgeCache = Record<string, Record<string, EdgeDefinition | null>>;
-export type RelationshipField = LegacyBelongsToField | LegacyHasManyField | ResourceField | CollectionField;
-export type RelationshipFieldKind = RelationshipField["kind"];
-export type CollectionKind = "hasMany" | "collection";
-export type ResourceKind = "belongsTo" | "resource";
-export declare const RELATIONSHIP_KINDS: string[];
-export declare function isLegacyField(field: FieldSchema): field is LegacyBelongsToField | LegacyHasManyField;
-export declare function isRelationshipField(field: FieldSchema): field is RelationshipField;
-export declare function temporaryConvertToLegacy(field: ResourceField | CollectionField): LegacyBelongsToField | LegacyHasManyField;
-/**
-*
-* Given RHS (Right Hand Side)
-*
-* ```ts
-* class User extends Model {
-*   @hasMany('animal', { async: false, inverse: 'owner' }) pets;
-* }
-* ```
-*
-* Given LHS (Left Hand Side)
-*
-* ```ts
-* class Animal extends Model {
-*  @belongsTo('user', { async: false, inverse: 'pets' }) owner;
-* }
-* ```
-*
-* The UpgradedMeta for the RHS would be:
-*
-* ```ts
-* {
-*   kind: 'hasMany',
-*   key: 'pets',
-*   type: 'animal',
-*   isAsync: false,
-*   isImplicit: false,
-*   isCollection: true,
-*   isPolymorphic: false,
-*   inverseKind: 'belongsTo',
-*   inverseKey: 'owner',
-*   inverseType: 'user',
-*   inverseIsAsync: false,
-*   inverseIsImplicit: false,
-*   inverseIsCollection: false,
-*   inverseIsPolymorphic: false,
-* }
-* ```
-*
-* The UpgradeMeta for the LHS would be:
-*
-* ```ts
-* {
-*   kind: 'belongsTo',
-*   key: 'owner',
-*   type: 'user',
-*   isAsync: false,
-*   isImplicit: false,
-*   isCollection: false,
-*   isPolymorphic: false,
-*   inverseKind: 'hasMany',
-*   inverseKey: 'pets',
-*   inverseType: 'animal',
-*   inverseIsAsync: false,
-*   inverseIsImplicit: false,
-*   inverseIsCollection: true,
-*   inverseIsPolymorphic: false,
-* }
-* ```
-*
-*
-* @class UpgradedMeta
-* @internal
-*/
-export interface UpgradedMeta {
-	kind: "implicit" | RelationshipFieldKind;
-	/**
-	* The field name on `this` record
-	*
-	* @internal
-	*/
-	key: string;
-	/**
-	* The `type` of the related record
-	*
-	* @internal
-	*/
-	type: string;
-	isAsync: boolean;
-	isImplicit: boolean;
-	isCollection: boolean;
-	isPolymorphic: boolean;
-	resetOnRemoteUpdate: boolean;
-	isLinksMode: boolean;
-	inverseKind: "implicit" | RelationshipFieldKind;
-	/**
-	* The field name on the opposing record
-	* @internal
-	*/
-	inverseKey: string;
-	/**
-	* The `type` of `this` record
-	* @internal
-	*/
-	inverseType: string;
-	inverseIsAsync: boolean;
-	inverseIsImplicit: boolean;
-	inverseIsCollection: boolean;
-	inverseIsPolymorphic: boolean;
-	inverseIsLinksMode: boolean;
-}
-export interface EdgeDefinition {
-	lhs_key: string;
-	lhs_modelNames: string[];
-	lhs_baseModelName: string;
-	lhs_relationshipName: string;
-	lhs_definition: UpgradedMeta;
-	lhs_isPolymorphic: boolean;
-	rhs_key: string;
-	rhs_modelNames: string[];
-	rhs_baseModelName: string;
-	rhs_relationshipName: string;
-	rhs_definition: UpgradedMeta | null;
-	rhs_isPolymorphic: boolean;
-	hasInverse: boolean;
-	/**
-	* Whether this relationship points back at the same type.
-	*
-	* If the relationship is polymorphic, this will be true if
-	* it points back at the same abstract type.
-	*
-	* @internal
-	*/
-	isSelfReferential: boolean;
-	/**
-	* If this is a reflexive relationship, this is true
-	* if the relationship also points back at the same
-	* field.
-	*
-	* @internal
-	*/
-	isReflexive: boolean;
-}
-export declare function isLHS(info: EdgeDefinition, type: string, key: string): boolean;
-export declare function isRHS(info: EdgeDefinition, type: string, key: string): boolean;
-export declare function upgradeDefinition(graph: Graph, identifier: StableRecordIdentifier, propertyName: string, isImplicit?: boolean): EdgeDefinition | null;

package/declarations/graph/-private/-state.d.ts

@@ -1,96 +0,0 @@
-export interface RelationshipState {
-	/*
-	This flag indicates whether we should consider the content
-	of this relationship "known".
-	
-	If we have no relationship knowledge, and the relationship
-	is `async`, we will attempt to fetch the relationship on
-	access if it is also stale.
-	
-	Snapshot uses this to tell the difference between unknown
-	(`undefined`) or empty (`null`). The reason for this is that
-	we wouldn't want to serialize  unknown relationships as `null`
-	as that might overwrite remote state.
-	
-	All relationships for a newly created (`store.createRecord()`) are
-	considered known (`hasReceivedData === true`).
-	
-	true when
-	=> we receive a push with either new data or explicit empty (`[]` or `null`)
-	=> the relationship is a belongsTo and we have received data from
-	the other side.
-	
-	false when
-	=> we have received no signal about what data belongs in this relationship
-	=> the relationship is a hasMany and we have only received data from
-	the other side.
-	*/
-	hasReceivedData: boolean;
-	/*
-	Flag that indicates whether an empty relationship is explicitly empty
-	(signaled by push giving us an empty array or null relationship)
-	e.g. an API response has told us that this relationship is empty.
-	
-	Thus far, it does not appear that we actually need this flag; however,
-	@runspired has found it invaluable when debugging relationship tests
-	to determine whether (and why if so) we are in an incorrect state.
-	
-	true when
-	=> we receive a push with explicit empty (`[]` or `null`)
-	=> we have received no signal about what data belongs in this relationship
-	=> on initial create (as no signal is known yet)
-	
-	false at all other times
-	*/
-	isEmpty: boolean;
-	/*
-	This flag indicates whether we should
-	re-fetch the relationship the next time
-	it is accessed.
-	
-	The difference between this flag and `shouldForceReload`
-	is in how we treat the presence of partially missing data:
-	- for a forced reload, we will reload the link or EVERY record
-	- for a stale reload, we will reload the link (if present) else only MISSING records
-	
-	Ideally these flags could be merged, but because we don't give the
-	request layer the option of deciding how to resolve the data being queried
-	we are forced to differentiate for now.
-	
-	It is also possible for a relationship to remain stale after a forced reload; however,
-	in this case `state.hasFailedLoadAttempt` ought to be `true`.
-	
-	false when
-	=> cache.isNew(identifier) on initial setup
-	=> a previously triggered request has resolved
-	=> we get relationship data via push
-	
-	true when
-	=> !cache.isNew(identifier) on initial setup
-	=> an inverse has been unloaded
-	=> we get a new link for the relationship
-	
-	TODO @runspired unskip the acceptance tests and fix these flags
-	*/
-	isStale: boolean;
-	hasFailedLoadAttempt: boolean;
-	/*
-	This flag forces fetch. `true` for a single request once `reload()`
-	has been called `false` at all other times.
-	*/
-	shouldForceReload: boolean;
-	/*
-	This flag indicates whether we should
-	**partially** re-fetch the relationship the
-	next time it is accessed.
-	
-	false when
-	=> initial setup
-	=> a previously triggered request has resolved
-	
-	true when
-	=> an inverse has been unloaded
-	*/
-	hasDematerializedInverse: boolean;
-}
-export declare function createState(): RelationshipState;

package/declarations/graph/-private/-utils.d.ts

@@ -1,31 +0,0 @@
-import type { Store } from "../../store/-private.js";
-import type { CacheCapabilitiesManager } from "../../types.js";
-import type { UpdateResourceRelationshipOperation } from "../../types/cache/operations.js";
-import type { UpdateRelationshipOperation } from "../../types/graph.js";
-import type { StableRecordIdentifier } from "../../types/identifier.js";
-import type { ResourceIdentifierObject } from "../../types/spec/json-api-raw.js";
-import type { UpgradedMeta } from "./-edge-definition.js";
-import type { CollectionEdge } from "./edges/collection.js";
-import type { ImplicitEdge } from "./edges/implicit.js";
-import type { ResourceEdge } from "./edges/resource.js";
-import type { Graph, GraphEdge } from "./graph.js";
-export declare function getStore(wrapper: CacheCapabilitiesManager | {
-	_store: Store;
-}): Store;
-export declare function expandingGet<T>(cache: Record<string, Record<string, T>>, key1: string, key2: string): T | undefined;
-export declare function expandingSet<T>(cache: Record<string, Record<string, T>>, key1: string, key2: string, value: T): void;
-export declare function assertValidRelationshipPayload(graph: Graph, op: UpdateRelationshipOperation | UpdateResourceRelationshipOperation): void;
-export declare function isNew(identifier: StableRecordIdentifier): boolean;
-export declare function isBelongsTo(relationship: GraphEdge): relationship is ResourceEdge;
-export declare function isImplicit(relationship: GraphEdge): relationship is ImplicitEdge;
-export declare function isHasMany(relationship: GraphEdge): relationship is CollectionEdge;
-export declare function forAllRelatedIdentifiers(rel: GraphEdge, cb: (identifier: StableRecordIdentifier) => void): void;
-/*
-Removes the given identifier from BOTH remote AND local state.
-
-This method is useful when either a deletion or a rollback on a new record
-needs to entirely purge itself from an inverse relationship.
-*/
-export declare function removeIdentifierCompletelyFromRelationship(graph: Graph, relationship: GraphEdge, value: StableRecordIdentifier, silenceNotifications?: boolean): void;
-export declare function notifyChange(graph: Graph, relationship: CollectionEdge | ResourceEdge): void;
-export declare function assertRelationshipData(store: Store, identifier: StableRecordIdentifier, data: ResourceIdentifierObject, meta: UpgradedMeta): void;

package/declarations/graph/-private/coerce-id.d.ts

@@ -1,10 +0,0 @@
-// Used by the store to normalize IDs entering the store.  Despite the fact
-// that developers may provide IDs as numbers (e.g., `store.findRecord('person', 1)`),
-// it is important that internally we use strings, since IDs may be serialized
-// and lose type information.  For example, Ember's router may put a record's
-// ID into the URL, and if we later try to deserialize that URL and find the
-// corresponding record, we will not know if it is a string or a number.
-type Coercable = string | number | boolean | null | undefined | symbol;
-export declare function coerceId(id: Coercable): string | null;
-export declare function ensureStringId(id: Coercable): string;
-export {};

package/declarations/graph/-private/debug/assert-polymorphic-type.d.ts

@@ -1,18 +0,0 @@
-import type { CacheCapabilitiesManager } from "../../../types.js";
-import type { StableRecordIdentifier } from "../../../types/identifier.js";
-import { type UpgradedMeta } from "../-edge-definition.js";
-/*
-Assert that `addedRecord` has a valid type so it can be added to the
-relationship of the `record`.
-
-The assert basically checks if the `addedRecord` can be added to the
-relationship (specified via `relationshipMeta`) of the `record`.
-
-This utility should only be used internally, as both record parameters must
-be stable record identifiers and the `relationshipMeta` needs to be the meta
-information about the relationship, retrieved via
-`record.relationshipFor(key)`.
-*/
-declare let assertPolymorphicType: (parentIdentifier: StableRecordIdentifier, parentDefinition: UpgradedMeta, addedIdentifier: StableRecordIdentifier, store: CacheCapabilitiesManager) => void;
-declare let assertInheritedSchema: (definition: UpgradedMeta, type: string) => void;
-export { assertPolymorphicType, assertInheritedSchema };

package/declarations/graph/-private/edges/collection.d.ts

@@ -1,39 +0,0 @@
-import type { CollectionRelationship } from "../../../types/cache/relationship.js";
-import type { StableRecordIdentifier } from "../../../types/identifier.js";
-import type { Links, Meta, PaginationLinks } from "../../../types/spec/json-api-raw.js";
-import type { UpgradedMeta } from "../-edge-definition.js";
-import type { RelationshipState } from "../-state.js";
-export interface CollectionEdge {
-	definition: UpgradedMeta;
-	identifier: StableRecordIdentifier;
-	state: RelationshipState;
-	remoteMembers: Set<StableRecordIdentifier>;
-	remoteState: StableRecordIdentifier[];
-	additions: Set<StableRecordIdentifier> | null;
-	removals: Set<StableRecordIdentifier> | null;
-	meta: Meta | null;
-	links: Links | PaginationLinks | null;
-	localState: StableRecordIdentifier[] | null;
-	/**
-	* Whether the localState for this edge is out-of-sync
-	* with the remoteState.
-	*
-	* if state.hasReceivedData=false we are also
-	* not dirty since there is nothing to sync with.
-	*
-	*/
-	isDirty: boolean;
-	transactionRef: number;
-	/**
-	* Whether data for this edge has been accessed at least once
-	* via `graph.getData`
-	*
-	*/
-	accessed: boolean;
-	_diff?: {
-		add: Set<StableRecordIdentifier>;
-		del: Set<StableRecordIdentifier>;
-	};
-}
-export declare function createCollectionEdge(definition: UpgradedMeta, identifier: StableRecordIdentifier): CollectionEdge;
-export declare function legacyGetCollectionRelationshipData(source: CollectionEdge, getRemoteState: boolean): CollectionRelationship;

package/declarations/graph/-private/edges/implicit.d.ts

@@ -1,43 +0,0 @@
-import type { StableRecordIdentifier } from "../../../types/identifier.js";
-import type { UpgradedMeta } from "../-edge-definition.js";
-export type ImplicitMeta = UpgradedMeta & {
-	kind: "implicit";
-	isImplicit: true;
-};
-/**
-Implicit relationships are relationships which have not been declared but the inverse side exists on
-another record somewhere
-
-For example consider the following two models
-
-::: code-group
-
-```js [./models/comment.js]
-import { Model, attr } from '@warp-drive/legacy/model';
-
-export default class Comment extends Model {
-@attr text;
-}
-```
-
-```js [./models/post.js]
-import { Model, attr, hasMany } from '@warp-drive/legacy/model';
-
-export default class Post extends Model {
-@attr title;
-@hasMany('comment', { async: true, inverse: null }) comments;
-}
-```
-
-:::
-
-Then we would have a implicit 'post' relationship for the comment record in order
-to be do things like remove the comment from the post if the comment were to be deleted.
-*/
-export interface ImplicitEdge {
-	definition: ImplicitMeta;
-	identifier: StableRecordIdentifier;
-	localMembers: Set<StableRecordIdentifier>;
-	remoteMembers: Set<StableRecordIdentifier>;
-}
-export declare function createImplicitEdge(definition: ImplicitMeta, identifier: StableRecordIdentifier): ImplicitEdge;

package/declarations/graph/-private/edges/resource.d.ts

@@ -1,24 +0,0 @@
-import type { ResourceRelationship } from "../../../types/cache/relationship.js";
-import type { StableRecordIdentifier } from "../../../types/identifier.js";
-import type { Links, Meta, PaginationLinks } from "../../../types/spec/json-api-raw.js";
-import type { UpgradedMeta } from "../-edge-definition.js";
-import type { RelationshipState } from "../-state.js";
-/**
-* Stores the data for one side of a "single" resource relationship.
-*
-* @class ResourceEdge
-* @internal
-*/
-export interface ResourceEdge {
-	definition: UpgradedMeta;
-	identifier: StableRecordIdentifier;
-	state: RelationshipState;
-	localState: StableRecordIdentifier | null;
-	remoteState: StableRecordIdentifier | null;
-	meta: Meta | null;
-	links: Links | PaginationLinks | null;
-	transactionRef: number;
-	accessed: boolean;
-}
-export declare function createResourceEdge(definition: UpgradedMeta, identifier: StableRecordIdentifier): ResourceEdge;
-export declare function legacyGetResourceRelationshipData(source: ResourceEdge, getRemoteState: boolean): ResourceRelationship;

package/declarations/graph/-private/graph.d.ts

@@ -1,90 +0,0 @@
-import type { CacheCapabilitiesManager, StableRecordIdentifier } from "../../types.js";
-import type { RelationshipDiff } from "../../types/cache.js";
-import type { MergeOperation } from "../../types/cache/operations.js";
-import type { CollectionRelationship, ResourceRelationship } from "../../types/cache/relationship.js";
-import type { DeleteRecordOperation, LocalRelationshipOperation, RemoteRelationshipOperation } from "../../types/graph.js";
-import type { EdgeCache, UpgradedMeta } from "./-edge-definition.js";
-import { type CollectionEdge } from "./edges/collection.js";
-import type { ImplicitEdge } from "./edges/implicit.js";
-import { type ResourceEdge } from "./edges/resource.js";
-export type GraphEdge = ImplicitEdge | CollectionEdge | ResourceEdge;
-export declare const Graphs: Map<CacheCapabilitiesManager, Graph>;
-type PendingOps = {
-	belongsTo?: Map<string, Map<string, RemoteRelationshipOperation[]>>;
-	hasMany?: Map<string, Map<string, RemoteRelationshipOperation[]>>;
-	deletions: DeleteRecordOperation[];
-};
-/*
-* Graph acts as the cache for relationship data. It allows for
-* us to ask about and update relationships for a given Identifier
-* without requiring other objects for that Identifier to be
-* instantiated (such as `RecordData` or a `Record`)
-*
-* This also allows for us to make more substantive changes to relationships
-* with increasingly minor alterations to other portions of the internals
-* over time.
-*
-* The graph is made up of nodes and edges. Each unique identifier gets
-* its own node, which is a dictionary with a list of that node's edges
-* (or connections) to other nodes. In `Model` terms, a node represents a
-* record instance, with each key (an edge) in the dictionary correlating
-* to either a `hasMany` or `belongsTo` field on that record instance.
-*
-* The value for each key, or `edge` is the identifier(s) the node relates
-* to in the graph from that key.
-*/
-export declare class Graph {
-	_definitionCache: EdgeCache;
-	_metaCache: Record<string, Record<string, UpgradedMeta>>;
-	_potentialPolymorphicTypes: Record<string, Record<string, boolean>>;
-	identifiers: Map<StableRecordIdentifier, Record<string, GraphEdge>>;
-	store: CacheCapabilitiesManager;
-	isDestroyed: boolean;
-	_willSyncRemote: boolean;
-	_willSyncLocal: boolean;
-	silenceNotifications: boolean;
-	_pushedUpdates: PendingOps;
-	_updatedRelationships: Set<CollectionEdge>;
-	_transaction: number | null;
-	_removing: StableRecordIdentifier | null;
-	constructor(store: CacheCapabilitiesManager);
-	has(identifier: StableRecordIdentifier, propertyName: string): boolean;
-	getDefinition(identifier: StableRecordIdentifier, propertyName: string): UpgradedMeta;
-	get(identifier: StableRecordIdentifier, propertyName: string): GraphEdge;
-	getData(identifier: StableRecordIdentifier, propertyName: string): ResourceRelationship | CollectionRelationship;
-	getRemoteData(identifier: StableRecordIdentifier, propertyName: string): ResourceRelationship | CollectionRelationship;
-	/*
-	* Allows for the graph to dynamically discover polymorphic connections
-	* without needing to walk prototype chains.
-	*
-	* Used by edges when an added `type` does not match the expected `type`
-	* for that edge.
-	*
-	* Currently we assert before calling this. For a public API we will want
-	* to call out to the schema manager to ask if we should consider these
-	* types as equivalent for a given relationship.
-	*/
-	registerPolymorphicType(type1: string, type2: string): void;
-	isReleasable(identifier: StableRecordIdentifier): boolean;
-	unload(identifier: StableRecordIdentifier, silenceNotifications?: boolean): void;
-	_isDirty(identifier: StableRecordIdentifier, field: string): boolean;
-	getChanged(identifier: StableRecordIdentifier): Map<string, RelationshipDiff>;
-	hasChanged(identifier: StableRecordIdentifier): boolean;
-	rollback(identifier: StableRecordIdentifier): string[];
-	remove(identifier: StableRecordIdentifier): void;
-	/*
-	* Remote state changes
-	*/
-	push(op: RemoteRelationshipOperation): void;
-	/*
-	* Local state changes
-	*/
-	update(op: RemoteRelationshipOperation | MergeOperation, isRemote: true): void;
-	update(op: LocalRelationshipOperation, isRemote?: false): void;
-	_scheduleLocalSync(relationship: CollectionEdge): void;
-	_flushRemoteQueue(): void;
-	_addToTransaction(relationship: CollectionEdge | ResourceEdge): void;
-	_flushLocalQueue(): void;
-	destroy(): void;
-}
-export {};

package/declarations/graph/-private/normalize-link.d.ts

@@ -1,8 +0,0 @@
-import type { Link, LinkObject } from "../../types/spec/json-api-raw.js";
-/*
-This method normalizes a link to an "links object". If the passed link is
-already an object it's returned without any modifications.
-
-See http://jsonapi.org/format/#document-links for more information.
-*/
-export default function _normalizeLink(link: Link): LinkObject | null;

package/declarations/graph/-private/operations/add-to-related-records.d.ts

@@ -1,4 +0,0 @@
-import type { AddToResourceRelationshipMutation } from "../../../types/cache/mutations.js";
-import type { AddToResourceRelationshipOperation } from "../../../types/cache/operations.js";
-import type { Graph } from "../graph.js";
-export default function addToRelatedRecords(graph: Graph, op: AddToResourceRelationshipOperation | AddToResourceRelationshipMutation, isRemote: boolean): void;

package/declarations/graph/-private/operations/merge-identifier.d.ts

@@ -1,3 +0,0 @@
-import type { MergeOperation } from "../../../types/cache/operations.js";
-import type { Graph, GraphEdge } from "../graph.js";
-export declare function mergeIdentifier(graph: Graph, op: MergeOperation, relationships: Record<string, GraphEdge>): void;

package/declarations/graph/-private/operations/remove-from-related-records.d.ts

@@ -1,4 +0,0 @@
-import type { RemoveFromResourceRelationshipMutation } from "../../../types/cache/mutations.js";
-import type { RemoveFromResourceRelationshipOperation } from "../../../types/cache/operations.js";
-import type { Graph } from "../graph.js";
-export default function removeFromRelatedRecords(graph: Graph, op: RemoveFromResourceRelationshipOperation | RemoveFromResourceRelationshipMutation, isRemote: boolean): void;

package/declarations/graph/-private/operations/replace-related-record.d.ts

@@ -1,3 +0,0 @@
-import type { ReplaceRelatedRecordOperation } from "../../../types/graph.js";
-import type { Graph } from "../graph.js";
-export default function replaceRelatedRecord(graph: Graph, op: ReplaceRelatedRecordOperation, isRemote?: boolean): void;

package/declarations/graph/-private/operations/replace-related-records.d.ts

@@ -1,62 +0,0 @@
-import type { StableRecordIdentifier } from "../../../types.js";
-import type { ReplaceRelatedRecordsOperation } from "../../../types/graph.js";
-import type { Graph } from "../graph.js";
-/*
-case many:1
-========
-In a bi-directional graph with Many:1 edges, adding a value
-results in up-to 3 discrete value transitions, while removing
-a value is only 2 transitions.
-
-For adding C to A
-If: A <<-> B, C <->> D is the initial state,
-and: B <->> A <<-> C, D is the final state
-
-then we would undergo the following transitions.
-
-add C to A
-remove C from D
-add A to C
-
-For removing B from A
-If: A <<-> B, C <->> D is the initial state,
-and: A, B, C <->> D is the final state
-
-then we would undergo the following transitions.
-
-remove B from A
-remove A from B
-
-case many:many
-===========
-In a bi-directional graph with Many:Many edges, adding or
-removing a value requires only 2 value transitions.
-
-For Adding
-If: A<<->>B, C<<->>D is the initial state (double arrows representing the many side)
-And: D<<->>C<<->>A<<->>B is the final state
-
-Then we would undergo two transitions.
-
-add C to A.
-add A to C
-
-For Removing
-If: A<<->>B, C<<->>D is the initial state (double arrows representing the many side)
-And: A, B, C<<->>D is the final state
-
-Then we would undergo two transitions.
-
-remove B from A
-remove A from B
-
-case many:?
-========
-In a uni-directional graph with Many:? edges (modeled in WarpDrive with `inverse:null`) with
-artificial (implicit) inverses, replacing a value results in 2 discrete value transitions.
-This is because a Many:? relationship is effectively Many:Many.
-*/
-export default function replaceRelatedRecords(graph: Graph, op: ReplaceRelatedRecordsOperation, isRemote: boolean): void;
-export declare function addToInverse(graph: Graph, identifier: StableRecordIdentifier, key: string, value: StableRecordIdentifier, isRemote: boolean): void;
-export declare function notifyInverseOfPotentialMaterialization(graph: Graph, identifier: StableRecordIdentifier, key: string, value: StableRecordIdentifier, isRemote: boolean): void;
-export declare function removeFromInverse(graph: Graph, identifier: StableRecordIdentifier, key: string, value: StableRecordIdentifier, isRemote: boolean): void;

package/declarations/graph/-private/operations/update-relationship.d.ts

@@ -1,13 +0,0 @@
-import type { Store } from "../../../index.js";
-import type { StableRecordIdentifier } from "../../../types.js";
-import type { UpdateResourceRelationshipOperation } from "../../../types/cache/operations.js";
-import type { UpdateRelationshipOperation } from "../../../types/graph.js";
-import type { ExistingResourceIdentifierObject, NewResourceIdentifierObject } from "../../../types/spec/json-api-raw.js";
-import type { Graph } from "../graph.js";
-type IdentifierCache = Store["identifierCache"];
-/*
-Updates the "canonical" or "remote" state of a relationship, replacing any existing
-state and blowing away any local changes (excepting new records).
-*/
-export default function updateRelationshipOperation(graph: Graph, op: UpdateRelationshipOperation | UpdateResourceRelationshipOperation): void;
-export declare function upgradeIdentifiers(arr: (ExistingResourceIdentifierObject | NewResourceIdentifierObject | StableRecordIdentifier)[], cache: IdentifierCache): StableRecordIdentifier[];

package/declarations/graph/-private.d.ts

@@ -1,13 +0,0 @@
-import type { Store } from "../index.js";
-import type { CacheCapabilitiesManager } from "../types.js";
-import { Graph } from "./-private/graph.js";
-export { isBelongsTo } from "./-private/-utils.js";
-export type { CollectionEdge } from "./-private/edges/collection.js";
-export type { ResourceEdge } from "./-private/edges/resource.js";
-export type { ImplicitEdge } from "./-private/edges/implicit.js";
-export type { GraphEdge } from "./-private/graph.js";
-export type { UpgradedMeta } from "./-private/-edge-definition.js";
-export type { Graph };
-export declare function peekGraph(store: CacheCapabilitiesManager | Store): Graph | undefined;
-export type peekGraph = typeof peekGraph;
-export declare function graphFor(store: CacheCapabilitiesManager | Store): Graph;