@warp-drive/legacy 5.6.0-beta.1 → 5.6.0-beta.3

package/declarations/model/-private/attr.d.ts

@@ -1,5 +1,5 @@
 import type { ArrayValue, ObjectValue, PrimitiveValue } from "@warp-drive/core/types/json/raw";
-import type { TransformName } from "@warp-drive/core/types/symbols";
+import { type TransformName } from "@warp-drive/core/types/symbols";
 import type { DecoratorPropertyDescriptor } from "./util.js";
 /**
 * Options provided to the attr decorator are
@@ -37,13 +37,6 @@ export type AttrOptions<DV = PrimitiveValue | object | unknown[]> = {
 	*/
 	defaultValue?: DV extends PrimitiveValue ? DV : () => DV;
 };
-// NOTE: Usage of Explicit ANY
-// -------------------------------------------------------------------
-// any is required here because we are the maximal not the minimal
-// subset of options allowed. If we used unknown, object, or
-// Record<string, unknown> we would get type errors when we try to
-// assert against a more specific implementation with precise options.
-// -------------------------------------------------------------------
 type LooseTransformInstance<
 	V,
 	Raw,
@@ -53,15 +46,11 @@ type LooseTransformInstance<
 	* value type must match the return type of the deserialize method
 	*
 	*/
-	// see note on Explicit ANY above
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	serialize: (value: V, options: any) => Raw;
 	/**
 	* defaultValue type must match the return type of the deserialize method
 	*
 	*/
-	// see note on Explicit ANY above
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	deserialize: (value: Raw, options: any) => V;
 	[TransformName]: Name;
 };
@@ -72,8 +61,6 @@ export type TypedTransformInstance<
 	V,
 	T extends string
 > = LooseTransformInstance<V, string, T> | LooseTransformInstance<V, number, T> | LooseTransformInstance<V, boolean, T> | LooseTransformInstance<V, null, T> | LooseTransformInstance<V, ObjectValue, T> | LooseTransformInstance<V, ArrayValue, T> | LooseTransformInstance<V, string | null, T> | LooseTransformInstance<V, number | null, T> | LooseTransformInstance<V, boolean | null, T> | LooseTransformInstance<V, ObjectValue | null, T> | LooseTransformInstance<V, ArrayValue | null, T>;
-// see note on Explicit ANY above
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type GetMaybeDeserializeValue<T> = T extends {
 	deserialize: (...args: any[]) => unknown;
 } ? ReturnType<T["deserialize"]> : never;

package/declarations/model/-private/belongs-to.d.ts

@@ -12,13 +12,6 @@ export type RelationshipOptions<
 	resetOnRemoteUpdate?: boolean;
 };
 export type NoNull<T> = Exclude<T, null>;
