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

package/declarations/store/-private/managers/notification-manager.d.ts

@@ -1,83 +0,0 @@
-import type { RequestKey, ResourceKey } from "../../../types/identifier.js";
-import type { Store } from "../store-service.js";
-export type UnsubscribeToken = object;
-export type CacheOperation = "added" | "removed" | "updated" | "state";
-export type DocumentCacheOperation = "invalidated" | "added" | "removed" | "updated" | "state";
-export type NotificationType = "attributes" | "relationships" | "identity" | "errors" | "meta" | CacheOperation;
-export interface NotificationCallback {
-	(cacheKey: ResourceKey, notificationType: "attributes" | "relationships", key?: string): void;
-	(cacheKey: ResourceKey, notificationType: "errors" | "meta" | "identity" | "state"): void;
-	(cacheKey: ResourceKey, notificationType: CacheOperation): void;
-}
-export interface ResourceOperationCallback {
-	(cacheKey: ResourceKey, notificationType: CacheOperation): void;
-}
-export interface DocumentOperationCallback {
-	(cacheKey: RequestKey, notificationType: DocumentCacheOperation): void;
-}
-/**
-* The NotificationManager provides the ability to subscribe to
-* changes to Cache state.
-*
-* This Feature is what allows WarpDrive to create subscriptions that
-* work with any framework or change-notification system.
-*
-* @hideconstructor
-* @public
-*/
-export declare class NotificationManager {
-	constructor(store: Store);
-	/**
-	* Subscribe to changes for a given ResourceKey, RequestKey, or addition/removal of any resource
-	* or document.
-	*
-	* ```ts
-	* export type CacheOperation = 'added' | 'removed' | 'updated' | 'state';
-	*
-	* export interface NotificationCallback {
-	*   (cacheKey: ResourceKey, notificationType: 'attributes' | 'relationships', key?: string): void;
-	*   (cacheKey: ResourceKey, notificationType: 'errors' | 'meta' | 'identity' | 'state'): void;
-	*   (cacheKey: ResourceKey, notificationType: NotificationType, key?: string): void;
-	* }
-	* export interface ResourceOperationCallback {
-	*   // resource updates
-	*   (cacheKey: ResourceKey, notificationType: CacheOperation): void;
-	* }
-	* export interface DocumentOperationCallback {
-	*   // document updates
-	*   (cacheKey: RequestKey, notificationType: CacheOperation): void;
-	* }
-	* ```
-	*
-	* @public
-	* @return an opaque token to be used with unsubscribe
-	*/
-	subscribe(cacheKey: ResourceKey, callback: NotificationCallback): UnsubscribeToken;
-	subscribe(cacheKey: "resource", callback: ResourceOperationCallback): UnsubscribeToken;
-	subscribe(cacheKey: "document" | RequestKey, callback: DocumentOperationCallback): UnsubscribeToken;
-	/**
-	* remove a previous subscription
-	*
-	* @public
-	*/
-	unsubscribe(token: UnsubscribeToken): void;
-	/**
-	* Custom Caches and Application Code should not call this method directly.
-	*
-	* @private
-	*/
-	notify(cacheKey: ResourceKey, value: "attributes" | "relationships", key?: string | null): boolean;
-	notify(cacheKey: ResourceKey, value: "errors" | "meta" | "identity" | "state", key?: null): boolean;
-	notify(cacheKey: ResourceKey, value: CacheOperation, key?: null): boolean;
-	notify(cacheKey: RequestKey, value: DocumentCacheOperation, key?: null): boolean;
-}
-/**
-* This type exists for internal use only for
-* where intimate contracts still exist either for
-* the Test Suite or for Legacy code.
-*
-* @private
-*/
-export interface PrivateNotificationManager extends NotificationManager {
-	_flush(): void;
-}

package/declarations/store/-private/managers/record-array-manager.d.ts

