@warp-drive/core 5.6.0-alpha.15 → 5.6.0-alpha.18

package/declarations/store/-private/cache-handler/types.d.ts

@@ -1,99 +1,98 @@
-import type { StableDocumentIdentifier } from '../../../types/identifier.ts';
-import type { ImmutableRequestInfo, ResponseInfo } from '../../../types/request.ts';
-import type { Store } from '../store-service';
+import type { StableDocumentIdentifier } from "../../../types/identifier.js";
+import type { ImmutableRequestInfo, ResponseInfo } from "../../../types/request.js";
+import type { Store } from "../store-service.js";
 /**
- * A service which an application may provide to the store via
- * the store's `lifetimes` property to configure the behavior
- * of the CacheHandler.
- *
- * The default behavior for request lifetimes is to never expire
- * unless manually refreshed via `cacheOptions.reload` or `cacheOptions.backgroundReload`.
- *
- * Implementing this service allows you to programatically define
- * when a request should be considered expired.
- *
- * @class (Interface) CachePolicy
- * @public
- */
+* A service which an application may provide to the store via
+* the store's `lifetimes` property to configure the behavior
+* of the CacheHandler.
+*
+* The default behavior for request lifetimes is to never expire
+* unless manually refreshed via `cacheOptions.reload` or `cacheOptions.backgroundReload`.
+*
+* Implementing this service allows you to programatically define
+* when a request should be considered expired.
+*
+* @class (Interface) CachePolicy
+* @public
+*/
 export interface CachePolicy {
-    /**
-     * Invoked to determine if the request may be fulfilled from cache
-     * if possible.
-     *
-     * Note, this is only invoked 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 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;
-    /**
-     * Invoked when a request will be sent to the configured request handlers.
-     * This is invoked for both foreground and background requests.
-     *
-     * Note, this is invoked regardless of whether the request has a cache-key.
-     *
-     * @public
-     * @param {ImmutableRequestInfo} request
-     * @param {StableDocumentIdentifier | null} identifier
-     * @param {Store} store
-     * @return {void}
-     */
-    willRequest?(request: ImmutableRequestInfo, identifier: StableDocumentIdentifier | null, store: Store): void;
-    /**
-     * Invoked when a request has been fulfilled from the configured request handlers.
-     * This is invoked for both foreground and background requests once the cache has
-     * been updated.
-     *
-     * Note, this is invoked regardless of whether the request has a cache-key.
-     *
-     * It is best practice to notify the store of any requests marked as invalidated
-     * so that request subscriptions can reload when needed.
-     *
-     * ```ts
-     * store.notifications.notify(identifier, 'invalidated');
-     * ```
-     *
-     * This allows anything subscribed to the request to be notified of the change
-     *
-     * e.g.
-     *
-     * ```ts
-     * store.notifications.subscribe(identifier, (_, type) => {
-     *   if (type === 'invalidated') {
-     *     // do update
-     *   }
-     * });
-     * ```
-     *
-     *
-     * @public
-     * @param {ImmutableRequestInfo} request
-     * @param {ImmutableResponse} response
-     * @param {StableDocumentIdentifier | null} identifier
-     * @param {Store} store
-     * @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 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 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;
+	/**
+	* Invoked when a request will be sent to the configured request handlers.
+	* This is invoked for both foreground and background requests.
+	*
+	* Note, this is invoked regardless of whether the request has a cache-key.
+	*
+	* @public
+	* @param {ImmutableRequestInfo} request
+	* @param {StableDocumentIdentifier | null} identifier
+	* @param {Store} store
+	* @return {void}
+	*/
+	willRequest?(request: ImmutableRequestInfo, identifier: StableDocumentIdentifier | null, store: Store): void;
+	/**
+	* Invoked when a request has been fulfilled from the configured request handlers.
+	* This is invoked for both foreground and background requests once the cache has
+	* been updated.
+	*
+	* Note, this is invoked regardless of whether the request has a cache-key.
+	*
+	* It is best practice to notify the store of any requests marked as invalidated
+	* so that request subscriptions can reload when needed.
+	*
+	* ```ts
+	* store.notifications.notify(identifier, 'invalidated');
+	* ```
+	*
+	* This allows anything subscribed to the request to be notified of the change
+	*
+	* e.g.
+	*
+	* ```ts
+	* store.notifications.subscribe(identifier, (_, type) => {
+	*   if (type === 'invalidated') {
+	*     // do update
+	*   }
+	* });
+	* ```
+	*
+	*
+	* @public
+	* @param {ImmutableRequestInfo} request
+	* @param {ImmutableResponse} response
+	* @param {StableDocumentIdentifier | null} identifier
+	* @param {Store} store
+	* @return {void}
+	*/
+	didRequest?(request: ImmutableRequestInfo, response: Response | ResponseInfo | null, identifier: StableDocumentIdentifier | null, store: Store): void;
 }
