@warp-drive/core 5.6.0-alpha.17 → 5.6.0-alpha.5

package/declarations/store/-private/default-cache-policy.d.ts

@@ -1,384 +0,0 @@
-import type { Cache } from "@warp-drive/core/types/cache";
-import type { StableDocumentIdentifier, StableRecordIdentifier } from "@warp-drive/core/types/identifier";
-import type { ImmutableRequestInfo, ResponseInfo, StructuredDocument } from "@warp-drive/core/types/request";
-import type { ResourceDocument } from "@warp-drive/core/types/spec/document";
-type UnsubscribeToken = object;
-type CacheOperation = "added" | "removed" | "updated" | "state";
-type DocumentCacheOperation = "invalidated" | "added" | "removed" | "updated" | "state";
-export interface NotificationCallback {
-	(identifier: StableRecordIdentifier, notificationType: "attributes" | "relationships", key?: string): void;
-	(identifier: StableRecordIdentifier, notificationType: "errors" | "meta" | "identity" | "state"): void;
-}
-interface ResourceOperationCallback {
-	// resource updates
-	(identifier: StableRecordIdentifier, notificationType: CacheOperation): void;
-}
-interface DocumentOperationCallback {
-	// document updates
-	(identifier: StableDocumentIdentifier, notificationType: DocumentCacheOperation): void;
-}
-type NotificationManager = {
-	subscribe(identifier: StableRecordIdentifier, callback: NotificationCallback): UnsubscribeToken;
-	subscribe(identifier: "resource", callback: ResourceOperationCallback): UnsubscribeToken;
-	subscribe(identifier: "document" | StableDocumentIdentifier, callback: DocumentOperationCallback): UnsubscribeToken;
-	notify(identifier: StableRecordIdentifier, value: "attributes" | "relationships", key?: string): boolean;
-	notify(identifier: StableRecordIdentifier, value: "errors" | "meta" | "identity" | "state"): boolean;
-	notify(identifier: StableRecordIdentifier, value: CacheOperation): boolean;
-	notify(identifier: StableDocumentIdentifier, value: DocumentCacheOperation): boolean;
-};
-type Store = {
-	cache: Cache;
-	notifications: NotificationManager;
-};
-export interface CacheControlValue {
-	immutable?: boolean;
-	"max-age"?: number;
-	"must-revalidate"?: boolean;
-	"must-understand"?: boolean;
-	"no-cache"?: boolean;
-	"no-store"?: boolean;
-	"no-transform"?: boolean;
-	"only-if-cached"?: boolean;
-	private?: boolean;
-	"proxy-revalidate"?: boolean;
-	public?: boolean;
-	"s-maxage"?: number;
-	"stale-if-error"?: number;
-	"stale-while-revalidate"?: number;
-}
-/**
-*  Parses a string Cache-Control header value into an object with the following structure:
-*
-* ```ts
-* interface CacheControlValue {
-*   immutable?: boolean;
-*   'max-age'?: number;
-*   'must-revalidate'?: boolean;
-*   'must-understand'?: boolean;
-*   'no-cache'?: boolean;
-*   'no-store'?: boolean;
-*   'no-transform'?: boolean;
-*   'only-if-cached'?: boolean;
-*   private?: boolean;
-*   'proxy-revalidate'?: boolean;
-*   public?: boolean;
-*   's-maxage'?: number;
-*   'stale-if-error'?: number;
-*   'stale-while-revalidate'?: number;
-* }
-* ```
-*
-* @public
-* @param {String} header
-* @return {CacheControlValue}
-*/
-export declare function parseCacheControl(header: string): CacheControlValue;
-/**
-* The configuration options for the {@link DefaultCachePolicy}
-*
-* ```ts
-* import { DefaultCachePolicy } from '@warp-drive/core/store';
-*
-* new DefaultCachePolicy({
-*   // ... PolicyConfig Settings ... //
-* });
-* ```
-*
-*/
-export type PolicyConfig = {
-	/**
-	* the number of milliseconds after which a request is considered
-	* stale. If a request is issued again after this time, the request
-	* will respond from cache immediately while a background request
-	* is made to update the cache.
-	*
-	* This is calculated against the `date` header of the response.
-	*
-	* If your API does not provide a `date` header, the `Fetch` handler
-	* provided by `@warp-drive/core` will automatically add
-	* it to responses if it is not present. Responses without a `date`
-	* header will be considered stale immediately.
-	*
-	*/
-	apiCacheSoftExpires: number;
-	/**
-	* the number of milliseconds after which a request is considered
-	* expired and should be re-fetched. If a request is issued again
-	* after this time, the request will disregard the cache and
-	* wait for a fresh response from the API.
-	*
-	* This is calculated against the `date` header of the response.
-	*
-	* If your API does not provide a `date` header, the `Fetch` handler
-	* provided by `@warp-drive/core` will automatically add
-	* it to responses if it is not present. Responses without a `date`
-	* header will be considered hard expired immediately.
-	*
-	*/
-	apiCacheHardExpires: number;
-	/**
-	* In Testing environments, the `apiCacheSoftExpires` will always be `false`
-	* and `apiCacheHardExpires` will use the `apiCacheSoftExpires` value.
-	*
-	* This helps reduce flakiness and produce predictably rendered results in test suites.
-	*
-	* Requests that specifically set `cacheOptions.backgroundReload = true` will
-	* still be background reloaded in tests.
-	*
-	* This behavior can be opted out of by setting this value to `true`.
-	*
-	*/
-	disableTestOptimization?: boolean;
-	/**
-	* In addition to the simple time-based expiration strategy, CachePolicy
-	* supports various common server-supplied expiration strategies via
-	* headers, as well as custom expiration strategies via the `isExpired`
-	* function.
-	*
-	* Requests will be validated for expiration against these constraints.
-	* If any of these constraints are not met, the request will be considered
-	* expired. If all constraints are met, the request will be considered
-	* valid and the time based expiration strategy will NOT be used.
-	*
-	* Meeting a constraint means BOTH that the properties the constraint
-	* requires are present AND that the expiration time indicated by those
-	* properties has not been exceeded.
-	*
-	* In other words, if the properties for a constraint are not present,
-	* this does not count either as meeting or as not meeting the constraint,
-	* the constraint simply does not apply.
-	*
-	* The `isExpired` function is called with the request and should return
-	* `true` if the request is expired, `false` if it is not expired, and
-	* `null` if the expiration status is unknown.
-	*
-	* In order constraints are checked:
-	*
-	* - isExpired function
-	* -  ↳ (if null) X-WarpDrive-Expires header
-	* -  ↳ (if null) Cache-Control header
-	* -  ↳ (if null) Expires header
-	*
-	*/
-	constraints?: {
-		/**
-		* Headers that should be checked for expiration.
-		*
-		*/
-		headers?: {
-			/**
-			* Whether the `Cache-Control` header should be checked for expiration.
-			* If `true`, then the `max-age` and `s-maxage` directives are used alongside
-			* the `Age` and `Date` headers to determine if the expiration time has passed.
-			*
-			* Other directives are ignored.
-			*
-			* 'Cache-Control' will take precedence over 'Expires' if both are present
-			* and both configured to be checked.
-			*
-			*/
-			"Cache-Control"?: boolean;
-			/**
-			* Whether the `Expires` header should be checked for expiration.
-			*
-			* If `true`, then the `Expires` header is used to caclulate the expiration time
-			* and determine if the expiration time has passed.
-			*
-			* 'Cache-Control' will take precedence over 'Expires' if both are present.
-			*
-			*/
-			Expires?: boolean;
-			/**
-			* Whether the `X-WarpDrive-Expires` header should be checked for expiration.
-			*
-			* If `true`, then the `X-WarpDrive-Expires` header is used to caclulate the expiration time
-			* and determine if the expiration time has passed.
-			*
-			* This header will take precedence over 'Cache-Control' and 'Expires' if all three are present.
-			*
-			* The header's value should be a [UTC date string](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toUTCString).
-			*
-			*/
-			"X-WarpDrive-Expires"?: boolean;
-		};
-		/**
-		* A function that should be called to determine if the request is expired.
-		*
-		* If present, this function will be called with the request and should return
-		* `true` if the request is expired, `false` if it is not expired, and
-		* `null` if the expiration status is unknown.
-		*
-		* If the function does not return `null`,
-		*
-		*/
-		isExpired?: (request: StructuredDocument<ResourceDocument>) => boolean | null;
-	};
-};
-/**
-* A basic CachePolicy that can be added to the Store service.
-*
-* Determines staleness based on time since the request was last received from the API
-* using the `date` header.
-*
-* Determines expiration based on configured constraints as well as a time based
-* expiration strategy based on the `date` header.
-*
-* In order expiration is determined by:
-*
-* - Is explicitly invalidated
-* -  ↳ (if null) isExpired function \<IF Constraint Active>
-* -  ↳ (if null) X-WarpDrive-Expires header \<IF Constraint Active>
-* -  ↳ (if null) Cache-Control header \<IF Constraint Active>
-* -  ↳ (if null) Expires header \<IF Constraint Active>
-* -  ↳ (if null) Date header + apiCacheHardExpires \< current time
-*
-* Invalidates any request for which `cacheOptions.types` was provided when a createRecord
-* request for that type is successful.
-*
-* For this to work, the `createRecord` request must include the `cacheOptions.types` array
-* with the types that should be invalidated, or its request should specify the identifiers
-* of the records that are being created via `records`. Providing both is valid.
-*
-* > [!NOTE]
-* > only requests that had specified `cacheOptions.types` and occurred prior to the
-* > createRecord request will be invalidated. This means that a given request should always
-* > specify the types that would invalidate it to opt into this behavior. Abstracting this
-* > behavior via builders is recommended to ensure consistency.
-*
-* This allows the Store's CacheHandler to determine if a request is expired and
-* should be refetched upon next request.
-*
-* The `Fetch` handler provided by `@warp-drive/core` will automatically
-* add the `date` header to responses if it is not present.
-*
-* > [!NOTE]
-* > Date headers do not have millisecond precision, so expiration times should
-* > generally be larger than 1000ms.
-*
-* Usage:
-*
-* ```ts
-* import { Store } from '@warp-drive/core';
-* import { DefaultCachePolicy } from '@warp-drive/core/store';
-*
-* export class AppStore extends Store {
-*   lifetimes = new DefaultCachePolicy({
-*     apiCacheSoftExpires: 30_000,
-*     apiCacheHardExpires: 60_000
-*   });
-* }
-* ```
-*
-* In Testing environments, the `apiCacheSoftExpires` will always be `false`
-* and `apiCacheHardExpires` will use the `apiCacheSoftExpires` value.
-*
-* This helps reduce flakiness and produce predictably rendered results in test suites.
-*
-* Requests that specifically set `cacheOptions.backgroundReload = true` will
-* still be background reloaded in tests.
-*
-* This behavior can be opted out of by setting `disableTestOptimization = true`
-* in the policy config.
-*
-* @public
-*/
-export declare class DefaultCachePolicy {
-	config: PolicyConfig;
-	_stores: WeakMap<Store, {
-		invalidated: Set<StableDocumentIdentifier>;
-		types: Map<string, Set<StableDocumentIdentifier>>;
-	}>;
-	_getStore(store: Store): {
-		invalidated: Set<StableDocumentIdentifier>;
-		types: Map<string, Set<StableDocumentIdentifier>>;
-	};
-	constructor(config: PolicyConfig);
-	/**
-	* Invalidate a request by its identifier for a given store instance.
-	*
-	* While the store argument may seem redundant, the CachePolicy
-	* is designed to be shared across multiple stores / forks
-	* of the store.
-	*
-	* ```ts
-	* store.lifetimes.invalidateRequest(store, identifier);
-	* ```
-	*
-	* @public
-	* @param {StableDocumentIdentifier} identifier
-	* @param {Store} store
-	*/
-	invalidateRequest(identifier: StableDocumentIdentifier, store: Store): void;
-	/**
-	* Invalidate all requests associated to a specific type
-	* for a given store instance.
-	*
-	* While the store argument may seem redundant, the CachePolicy
-	* is designed to be shared across multiple stores / forks
-	* of the store.
-	*
-	* This invalidation is done automatically when using this service
-	* for both the CacheHandler and the LegacyNetworkHandler.
-	*
-	* ```ts
-	* store.lifetimes.invalidateRequestsForType(store, 'person');
-	* ```
-	*
-	* @public
-	* @param {String} type
-	* @param {Store} store
-	*/
-	invalidateRequestsForType(type: string, store: Store): void;
-	/**
-	* Invoked when a request has been fulfilled from the configured request handlers.
-	* This is invoked by the CacheHandler for both foreground and background requests
-	* once the cache has been updated.
-	*
-	* Note, this is invoked by the CacheHandler regardless of whether
-	* the request has a cache-key.
-	*
-	* This method should not be invoked directly by consumers.
-	*
-	* @public
-	* @param {ImmutableRequestInfo} request
-	* @param {ImmutableResponse} response
-	* @param {Store} store
-	* @param {StableDocumentIdentifier | null} identifier
-	* @return {void}
-	*/
-	didRequest(request: ImmutableRequestInfo, response: Response | ResponseInfo | null, identifier: StableDocumentIdentifier | null, store: Store): void;
-	/**
-	* Invoked to determine if the request may be fulfilled from cache
-	* if possible.
-	*
-	* Note, this is only invoked by the CacheHandler if the request has
-	* a cache-key.
-	*
-	* If no cache entry is found or the entry is hard expired,
-	* the request will be fulfilled from the configured request handlers
-	* and the cache will be updated before returning the response.
-	*
-	* @public
-	* @param {StableDocumentIdentifier} identifier
-	* @param {Store} store
-	* @return {Boolean} true if the request is considered hard expired
-	*/
-	isHardExpired(identifier: StableDocumentIdentifier, store: Store): boolean;
-	/**
-	* Invoked if `isHardExpired` is false to determine if the request
-	* should be update behind the scenes if cache data is already available.
-	*
-	* Note, this is only invoked by the CacheHandler if the request has
-	* a cache-key.
-	*
-	* If true, the request will be fulfilled from cache while a backgrounded
-	* request is made to update the cache via the configured request handlers.
-	*
-	* @public
-	* @param {StableDocumentIdentifier} identifier
-	* @param {Store} store
-	* @return {Boolean} true if the request is considered soft expired
-	*/
-	isSoftExpired(identifier: StableDocumentIdentifier, store: Store): boolean;
-}
-export {};

