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

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

@@ -1,4 +1,4 @@
-import type { StableRecordIdentifier } from "../../types/identifier.js";
+import type { ResourceKey } from "../../types/identifier.js";
 import type { CollectionEdge } from "./edges/collection.js";
 import type { ResourceEdge } from "./edges/resource.js";
 import type { Graph } from "./graph.js";
@@ -10,8 +10,8 @@ type Diff<T> = {
 	changed: boolean;
 	remoteOrderChanged: boolean;
 };
-export declare function diffCollection(finalState: StableRecordIdentifier[], relationship: CollectionEdge, onAdd: (v: StableRecordIdentifier) => void, onDel: (v: StableRecordIdentifier) => void): Diff<StableRecordIdentifier>;
-export declare function computeLocalState(storage: CollectionEdge): StableRecordIdentifier[];
+export declare function diffCollection(finalState: ResourceKey[], relationship: CollectionEdge, onAdd: (v: ResourceKey) => void, onDel: (v: ResourceKey) => void): Diff<ResourceKey>;
+export declare function computeLocalState(storage: CollectionEdge): ResourceKey[];
 /**
 * A function which attempts to add a value to the local state of a collection
 * relationship, and returns true if the value was added, or false if it was
@@ -24,9 +24,9 @@ export declare function computeLocalState(storage: CollectionEdge): StableRecord
 *
 * @internal
 */
-export declare function _add(graph: Graph, record: StableRecordIdentifier, relationship: CollectionEdge, value: StableRecordIdentifier, index: number | null, isRemote: boolean): boolean;
-export declare function _remove(graph: Graph, record: StableRecordIdentifier, relationship: CollectionEdge, value: StableRecordIdentifier, index: number | null, isRemote: boolean): boolean;
-export declare function _removeLocal(relationship: CollectionEdge, value: StableRecordIdentifier): boolean;
-export declare function _removeRemote(relationship: CollectionEdge, value: StableRecordIdentifier): boolean;
-export declare function rollbackRelationship(graph: Graph, identifier: StableRecordIdentifier, field: string, relationship: CollectionEdge | ResourceEdge): void;
+export declare function _add(graph: Graph, record: ResourceKey, relationship: CollectionEdge, value: ResourceKey, index: number | null, isRemote: boolean): boolean;
+export declare function _remove(graph: Graph, record: ResourceKey, relationship: CollectionEdge, value: ResourceKey, index: number | null, isRemote: boolean): boolean;
+export declare function _removeLocal(relationship: CollectionEdge, value: ResourceKey): boolean;
+export declare function _removeRemote(relationship: CollectionEdge, value: ResourceKey): boolean;
+export declare function rollbackRelationship(graph: Graph, key: ResourceKey, field: string, relationship: CollectionEdge | ResourceEdge): void;
 export {};

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

@@ -1,4 +1,4 @@
-import type { StableRecordIdentifier } from "../../types.js";
+import type { ResourceKey } 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>>;
@@ -145,4 +145,4 @@ export interface EdgeDefinition {
 }
 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;
+export declare function upgradeDefinition(graph: Graph, key: ResourceKey, propertyName: string, isImplicit?: boolean): EdgeDefinition | null;

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