@@ -1,100 +0,0 @@
-import type { LocalRelationshipOperation } from "../../../types/graph.js";
-import type { RequestKey, ResourceKey } from "../../../types/identifier.js";
-import type { ImmutableRequestInfo } from "../../../types/request.js";
-import type { CollectionResourceDocument } from "../../../types/spec/json-api-raw.js";
-import type { LegacyLiveArray } from "../record-arrays/legacy-live-array.js";
-import { type LegacyQueryArray } from "../record-arrays/legacy-query.js";
-import { type ReactiveResourceArray } from "../record-arrays/resource-array.js";
-import type { Store } from "../store-service.js";
-/**
-* This is a clever optimization.
-*
-* clever optimizations rarely stand the test of time, so if you're
-* ever curious or think something better is possible please benchmark
-* and discuss. The benchmark for this at the time of writing is in
-* `scripts/benchmark-push.js`
-*
-* This approach turns out to be 150x faster in Chrome and node than
-* simply using push or concat. It's highly susceptible to the specifics
-* of the batch size, and may require tuning.
-*
-* Clever optimizations should always come with a `why`. This optimization
-* exists for two reasons.
-*
-* 1) array.push(...objects) and Array.prototype.push.apply(arr, objects)
-*   are susceptible to stack overflows. The size of objects at which this
-*   occurs varies by environment, browser, and current stack depth and memory
-*   pressure; however, it occurs in all browsers in fairly pristine conditions
-*   somewhere around 125k to 200k elements. Since WarpDrive regularly encounters
-*   arrays larger than this in size, we cannot use push.
-*
-* 2) `array.concat` or simply setting the array to a new reference is often an
-*   easier approach; however, native Proxy to an array cannot swap it's target array
-*   and attempts at juggling multiple array sources have proven to be victim to a number
-*   of browser implementation bugs. Should these bugs be addressed then we could
-*   simplify to using `concat`, however, do note this is currently 150x faster
-*   than concat, and due to the overloaded signature of concat will likely always
-*   be faster.
-*
-* Sincerely,
-*   - runspired (Chris Thoburn) 08/21/2022
-*
-* @private
-* @param target the array to push into
-* @param source the items to push into target
-*/
-export declare function fastPush<T>(target: T[], source: T[]): void;
-interface LegacyQueryInit {
-	type: string;
-	query: ImmutableRequestInfo | Record<string, unknown>;
-}
-interface AnonymousRequestCollectionInit {
-	source: ResourceKey[];
-}
-interface RequestCollectionInit {
-	source: ResourceKey[];
-	requestKey: RequestKey;
-}
-type ChangeSet = Map<ResourceKey, "add" | "del">;
-/**
-@hideconstructor
-@private
-*/
-export declare class RecordArrayManager {
-	constructor(options: {
-		store: Store;
-	});
-	mutate(mutation: LocalRelationshipOperation): void;
-	/**
-	Get the `RecordArray` for a modelName, which contains all loaded records of
-	given modelName.
-	
-	@private
-	*/
-	liveArrayFor(type: string): LegacyLiveArray;
-	getCollection(config: LegacyQueryInit): LegacyQueryArray;
-	getCollection(config: AnonymousRequestCollectionInit): ReactiveResourceArray;
-	getCollection(config: RequestCollectionInit): ReactiveResourceArray;
-	/**
-	* @private
-	*/
-	populateManagedArray(array: ReactiveResourceArray, identifiers: ResourceKey[], payload: CollectionResourceDocument | null): void;
-	pause(): void;
-	resume(): void;
-	destroy(): void;
-}
-/**
-* This type exists for internal use only for
-* where intimate contracts still exist either for
-* the Test Suite or for Legacy code.
-*
-* @private
-*/
-export interface PrivateRecordArrayManager extends RecordArrayManager {
-	_live: Map<string, LegacyLiveArray>;
-	_pending: Map<ReactiveResourceArray, ChangeSet>;
-	_managed: Set<ReactiveResourceArray>;
-	clear(isClear?: boolean): void;
-}
-export declare function disassociateIdentifier(ArraysCache: Map<ResourceKey, Set<ReactiveResourceArray>>, array: ReactiveResourceArray, identifier: ResourceKey): void;
-export {};

package/declarations/store/-private/network/request-cache.d.ts