-// type BelongsToDecoratorObject<getT> = {
-//   get: () => getT;
-//   // set: (value: Awaited<getT>) => void;
-//   set: (value: getT) => void;
-//   // init: () => getT;
-// };
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
 export type RelationshipDecorator<T> = <This>(target: This, key: string, desc?: PropertyDescriptor) => void;
 /**
 `belongsTo` is used to define One-To-One and One-To-Many, and One-To-None
@@ -179,8 +172,4 @@ type each record satisfies on both sides.
 export declare function belongsTo(): never;
 export declare function belongsTo(type: string): never;
 export declare function belongsTo<T>(type: TypeFromInstance<NoNull<T>>, options: RelationshipOptions<T, boolean>): RelationshipDecorator<T>;
-// export function belongsTo<K extends Promise<unknown>, T extends Awaited<K> = Awaited<K>>(
-//   type: TypeFromInstance<NoNull<T>>,
-//   options: RelationshipOptions<T, true>
-// ): RelationshipDecorator<K>;
 export declare function belongsTo(type: string, options: RelationshipOptions<unknown, boolean>): RelationshipDecorator<unknown>;

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

@@ -1,17 +1,5 @@
 import type { Store } from "@warp-drive/core";
 import type { UpgradedMeta } from "@warp-drive/core/graph/-private";
-import type { StableRecordIdentifier } from "@warp-drive/core/types/identifier";
-/*
-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: Store) => void;
+import type { ResourceKey } from "@warp-drive/core/types/identifier";
+declare let assertPolymorphicType: (parentIdentifier: ResourceKey, parentDefinition: UpgradedMeta, addedIdentifier: ResourceKey, store: Store) => void;
 export { assertPolymorphicType };

package/declarations/model/-private/errors.d.ts

@@ -6,16 +6,10 @@ type ValidationError = {
 	message: string;
 };
 interface ArrayProxyWithCustomOverrides<T> extends Omit<ArrayProxy<T>, "clear" | "content"> {
-	// Omit causes `content` to be merged with the class def for ArrayProxy
-	// which then causes it to be seen as a property, disallowing defining it
-	// as an accessor. This restores our ability to define it as an accessor.
 	content: NativeArray<T>;
 	clear(): void;
 	_has(name: string): boolean;
 }
-// we force the type here to our own construct because mixin and extend patterns
-// lose generic signatures. We also do this because we need to Omit `clear` from
-// the type of ArrayProxy as we override it's signature.
 declare const ArrayProxyWithCustomOverrides: new <T>() => ArrayProxyWithCustomOverrides<T>;
 /**
 Holds validation errors for a given record, organized by attribute names.

package/declarations/model/-private/has-many.d.ts

@@ -160,8 +160,4 @@ type each record satisfies on both sides.
 export declare function hasMany(): never;
 export declare function hasMany(type: string): never;
 export declare function hasMany<T>(type: TypeFromInstance<NoNull<T>>, options: RelationshipOptions<T, boolean>): RelationshipDecorator<T>;
-// export function hasMany<K extends Promise<unknown>, T extends Awaited<K> = Awaited<K>>(
-//   type: TypeFromInstance<NoNull<T>>,
-//   options: RelationshipOptions<T, true>
-// ): RelationshipDecorator<K>;
 export declare function hasMany(type: string, options: RelationshipOptions<unknown, boolean>): RelationshipDecorator<unknown>;

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

@@ -1,8 +1,8 @@
 import { type Store } from "@warp-drive/core/store/-private";
-import type { StableRecordIdentifier } from "@warp-drive/core/types/identifier";
+import type { ResourceKey } from "@warp-drive/core/types/identifier";
 import type { TypeFromInstance } from "@warp-drive/core/types/record";
 import type { Model } from "./model.js";
-export declare function instantiateRecord(this: Store, identifier: StableRecordIdentifier, createRecordArgs: {
+export declare function instantiateRecord(this: Store, identifier: ResourceKey, createRecordArgs: {
 	[key: string]: unknown;
 }): Model;
 export declare function teardownRecord(record: Model): void;

package/declarations/model/-private/legacy-relationships-support.d.ts

@@ -1,9 +1,7 @@
 import type { Store } from "@warp-drive/core";
-import type { CollectionEdge, Graph, ResourceEdge, UpgradedMeta } from "@warp-drive/core/graph/-private";
-import type { LiveArray } from "@warp-drive/core/store/-private";
-import { RelatedCollection as ManyArray } from "@warp-drive/core/store/-private";
-import type { BaseFinderOptions, StableRecordIdentifier } from "@warp-drive/core/types";
-import type { Cache } from "@warp-drive/core/types/cache";
+import type { CollectionEdge, ResourceEdge, UpgradedMeta } from "@warp-drive/core/graph/-private";
+import type { LegacyManyArray } from "@warp-drive/core/store/-private";
+import type { BaseFinderOptions, ResourceKey } from "@warp-drive/core/types";
 import type { CollectionRelationship } from "@warp-drive/core/types/cache/relationship";
 import type { LocalRelationshipOperation } from "@warp-drive/core/types/graph";
 import type { OpaqueRecordInstance, TypeFromInstanceOrString } from "@warp-drive/core/types/record";
@@ -15,33 +13,26 @@ import type { HasManyProxyCreateArgs } from "./promise-many-array.js";
 import { PromiseManyArray } from "./promise-many-array.js";
 import BelongsToReference from "./references/belongs-to.js";
 import HasManyReference from "./references/has-many.js";
-export declare const LEGACY_SUPPORT: Map<StableRecordIdentifier | MinimalLegacyRecord, LegacySupport>;
+export declare const LEGACY_SUPPORT: Map<ResourceKey | MinimalLegacyRecord, LegacySupport>;
 export declare function lookupLegacySupport(record: MinimalLegacyRecord): LegacySupport;
+/**
+* @hideconstructor
+*/
 export declare class LegacySupport {
-	record: MinimalLegacyRecord;
-	store: Store;
-	graph: Graph;
-	cache: Cache;
-	references: Record<string, BelongsToReference | HasManyReference>;
-	identifier: StableRecordIdentifier;
-	_manyArrayCache: Record<string, ManyArray>;
-	_relationshipPromisesCache: Record<string, Promise<ManyArray | OpaqueRecordInstance>>;
-	_relationshipProxyCache: Record<string, PromiseManyArray | PromiseBelongsTo | undefined>;
-	_pending: Record<string, Promise<StableRecordIdentifier | null> | undefined>;
-	isDestroying: boolean;
-	isDestroyed: boolean;
-	constructor(record: MinimalLegacyRecord);
-	_syncArray(array: LiveArray): void;
+	identifier: ResourceKey;
+	constructor(record: MinimalLegacyRecord, identifier: ResourceKey);
+	/** @private */
+	_syncArray(array: LegacyManyArray): void;
 	mutate(mutation: LocalRelationshipOperation): void;
 	_findBelongsTo(key: string, resource: SingleResourceRelationship, relationship: ResourceEdge, options?: BaseFinderOptions): Promise<OpaqueRecordInstance | null>;
 	reloadBelongsTo(key: string, options?: BaseFinderOptions): Promise<OpaqueRecordInstance | null>;
 	getBelongsTo(key: string, options?: BaseFinderOptions): PromiseBelongsTo | OpaqueRecordInstance | null;
 	setDirtyBelongsTo(key: string, value: OpaqueRecordInstance | null): void;
-	_getCurrentState<T>(identifier: StableRecordIdentifier, field: string): [StableRecordIdentifier<TypeFromInstanceOrString<T>>[], CollectionRelationship];
-	getManyArray<T>(key: string, definition?: UpgradedMeta): ManyArray<T>;
-	fetchAsyncHasMany(key: string, relationship: CollectionEdge, manyArray: ManyArray, options?: BaseFinderOptions): Promise<ManyArray>;
-	reloadHasMany<T>(key: string, options?: BaseFinderOptions): Promise<ManyArray<T>> | PromiseManyArray<T>;
-	getHasMany(key: string, options?: BaseFinderOptions): PromiseManyArray | ManyArray;
+	_getCurrentState<T>(identifier: ResourceKey, field: string): [ResourceKey<TypeFromInstanceOrString<T>>[], CollectionRelationship];
+	getManyArray<T>(key: string, definition?: UpgradedMeta): LegacyManyArray<T>;
+	fetchAsyncHasMany(key: string, relationship: CollectionEdge, manyArray: LegacyManyArray, options?: BaseFinderOptions): Promise<LegacyManyArray>;
+	reloadHasMany<T>(key: string, options?: BaseFinderOptions): Promise<LegacyManyArray<T>> | PromiseManyArray<T>;
+	getHasMany(key: string, options?: BaseFinderOptions): PromiseManyArray | LegacyManyArray;
 	_updatePromiseProxyFor(kind: "hasMany", key: string, args: HasManyProxyCreateArgs): PromiseManyArray;
 	_updatePromiseProxyFor(kind: "belongsTo", key: string, args: BelongsToProxyCreateArgs): PromiseBelongsTo;
 	_updatePromiseProxyFor(kind: "belongsTo", key: string, args: {
@@ -49,8 +40,8 @@ export declare class LegacySupport {
 	}): PromiseBelongsTo;
 	referenceFor(kind: "belongsTo", name: string): BelongsToReference;
 	referenceFor(kind: "hasMany", name: string): HasManyReference;
-	_findHasManyByJsonApiResource(resource: CollectionResourceRelationship, parentIdentifier: StableRecordIdentifier, relationship: CollectionEdge, options?: BaseFinderOptions): Promise<void | unknown[]> | void;
-	_findBelongsToByJsonApiResource(resource: SingleResourceRelationship, parentIdentifier: StableRecordIdentifier, relationship: ResourceEdge, options?: BaseFinderOptions): Promise<StableRecordIdentifier | null>;
+	_findHasManyByJsonApiResource(resource: CollectionResourceRelationship, parentIdentifier: ResourceKey, relationship: CollectionEdge, options?: BaseFinderOptions): Promise<void | unknown[]> | void;
+	_findBelongsToByJsonApiResource(resource: SingleResourceRelationship, parentIdentifier: ResourceKey, relationship: ResourceEdge, options?: BaseFinderOptions): Promise<ResourceKey | null>;
 	destroy(): void;
 }
 export declare function areAllInverseRecordsLoaded(store: Store, resource: InnerRelationshipDocument): boolean;

package/declarations/model/-private/model-for-mixin.d.ts

@@ -1,19 +1,3 @@
 import type { Store } from "@warp-drive/core";
 import { type ModelFactory } from "./model.js";
-/*
-In case someone defined a relationship to a mixin, for example:
-```ts
-class CommentModel extends Model {
-@belongsTo('commentable', { polymorphic: true }) owner;
-}
-
-let Commentable = Mixin.create({
-@hasMany('comment') comments;
-});
-```
-we want to look up a Commentable class which has all the necessary
-relationship meta data. Thus, we look up the mixin and create a mock
-Model, so we can access the relationship CPs of the mixin (`comments`)
-in this case
-*/
 export default function modelForMixin(store: Store, normalizedModelName: string): ModelFactory | undefined;

package/declarations/model/-private/model-methods.d.ts

@@ -1,6 +1,4 @@
-import type { Store } from "@warp-drive/core";
 import type { ChangedAttributesHash } from "@warp-drive/core/types/cache";
-import { RecordStore } from "@warp-drive/core/types/symbols";
 import type { Snapshot } from "../../compat/-private.js";
 import type { Errors } from "./errors.js";
 import type RecordState from "./record-state.js";
@@ -9,13 +7,11 @@ import type HasManyReference from "./references/has-many.js";
 import type { MaybeBelongsToFields, MaybeHasManyFields } from "./type-utils.js";
 export interface MinimalLegacyRecord {
 	errors: Errors;
-	___recordState: RecordState;
 	currentState: RecordState;
 	isDestroyed: boolean;
 	isDestroying: boolean;
 	isReloading: boolean;
 	isValid: boolean;
-	[RecordStore]: Store;
 	deleteRecord(): void;
 	unloadRecord(): void;
 	save<T extends MinimalLegacyRecord>(this: T, options?: Record<string, unknown>): Promise<this>;
@@ -32,9 +28,12 @@ export declare function hasMany<
 	K extends MaybeHasManyFields<T>
 >(this: T, prop: K): HasManyReference<T, K>;
 export declare function reload<T extends MinimalLegacyRecord>(this: T, options?: Record<string, unknown>): Promise<T>;
+export declare function _reload<T extends MinimalLegacyRecord>(this: T, options?: Record<string, unknown>): Promise<T>;
 export declare function changedAttributes<T extends MinimalLegacyRecord>(this: T): ChangedAttributesHash;
 export declare function serialize<T extends MinimalLegacyRecord>(this: T, options?: Record<string, unknown>): unknown;
 export declare function deleteRecord<T extends MinimalLegacyRecord>(this: T): void;
 export declare function save<T extends MinimalLegacyRecord>(this: T, options?: Record<string, unknown>): Promise<T>;
+export declare function _save<T extends MinimalLegacyRecord>(this: T, options?: Record<string, unknown>): Promise<T>;
 export declare function destroyRecord<T extends MinimalLegacyRecord>(this: T, options?: Record<string, unknown>): Promise<T>;
+export declare function _destroyRecord<T extends MinimalLegacyRecord>(this: T, options?: Record<string, unknown>): Promise<T>;
 export declare function createSnapshot<T extends MinimalLegacyRecord>(this: T): Snapshot<T>;

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

@@ -1,9 +1,8 @@
 import EmberObject from "@ember/object";
 import type { Store } from "@warp-drive/core";
-import type { ModelSchema, StableRecordIdentifier } from "@warp-drive/core/types";
-import type { Cache, ChangedAttributesHash } from "@warp-drive/core/types/cache";
+import type { ModelSchema, ResourceKey } from "@warp-drive/core/types";
+import type { ChangedAttributesHash } from "@warp-drive/core/types/cache";
 import type { LegacyAttributeField, LegacyRelationshipField } from "@warp-drive/core/types/schema/fields";
-import { RecordStore } from "@warp-drive/core/types/symbols";
 import type { Snapshot } from "../../compat/-private.js";
 import { Errors } from "./errors.js";
 import type { MinimalLegacyRecord } from "./model-methods.js";
@@ -13,12 +12,10 @@ import type HasManyReference from "./references/has-many.js";
 import type { _MaybeBelongsToFields, isSubClass, MaybeAttrFields, MaybeHasManyFields, MaybeRelationshipFields } from "./type-utils.js";
 export type ModelCreateArgs = {
 	_createProps: Record<string, unknown>;
-	// TODO @deprecate consider deprecating accessing record properties during init which the below is necessary for
 	_secretInit: {
-		identifier: StableRecordIdentifier;
-		cache: Cache;
+		identifier: ResourceKey;
 		store: Store;
-		cb: (record: Model, cache: Cache, identifier: StableRecordIdentifier, store: Store) => void;
+		cb: (record: Model, identifier: ResourceKey, store: Store) => void;
 	};
 };
 export type StaticModel = typeof Model & {
@@ -28,8 +25,6 @@ export type ModelFactory = {
 	class: StaticModel;
 };
 export type FactoryCache = Record<string, ModelFactory>;
-// we put this on the store for interop because it's used by modelFor and
-// instantiateRecord as well.
 export type ModelStore = Store & {
 	_modelFactoryCache: FactoryCache;
 };
@@ -37,17 +32,10 @@ export type ModelStore = Store & {
 * @noInheritDoc
 */
 interface Model {
-	// set during create by the store
 	/**
 	* The store service instance which created this record instance
 	*/
 	store: Store;
-	/** @internal */
-	___recordState: RecordState;
-	/** @internal */
-	___private_notifications: object;
-	/** @internal */
-	[RecordStore]: Store;
 	/**
 	Create a JSON representation of the record, using the serialization
 	strategy of the store's adapter.
@@ -177,7 +165,6 @@ interface Model {
 	@public
 	*/
 	rollbackAttributes<T extends MinimalLegacyRecord>(this: T): void;
-	// TODO @deprecate in favor of a public API or examples of how to test successfully
 	/**
 	@private
 	*/
@@ -249,10 +236,6 @@ interface Model {
 	with an error.
 	*/
 	reload<T extends MinimalLegacyRecord>(this: T, options?: Record<string, unknown>): Promise<T>;
-	// belongsTo<T extends MinimalLegacyRecord, K extends MaybeBelongsToFields<T>>(
-	//   this: T,
-	//   prop: K
-	// ): BelongsToReference<T, K>;
 	/**
 	Get the reference for the specified belongsTo relationship.
 	
@@ -434,10 +417,7 @@ interface Model {
 * @noInheritDoc
 */
 declare class Model extends EmberObject implements MinimalLegacyRecord {
-	/** @internal */
-	init(options: ModelCreateArgs): void;
-	/** @internal */
-	// @ts-expect-error destroy should not return a value, but ember's types force it to
+	/** @private */
 	destroy(): this;
 	/**
 	If this property is `true` the record is in the `empty`
@@ -687,8 +667,6 @@ declare class Model extends EmberObject implements MinimalLegacyRecord {
 	@property currentState
 	@private
 	*/
-	// TODO we can probably make this a computeOnce
-	// we likely do not need to notify the currentState root anymore
 	get currentState(): RecordState;
 	set currentState(_v: RecordState);
 	/**
@@ -758,18 +736,7 @@ declare class Model extends EmberObject implements MinimalLegacyRecord {
 	*/
 	get adapterError(): unknown;
 	set adapterError(v: unknown);
-	/*
-	We hook the default implementation to ensure
-	our tagged properties are properly notified
-	as well. We still super for everything because
-	sync observers require a direct call occuring
-	to trigger their flush. We wouldn't need to
-	super in 4.0+ where sync observers are removed.
-	*/
-	// @ts-expect-error no return is necessary, but Ember's types are forcing it
 	notifyPropertyChange(prop: string): this;
-	/** @internal */
-	attr(): void;
 	/**
 	Given a callback, iterates over each of the relationships in the model,
 	invoking the callback with the name of each relationship and its relationship
@@ -819,18 +786,14 @@ declare class Model extends EmberObject implements MinimalLegacyRecord {
 	```
 	
 	@public
-	@param {Function} callback the callback to invoke
-	@param {any} binding the value to which the callback's `this` should be bound
+	@param callback the callback to invoke
+	@param binding the value to which the callback's `this` should be bound
 	*/
 	eachRelationship<T>(callback: (this: NoInfer<T> | undefined, key: MaybeRelationshipFields<this>, meta: LegacyRelationshipField) => void, binding?: T): void;
 	relationshipFor(name: string): LegacyRelationshipField | undefined;
 	inverseFor(name: string): LegacyRelationshipField | null;
 	eachAttribute<T>(callback: (this: NoInfer<T> | undefined, key: isSubClass<this> extends true ? MaybeAttrFields<this> : string, meta: LegacyAttributeField) => void, binding?: T): void;
 	/**
-	* @internal
-	*/
-	static isModel: boolean;
-	/**
 	Represents the model's class name as a string. This can be used to look up the model's class name through
 	`Store`'s modelFor method.
 	
@@ -860,22 +823,6 @@ declare class Model extends EmberObject implements MinimalLegacyRecord {
 	@readonly
 	*/
 	static modelName: string;
-	/*
-	These class methods below provide relationship
-	introspection abilities about relationships.
-	
-	A note about the computed properties contained here:
-	
-	**These properties are effectively sealed once called for the first time.**
-	To avoid repeatedly doing expensive iteration over a model's fields, these
-	values are computed once and then cached for the remainder of the runtime of
-	your application.
-	
-	If your application needs to modify a class after its initial definition
-	(for example, using `reopen()` to add additional attributes), make sure you
-	do it before using your model with the store, which uses these properties
-	extensively.
-	*/
 	/**
 	For a given relationship name, returns the model type of the relationship.
 	
@@ -892,9 +839,9 @@ declare class Model extends EmberObject implements MinimalLegacyRecord {
 	Calling `store.modelFor('post').typeForRelationship('comments', store)` will return `Comment`.
 	
 	@public
-	@param {String} name the name of the relationship
-	@param {store} store an instance of Store
-	@return {Model} the type of the relationship, or undefined
+	@param name the name of the relationship
+	@param store an instance of Store
+	@return the type of the relationship, or undefined
 	*/
 	static typeForRelationship(name: string, store: Store): ModelSchema | undefined;
 	static get inverseMap(): Record<string, LegacyRelationshipField | null>;
@@ -925,12 +872,11 @@ declare class Model extends EmberObject implements MinimalLegacyRecord {
 	```
 	
 	@public
-	@param {String} name the name of the relationship
-	@param {Store} store
-	@return {Object} the inverse relationship, or null
+	@param name the name of the relationship
+	@param store
+	@return the inverse relationship, or null
 	*/
 	static inverseFor(name: string, store: Store): LegacyRelationshipField | null;
-	//Calculate the inverse, ignoring the cache
 	static _findInverseFor(name: string, store: Store): LegacyRelationshipField | null;
 	/**
 	The model's relationships as a map, keyed on the type of the
@@ -1319,4 +1265,5 @@ declare class Model extends EmberObject implements MinimalLegacyRecord {
 	*/
 	static toString(): string;
 }
+export declare function restoreDeprecatedModelRequestBehaviors(ModelKlass: typeof Model): void;
 export { Model };

package/declarations/model/-private/notify-changes.d.ts

@@ -1,4 +1,4 @@
 import type { NotificationType, Store } from "@warp-drive/core";
-import type { StableRecordIdentifier } from "@warp-drive/core/types/identifier";
+import type { ResourceKey } from "@warp-drive/core/types/identifier";
 import type { Model } from "./model.js";
-export default function notifyChanges(identifier: StableRecordIdentifier, value: NotificationType, key: string | undefined, record: Model, store: Store): void;
+export default function notifyChanges(identifier: ResourceKey, value: NotificationType, key: string | undefined, record: Model, store: Store): void;

package/declarations/model/-private/promise-belongs-to.d.ts

@@ -16,13 +16,10 @@ export interface BelongsToProxyCreateArgs<T = unknown> {
 }
 export declare const LegacyPromiseProxy: unique symbol;
 interface PromiseObjectType<T> extends PromiseProxyMixin<T | null>, ObjectProxy<T> {
-	// eslint-disable-next-line @typescript-eslint/no-misused-new
 	new <PT>(...args: unknown[]): PromiseObjectType<PT>;
 }
-// eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-extraneous-class
 declare class PromiseObjectType<T> {}
 declare const Extended: PromiseObjectType<OpaqueRecordInstance>;
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
 interface PromiseBelongsTo<T> {
 	[LegacyPromiseProxy]: true;
 }
@@ -37,9 +34,6 @@ Right now we proxy:
 declare class PromiseBelongsTo<T = unknown> extends Extended<T> {
 	_belongsToState: BelongsToProxyMeta<T>;
 	get id(): string | null;
-	// we don't proxy meta because we would need to proxy it to the relationship state container
-	//  however, meta on relationships does not trigger change notifications.
-	//  if you need relationship meta, you should do `record.belongsTo(relationshipName).meta()`
 	get meta(): void;
 	reload(options: Record<string, unknown>): Promise<this>;
 }

package/declarations/model/-private/promise-many-array.d.ts

@@ -6,7 +6,6 @@ export interface HasManyProxyCreateArgs<T = unknown> {
 	promise: Promise<ManyArray<T>>;
 	content?: ManyArray<T>;
 }
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
 export interface PromiseManyArray<T> {
 	[LegacyPromiseProxy]: true;
 }
@@ -37,10 +36,6 @@ export declare class PromiseManyArray<T = unknown> {
 	* @public
 	*/
 	get length(): number;
-	// this will error if someone tries to call
-	// A(identifierArray) since it is not configurable
-	// which is preferrable to the `meta` override we used
-	// before which required importing all of Ember
 	get "[]"(): 0 | ManyArray<T> | undefined;
 	/**
 	* Iterate the proxied content. Called by the glimmer iterator in #each
@@ -59,7 +54,6 @@ export declare class PromiseManyArray<T = unknown> {
 	* @return
 	*/
 	reload(options: Omit<BaseFinderOptions, "">): this;
-	//----  Properties/Methods from the PromiseProxyMixin that we will keep as our API
 	/**
 	* Whether the loading promise is still pending
 	*
@@ -113,9 +107,7 @@ export declare class PromiseManyArray<T = unknown> {
 	* @return {Promise}
 	*/
 	finally(cb: Parameters<Promise<ManyArray<T>>["finally"]>[0]): Promise<unknown>;
-	//---- Methods on EmberObject that we should keep
 	destroy(): void;
-	//---- Methods/Properties on ManyArray that we own and proxy to
 	/**
 	* Retrieve the links for this relationship
 	* @property links
@@ -128,8 +120,5 @@ export declare class PromiseManyArray<T = unknown> {
 	* @public
 	*/
 	get meta(): Record<string, unknown> | null | undefined;
-	//---- Our own stuff
-	/** @internal */
-	_update(promise: Promise<ManyArray<T>>, content?: ManyArray<T>): void;
 	static create<T>({ promise, content }: HasManyProxyCreateArgs<T>): PromiseManyArray<T>;
 }

package/declarations/model/-private/record-state.d.ts

@@ -1,8 +1,3 @@
-import type { Store } from "@warp-drive/core";
-import type { RequestCacheRequestState, RequestStateService } from "@warp-drive/core/store/-private";
-import type { Cache } from "@warp-drive/core/types/cache";
-import type { StableRecordIdentifier } from "@warp-drive/core/types/identifier";
-import type { Errors } from "./errors.js";
 import type { MinimalLegacyRecord } from "./model-methods.js";
 /**
 Historically EmberData managed a state machine
@@ -41,29 +36,11 @@ uncommitted
 invalid
 inFlight
 
-@internal
+@hideconstructor
+@private
 */
 export default class RecordState {
-	store: Store;
-	identifier: StableRecordIdentifier;
-	record: MinimalLegacyRecord;
-	rs: RequestStateService;
-	pendingCount: number;
-	fulfilledCount: number;
-	rejectedCount: number;
-	cache: Cache;
-	_errorRequests: RequestCacheRequestState[];
-	_lastError: RequestCacheRequestState | null;
-	handler: object;
 	constructor(record: MinimalLegacyRecord);
-	/** @internal */
-	destroy(): void;
-	/** @internal */
-	notify(key: keyof this & string): void;
-	/** @internal */
-	updateInvalidErrors(errors: Errors): void;
-	/** @internal */
-	cleanErrorRequests(): void;
 	isSaving: boolean;
 	get isLoading(): boolean;
 	get isLoaded(): boolean;

package/declarations/model/-private/references/belongs-to.d.ts

@@ -1,6 +1,6 @@
 import type { Store } from "@warp-drive/core";
 import type { Graph, ResourceEdge } from "@warp-drive/core/graph/-private";
-import type { StableRecordIdentifier } from "@warp-drive/core/types/identifier";
+import type { ResourceKey } from "@warp-drive/core/types/identifier";
 import type { TypeFromInstance, TypeFromInstanceOrString } from "@warp-drive/core/types/record";
 import type { Links, Meta, SingleResourceDocument, SingleResourceRelationship } from "@warp-drive/core/types/spec/json-api-raw";
 import type { IsUnknown } from "../belongs-to.js";
@@ -57,22 +57,21 @@ export default class BelongsToReference<
 	* @public
 	*/
 	type: TypeFromInstanceOrString<Related>;
-	// unsubscribe tokens given to us by the notification manager
 	___token: object;
-	___identifier: StableRecordIdentifier<TypeFromInstanceOrString<T>>;
+	___identifier: ResourceKey<TypeFromInstanceOrString<T>>;
 	___relatedToken: object | null;
 	_ref: number;
-	constructor(store: Store, graph: Graph, parentIdentifier: StableRecordIdentifier<TypeFromInstanceOrString<T>>, belongsToRelationship: ResourceEdge, key: K);
+	constructor(store: Store, graph: Graph, parentIdentifier: ResourceKey<TypeFromInstanceOrString<T>>, belongsToRelationship: ResourceEdge, key: K);
 	destroy(): void;
 	/**
 	* The identifier of the record that this reference refers to.
 	* `null` if no related record is known.
 	*
 	* @property identifier
-	* @type {StableRecordIdentifier | null}
+	* @type {ResourceKey | null}
 	* @public
 	*/
-	get identifier(): StableRecordIdentifier<TypeFromInstanceOrString<Related>> | null;
+	get identifier(): ResourceKey<TypeFromInstanceOrString<Related>> | null;
 	/**
 	The `id` of the record that this reference refers to. Together, the
 	`type()` and `id()` methods form a composite key for the identity
@@ -198,7 +197,7 @@ export default class BelongsToReference<
 	@return {Object} The meta information for the belongs-to relationship.
 	*/
 	meta(): Meta | null;
-	_resource(): SingleResourceRelationship<StableRecordIdentifier<TypeFromInstance<Related>>>;
+	_resource(): SingleResourceRelationship<ResourceKey<TypeFromInstance<Related>>>;
 	/**
 	This returns a string that represents how the reference will be
 	looked up when it is loaded. If the relationship has a link it will

package/declarations/model/-private/references/has-many.d.ts

@@ -2,7 +2,7 @@ import type { Store } from "@warp-drive/core";
 import type { CollectionEdge, Graph } from "@warp-drive/core/graph/-private";
 import type { RelatedCollection as ManyArray } from "@warp-drive/core/store/-private";
 import type { BaseFinderOptions } from "@warp-drive/core/types";
-import type { StableRecordIdentifier } from "@warp-drive/core/types/identifier";
+import type { ResourceKey } from "@warp-drive/core/types/identifier";
 import type { TypeFromInstanceOrString } from "@warp-drive/core/types/record";
 import type { CollectionResourceDocument, CollectionResourceRelationship, ExistingResourceObject, LinkObject, Meta, PaginationLinks } from "@warp-drive/core/types/spec/json-api-raw";
 import type { IsUnknown } from "../belongs-to.js";
@@ -66,26 +66,19 @@ export default class HasManyReference<
 	* @public
 	*/
 	type: TypeFromInstanceOrString<Related>;
-	// unsubscribe tokens given to us by the notification manager
 	___token: object;
-	___identifier: StableRecordIdentifier<TypeFromInstanceOrString<T>>;
-	___relatedTokenMap: Map<StableRecordIdentifier, object>;
+	___identifier: ResourceKey<TypeFromInstanceOrString<T>>;
+	___relatedTokenMap: Map<ResourceKey, object>;
 	_ref: number;
-	constructor(store: Store, graph: Graph, parentIdentifier: StableRecordIdentifier<TypeFromInstanceOrString<T>>, hasManyRelationship: CollectionEdge, key: K);
-	/**
-	* This method should never be called by user code.
-	*
-	* @internal
-	*/
-	destroy(): void;
+	constructor(store: Store, graph: Graph, parentIdentifier: ResourceKey<TypeFromInstanceOrString<T>>, hasManyRelationship: CollectionEdge, key: K);
 	/**
 	* An array of identifiers for the records that this reference refers to.
 	*
 	* @property identifiers
-	* @type {StableRecordIdentifier[]}
+	* @type {ResourceKey[]}
 	* @public
 	*/
-	get identifiers(): StableRecordIdentifier<TypeFromInstanceOrString<Related>>[];
+	get identifiers(): ResourceKey<TypeFromInstanceOrString<Related>>[];
 	_resource(): CollectionResourceRelationship;
 	/**
 	This returns a string that represents how the reference will be