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

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

@@ -0,0 +1,73 @@
+import type { Store } from "../../store/-private.js";
+import type { SignalStore } from "../../store/-private/new-core-tmp/reactivity/internal.js";
+import type { StableRecordIdentifier } from "../../types.js";
+import type { FieldSchema, HashField, IdentityField, SchemaArrayField, SchemaObjectField } from "../../types/schema/fields.js";
+import type { ReactiveResource } from "./record.js";
+export type PathLike = string | symbol | Array<string | symbol>;
+export type ModeName = "polaris" | "legacy";
+export interface ModeInfo {
+	name: ModeName;
+	legacy: boolean;
+	editable: boolean;
+}
+export interface BaseContext {
+	store: Store;
+	resourceKey: StableRecordIdentifier;
+	modeName: ModeName;
+	legacy: boolean;
+	editable: boolean;
+}
+export interface ResourceContext extends BaseContext {
+	path: null;
+	field: null;
+	value: null;
+}
+export interface ObjectContext extends BaseContext {
+	path: string[];
+	field: SchemaObjectField | SchemaArrayField;
+	value: string;
+}
+export interface KindContext<T extends FieldSchema | IdentityField | HashField> extends BaseContext {
+	path: string[];
+	field: T;
+	value: unknown;
+	record: ReactiveResource;
+	signals: SignalStore;
+}
+export interface KindImpl<T extends FieldSchema | IdentityField | HashField> {
+	/**
+	* A function which produces the value for the field when invoked.
+	*/
+	get: (context: KindContext<T>) => unknown;
+	/**
+	* A function which updates the value for the field when invoked.
+	*
+	* This will never be invoked when the record is in a non-editable mode.
+	*
+	* This should assert in dev and return false if mutation is not allowed.
+	*/
+	set: (context: KindContext<T>) => boolean;
+	/**
+	* Whether this field is ever mutable (writable). This should be
+	* if there is ever a scenario in which the field can be written
+	* and false only if the field can never be written to.
+	*/
+	mutable: boolean;
+	/**
+	* Whether this field's of this kind should be included in the
+	* enumerated (iterable) keys of the record/object instance.
+	*
+	* This should generally be true except for fields that are not
+	* producing a value backed by the cache. For instance, locals
+	* should not be enumerable, as their value is not tied to the
+	* cache at all.
+	*/
+	enumerable: boolean;
+	/**
+	*
+	*/
+	serializable: boolean;
+}
+type Mode = { [Field in FieldSchema | IdentityField | HashField as Field["kind"]] : KindImpl<Field> };
+export declare const DefaultMode: Mode;
+export {};

package/declarations/reactive/-private/fields/get-field-key.d.ts

@@ -0,0 +1,8 @@
+import type { CacheableFieldSchema, FieldSchema, HashField, IdentityField } from "../../../types/schema/fields.js";
+type InvalidKind = "alias" | "derived" | "@local";
+export declare function isInvalidKind(kind: string): kind is InvalidKind;
+export declare function isNonIdentityCacheableField(field: FieldSchema | IdentityField | HashField): field is Exclude<CacheableFieldSchema, IdentityField>;
+export declare function getFieldCacheKeyStrict(field: CacheableFieldSchema): string;
+export declare function getFieldCacheKey(field: FieldSchema | IdentityField | HashField): string | null;
+export declare function assertIsCacheField(field: FieldSchema | IdentityField): asserts field is CacheableFieldSchema;
+export {};

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

@@ -1,16 +1,14 @@
-import type { Store } from "../../../index.js";
 import type { WarpDriveSignal } from "../../../store/-private.js";
 import { ARRAY_SIGNAL } from "../../../store/-private.js";
