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

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

@@ -1,6 +1,6 @@
 import type { Store } from "@warp-drive/core";
 import type { SchemaService } from "@warp-drive/core/types";
-import type { RecordIdentifier, StableRecordIdentifier } from "@warp-drive/core/types/identifier";
+import type { ResourceKey } from "@warp-drive/core/types/identifier";
 import type { ObjectValue } from "@warp-drive/core/types/json/raw";
 import type { Derivation, HashFn, Transformation } from "@warp-drive/core/types/schema/concepts";
 import type { ArrayField, DerivedField, GenericField, HashField, LegacyField, ObjectField, ObjectSchema, ResourceSchema } from "@warp-drive/core/types/schema/fields";
@@ -8,22 +8,19 @@ import type { ModelFactory, ModelStore } from "./model.js";
 type AttributesSchema = ReturnType<Exclude<SchemaService["attributesDefinitionFor"], undefined>>;
 type RelationshipsSchema = ReturnType<Exclude<SchemaService["relationshipsDefinitionFor"], undefined>>;
 export interface ModelSchemaProvider {
-	attributesDefinitionFor(resource: RecordIdentifier | {
+	attributesDefinitionFor(resource: ResourceKey | {
 		type: string;
 	}): AttributesSchema;
-	relationshipsDefinitionFor(resource: RecordIdentifier | {
+	relationshipsDefinitionFor(resource: ResourceKey | {
 		type: string;
 	}): RelationshipsSchema;
 	doesTypeExist(type: string): boolean;
 }
 export declare class ModelSchemaProvider implements SchemaService {
-	private store;
-	private _schemas;
-	private _typeMisses;
 	constructor(store: ModelStore);
 	resourceTypes(): Readonly<string[]>;
 	hasTrait(type: string): boolean;
-	resourceHasTrait(resource: StableRecordIdentifier | {
+	resourceHasTrait(resource: ResourceKey | {
 		type: string;
 	}, trait: string): boolean;
 	transformation(field: GenericField | ObjectField | ArrayField | {
@@ -35,7 +32,7 @@ export declare class ModelSchemaProvider implements SchemaService {
 	hashFn(field: HashField | {
 		type: string;
 	}): HashFn;
-	resource(resource: StableRecordIdentifier | {
+	resource(resource: ResourceKey | {
 		type: string;
 	}): ResourceSchema | ObjectSchema;
 	registerResources(schemas: Array<ResourceSchema | ObjectSchema>): void;
@@ -47,8 +44,7 @@ export declare class ModelSchemaProvider implements SchemaService {
 		FM extends ObjectValue | null
 	>(derivation: Derivation<R, T, FM>): void;
 	registerHashFn(hashFn: HashFn): void;
-	private _loadModelSchema;
-	fields(resource: RecordIdentifier | {
+	fields(resource: ResourceKey | {
 		type: string;
 	}): Map<string, LegacyField>;
 	hasResource(resource: {

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

@@ -1,8 +1,8 @@
 export { type MinimalLegacyRecord } from "./-private/model-methods.js";
 export type { ModelStore } from "./-private/model.js";
 export { Errors } from "./-private/errors.js";
-export { RelatedCollection as ManyArray } from "@warp-drive/core/store/-private";
+export type { LegacyManyArray as ManyArray } from "@warp-drive/core/store/-private";
 export { PromiseBelongsTo } from "./-private/promise-belongs-to.js";
 export { PromiseManyArray } from "./-private/promise-many-array.js";
-// // Used by tests, migration support
 export { lookupLegacySupport, LEGACY_SUPPORT } from "./-private/legacy-relationships-support.js";
+export type { MaybeHasManyFields, MaybeBelongsToFields, MaybeRelationshipFields } from "./-private/type-utils.js";

package/declarations/model/migration-support.d.ts

@@ -1,28 +1,9 @@
-/**
-* This module provides support for migrating away from @ember-data/model
-* to @warp-drive/schema-record.
-*
-* It includes:
-*
-* - A `withDefaults` function to assist in creating a schema in LegacyMode
-* - A `registerDerivations` function to register the derivations necessary to support LegacyMode
-* - A `DelegatingSchemaService` that can be used to provide a schema service that works with both
-*   @ember-data/model and @warp-drive/schema-record simultaneously for migration purposes.
-* - A `WithLegacy` type util that can be used to create a type that includes the legacy
-*   properties and methods of a record.
-*
-* Using LegacyMode features on a ReactiveResource *requires* the use of these derivations and schema
-* additions. LegacyMode is not intended to be a long-term solution, but rather a stepping stone
-* to assist in more rapidly adopting modern WarpDrive features.
-*
-* @module
-*/
 import type { Store } from "@warp-drive/core";
 import type { CAUTION_MEGA_DANGER_ZONE_Extension, ProcessedExtension } from "@warp-drive/core/reactive";
 import type { ExtensibleField } from "@warp-drive/core/reactive/-private/schema";
 import type { SchemaService } from "@warp-drive/core/types";
 import type { ChangedAttributesHash } from "@warp-drive/core/types/cache";
-import type { StableRecordIdentifier } from "@warp-drive/core/types/identifier";
+import type { ResourceKey } from "@warp-drive/core/types/identifier";
 import type { ObjectValue } from "@warp-drive/core/types/json/raw";
 import type { TypedRecordInstance, TypeFromInstance } from "@warp-drive/core/types/record";
 import type { Derivation, HashFn, Transformation } from "@warp-drive/core/types/schema/concepts";
@@ -170,6 +151,7 @@ export type WithLegacy<T extends TypedRecordInstance> = T & LegacyModeRecord<T>;
 * @public
 */
 export declare function withDefaults(schema: WithPartial<LegacyResourceSchema, "legacy" | "identity">): LegacyResourceSchema;
+export declare function withRestoredDeprecatedModelRequestBehaviors(schema: WithPartial<LegacyResourceSchema, "legacy" | "identity">): LegacyResourceSchema;
 /**
 * A function which registers the necessary derivations to support
 * the LegacyMode features of @ember-data/model while migrating to WarpDrive.
@@ -216,10 +198,10 @@ export declare function registerDerivations(schema: SchemaService): void;
 * @public
 */
 export interface DelegatingSchemaService {
-	attributesDefinitionFor?(resource: StableRecordIdentifier | {
+	attributesDefinitionFor?(resource: ResourceKey | {
 		type: string;
 	}): AttributesSchema;
-	relationshipsDefinitionFor?(resource: StableRecordIdentifier | {
+	relationshipsDefinitionFor?(resource: ResourceKey | {
 		type: string;
 	}): RelationshipsSchema;
 	doesTypeExist?(type: string): boolean;
@@ -228,18 +210,18 @@ export declare class DelegatingSchemaService implements SchemaService {
 	_preferred: SchemaService;
 	_secondary: SchemaService;
 	constructor(store: Store, schema: SchemaService);
-	isDelegated(resource: StableRecordIdentifier | {
+	isDelegated(resource: ResourceKey | {
 		type: string;
 	}): boolean;
 	resourceTypes(): Readonly<string[]>;
-	hasResource(resource: StableRecordIdentifier | {
+	hasResource(resource: ResourceKey | {
 		type: string;
 	}): boolean;
 	hasTrait(type: string): boolean;
-	resourceHasTrait(resource: StableRecordIdentifier | {
+	resourceHasTrait(resource: ResourceKey | {
 		type: string;
 	}, trait: string): boolean;
-	fields(resource: StableRecordIdentifier | {
+	fields(resource: ResourceKey | {
 		type: string;
 	}): Map<string, FieldSchema>;
 	transformation(field: GenericField | ObjectField | ArrayField | {
@@ -251,7 +233,7 @@ export declare class DelegatingSchemaService implements SchemaService {
 	derivation(field: DerivedField | {
 		type: string;
 	}): Derivation;
-	resource(resource: StableRecordIdentifier | {
+	resource(resource: ResourceKey | {
 		type: string;
 	}): ResourceSchema | ObjectSchema;
 	registerResources(schemas: Array<ResourceSchema | ObjectSchema>): void;
@@ -264,34 +246,10 @@ export declare class DelegatingSchemaService implements SchemaService {
 	>(derivation: Derivation<R, T, FM>): void;
 	registerHashFn(hashFn: HashFn): 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): null | ProcessedExtension["features"];
+	CAUTION_MEGA_DANGER_ZONE_objectExtensions(field: ExtensibleField, resolvedType: string | null): null | ProcessedExtension["features"];
 	CAUTION_MEGA_DANGER_ZONE_arrayExtensions(field: ExtensibleField): null | ProcessedExtension["features"];
-	/**
-	* This is an internal method used to register behaviors for legacy mode.
-	* It is not intended for public use.
-	*
-	* We do think a generalized `kind` registration system would be useful,
-	* but we have not yet designed it.
-	*
-	* See https://github.com/emberjs/data/issues/9534
-	*
-	* @internal
-	*/
-	_registerMode(mode: string, kinds: unknown): void;
-	/**
-	* This is an internal method used to enable legacy behaviors for legacy mode.
-	* It is not intended for public use.
-	*
-	* We do think a generalized `kind` registration system would be useful,
-	* but we have not yet designed it.
-	*
-	* See https://github.com/emberjs/data/issues/9534
-	*
-	* @internal
-	*/
-	_kind(mode: string, kind: "belongsTo" | "hasMany"): () => unknown;
 }
 export {};

package/declarations/model.d.ts

@@ -39,7 +39,7 @@ and dasherized.
 export { attr } from "./model/-private/attr.js";
 export { belongsTo } from "./model/-private/belongs-to.js";
 export { hasMany } from "./model/-private/has-many.js";
-export { Model } from "./model/-private/model.js";
+export { Model, restoreDeprecatedModelRequestBehaviors } from "./model/-private/model.js";
 export { Model as default } from "./model/-private/model.js";
 export type { PromiseBelongsTo as AsyncBelongsTo } from "./model/-private/promise-belongs-to.js";
 export type { PromiseManyArray as AsyncHasMany } from "./model/-private/promise-many-array.js";

package/declarations/serializer/json-api.d.ts

@@ -121,6 +121,5 @@ return normalizedRelationship;
 @class JSONAPISerializer
 @public
 */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 declare const JSONAPISerializer: any;
 export { JSONAPISerializer };

package/declarations/serializer/json.d.ts

@@ -73,6 +73,5 @@ turn the record payload into the JSON API format.
 @class JSONSerializer
 @public
 */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 declare const JSONSerializer: any;
 export { JSONSerializer };

package/declarations/serializer/rest.d.ts

@@ -48,7 +48,6 @@ the method (`serialize` or `deserialize`) as the third parameter.
 @class RESTSerializer
 @public
 */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 declare const RESTSerializer: any;
 export { EmbeddedRecordsMixin } from "./-private/embedded-records-mixin.js";
 export { RESTSerializer };

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

@@ -0,0 +1,223 @@
+import { type InstanceCache } from "@warp-drive/core/store/-private";
+import type { NewResourceKey, ResourceKey } from "@warp-drive/core/types/identifier";
+import type { Value } from "@warp-drive/core/types/json/raw";
+import type { OpaqueRecordInstance, TypedRecordInstance, TypeFromInstance } from "@warp-drive/core/types/record";
+import type { LegacyAttributeField, LegacyRelationshipField } from "@warp-drive/core/types/schema/fields";
+import type { SingleResourceDocument } from "@warp-drive/core/types/spec/json-api-raw";
+import type { Store } from "../store.js";
+export declare function preloadData(store: Store, identifier: NewResourceKey, preload: Record<string, Value>): void;
+export interface BaseFinderOptions {
+	reload?: boolean;
+	backgroundReload?: boolean;
+	include?: string | string[];
+	adapterOptions?: Record<string, unknown>;
+}
+export interface FindRecordOptions extends BaseFinderOptions {
+	/**
+	* Data to preload into the store before the request is made.
+	* This feature is *highly* discouraged and has no corresponding
+	* feature when using builders and handlers.
+	*
+	* Excepting relationships: the data should be in the form of a
+	* JSON object where the keys are fields on the record and the value
+	* is the raw value to be added to the cache.
+	*
+	* Relationships can either be provided as string IDs from which
+	* an identifier will be built base upon the relationship's expected
+	* resource type, or be record instances from which the identifier
+	* will be extracted.
+	*
+	*/
+	preload?: Record<string, Value>;
+}
+export type QueryOptions = { [K in string | "adapterOptions"]? : K extends "adapterOptions" ? Record<string, unknown> : unknown };
+export type FindAllOptions = BaseFinderOptions;
+export type LegacyResourceQuery = {
+	include?: string | string[];
+	[key: string]: Value | undefined;
+};
+export type KeyOrString<T> = keyof T & string extends never ? string : keyof T & string;
+/**
+* Minimum subset of static schema methods and properties on the
+* "model" class.
+*
+* Only used when using the legacy schema-service implementation
+* for @ember-data/model or when wrapping schema for legacy
+* Adapters/Serializers.
+*
+*/
+export interface ModelSchema<T = unknown> {
+	modelName: T extends TypedRecordInstance ? TypeFromInstance<T> : string;
+	fields: Map<KeyOrString<T>, "attribute" | "belongsTo" | "hasMany">;
+	attributes: Map<KeyOrString<T>, LegacyAttributeField>;
+	relationshipsByName: Map<KeyOrString<T>, LegacyRelationshipField>;
+	eachAttribute<K extends KeyOrString<T>>(callback: (this: ModelSchema<T>, key: K, attribute: LegacyAttributeField) => void, binding?: T): void;
+	eachRelationship<K extends KeyOrString<T>>(callback: (this: ModelSchema<T>, key: K, relationship: LegacyRelationshipField) => void, binding?: T): void;
+	eachTransformedAttribute<K extends KeyOrString<T>>(callback: (this: ModelSchema<T>, key: K, type: string | null) => void, binding?: T): void;
+}
+export declare function resourceIsFullyDeleted(instanceCache: InstanceCache, identifier: ResourceKey): boolean;
+/**
+A `RecordReference` is a low-level API that allows users and
+addon authors to perform meta-operations on a record.
+
+@hideconstructor
+@public
+*/
+export declare class RecordReference {
+	constructor(store: Store, identifier: ResourceKey);
+	get type(): string;
+	/**
+	The `id` of the record that this reference refers to.
+	
+	Together, the `type` and `id` properties form a composite key for
+	the identity map.
+	
+	Example
+	
+	```javascript
+	let userRef = store.getReference('user', 1);
+	
+	userRef.id(); // '1'
+	```
+	
+	@public
+	@return The id of the record.
+	*/
+	id(): string | null;
+	/**
+	The `identifier` of the record that this reference refers to.
+	
+	Together, the `type` and `id` properties form a composite key for
+	the identity map.
+	
+	Example
+	
+	```javascript
+	let userRef = store.getReference('user', 1);
+	
+	userRef.identifier(); // '1'
+	```
+	
+	@public
+	@return The identifier of the record.
+	*/
+	identifier(): ResourceKey;
+	/**
+	How the reference will be looked up when it is loaded. Currently
+	this always returns `identity` to signify that a record will be
+	loaded by its `type` and `id`.
+	
+	Example
+	
+	```javascript
+	const userRef = store.getReference('user', 1);
+	
+	userRef.remoteType(); // 'identity'
+	```
+	
+	@public
+	*/
+	remoteType(): "identity";
+	/**
+	This API allows you to provide a reference with new data. The
+	simplest usage of this API is similar to `store.push`: you provide a
+	normalized hash of data and the object represented by the reference
+	will update.
+	
+	If you pass a promise to `push`, Ember Data will not ask the adapter
+	for the data if another attempt to fetch it is made in the
+	interim. When the promise resolves, the underlying object is updated
+	with the new data, and the promise returned by *this function* is resolved
+	with that object.
+	
+	For example, `recordReference.push(promise)` will be resolved with a
+	record.
+	
+	Example
+	
+	```javascript
+	let userRef = store.getReference('user', 1);
+	
+	// provide data for reference
+	userRef.push({
+	data: {
+	id: "1",
+	type: "user",
+	attributes: {
+	username: "@user"
+	}
+	}
+	}).then(function(user) {
+	userRef.value() === user;
+	});
+	```
+	
+	@public
+	@param objectOrPromise a JSON:API ResourceDocument or a promise resolving to one
+	@return a promise for the value (record or relationship)
+	*/
+	push(objectOrPromise: SingleResourceDocument | Promise<SingleResourceDocument>): Promise<OpaqueRecordInstance>;
+	/**
+	If the entity referred to by the reference is already loaded, it is
+	present as `reference.value`. Otherwise the value returned by this function
+	is `null`.
+	
+	Example
+	
+	```javascript
+	let userRef = store.getReference('user', 1);
+	
+	userRef.value(); // user
+	```
+	
+	@public
+	@return {Model} the record for this RecordReference
+	*/
+	value(): OpaqueRecordInstance | null;
+	/**
+	Triggers a fetch for the backing entity based on its `remoteType`
+	(see `remoteType` definitions per reference type).
+	
+	Example
+	
+	```javascript
+	let userRef = store.getReference('user', 1);
+	
+	// load user (via store.find)
+	userRef.load().then(...)
+	```
+	
+	@public
+	@return the record for this RecordReference
+	*/
+	load(): Promise<unknown>;
+	/**
+	Reloads the record if it is already loaded. If the record is not
+	loaded it will load the record via `store.findRecord`
+	
+	Example
+	
+	```javascript
+	let userRef = store.getReference('user', 1);
+	
+	// or trigger a reload
+	userRef.reload().then(...)
+	```
+	
+	@public
+	@return the record for this RecordReference
+	*/
+	reload(): Promise<unknown>;
+}
+export declare function getShimClass<T>(store: Store, modelName: T extends TypedRecordInstance ? TypeFromInstance<T> : string): ShimModelClass<T>;
+export declare class ShimModelClass<T = unknown> implements ModelSchema<T> {
+	__store: Store;
+	modelName: T extends TypedRecordInstance ? TypeFromInstance<T> : string;
+	constructor(store: Store, modelName: T extends TypedRecordInstance ? TypeFromInstance<T> : string);
+	get fields(): Map<KeyOrString<T>, "attribute" | "belongsTo" | "hasMany">;
+	get attributes(): Map<KeyOrString<T>, LegacyAttributeField>;
+	get relationshipsByName(): Map<KeyOrString<T>, LegacyRelationshipField>;
+	eachAttribute<K extends KeyOrString<T>>(callback: (key: K, attribute: LegacyAttributeField) => void, binding?: T): void;
+	eachRelationship<K extends KeyOrString<T>>(callback: (key: K, relationship: LegacyRelationshipField) => void, binding?: T): void;
+	eachTransformedAttribute<K extends KeyOrString<T>>(callback: (key: K, type: string | null) => void, binding?: T): void;
+}

package/declarations/store.d.ts

@@ -0,0 +1,3 @@
+import type { Store } from "@warp-drive/core";
+export declare function restoreDeprecatedStoreBehaviors(StoreKlass: typeof Store): void;
+export { Store };