@warp-drive/core 5.7.0-alpha.0 → 5.7.0-alpha.10

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

@@ -1,4 +1,5 @@
-export { Store, storeFor } from "./-private/store-service.js";
+export { Store } from "./deprecated/store.js";
+export { storeFor } from "./-private/store-service.js";
 export { recordIdentifierFor } from "./-private/caches/instance-cache.js";
 export { CacheHandler, type StoreRequestContext } from "./-private/cache-handler/handler.js";
 export { type CachePolicy } from "./-private/cache-handler/types.js";
@@ -27,5 +28,5 @@ export { getPromiseState, type PromiseState } from "./-private/new-core-tmp/prom
 export { DISPOSE, createRequestSubscription, type SubscriptionArgs, type RequestSubscription } from "./-private/new-core-tmp/request-subscription.js";
 export { getRequestState, type RequestLoadingState, type RequestCacheRequestState as RequestState } from "./-private/new-core-tmp/request-state.js";
 export { createMemo, type SignalHooks, waitFor } from "./-private/new-core-tmp/reactivity/configure.js";
-export { memoized, gate, entangleSignal, defineSignal, defineNonEnumerableSignal } from "./-private/new-core-tmp/reactivity/signal.js";
+export { memoized, gate, entangleSignal, defineSignal, defineGate, defineNonEnumerableSignal } from "./-private/new-core-tmp/reactivity/signal.js";
 export { ARRAY_SIGNAL, OBJECT_SIGNAL, Signals, type WarpDriveSignal, peekInternalSignal, withSignalStore, notifyInternalSignal, consumeInternalSignal, getOrCreateInternalSignal } from "./-private/new-core-tmp/reactivity/internal.js";

package/declarations/store/-types/q/schema-service.d.ts

@@ -3,7 +3,7 @@ import type { ExtensibleField } from "../../../reactive/-private/schema.js";
 import type { RecordIdentifier, StableRecordIdentifier } from "../../../types/identifier.js";
 import type { ObjectValue } from "../../../types/json/raw.js";
 import type { Derivation, HashFn, Transformation } from "../../../types/schema/concepts.js";