@@ -61,12 +61,12 @@ export interface RelationshipState {
 	in this case `state.hasFailedLoadAttempt` ought to be `true`.
 	
 	false when
-	=> cache.isNew(identifier) on initial setup
+	=> cache.isNew(resourceKey) on initial setup
 	=> a previously triggered request has resolved
 	=> we get relationship data via push
 	
 	true when
-	=> !cache.isNew(identifier) on initial setup
+	=> !cache.isNew(resourceKey) on initial setup
 	=> an inverse has been unloaded
 	=> we get a new link for the relationship
 	

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

@@ -2,7 +2,7 @@ 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 { ResourceKey } 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";
@@ -15,17 +15,17 @@ export declare function getStore(wrapper: CacheCapabilitiesManager | {
 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 checkIfNew(store: Store, identifier: StableRecordIdentifier): boolean;
+export declare function checkIfNew(store: Store, resourceKey: ResourceKey): 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;
+export declare function forAllRelatedIdentifiers(rel: GraphEdge, cb: (resourceKey: ResourceKey) => 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 removeIdentifierCompletelyFromRelationship(graph: Graph, relationship: GraphEdge, value: ResourceKey, 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;
+export declare function assertRelationshipData(store: Store, resourceKey: ResourceKey, data: ResourceIdentifierObject, meta: UpgradedMeta): void;

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

@@ -1,5 +1,5 @@
 import type { CacheCapabilitiesManager } from "../../../types.js";
-import type { StableRecordIdentifier } from "../../../types/identifier.js";
+import type { ResourceKey } 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
@@ -9,10 +9,10 @@ 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
+be ResourceKeys 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 assertPolymorphicType: (parentIdentifier: ResourceKey, parentDefinition: UpgradedMeta, addedIdentifier: ResourceKey, store: CacheCapabilitiesManager) => void;
 declare let assertInheritedSchema: (definition: UpgradedMeta, type: string) => void;
 export { assertPolymorphicType, assertInheritedSchema };

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

@@ -1,19 +1,19 @@
 import type { CollectionRelationship } from "../../../types/cache/relationship.js";
-import type { StableRecordIdentifier } from "../../../types/identifier.js";
+import type { ResourceKey } 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;
+	identifier: ResourceKey;
 	state: RelationshipState;
-	remoteMembers: Set<StableRecordIdentifier>;
-	remoteState: StableRecordIdentifier[];
-	additions: Set<StableRecordIdentifier> | null;
-	removals: Set<StableRecordIdentifier> | null;
+	remoteMembers: Set<ResourceKey>;
+	remoteState: ResourceKey[];
+	additions: Set<ResourceKey> | null;
+	removals: Set<ResourceKey> | null;
 	meta: Meta | null;
 	links: Links | PaginationLinks | null;
-	localState: StableRecordIdentifier[] | null;
+	localState: ResourceKey[] | null;
 	/**
 	* Whether the localState for this edge is out-of-sync
 	* with the remoteState.
@@ -31,9 +31,9 @@ export interface CollectionEdge {
 	*/
 	accessed: boolean;
 	_diff?: {
-		add: Set<StableRecordIdentifier>;
-		del: Set<StableRecordIdentifier>;
+		add: Set<ResourceKey>;
+		del: Set<ResourceKey>;
 	};
 }
-export declare function createCollectionEdge(definition: UpgradedMeta, identifier: StableRecordIdentifier): CollectionEdge;
+export declare function createCollectionEdge(definition: UpgradedMeta, identifier: ResourceKey): CollectionEdge;
 export declare function legacyGetCollectionRelationshipData(source: CollectionEdge, getRemoteState: boolean): CollectionRelationship;

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

@@ -1,4 +1,4 @@
-import type { StableRecordIdentifier } from "../../../types/identifier.js";
+import type { ResourceKey } from "../../../types/identifier.js";
 import type { UpgradedMeta } from "../-edge-definition.js";
 export type ImplicitMeta = UpgradedMeta & {
 	kind: "implicit";
@@ -36,8 +36,8 @@ to be do things like remove the comment from the post if the comment were to be
 */
 export interface ImplicitEdge {
 	definition: ImplicitMeta;
-	identifier: StableRecordIdentifier;
-	localMembers: Set<StableRecordIdentifier>;
-	remoteMembers: Set<StableRecordIdentifier>;
+	identifier: ResourceKey;
+	localMembers: Set<ResourceKey>;
+	remoteMembers: Set<ResourceKey>;
 }
-export declare function createImplicitEdge(definition: ImplicitMeta, identifier: StableRecordIdentifier): ImplicitEdge;
+export declare function createImplicitEdge(definition: ImplicitMeta, identifier: ResourceKey): ImplicitEdge;

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

@@ -1,5 +1,5 @@
 import type { ResourceRelationship } from "../../../types/cache/relationship.js";
-import type { StableRecordIdentifier } from "../../../types/identifier.js";
+import type { ResourceKey } 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";
@@ -11,14 +11,14 @@ import type { RelationshipState } from "../-state.js";
 */
 export interface ResourceEdge {
 	definition: UpgradedMeta;
-	identifier: StableRecordIdentifier;
+	identifier: ResourceKey;
 	state: RelationshipState;
-	localState: StableRecordIdentifier | null;
-	remoteState: StableRecordIdentifier | null;
+	localState: ResourceKey | null;
+	remoteState: ResourceKey | null;
 	meta: Meta | null;
 	links: Links | PaginationLinks | null;
 	transactionRef: number;
 	accessed: boolean;
 }
-export declare function createResourceEdge(definition: UpgradedMeta, identifier: StableRecordIdentifier): ResourceEdge;
+export declare function createResourceEdge(definition: UpgradedMeta, identifier: ResourceKey): ResourceEdge;
 export declare function legacyGetResourceRelationshipData(source: ResourceEdge, getRemoteState: boolean): ResourceRelationship;

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

@@ -1,5 +1,5 @@
 import type { Store } from "../../store/-private.js";
-import type { CacheCapabilitiesManager, StableRecordIdentifier } from "../../types.js";
+import type { CacheCapabilitiesManager, ResourceKey } 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";
@@ -38,7 +38,7 @@ export declare class Graph {
 	_definitionCache: EdgeCache;
 	_metaCache: Record<string, Record<string, UpgradedMeta>>;
 	_potentialPolymorphicTypes: Record<string, Record<string, boolean>>;
-	identifiers: Map<StableRecordIdentifier, Record<string, GraphEdge>>;
+	identifiers: Map<ResourceKey, Record<string, GraphEdge>>;
 	store: CacheCapabilitiesManager;
 	_realStore: Store;
 	isDestroyed: boolean;
@@ -48,13 +48,13 @@ export declare class Graph {
 	_pushedUpdates: PendingOps;
 	_updatedRelationships: Set<CollectionEdge>;
 	_transaction: number | null;
-	_removing: StableRecordIdentifier | null;
+	_removing: ResourceKey | 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;
+	has(resourceKey: ResourceKey, propertyName: string): boolean;
+	getDefinition(resourceKey: ResourceKey, propertyName: string): UpgradedMeta;
+	get(resourceKey: ResourceKey, propertyName: string): GraphEdge;
+	getData(resourceKey: ResourceKey, propertyName: string): ResourceRelationship | CollectionRelationship;
+	getRemoteData(resourceKey: ResourceKey, propertyName: string): ResourceRelationship | CollectionRelationship;
 	/*
 	* Allows for the graph to dynamically discover polymorphic connections
 	* without needing to walk prototype chains.
@@ -67,13 +67,13 @@ export declare class Graph {
 	* 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;
+	isReleasable(resourceKey: ResourceKey): boolean;
+	unload(resourceKey: ResourceKey, silenceNotifications?: boolean): void;
+	_isDirty(resourceKey: ResourceKey, field: string): boolean;
+	getChanged(resourceKey: ResourceKey): Map<string, RelationshipDiff>;
+	hasChanged(resourceKey: ResourceKey): boolean;
+	rollback(resourceKey: ResourceKey): string[];
+	remove(resourceKey: ResourceKey): void;
 	/*
 	* Remote state changes
 	*/

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

@@ -1,4 +1,4 @@
-import type { StableRecordIdentifier } from "../../../types.js";
+import type { ResourceKey } from "../../../types.js";
 import type { ReplaceRelatedRecordsOperation } from "../../../types/graph.js";
 import type { Graph } from "../graph.js";
 /*
@@ -57,6 +57,6 @@ artificial (implicit) inverses, replacing a value results in 2 discrete value tr
 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;
+export declare function addToInverse(graph: Graph, resourceKey: ResourceKey, key: string, value: ResourceKey, isRemote: boolean): void;
+export declare function notifyInverseOfPotentialMaterialization(graph: Graph, resourceKey: ResourceKey, key: string, value: ResourceKey, isRemote: boolean): void;
+export declare function removeFromInverse(graph: Graph, resourceKey: ResourceKey, key: string, value: ResourceKey, isRemote: boolean): void;

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

@@ -1,13 +1,13 @@
 import type { Store } from "../../../index.js";
-import type { StableRecordIdentifier } from "../../../types.js";
+import type { ResourceKey } 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"];
+type CacheKeyManager = Store["cacheKeyManager"];
 /*
 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[];
+export declare function upgradeIdentifiers(arr: (ExistingResourceIdentifierObject | NewResourceIdentifierObject | ResourceKey)[], cache: CacheKeyManager): ResourceKey[];

package/declarations/index.d.ts

@@ -11,4 +11,4 @@ export { Store, type StoreRequestContext, CacheHandler, type CachePolicy, type S
 */
 export type Document<T> = ReactiveDocument<T>;
 export type { DocumentCacheOperation, CacheOperation, NotificationType } from "./store/-private/managers/notification-manager.js";
-export { setIdentifierGenerationMethod, setIdentifierUpdateMethod, setIdentifierForgetMethod, setIdentifierResetMethod, setKeyInfoForResource } from "./store/-private/caches/identifier-cache.js";
+export { setIdentifierGenerationMethod, setIdentifierUpdateMethod, setIdentifierForgetMethod, setIdentifierResetMethod, setKeyInfoForResource } from "./store/-private/managers/cache-key-manager.js";

package/declarations/reactive/-private/default-mode.d.ts

@@ -1,6 +1,6 @@
 import type { Store } from "../../store/-private.js";
 import type { SignalStore } from "../../store/-private/new-core-tmp/reactivity/internal.js";
-import type { StableRecordIdentifier } from "../../types.js";
+import type { ResourceKey } from "../../types.js";
 import type { FieldSchema, HashField, IdentityField, SchemaArrayField, SchemaObjectField } from "../../types/schema/fields.js";
 import type { ReactiveResource } from "./record.js";
 export type PathLike = string | symbol | Array<string | symbol>;
@@ -12,7 +12,7 @@ export interface ModeInfo {
 }
 export interface BaseContext {
 	store: Store;
-	resourceKey: StableRecordIdentifier;
+	resourceKey: ResourceKey;
 	modeName: ModeName;
 	legacy: boolean;
 	editable: boolean;

package/declarations/reactive/-private/document.d.ts

@@ -1,12 +1,12 @@
 import type { Store } from "../../store/-private/store-service.js";
-import type { StableDocumentIdentifier } from "../../types/identifier.js";
+import type { RequestKey } from "../../types/identifier.js";
 import type { ImmutableRequestInfo, RequestInfo } from "../../types/request.js";
 import type { ResourceDocument } from "../../types/spec/document.js";
 import type { Meta, PaginationLinks } from "../../types/spec/json-api-raw.js";
 /**
 * A Document is a class that wraps the response content from a request to the API
-* returned by `Cache.put` or `Cache.peek`, converting resource-identifiers into
-* record instances.
+* returned by `Cache.put` or `Cache.peek`, converting ResourceKeys into
+* ReactiveResource instances.
 *
 * It is not directly instantiated by the user, and its properties should not
 * be directly modified. Whether individual properties are mutable or not is
@@ -28,8 +28,6 @@ export declare class ReactiveDocument<T> {
 	* }
 	* ```
 	*
-	* @property links
-	* @type {Object|undefined} - a links object
 	* @public
 	*/
 	readonly links?: PaginationLinks;
@@ -42,41 +40,33 @@ export declare class ReactiveDocument<T> {
 	* For collections this will be an array of record instances,
 	* for single resource requests it will be a single record instance or null.
 	*
-	* @property data
 	* @public
-	* @type {Object|Array<object>|null|undefined} - a data object
 	*/
 	readonly data?: T;
 	/**
 	* The errors returned by the API for this request, if any
 	*
-	* @property errors
 	* @public
-	* @type {Object|undefined} - an errors object
 	*/
 	readonly errors?: object[];
 	/**
 	* The meta object for this document, if any
 	*
-	* @property meta
 	* @public
-	* @type {Object|undefined} - a meta object
 	*/
 	readonly meta?: Meta;
 	/**
-	* The identifier associated with this document, if any
+	* The RequestKey associated with this document, if any
 	*
-	* @property identifier
 	* @public
-	* @type {StableDocumentIdentifier|null}
 	*/
-	readonly identifier: StableDocumentIdentifier | null;
+	readonly identifier: RequestKey | null;
 	protected readonly _store: Store;
 	protected readonly _localCache: {
 		document: ResourceDocument;
 		request: ImmutableRequestInfo;
 	} | null;
-	constructor(store: Store, identifier: StableDocumentIdentifier | null, localCache: {
+	constructor(store: Store, cacheKey: RequestKey | null, localCache: {
 		document: ResourceDocument;
 		request: ImmutableRequestInfo;
 	} | null);

package/declarations/reactive/-private/fields/managed-array.d.ts

@@ -1,13 +1,13 @@
 import type { WarpDriveSignal } from "../../../store/-private.js";
 import { ARRAY_SIGNAL } from "../../../store/-private.js";
-import type { StableRecordIdentifier } from "../../../types/identifier.js";
+import type { ResourceKey } from "../../../types/identifier.js";
 import type { ArrayField, SchemaArrayField } from "../../../types/schema/fields.js";
 import type { KindContext } from "../default-mode.js";
 import { ReactiveResource } from "../record.js";
 import { Context, SOURCE } from "../symbols.js";
 export interface ManagedArray extends Omit<Array<unknown>, "[]"> {
 	[SOURCE]: unknown[];
-	identifier: StableRecordIdentifier;
+	identifier: ResourceKey;
 	path: string | string[];
 	owner: ReactiveResource;
 	[ARRAY_SIGNAL]: WarpDriveSignal;

package/declarations/reactive/-private/fields/many-array-manager.d.ts

@@ -1,7 +1,7 @@
 import type { Store } from "../../../index.js";
 import type { RelatedCollection as ManyArray } from "../../../store/-private.js";
 import type { LocalRelationshipOperation } from "../../../types/graph.js";
-import type { StableRecordIdentifier } from "../../../types/identifier.js";
+import type { ResourceKey } from "../../../types/identifier.js";
 import type { ReactiveResource } from "../record.js";
 export interface FindHasManyOptions {
 	reload?: boolean;
@@ -10,7 +10,7 @@ export interface FindHasManyOptions {
 export declare class ManyArrayManager {
 	record: ReactiveResource;
 	store: Store;
-	identifier: StableRecordIdentifier;
+	identifier: ResourceKey;
 	editable: boolean;
 	constructor(record: ReactiveResource, editable: boolean);
 	_syncArray(array: ManyArray): void;

package/declarations/reactive/-private/hooks.d.ts

@@ -1,5 +1,5 @@
 import type { Store } from "../../index.js";
-import type { StableRecordIdentifier } from "../../types.js";
+import type { ResourceKey } from "../../types.js";
 import { ReactiveResource } from "./record.js";
-export declare function instantiateRecord(store: Store, identifier: StableRecordIdentifier, createArgs?: Record<string, unknown>): ReactiveResource;
+export declare function instantiateRecord(store: Store, identifier: ResourceKey, createArgs?: Record<string, unknown>): ReactiveResource;
 export declare function teardownRecord(record: unknown): void;

package/declarations/reactive/-private/record.d.ts

@@ -1,8 +1,9 @@
 import type { Store } from "../../store/-private.js";
 import { RecordStore } from "../../types/symbols.js";
 import type { ObjectContext, ResourceContext } from "./default-mode.js";
-import { Checkout, Context, Destroy } from "./symbols.js";
+import { Checkout, Commit, Context, Destroy } from "./symbols.js";
 export interface ReactiveResource {
+	/** @internal */
 	[Symbol.toStringTag]: `ReactiveResource<${string}>`;
 	/** @internal */
 	[Context]: ObjectContext | ResourceContext;
@@ -12,14 +13,16 @@ export interface ReactiveResource {
 	___notifications: object;
 	/** @internal */
 	[Destroy](): void;
+	/** @internal */
+	[Commit](): Promise<void>;
 	/**
 	* Create an editable copy of the record
 	*
 	* ReactiveResource instances are not editable by default. This method creates an editable copy of the record. To use,
-	* import the `Checkout` symbol from `@warp-drive/schema-record` and call it on the record.
+	* import the `Checkout` symbol from `@warp-drive/core/reactive` and call it on the record.
 	*
 	* ```ts
-	* import { Checkout } from '@warp-drive/schema-record';
+	* import { Checkout } from '@warp-drive/core/reactive';
 	*
 	* const record = store.peekRecord('user', '1');
 	* const editableRecord = await record[Checkout]();
@@ -27,13 +30,13 @@ export interface ReactiveResource {
 	*
 	* @returns a promise that resolves to the editable record
 	* @throws if the record is already editable or if the record is embedded
-	*
+	* @internal
 	*/
 	[Checkout]<T>(): Promise<T>;
 }
 /**
 * A class that uses a the ResourceSchema for a ResourceType
-* and a ResouceKey to transform data from the cache into a rich, reactive
+* and a ResourceKey to transform data from the cache into a rich, reactive
 * object.
 *
 * This class is not directly instantiable. To use it, you should
@@ -48,3 +51,39 @@ export declare class ReactiveResource {
 	constructor(context: ResourceContext | ObjectContext);
 }
 export declare function _CHECKOUT(record: ReactiveResource): ReactiveResource;
+/**
+* Checkout an immutable resource for editing.
+*
+* {@link ReactiveResource | ReactiveResources} are not editable by default. This method
+* creates an editable copy of the resource.
+*
+* This returns a promise which resolves with the editable
+* version of the resource.
+*
+* ```ts
+* import { checkout } from '@warp-drive/core/reactive';
+*
+* const immutable = store.peekRecord('user', '1');
+* const editable = await checkout(immutable);
+* ```
+*
+* Edits to editable resources will be automatically committed if a new
+* payload from the cache matches their existing value.
+*
+* @public
+*
+* @returns a promise that resolves to the editable resource
+* @throws if the resource is already editable or if resource is an embedded object
+*/
+export declare function checkout<T>(resource: unknown): Promise<T & ReactiveResource>;
+/**
+* Forcibly commit all local changes on an editable resource to
+* the remote (immutable) version.
+*
+* This API should only be used cautiously. Typically a better
+* approach is for either the API or a Handler to reflect saved
+* changes back to update the cache.
+*
+* @public
+*/
+export declare function commit(record: ReactiveResource): Promise<void>;

package/declarations/reactive/-private/schema.d.ts

@@ -1,6 +1,6 @@
 import type { Store } from "../../store/-private.js";
 import type { SchemaService as SchemaServiceInterface } from "../../types.js";
-import type { StableRecordIdentifier } from "../../types/identifier.js";
+import type { ResourceKey } from "../../types/identifier.js";
 import type { ObjectValue, Value } from "../../types/json/raw.js";
 import type { Derivation, HashFn } from "../../types/schema/concepts.js";
 import { type ArrayField, type CacheableFieldSchema, type DerivedField, type FieldSchema, type GenericField, type HashField, type IdentityField, type LegacyAttributeField, type LegacyBelongsToField, type LegacyHasManyField, type LegacyRelationshipField, type ObjectField, type ObjectSchema, type PolarisResourceSchema, type ResourceSchema, type Trait } from "../../types/schema/fields.js";
@@ -95,11 +95,11 @@ interface FromIdentityDerivation {
 	}, key: string): string | null;
 	(record: ReactiveResource, options: {
 		key: "^";
-	}, key: string): StableRecordIdentifier;
+	}, key: string): ResourceKey;
 	(record: ReactiveResource, options: null, key: string): asserts options;
 	(record: ReactiveResource, options: {
 		key: "id" | "lid" | "type" | "^";
-	} | null, key: string): StableRecordIdentifier | string | null;
+	} | null, key: string): ResourceKey | string | null;
 	[Type]: "@identity";
 }
 /**
@@ -151,18 +151,18 @@ export type Transformation<
 > = {
 	serialize(value: PT, options: Record<string, unknown> | null, record: ReactiveResource): T;
 	hydrate(value: T | undefined, options: Record<string, unknown> | null, record: ReactiveResource): PT;
-	defaultValue?(options: Record<string, unknown> | null, identifier: StableRecordIdentifier): T;
+	defaultValue?(options: Record<string, unknown> | null, identifier: ResourceKey): T;
 	[Type]: string;
 };
 interface KindFns {
 	belongsTo: {
-		get: (store: Store, record: object, resourceKey: StableRecordIdentifier, field: LegacyBelongsToField) => unknown;
-		set: (store: Store, record: object, cacheKey: StableRecordIdentifier, field: LegacyBelongsToField, value: unknown) => void;
+		get: (store: Store, record: object, resourceKey: ResourceKey, field: LegacyBelongsToField) => unknown;
+		set: (store: Store, record: object, cacheKey: ResourceKey, field: LegacyBelongsToField, value: unknown) => void;
 	};
 	hasMany: {
-		get: (store: Store, record: object, resourceKey: StableRecordIdentifier, field: LegacyHasManyField) => unknown;
-		set: (store: Store, record: object, cacheKey: StableRecordIdentifier, field: LegacyHasManyField, value: unknown) => void;
-		notify: (store: Store, record: object, cacheKey: StableRecordIdentifier, field: LegacyHasManyField) => boolean;
+		get: (store: Store, record: object, resourceKey: ResourceKey, field: LegacyHasManyField) => unknown;
+		set: (store: Store, record: object, cacheKey: ResourceKey, field: LegacyHasManyField, value: unknown) => void;
+		notify: (store: Store, record: object, cacheKey: ResourceKey, field: LegacyHasManyField) => boolean;
 	};
 }
 export interface SchemaService {
@@ -212,7 +212,7 @@ export declare class SchemaService implements SchemaServiceInterface {
 	constructor();
 	resourceTypes(): Readonly<string[]>;
 	hasTrait(type: string): boolean;
-	resourceHasTrait(resource: StableRecordIdentifier | {
+	resourceHasTrait(resource: ResourceKey | {
 		type: string;
 	}, trait: string): boolean;
 	transformation(field: GenericField | ObjectField | ArrayField | {
@@ -224,7 +224,7 @@ export declare class SchemaService implements SchemaServiceInterface {
 	hashFn(field: HashField | {
 		type: string;
 	}): HashFn;
-	resource(resource: StableRecordIdentifier | {
+	resource(resource: ResourceKey | {
 		type: string;
 	}): ResourceSchema | ObjectSchema;
 	registerResources(schemas: Array<ResourceSchema | ObjectSchema>): void;
@@ -268,7 +268,7 @@ export declare class SchemaService implements SchemaServiceInterface {
 		FM extends ObjectValue | null
 	>(derivation: Derivation<R, T, FM>): void;
 	CAUTION_MEGA_DANGER_ZONE_registerExtension(extension: CAUTION_MEGA_DANGER_ZONE_Extension): void;
-	CAUTION_MEGA_DANGER_ZONE_resourceExtensions(resource: StableRecordIdentifier | {
+	CAUTION_MEGA_DANGER_ZONE_resourceExtensions(resource: ResourceKey | {
 		type: string;
 	}): null | ProcessedExtension["features"];
 	CAUTION_MEGA_DANGER_ZONE_objectExtensions(field: ExtensibleField, resolvedType: string | null): null | ProcessedExtension["features"];

package/declarations/reactive/-private/symbols.d.ts

@@ -27,4 +27,5 @@
 export declare const SOURCE: "___(unique) Symbol(SOURCE)";
 export declare const Destroy: "___(unique) Symbol(Destroy)";
 export declare const Checkout: "___(unique) Symbol(Checkout)";
+export declare const Commit: "___(unique) Symbol(Commit)";
 export declare const Context: "___(unique) Symbol(Context)";