@@ -1,103 +0,0 @@
-import type { ResourceKey } from "../../../types/identifier.js";
-import type { FindRecordOptions } from "../../-types/q/store.js";
-import type { Store } from "../store-service.js";
-declare const Touching: "___(unique) Symbol(Touching)";
-export declare const RequestPromise: "___(unique) Symbol(RequestPromise)";
-export interface Operation {
-	op: string;
-	options: FindRecordOptions | undefined;
-	recordIdentifier: ResourceKey;
-}
-export interface FindRecordQuery extends Operation {
-	op: "findRecord";
-}
-export interface SaveRecordMutation extends Operation {
-	op: "saveRecord";
-}
-export interface Request {
-	data: Operation[];
-	options?: Record<string, unknown>;
-}
-export type RequestStates = "pending" | "fulfilled" | "rejected";
-export interface RequestCacheRequestState {
-	state: RequestStates;
-	type: "query" | "mutation";
-	request: Request;
-	response?: Response;
-}
-export interface Response {
-	data: unknown;
-}
-interface InternalRequest extends RequestCacheRequestState {
-	[Touching]: ResourceKey[];
-	[RequestPromise]?: Promise<unknown>;
-}
-export type RequestSubscription = (requestState: RequestCacheRequestState) => void;
-/**
-* The RequestStateService is used to track the state of requests
-* for fetching or updating known resource identifies that are inflight.
-*
-* @hideconstructor
-* @public
-*/
-export declare class RequestStateService {
-	constructor(store: Store);
-	/**
-	* Subscribe to requests for a given resource identity.
-	*
-	* The callback will receive the current state of the request.
-	*
-	* ```ts
-	* interface RequestState {
-	*   state: 'pending' | 'fulfilled' | 'rejected';
-	*   type: 'query' | 'mutation';
-	*   request: Request;
-	*   response?: { data: unknown };
-	* }
-	* ```
-	*
-	* Note: It should be considered dangerous to use this API for more than simple
-	* state derivation or debugging. The `request` and `response` properties are poorly
-	* spec'd and may change unexpectedly when shifting what Handlers are in use or how
-	* requests are issued from the Store.
-	*
-	* We expect to revisit this API in the near future as we continue to refine the
-	* RequestManager ergonomics, as a simpler but more powerful direct integration
-	* with the RequestManager for these purposes is likely to be a better long-term
-	* design.
-	*
-	* @public
-	* @param {ResourceKey} identifier
-	* @param {(state: RequestCacheRequestState) => void} callback
-	*/
-	subscribeForRecord(identifier: ResourceKey, callback: RequestSubscription): void;
-	/**
-	* Retrieve all active requests for a given resource identity.
-	*
-	* @public
-	* @param {ResourceKey} identifier
-	* @return {RequestCacheRequestState[]} an array of request states for any pending requests for the given identifier
-	*/
-	getPendingRequestsForRecord(identifier: ResourceKey): RequestCacheRequestState[];
-	/**
-	* Retrieve the last completed request for a given resource identity.
-	*
-	* @public
-	* @param {ResourceKey} identifier
-	* @return {RequestCacheRequestState | null} the state of the most recent request for the given identifier
-	*/
-	getLastRequestForRecord(identifier: ResourceKey): RequestCacheRequestState | null;
-}
-/**
-* This type exists for internal use only for
-* where intimate contracts still exist either for
-* the Test Suite or for Legacy code.
-*
-* @private
-*/
-export interface PrivateRequestStateService extends RequestStateService {
-	_pending: Map<ResourceKey, InternalRequest[]>;
-	_clearEntries(identifier: ResourceKey): void;
-	_enqueue<T>(promise: Promise<T>, queryRequest: Request): Promise<T>;
-}
-export {};

package/declarations/store/-private/record-arrays/-utils.d.ts

