@warp-drive/core 5.6.0-beta.0 → 5.6.0-beta.2

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/kind/alias-field.d.ts

@@ -0,0 +1,4 @@
+import type { LegacyAliasField, ObjectAliasField, PolarisAliasField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export declare function getAliasField(context: KindContext<LegacyAliasField | ObjectAliasField | PolarisAliasField>): unknown;
+export declare function setAliasField(context: KindContext<LegacyAliasField | ObjectAliasField | PolarisAliasField>): boolean;

package/declarations/reactive/-private/kind/array-field.d.ts

@@ -0,0 +1,4 @@
+import type { ArrayField, SchemaArrayField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export declare function getArrayField(context: KindContext<ArrayField | SchemaArrayField>): unknown;
+export declare function setArrayField(context: KindContext<ArrayField>): boolean;

package/declarations/reactive/-private/kind/attribute-field.d.ts

@@ -0,0 +1,4 @@
+import type { LegacyAttributeField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export declare function getAttributeField(context: KindContext<LegacyAttributeField>): unknown;
+export declare function setAttributeField(context: KindContext<LegacyAttributeField>): boolean;

package/declarations/reactive/-private/kind/belongs-to-field.d.ts

@@ -0,0 +1,4 @@
+import type { LegacyBelongsToField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export declare function getBelongsToField(context: KindContext<LegacyBelongsToField>): unknown;
+export declare function setBelongsToField(context: KindContext<LegacyBelongsToField>): boolean;

package/declarations/reactive/-private/kind/collection-field.d.ts

@@ -0,0 +1,4 @@
+import type { CollectionField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export declare function getCollectionField(context: KindContext<CollectionField>): unknown;
+export declare function setCollectionField(context: KindContext<CollectionField>): boolean;

package/declarations/reactive/-private/kind/derived-field.d.ts

@@ -0,0 +1,4 @@
+import type { DerivedField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export declare function getDerivedField(context: KindContext<DerivedField>): unknown;
+export declare function setDerivedField(context: KindContext<DerivedField>): boolean;

package/declarations/reactive/-private/kind/generic-field.d.ts

@@ -0,0 +1,4 @@
+import type { GenericField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export declare function getGenericField(context: KindContext<GenericField>): unknown;
+export declare function setGenericField(context: KindContext<GenericField>): boolean;

package/declarations/reactive/-private/kind/has-many-field.d.ts

@@ -0,0 +1,4 @@
+import type { LegacyHasManyField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export declare function getHasManyField(context: KindContext<LegacyHasManyField>): unknown;
+export declare function setHasManyField(context: KindContext<LegacyHasManyField>): boolean;

package/declarations/reactive/-private/kind/hash-field.d.ts

@@ -0,0 +1,4 @@
+import type { HashField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export declare function getHashField(context: KindContext<HashField>): unknown;
+export declare function setHashField(context: KindContext<HashField>): boolean;

package/declarations/reactive/-private/kind/identity-field.d.ts

@@ -0,0 +1,4 @@
+import type { IdentityField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export declare function getIdentityField(context: KindContext<IdentityField>): unknown;
+export declare function setIdentityField(context: KindContext<IdentityField>): boolean;

package/declarations/reactive/-private/kind/local-field.d.ts

@@ -0,0 +1,4 @@
+import type { LocalField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export declare function getLocalField(context: KindContext<LocalField>): unknown;
+export declare function setLocalField(context: KindContext<LocalField>): boolean;

package/declarations/reactive/-private/kind/object-field.d.ts

@@ -0,0 +1,4 @@
+import type { ObjectField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export declare function getObjectField(context: KindContext<ObjectField>): unknown;
+export declare function setObjectField(context: KindContext<ObjectField>): boolean;

package/declarations/reactive/-private/kind/resource-field.d.ts

@@ -0,0 +1,4 @@
+import type { ResourceField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export declare function getResourceField(context: KindContext<ResourceField>): unknown;
+export declare function setResourceField(context: KindContext<ResourceField>): boolean;

package/declarations/reactive/-private/kind/schema-array-field.d.ts

@@ -0,0 +1,4 @@
+import type { SchemaArrayField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export { getArrayField as getSchemaArrayField } from "./array-field.js";
+export declare function setSchemaArrayField(context: KindContext<SchemaArrayField>): boolean;

package/declarations/reactive/-private/kind/schema-object-field.d.ts

@@ -0,0 +1,4 @@
+import type { SchemaObjectField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export declare function getSchemaObjectField(context: KindContext<SchemaObjectField>): unknown;
+export declare function setSchemaObjectField(context: KindContext<SchemaObjectField>): boolean;

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

@@ -1,37 +1,14 @@
-import type { Store } from "../../index.js";
-import type { StableRecordIdentifier } from "../../types/identifier.js";
-import type { SchemaArrayField, SchemaObjectField } from "../../types/schema/fields.js";
-import { RecordStore } from "../../types/symbols.js";
-import { Checkout, Destroy, Editable, EmbeddedField, EmbeddedPath, Identifier, Legacy, Parent } from "./symbols.js";
-export { Editable, Legacy, Checkout } from "./symbols.js";
+import type { ObjectContext, ResourceContext } from "./default-mode.js";
+import { Checkout } from "./symbols.js";
 export interface ReactiveResource {
-	[Symbol.toStringTag]: `ReactiveResource<${string}>`;
-	/** @internal */
-	[RecordStore]: Store;
-	/** @internal */
-	[Identifier]: StableRecordIdentifier;
-	/** @internal */
-	[Parent]: StableRecordIdentifier;
-	/** @internal */
-	[EmbeddedField]: SchemaArrayField | SchemaObjectField | null;
-	/** @internal */
-	[EmbeddedPath]: string[] | null;
-	/** @internal */
-	[Editable]: boolean;
-	/** @internal */
-	[Legacy]: boolean;
-	/** @internal */
-	___notifications: object;
-	/** @internal */
-	[Destroy](): 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]();
@@ -39,13 +16,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
-	*
+	* @private
 	*/
 	[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
@@ -57,8 +34,42 @@ export interface ReactiveResource {
 */
 // eslint-disable-next-line @typescript-eslint/no-extraneous-class
 export declare class ReactiveResource {
-	constructor(store: Store, identifier: StableRecordIdentifier, Mode: {
-		[Editable]: boolean;
-		[Legacy]: boolean;
-	}, isEmbedded?: boolean, embeddedField?: SchemaArrayField | SchemaObjectField | null, embeddedPath?: string[] | null);
+	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,9 +1,8 @@
-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 DerivedField, type FieldSchema, type GenericField, type HashField, type LegacyAttributeField, type LegacyBelongsToField, type LegacyHasManyField, type LegacyRelationshipField, type ObjectField, type ObjectSchema, type PolarisResourceSchema, type ResourceSchema } from "../../types/schema/fields.js";
+import { type ArrayField, type CacheableFieldSchema, type DerivedField, type FieldSchema, type GenericField, type HashField, type IdentityField, type LegacyAttributeField, type LegacyRelationshipField, type ObjectField, type ObjectSchema, type PolarisResourceSchema, type ResourceSchema, type Trait } from "../../types/schema/fields.js";
 import { Type } from "../../types/symbols.js";
 import type { WithPartial } from "../../types/utils.js";
 import type { ReactiveResource } from "./record.js";
@@ -95,11 +94,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";
 }
 /**
@@ -133,13 +132,14 @@ export declare const fromIdentity: FromIdentityDerivation;
 * ```
 *
 * @public
-* @param {SchemaService} schema
 */
 export declare function registerDerivations(schema: SchemaServiceInterface): void;
 interface InternalSchema {
 	original: ResourceSchema | ObjectSchema;
+	finalized: boolean;
 	traits: Set<string>;
 	fields: Map<string, FieldSchema>;
+	cacheFields: Map<string, Exclude<CacheableFieldSchema, IdentityField>>;
 	attributes: Record<string, LegacyAttributeField>;
 	relationships: Record<string, LegacyRelationshipField>;
 }
@@ -149,20 +149,9 @@ 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;
-	};
-	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;
-	};
-}
 export interface SchemaService {
 	doesTypeExist(type: string): boolean;
 	attributesDefinitionFor(identifier: {
@@ -175,36 +164,13 @@ export interface SchemaService {
 /**
 * A SchemaService designed to work with dynamically registered schemas.
 *
-* @class SchemaService
 * @public
 */
 export declare class SchemaService implements SchemaServiceInterface {
-	/** @internal */
-	_schemas: Map<string, InternalSchema>;
-	/** @internal */
-	_transforms: Map<string, Transformation>;
-	/** @internal */
-	_hashFns: Map<string, HashFn>;
-	/** @internal */
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	_derivations: Map<string, Derivation<any, any, any>>;
-	/** @internal */
-	_traits: Set<string>;
-	/** @internal */
-	_modes: Map<string, KindFns>;
-	/** @internal */
-	_extensions: {
-		object: Map<string, ProcessedExtension>;
-		array: Map<string, ProcessedExtension>;
-	};
-	_cachedFieldExtensionsByField: {
-		object: Map<object, ProcessedExtension["features"] | null>;
-		array: Map<object, ProcessedExtension["features"] | null>;
-	};
 	constructor();
 	resourceTypes(): Readonly<string[]>;
 	hasTrait(type: string): boolean;
-	resourceHasTrait(resource: StableRecordIdentifier | {
+	resourceHasTrait(resource: ResourceKey | {
 		type: string;
 	}, trait: string): boolean;
 	transformation(field: GenericField | ObjectField | ArrayField | {
@@ -216,11 +182,40 @@ 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;
 	registerResource(schema: ResourceSchema | ObjectSchema): 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;
 	registerTransformation<
 		T extends Value = string,
 		PT = unknown
@@ -231,39 +226,28 @@ 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): 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"];
+	CAUTION_MEGA_DANGER_ZONE_hasExtension(ext: {
+		kind: "object" | "array";
+		name: string;
+	}): boolean;
 	/**
-	* 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: KindFns): 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.
+	* Registers a {@link HashFn} for use with a {@link HashField} for
+	* either {@link ObjectSchema} identity or polymorphic type calculation.
 	*
-	* See https://github.com/emberjs/data/issues/9534
-	*
-	* @internal
+	* @public
 	*/
-	_kind<T extends keyof KindFns>(mode: string, kind: T): KindFns[T];
 	registerHashFn<T extends object>(hashFn: HashFn<T>): void;
 	fields({ type }: {
 		type: string;
 	}): InternalSchema["fields"];
+	cacheFields({ type }: {
+		type: string;
+	}): InternalSchema["cacheFields"];
 	hasResource(resource: {
 		type: string;
 	}): boolean;

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

@@ -25,12 +25,7 @@
 // Note that none of these symbols are part of the public API, these are used for
 // debugging DX and as a safe way to provide an intimate contract on public objects.
 export declare const SOURCE: "___(unique) Symbol(SOURCE)";
-export declare const MUTATE: "___(unique) Symbol(MUTATE)";
 export declare const Destroy: "___(unique) Symbol(Destroy)";
-export declare const Identifier: "___(unique) Symbol(Identifier)";
-export declare const Editable: "___(unique) Symbol(Editable)";
-export declare const Parent: "___(unique) Symbol(Parent)";
 export declare const Checkout: "___(unique) Symbol(Checkout)";
-export declare const Legacy: "___(unique) Symbol(Legacy)";
-export declare const EmbeddedPath: "___(unique) Symbol(EmbeddedPath)";
-export declare const EmbeddedField: "___(unique) Symbol(EmbeddedField)";
+export declare const Commit: "___(unique) Symbol(Commit)";
+export declare const Context: "___(unique) Symbol(Context)";

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

@@ -1 +1 @@
-export { Editable, Legacy } from "./-private/symbols.js";
+export { Context } from "./-private/symbols.js";