-import type { Cache } from "../../../types/cache.js";
 import type { StableRecordIdentifier } from "../../../types/identifier.js";
 import type { ArrayField, SchemaArrayField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
 import { ReactiveResource } from "../record.js";
-import type { SchemaService } from "../schema.js";
 import { Editable, Legacy, SOURCE } from "../symbols.js";
 export interface ManagedArray extends Omit<Array<unknown>, "[]"> {
 	[SOURCE]: unknown[];
 	identifier: StableRecordIdentifier;
-	path: string[];
+	path: string | string[];
 	owner: ReactiveResource;
 	[ARRAY_SIGNAL]: WarpDriveSignal;
 	[Editable]: boolean;
@@ -18,5 +16,5 @@ export interface ManagedArray extends Omit<Array<unknown>, "[]"> {
 }
 // eslint-disable-next-line @typescript-eslint/no-extraneous-class
 export declare class ManagedArray {
-	constructor(store: Store, schema: SchemaService, cache: Cache, field: ArrayField | SchemaArrayField, data: unknown[], identifier: StableRecordIdentifier, path: string[], owner: ReactiveResource, isSchemaArray: boolean, editable: boolean, legacy: boolean);
+	constructor(context: KindContext<SchemaArrayField | ArrayField>, owner: ReactiveResource, data: unknown[]);
 }

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

@@ -1,9 +1,8 @@
 import { OBJECT_SIGNAL, type WarpDriveSignal } from "../../../store/-private.js";
-import type { Cache } from "../../../types/cache.js";
 import type { StableRecordIdentifier } from "../../../types/identifier.js";
 import type { ObjectField, SchemaObjectField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
 import type { ReactiveResource } from "../record.js";
-import type { SchemaService } from "../schema.js";
 import { Editable, EmbeddedPath, Legacy, Parent, SOURCE } from "../symbols.js";
 export declare function notifyObject(obj: ManagedObject): void;
 // const ignoredGlobalFields = new Set<string>(['setInterval', 'nodeType', 'nodeName', 'length', 'document', STRUCTURED]);
@@ -17,5 +16,8 @@ export interface ManagedObject {
 }
 // eslint-disable-next-line @typescript-eslint/no-extraneous-class
 export declare class ManagedObject {
-	constructor(schema: SchemaService, cache: Cache, field: ObjectField | SchemaObjectField, data: object, identifier: StableRecordIdentifier, path: string[], owner: ReactiveResource, editable: boolean, legacy: boolean);
+	constructor(context: KindContext<ObjectField>);
 }
+export declare const ManagedObjectMap: Map<ReactiveResource, Map<string, ManagedObject | ReactiveResource>>;
+export declare function peekManagedObject(record: ReactiveResource, field: ObjectField): ManagedObject | undefined;
+export declare function peekManagedObject(record: ReactiveResource, field: SchemaObjectField): ReactiveResource | undefined;

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

@@ -2,6 +2,7 @@ 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 type { ObjectContext, ResourceContext } from "./default-mode.js";
 import { Checkout, Destroy, Editable, EmbeddedField, EmbeddedPath, Identifier, Legacy, Parent } from "./symbols.js";
 export { Editable, Legacy, Checkout } from "./symbols.js";
 export interface ReactiveResource {
@@ -57,8 +58,5 @@ 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);
 }

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

@@ -3,7 +3,7 @@ import type { SchemaService as SchemaServiceInterface } from "../../types.js";
 import type { StableRecordIdentifier } 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 LegacyBelongsToField, type LegacyHasManyField, 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";
@@ -138,8 +138,10 @@ export declare const fromIdentity: FromIdentityDerivation;
 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>;
 }
@@ -172,6 +174,12 @@ export interface SchemaService {
 		type: string;
 	}): InternalSchema["relationships"];
 }
+interface InternalTrait {
+	name: string;
+	mode: "legacy" | "polaris";
+	fields: Map<string, FieldSchema>;
+	traits: string[];
+}
 /**
 * A SchemaService designed to work with dynamically registered schemas.
 *
@@ -189,7 +197,7 @@ export declare class SchemaService implements SchemaServiceInterface {
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	_derivations: Map<string, Derivation<any, any, any>>;
 	/** @internal */
-	_traits: Set<string>;
+	_traits: Map<string, InternalTrait>;
 	/** @internal */
 	_modes: Map<string, KindFns>;
 	/** @internal */
@@ -221,6 +229,35 @@ export declare class SchemaService implements SchemaServiceInterface {
 	}): 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