@@ -1,80 +0,0 @@
-import type { BaseFinderOptions } from "../../../types.js";
-import type { LocalRelationshipOperation } from "../../../types/graph.js";
-import type { ResourceKey } from "../../../types/identifier.js";
-import type { Store } from "../store-service.js";
-import type { NativeProxy } from "./native-proxy-type-fix.js";
-import type { ReactiveResourceArray } from "./resource-array.js";
-/**
-* LegacyArrays have the capability of updating via `array.update()`
-* and saving each contained record individually via `array.save()`
-*/
-export interface LegacyArray<T = unknown> extends ReactiveResourceArray<T> {
-	/**
-	The flag to signal a `RecordArray` is currently loading data.
-	Example
-	```javascript
-	let people = store.peekAll('person');
-	people.isUpdating; // false
-	people.update();
-	people.isUpdating; // true
-	```
-	*/
-	isUpdating: boolean;
-	/**
-	Used to get the latest version of all of the records in this array
-	from the adapter.
-	
-	Example
-	
-	```javascript
-	let people = store.peekAll('person');
-	people.isUpdating; // false
-	
-	people.update().then(function() {
-	people.isUpdating; // false
-	});
-	
-	people.isUpdating; // true
-	```
-	
-	@public
-	*/
-	update(this: LegacyArray<T>): Promise<LegacyArray<T>>;
-	/**
-	Saves all of the records in the `RecordArray`.
-	
-	Example
-	
-	```js
-	let messages = store.peekAll('message');
-	messages.forEach(function(message) {
-	message.hasBeenSeen = true;
-	});
-	messages.save();
-	```
-	
-	@public
-	*/
-	save(this: LegacyArray<T>): Promise<LegacyArray<T>>;
-}
-export declare function upgradeThis(obj: unknown): asserts obj is LegacyArray;
-export declare function update(this: ReactiveResourceArray): Promise<ReactiveResourceArray>;
-export declare function save(this: ReactiveResourceArray): Promise<ReactiveResourceArray>;
-export type KeyType = string | symbol | number;
-export declare function isArrayGetter<T>(prop: KeyType): prop is keyof Array<T>;
-export declare function isArraySetter<T>(prop: KeyType): prop is keyof Array<T>;
-export declare function convertToInt(prop: KeyType): number | null;
-export type ForEachCB<T> = (record: T, index: number, context: typeof NativeProxy<ResourceKey[], T[]>) => void;
-export declare function safeForEach<T>(instance: typeof NativeProxy<ResourceKey[], T[]>, arr: ResourceKey[], store: Store, callback: ForEachCB<T>, target: unknown): typeof NativeProxy<ResourceKey[], T[]>;
-type PromiseTo<T> = Omit<Promise<T>, typeof Symbol.toStringTag>;
-type PromiseManyArray<T> = {
-	length: number;
-	content: ReactiveResourceArray<T> | null;
-	promise: Promise<ReactiveResourceArray<T>> | null;
-} & PromiseTo<ReactiveResourceArray<T>>;
-export interface MinimumManager {
-	_syncArray(array: ReactiveResourceArray): void;
-	mutate?(mutation: LocalRelationshipOperation): void;
-	reloadHasMany?<T>(key: string, options?: BaseFinderOptions): Promise<ReactiveResourceArray> | PromiseManyArray<T>;
-}
-export {};

package/declarations/store/-private/record-arrays/legacy-live-array.d.ts