-import type { ArrayField, DerivedField, FieldSchema, GenericField, HashField, LegacyAttributeField, LegacyRelationshipField, ObjectField, Schema } from "../../../types/schema/fields.js";
+import type { ArrayField, CacheableFieldSchema, DerivedField, FieldSchema, GenericField, HashField, IdentityField, LegacyAttributeField, LegacyRelationshipField, ObjectField, Schema, Trait } from "../../../types/schema/fields.js";
 export type AttributesSchema = Record<string, LegacyAttributeField>;
 export type RelationshipsSchema = Record<string, LegacyRelationshipField>;
 interface ObjectWithStringTypeProperty {
@@ -57,7 +57,6 @@ interface ObjectWithStringTypeProperty {
 * }
 * ```
 *
-* @class (Interface) SchemaService
 * @public
 */
 export interface SchemaService {
@@ -68,33 +67,24 @@ export interface SchemaService {
 	*
 	* @public
 	* @deprecated
-	* @param {String} type
-	* @return {Boolean}
 	*/
 	doesTypeExist?(type: string): boolean;
 	/**
 	* Queries whether the SchemaService recognizes `type` as a resource type
 	*
 	* @public
-	* @param {StableRecordIdentifier|ObjectWithStringTypeProperty} resource
-	* @return {Boolean}
 	*/
 	hasResource(resource: ObjectWithStringTypeProperty | StableRecordIdentifier): boolean;
 	/**
 	* Queries whether the SchemaService recognizes `type` as a resource trait
 	*
 	* @public
-	* @param {String} type
-	* @return {Boolean}
 	*/
 	hasTrait(type: string): boolean;
 	/**
 	* Queries whether the given resource has the given trait
 	*
 	* @public
-	* @param {StableRecordIdentifier|ObjectWithStringTypeProperty} resource
-	* @param {String} trait
-	* @return {Boolean}
 	*/
 	resourceHasTrait(resource: ObjectWithStringTypeProperty | StableRecordIdentifier, trait: string): boolean;
 	/**
@@ -103,17 +93,21 @@ export interface SchemaService {
 	* Should error if the resource type is not recognized.
 	*
 	* @public
-	* @param {StableRecordIdentifier|ObjectWithStringTypeProperty} resource
-	* @return {Map<string, FieldSchema>}
 	*/
 	fields(resource: ObjectWithStringTypeProperty | StableRecordIdentifier): Map<string, FieldSchema>;
 	/**
+	* Queries for the fields of a given resource type or resource identity.
+	*
+	* Should error if the resource type is not recognized.
+	*
+	* @public
+	*/
+	cacheFields?(resource: ObjectWithStringTypeProperty | StableRecordIdentifier): Map<string, Exclude<CacheableFieldSchema, IdentityField>>;
+	/**
 	* Returns the transformation registered with the name provided
 	* by `field.type`. Validates that the field is a valid transformable.
 	*
 	* @public
-	* @param {TransformableField|ObjectWithStringTypeProperty} field
-	* @return {Transformation}
 	*/
 	transformation(field: GenericField | ObjectField | ArrayField | ObjectWithStringTypeProperty): Transformation;
 	/**
@@ -121,8 +115,6 @@ export interface SchemaService {
 	* by `field.type`. Validates that the field is a valid HashField.
 	*
 	* @public
-	* @param {HashField|ObjectWithStringTypeProperty} field
-	* @return {HashFn}
 	*/
 	hashFn(field: HashField | ObjectWithStringTypeProperty): HashFn;
 	/**
@@ -130,16 +122,12 @@ export interface SchemaService {
 	* by `field.type`. Validates that the field is a valid DerivedField.
 	*
 	* @public
-	* @param {DerivedField|ObjectWithStringTypeProperty} field
-	* @return {Derivation}
 	*/
 	derivation(field: DerivedField | ObjectWithStringTypeProperty): Derivation;
 	/**
 	* Returns the schema for the provided resource type.
 	*
 	* @public
-	* @param {StableRecordIdentifier|ObjectWithStringTypeProperty} resource
-	* @return {ResourceSchema}
 	*/
 	resource(resource: ObjectWithStringTypeProperty | StableRecordIdentifier): Schema;
 	/**
@@ -150,7 +138,6 @@ export interface SchemaService {
 	* or other sources just-in-time.
 	*
 	* @public
-	* @param {Schema[]} schemas
 	*/
 	registerResources(schemas: Schema[]): void;
 	/**
@@ -163,7 +150,6 @@ export interface SchemaService {
 	* or other sources just-in-time.
 	*
 	* @public
-	* @param {Schema} schema
 	*/
 	registerResource(schema: Schema): void;
 	/**
@@ -173,7 +159,6 @@ export interface SchemaService {
 	* attached to it's `[Type]` property.
 	*
 	* @public
-	* @param {Transformation} transform
 	*/
 	registerTransformation(transform: Transformation): void;
 	/**
@@ -183,7 +168,6 @@ export interface SchemaService {
 	* attached to it's `[Type]` property.
 	*
 	* @public
-	* @param {Derivation} derivation
 	*/
 	registerDerivation<
 		R,
@@ -197,10 +181,38 @@ export interface SchemaService {
 	* attached to it's `[Type]` property.
 	*
 	* @public
-	* @param {HashFn} hashfn
 	*/
 	registerHashFn(hashFn: HashFn): void;
 	/**
+	* Registers a {@link Trait} for use by resource schemas.
+	*
+	* Traits are re-usable collections of fields that can be composed to
+	* build up a resource schema. Often they represent polymorphic behaviors
+	* a resource should exhibit.
+	*
+	* When we finalize a resource, we walk its traits and apply their fields
+	* to the resource's fields. All specified traits must be registered by
+	* this time or an error will be thrown.
+	*
+	* Traits are applied left-to-right, with traits of traits being applied in the same
+	* way. Thus for the most part, application of traits is a post-order graph traversal
+	* problem.
+	*
+	* A trait is only ever processed once. If multiple traits (A, B, C) have the same
+	* trait (D) as a dependency, D will be included only once when first encountered by
+	* A.
+	*
+	* If a cycle exists such that trait A has trait B which has Trait A, trait A will
+	* be applied *after* trait B in production. In development a cycle error will be thrown.
+	*
+	* Fields are finalized on a "last wins principle". Thus traits appearing higher in
+	* the tree and further to the right of a traits array take precedence, with the
+	* resource's fields always being applied last and winning out.
+	*
+	* @public
+	*/
+	registerTrait?(trait: Trait): void;
+	/**
 	* DEPRECATED - use `fields` instead
 	*
 	* Returns definitions for all properties of the specified resource
@@ -240,8 +252,6 @@ export interface SchemaService {
 	*
 	* @public
 	* @deprecated
-	* @param {RecordIdentifier|ObjectWithStringTypeProperty} identifier
-	* @return {AttributesSchema}
 	*/
 	attributesDefinitionFor?(identifier: RecordIdentifier | ObjectWithStringTypeProperty): AttributesSchema;
 	/**
@@ -321,34 +331,48 @@ export interface SchemaService {
 	*
 	* @public
 	* @deprecated
-	* @param {RecordIdentifier|ObjectWithStringTypeProperty} identifier
-	* @return {RelationshipsSchema}
 	*/
 	relationshipsDefinitionFor?(identifier: RecordIdentifier | ObjectWithStringTypeProperty): RelationshipsSchema;
 	/**
 	* Returns all known resource types
 	*
 	* @public
-	* @return {String[]}
 	*/
 	resourceTypes(): Readonly<string[]>;
 	/**
 	* Register an extension for either objects or arrays
+	*
+	* @public
 	*/
 	CAUTION_MEGA_DANGER_ZONE_registerExtension?(extension: CAUTION_MEGA_DANGER_ZONE_Extension): void;
 	/**
 	* Retrieve the extension map for a resource
+	*
+	* @public
 	*/
 	CAUTION_MEGA_DANGER_ZONE_resourceExtensions?(resource: StableRecordIdentifier | {
 		type: string;
 	}): null | ProcessedExtension["features"];
 	/**
 	* Retrieve the extension map for an object field
+	*
+	* @public
 	*/
-	CAUTION_MEGA_DANGER_ZONE_objectExtensions?(field: ExtensibleField): null | ProcessedExtension["features"];
+	CAUTION_MEGA_DANGER_ZONE_objectExtensions?(field: ExtensibleField, resolvedType: string | null): null | ProcessedExtension["features"];
 	/**
 	* Retrieve the extension map for an array field
+	*
+	* @public
 	*/
 	CAUTION_MEGA_DANGER_ZONE_arrayExtensions?(field: ExtensibleField): null | ProcessedExtension["features"];
+	/**
+	* Check if a specific extension has been registered previously
+	*
+	* @public
+	*/
+	CAUTION_MEGA_DANGER_ZONE_hasExtension?(ext: {
+		kind: "object" | "array";
+		name: string;
+	}): boolean;
 }
 export {};

package/declarations/store/-types/q/store.d.ts

@@ -1,12 +1,11 @@
 import type { Value } from "../../../types/json/raw.js";
-import type { Includes, TypedRecordInstance } from "../../../types/record.js";
-export interface BaseFinderOptions<T = unknown> {
+export interface BaseFinderOptions {
 	reload?: boolean;
 	backgroundReload?: boolean;
-	include?: T extends TypedRecordInstance ? Includes<T>[] : string | string[];
+	include?: string | string[];
 	adapterOptions?: Record<string, unknown>;
 }
-export interface FindRecordOptions<T = unknown> extends BaseFinderOptions<T> {
+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
@@ -25,8 +24,8 @@ export interface FindRecordOptions<T = unknown> extends BaseFinderOptions<T> {
 	preload?: Record<string, Value>;
 }
 export type QueryOptions = { [K in string | "adapterOptions"]? : K extends "adapterOptions" ? Record<string, unknown> : unknown };
-export type FindAllOptions<T = unknown> = BaseFinderOptions<T>;
-export type LegacyResourceQuery<T = unknown> = {
-	include?: T extends TypedRecordInstance ? Includes<T>[] : string | string[];
+export type FindAllOptions = BaseFinderOptions;
+export type LegacyResourceQuery = {
+	include?: string | string[];
 	[key: string]: Value | undefined;
 };

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

@@ -0,0 +1,235 @@
+import type { StableNewRecordIdentifier, StableRecordIdentifier } from "../../types/identifier.js";
+import type { Value } from "../../types/json/raw.js";
+import type { OpaqueRecordInstance, TypedRecordInstance, TypeFromInstance } from "../../types/record.js";
+import type { LegacyAttributeField, LegacyRelationshipField } from "../../types/schema/fields.js";
+import type { SingleResourceDocument } from "../../types/spec/json-api-raw.js";
+import { type InstanceCache } from "../-private.js";
+import type { Store } from "./store.js";
+export declare function preloadData(store: Store, identifier: StableNewRecordIdentifier, 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: StableRecordIdentifier): 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 {
+	/** @internal */
+	private store;
+	// unsubscribe token given to us by the notification manager
+	/** @internal */
+	private ___token;
+	/** @internal */
+	private ___identifier;
+	/** @internal */
+	private _ref;
+	constructor(store: Store, identifier: StableRecordIdentifier);
+	/** @internal */
+	destroy(): void;
+	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(): StableRecordIdentifier;
+	/**
+	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 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>;
+// Mimics the static apis of @ember-data/model
+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;
+}