package/declarations/store/-private/legacy-model-support/record-reference.d.ts

@@ -1,159 +0,0 @@
-import type { StableRecordIdentifier } from "../../../types/identifier.js";
-import type { SingleResourceDocument } from "../../../types/spec/json-api-raw.js";
-import type { OpaqueRecordInstance } from "../../-types/q/record-instance.js";
-import type { Store } from "../store-service.js";
-/**
-A `RecordReference` is a low-level API that allows users and
-addon authors to perform meta-operations on a record.
-
-@hideconstructor
-@public
-*/
-export default class RecordReference {
-	private store;
-	// unsubscribe token given to us by the notification manager
-	private ___token;
-	private ___identifier;
-	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
-	*/
-	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
-	*/
-	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
-	*/
-	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
-	*/
-	load(): Promise<OpaqueRecordInstance>;
-	/**
-	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
-	*/
-	reload(): Promise<OpaqueRecordInstance>;
-}

package/declarations/store/-private/legacy-model-support/shim-model-class.d.ts

@@ -1,17 +0,0 @@
-import type { TypedRecordInstance, TypeFromInstance } from "../../../types/record.js";
-import type { LegacyAttributeField, LegacyRelationshipField } from "../../../types/schema/fields.js";
-import type { KeyOrString, ModelSchema } from "../../-types/q/ds-model.js";
-import type { Store } from "../store-service.js";
-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 default class ShimModelClass<T = unknown> implements ModelSchema<T> {
-	private __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/-private/managers/cache-capabilities-manager.d.ts

@@ -1,25 +0,0 @@
-import type { StableDocumentIdentifier, StableRecordIdentifier } from "../../../types/identifier.js";
-import type { CacheCapabilitiesManager as StoreWrapper } from "../../-types/q/cache-capabilities-manager.js";
-import type { SchemaService } from "../../-types/q/schema-service.js";
-import type { IdentifierCache } from "../caches/identifier-cache.js";
-import type { Store } from "../store-service.js";
-import type { NotificationType } from "./notification-manager.js";
-export interface CacheCapabilitiesManager {
-	getSchemaDefinitionService(): SchemaService;
-}
-export declare class CacheCapabilitiesManager implements StoreWrapper {
-	_willNotify: boolean;
-	_pendingNotifies: Map<StableRecordIdentifier, Set<string>>;
-	_store: Store;
-	constructor(_store: Store);
-	get identifierCache(): IdentifierCache;
-	_scheduleNotification(identifier: StableRecordIdentifier, key: string): void;
-	_flushNotifications(): void;
-	notifyChange(identifier: StableRecordIdentifier, namespace: "added" | "removed", key: null): void;
-	notifyChange(identifier: StableDocumentIdentifier, namespace: "added" | "updated" | "removed", key: null): void;
-	notifyChange(identifier: StableRecordIdentifier, namespace: NotificationType, key: string | null): void;
-	get schema(): SchemaService;
-	setRecordId(identifier: StableRecordIdentifier, id: string): void;
-	hasRecord(identifier: StableRecordIdentifier): boolean;
-	disconnectRecord(identifier: StableRecordIdentifier): void;
-}