@@ -1,81 +0,0 @@
-import type { ResourceKey } from "../../../types/identifier.js";
-import type { TypeFromInstanceOrString } from "../../../types/record.js";
-import type { Store } from "../store-service.js";
-import type { LegacyArray, MinimumManager } from "./-utils.js";
-/**
-* LiveArrays contain all the known records for a given `ResourceType`.
-*
-* ### Basic Example
-*
-* For instance, if an application were to have a `'user'` type:
-*
-* ```ts
-* const usersLiveArray = store.peekAll('user');
-* ```
-*
-* ---
-*
-*  
-*
-* ### LiveArrays are Arrays
-*
-* LiveArrays have all array APIs, and will report `true`
-* for both `liveArray instanceof Array` and `Array.isArray(liveArray)`
-*
-* ---
-*
-*  
-*
-* ### Reactive
-*
-* The array is "live" as it will reactively update any time new
-* users are added to the store's cache.
-*
-* There is only one LiveArray instance per ResourceType, and it
-* can be accessed either via {@link Store.peekAll} or {@link Store.findAll}
-*
-* ```ts
-* const users = await store.findAll('user');
-* const peekedUsers = store.peekAll('user');
-* peekedUsers === users; // true
-* ```
-*
-* ---
-*
-*  
-*
-* ### New Records
-*
-* Records in the `"new"` state (created locally on the client
-* but not yet saved) appear in LiveArrays if they are in LegacyMode.
-*
-* PolarisMode records in the `"new"` state do not appear in LiveArrays.
-*
-* ---
-*
-*  
-*
-* ### Polymorphism
-*
-* LiveArrays are not polymorphic. If your application has an abstract
-* type "car" with concrete types "ferrari" and "bmw", then "ferrari"
-* and "bmw" will have populated LiveArrays, but the LiveArray for "car"
-* would be empty.
-*
-* @legacy we recommend againt using LiveArrays. Use {@link Store.request} instead
-*/
-export interface LegacyLiveArray<T = unknown> extends LegacyArray<T> {
-	isLoaded: boolean;
-	modelName: TypeFromInstanceOrString<T>;
-}
-/**
-* The options for {@link createLegacyLiveArray}
-*
-* @private
-*/
-export interface LegacyLiveArrayCreateOptions {
-	store: Store;
-	manager: MinimumManager;
-	source: ResourceKey[];
-	type: string;
-}

package/declarations/store/-private/record-arrays/legacy-many-array.d.ts

@@ -1,133 +0,0 @@
-import type { BaseFinderOptions, ResourceKey } from "../../../types.js";
-import type { TypedRecordInstance, TypeFromInstance } from "../../../types/record.js";
-import type { LegacyHasManyField, LinksModeHasManyField } from "../../../types/schema/fields.js";
-import type { Links, Meta, PaginationLinks } from "../../../types/spec/json-api-raw.js";
-import type { CreateRecordProperties } from "../store-service.js";
-import type { LegacyLiveArrayCreateOptions } from "./legacy-live-array.js";
-import { type ReactiveResourceArray } from "./resource-array.js";
-/**
-A `ManyArray` is a `MutableArray` that represents the contents of a has-many
-relationship.
-
-The `ManyArray` is instantiated lazily the first time the relationship is
-requested.
-
-This class is not intended to be directly instantiated by consuming applications.
-
-### Inverses
-
-Often, the relationships in WarpDrive applications will have
-an inverse. For example, imagine the following models are
-defined:
-
-```js [app/models/post.js]
-import Model, { hasMany } from '@ember-data/model';
-
-export default class PostModel extends Model {
-@hasMany('comment') comments;
-}
-```
-
-```js [app/models/comment.js]
-import { Model, belongsTo } from '@warp-drive/legacy/model';
-
-export default class CommentModel extends Model {
-@belongsTo('post') post;
-}
-```
-
-If you created a new instance of `Post` and added
-a `Comment` record to its `comments` has-many
-relationship, you would expect the comment's `post`
-property to be set to the post that contained
-the has-many.
-
-We call the record to which a relationship belongs-to the
-relationship's _owner_.
-
-@public
-*/
-export interface LegacyManyArray<T = unknown> extends ReactiveResourceArray<T> {
-	meta: Meta | null;
-	links: Links | PaginationLinks | null;
-	/** @private */
-	key: string;
-	/** @private */
-	modelName: T extends TypedRecordInstance ? TypeFromInstance<T> : string;
-	/**
-	The loading state of this array
-	@public
-	*/
-	isLoaded: boolean;
-	/**
-	Reloads all of the records in the manyArray. If the manyArray
-	holds a relationship that was originally fetched using a links url
-	WarpDrive will revisit the original links url to repopulate the
-	relationship.
-	
-	If the ManyArray holds the result of a `store.query()` reload will
-	re-run the original query.
-	
-	Example
-	
-	```javascript
-	let user = store.peekRecord('user', '1')
-	await login(user);
-	
-	let permissions = await user.permissions;
-	await permissions.reload();
-	```
-	
-	@public
-	*/
-	reload(options?: BaseFinderOptions): Promise<LegacyManyArray<T>>;
-	/**
-	Create a child record and associated it to the collection
-	
-	@public
-	*/
-	createRecord(hash: CreateRecordProperties<T>): T;
-	/**
-	Saves all of the records in the `ManyArray`.
-	
-	Note: this API can only be used in legacy mode with a configured Adapter.
-	
-	Example
-	
-	```js
-	const { content: { data: inbox } } = await store.request(findRecord({ type: 'inbox', id: '1' }));
-	
-	let messages = await inbox.messages;
-	messages.forEach((message) => {
-	message.isRead = true;
-	});
-	messages.save();
-	```
-	
-	@public
-	*/
-	save: () => Promise<LegacyManyArray<T>>;
-	/** @private */
-	destroy: () => void;
-}
-/**
-* The options for {@link createLegacyManyArray}
-*
-* @private
-*/
-export interface LegacyManyArrayCreateOptions extends LegacyLiveArrayCreateOptions {
-	isLoaded: boolean;
-	editable: boolean;
-	isAsync: boolean;
-	isPolymorphic: boolean;
-	field: LegacyHasManyField | LinksModeHasManyField;
-	identifier: ResourceKey;
-	links: Links | PaginationLinks | null;
-	meta: Meta | null;
-}
-/**
-* Creates a {@link LegacyManyArray}
-*
-* @private
-*/
-export declare function createLegacyManyArray<T>(options: LegacyManyArrayCreateOptions): LegacyManyArray<T>;