-//# sourceMappingURL=types.d.ts.map

package/declarations/store/-private/cache-handler/utils.d.ts

@@ -1,32 +1,32 @@
-import type { StableDocumentIdentifier } from '../../../types/identifier.ts';
-import type { ImmutableCreateRequestOptions, ImmutableDeleteRequestOptions, ImmutableRequestInfo, ImmutableUpdateRequestOptions, StructuredDataDocument } from '../../../types/request.ts';
-import type { ResourceDataDocument, ResourceErrorDocument } from '../../../types/spec/document.ts';
-import type { ApiError } from '../../../types/spec/error.ts';
-import type { Store } from '../store-service.ts';
+import type { StableDocumentIdentifier } from "../../../types/identifier.js";
+import type { ImmutableCreateRequestOptions, ImmutableDeleteRequestOptions, ImmutableRequestInfo, ImmutableUpdateRequestOptions, StructuredDataDocument } from "../../../types/request.js";
+import type { ResourceDataDocument, ResourceErrorDocument } from "../../../types/spec/document.js";
+import type { ApiError } from "../../../types/spec/error.js";
+import type { Store } from "../store-service.js";
 export declare const MUTATION_OPS: Set<string>;
 export declare function calcShouldFetch(store: Store, request: ImmutableRequestInfo, hasCachedValue: boolean, identifier: StableDocumentIdentifier | null): boolean;
 export declare function calcShouldBackgroundFetch(store: Store, request: ImmutableRequestInfo, willFetch: boolean, identifier: StableDocumentIdentifier | null): boolean;
 export declare function isMutation(request: Partial<ImmutableRequestInfo>): request is ImmutableUpdateRequestOptions | ImmutableCreateRequestOptions | ImmutableDeleteRequestOptions;
 export declare function isCacheAffecting<T>(document: StructuredDataDocument<T>): boolean;
 export declare function isAggregateError(error: Error & {
-    errors?: ApiError[];
+	errors?: ApiError[];
 }): error is AggregateError & {
-    errors: ApiError[];
+	errors: ApiError[];
 };
 export type RobustError = Error & {
-    error: string | object;
-    errors?: ApiError[];
-    content?: unknown;
+	error: string | object;
+	errors?: ApiError[];
+	content?: unknown;
 };
+// TODO @runspired, consider if we should deep freeze errors (potentially only in debug) vs cloning them
 export declare function cloneError(error: RobustError): RobustError;
 export declare function isErrorDocument(document: ResourceDataDocument | ResourceErrorDocument): document is ResourceErrorDocument;
 export declare function getPriority(identifier: StableDocumentIdentifier | null, deduped: Map<StableDocumentIdentifier, {
-    priority: {
-        blocking: boolean;
-    };
+	priority: {
+		blocking: boolean;
+	};
 }>, priority: {
-    blocking: boolean;
+	blocking: boolean;
 }): {
-    blocking: boolean;
+	blocking: boolean;
 };
-//# sourceMappingURL=utils.d.ts.map

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

@@ -1,9 +1,12 @@
-import type { Cache } from '../../../types/cache.ts';
-import type { StableRecordIdentifier } from '../../../types/identifier.ts';
-import type { OpaqueRecordInstance } from '../../-types/q/record-instance';
+import type { Cache } from "../../../types/cache.js";
+import type { StableRecordIdentifier } from "../../../types/identifier.js";
+import type { OpaqueRecordInstance } from "../../-types/q/record-instance.js";
+/*
+* Returns the Cache instance associated with a given
+* Model or Identifier
+*/
 export declare const CacheForIdentifierCache: Map<unknown, Cache>;
 export declare function setCacheFor(identifier: StableRecordIdentifier | OpaqueRecordInstance, cache: Cache): void;
 export declare function removeRecordDataFor(identifier: StableRecordIdentifier | OpaqueRecordInstance): void;
 export declare function peekCache(instance: StableRecordIdentifier): Cache | null;
 export declare function peekCache(instance: OpaqueRecordInstance): Cache;
-//# sourceMappingURL=cache-utils.d.ts.map