@@ -234,8 +271,12 @@ export declare class SchemaService implements SchemaServiceInterface {
 	CAUTION_MEGA_DANGER_ZONE_resourceExtensions(resource: StableRecordIdentifier | {
 		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.
@@ -264,6 +305,9 @@ export declare class SchemaService implements SchemaServiceInterface {
 	fields({ type }: {
 		type: string;
 	}): InternalSchema["fields"];
+	cacheFields({ type }: {
+		type: string;
+	}): InternalSchema["cacheFields"];
 	hasResource(resource: {
 		type: string;
 	}): boolean;

package/declarations/reactive.d.ts

@@ -2,3 +2,4 @@ export { instantiateRecord, teardownRecord } from "./reactive/-private/hooks.js"
 export { type CAUTION_MEGA_DANGER_ZONE_Extension, type ProcessedExtension, type ExtensionDef, type Transformation, SchemaService, withDefaults, fromIdentity, registerDerivations } from "./reactive/-private/schema.js";
 export { type ReactiveResource } from "./reactive/-private/record.js";
 export { Checkout } from "./reactive/-private/symbols.js";
+export { type ReactiveDocument } from "./reactive/-private/document.js";

package/declarations/request/-private/fetch.d.ts

@@ -1,4 +1,6 @@
 import { type Context } from "./context.js";
+import type { HttpErrorProps } from "./utils.js";
+export type { HttpErrorProps };
 interface FastbootRequest extends Request {
 	protocol: string;
 	host: string;

package/declarations/store/-private/caches/instance-cache.d.ts

@@ -1,10 +1,8 @@
 import { ReactiveDocument } from "../../../reactive/-private/document.js";
 import type { Cache } from "../../../types/cache.js";
 import type { StableDocumentIdentifier, StableRecordIdentifier } from "../../../types/identifier.js";
-import type { Value } from "../../../types/json/raw.js";
 import type { TypedRecordInstance, TypeFromInstance } from "../../../types/record.js";
 import type { OpaqueRecordInstance } from "../../-types/q/record-instance.js";
-import RecordReference from "../legacy-model-support/record-reference.js";
 import { CacheCapabilitiesManager } from "../managers/cache-capabilities-manager.js";
 import type { CacheManager } from "../managers/cache-manager.js";
 import type { CreateRecordProperties, Store } from "../store-service.js";
@@ -36,9 +34,8 @@ export declare const StoreMap: Map<unknown, Store>;
 * @internal
 */
 export declare function storeFor(record: OpaqueRecordInstance): Store | undefined;
-type Caches = {
+export type Caches = {
 	record: Map<StableRecordIdentifier, OpaqueRecordInstance>;
-	reference: WeakMap<StableRecordIdentifier, RecordReference>;
 	document: Map<StableDocumentIdentifier, ReactiveDocument<OpaqueRecordInstance | OpaqueRecordInstance[] | null | undefined>>;
 };
 export declare class InstanceCache {
@@ -51,7 +48,6 @@ export declare class InstanceCache {
 	peek(identifier: StableRecordIdentifier): Cache | OpaqueRecordInstance | undefined;
 	getDocument<T>(identifier: StableDocumentIdentifier): ReactiveDocument<T>;
 	getRecord(identifier: StableRecordIdentifier, properties?: CreateRecordProperties): OpaqueRecordInstance;
-	getReference(identifier: StableRecordIdentifier): RecordReference;
 	recordIsLoaded(identifier: StableRecordIdentifier, filterDeleted?: boolean): boolean;
 	disconnect(identifier: StableRecordIdentifier): void;
 	unloadRecord(identifier: StableRecordIdentifier): void;
@@ -59,7 +55,4 @@ export declare class InstanceCache {
 	// TODO this should move into something coordinating operations
 	setRecordId(identifier: StableRecordIdentifier, id: string): void;
 }
-export declare function resourceIsFullyDeleted(instanceCache: InstanceCache, identifier: StableRecordIdentifier): boolean;
-export declare function preloadData(store: Store, identifier: StableRecordIdentifier, preload: Record<string, Value>): void;
 export declare function _clearCaches(): void;
-export {};