package/declarations/store/-private/record-arrays/legacy-query.d.ts

@@ -1,81 +0,0 @@
-import type { ImmutableRequestInfo } from "../../../types/request.js";
-import type { Links, Meta, PaginationLinks } from "../../../types/spec/json-api-raw.js";
-import type { LegacyLiveArray } from "./legacy-live-array.js";
-/**
-* QueryArrays contain the primary records returned when querying
-* for records by `ResourceType`.
-*
-* ### Basic Example
-*
-* For instance, if an application were to have a `'user'` type:
-*
-* ```ts
-* const users = await store.query('user', { name: 'Chris' });
-* ```
-*
-* ---
-*
-*  
-*
-* ### QueryArrays are Arrays
-*
-* QueryArrays have all array APIs, and will report `true`
-* for both `queryArray instanceof Array` and `Array.isArray(queryArray)`
-*
-* However, any mutation of the array will throw an error.
-*
-* ---
-*
-*  
-*
-* ### Reactive
-*
-* If a record in a QueryArray is deleted and unloaded, it will be
-* automatically removed from the array.
-*
-* ---
-*
-*  
-*
-* ### Immutable
-*
-* Records cannot be directly added to or removed from a QueryArray.
-*
-* ---
-*
-*  
-*
-* ### Polymorphism
-*
-* QueryArrays are not intended to be polymorphic. If your application has
-* an abstract type "car" with concrete types "ferrari" and "bmw", a query
-* which returns primary data containing both ferraris and bmws will *likely*
-* work, but it is not guaranteed.
-*
-* In contrast, the {@link ReactiveResourceArray} returned when using {@link Store.request}
-* is guaranteed to work with polymorphic responses.
-*
-* ---
-*
-*  
-*
-* ### Memory Leaks
-*
-* QueryArrays are meant to be long lived. They can be refreshed using
-* `array.update()`, and destroyed via `array.destroy()`.
-*
-* Unlike most Reactive state in WarpDrive, applications must choose to call
-* `destroy` when the `QueryArray` is no longer needed, else the array instance
-* will be retained until either the application or the store which created it
-* are destroyed. Destroying a QueryArray does not remove its records
-* from the cache, but it does remove the array as well as the overhead it requires
-* from the store for book-keeping.
-*
-* @legacy we recommend againt using QueryArrays. Use {@link Store.request} instead
-*/
-export interface LegacyQueryArray<T = unknown> extends LegacyLiveArray<T> {
-	query: ImmutableRequestInfo | Record<string, unknown> | null;
-	destroy(): void;
-	links: PaginationLinks | Links | null;
-	meta: Meta | null;
-}

package/declarations/store/-private/record-arrays/native-proxy-type-fix.d.ts

@@ -1,3 +0,0 @@
-interface ProxyConstructor {}
-export declare const NativeProxy: ProxyConstructor;
-export {};