@warp-drive/experiments 0.2.5-alpha.8 → 0.2.5-beta.0

package/README.md

@@ -22,7 +22,7 @@
 
 Install using your javascript package manager of choice. For instance with [pnpm](https://pnpm.io/)
 
-```no-highlight
+```sh
 pnpm add @warp-drive/experiments
 ```
 
@@ -31,4 +31,3 @@ pnpm add @warp-drive/experiments
 - [DataWorker](./src/data-worker/README.md)
 - [DocumentStorage](./src/document-storage/README.md)
 - [ImageWorker](./src/image-worker/README.md)
-- [PersistedCache](./src/persisted-cache/README.md)

package/declarations/data-worker/utils.d.ts

@@ -1,14 +1,6 @@
-import type { Store } from "@warp-drive/core";
-import type { StableDocumentIdentifier } from "@warp-drive/core/types/identifier";
 import type { ImmutableCreateRequestOptions, ImmutableDeleteRequestOptions, ImmutableRequestInfo, ImmutableUpdateRequestOptions, StructuredDataDocument } from "@warp-drive/core/types/request";
 import type { ApiError } from "@warp-drive/core/types/spec/error";
 export declare const MUTATION_OPS: Set<string>;
-/**
-* In a Worker, any time we are asked to make a request, data needs to be returned.
-* background requests are ergo no different than foreground requests.
-* @internal
-*/
-export declare function calcShouldFetch(store: Store, request: ImmutableRequestInfo, hasCachedValue: 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;
 type RobustError = Error & {
@@ -16,6 +8,5 @@ type RobustError = Error & {
 	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 {};

package/declarations/document-storage/index.d.ts

@@ -1,4 +1,4 @@
-import type { ExistingRecordIdentifier } from "@warp-drive/core/types/identifier";
+import type { PersistedResourceKey } from "@warp-drive/core/types/identifier";
 import type { StructuredDocument } from "@warp-drive/core/types/request";
 import type { ResourceDataDocument, ResourceDocument } from "@warp-drive/core/types/spec/document";
 import type { ExistingResourceObject } from "@warp-drive/core/types/spec/json-api-raw";
@@ -29,7 +29,7 @@ export type DocumentStorageOptions = {
 * CacheFileDocument is a StructuredDocument (request response) whose `content` is
 * the ResourceDocument returned by inserting the request into a Store's Cache.
 */
-type CacheFileDocument = StructuredDocument<ResourceDocument<ExistingRecordIdentifier>>;
+type CacheFileDocument = StructuredDocument<ResourceDocument>;
 /**
 * A CacheDocument is a reconstructed request response that rehydrates ResourceDocument
 * with the associated resources based on their identifiers.
@@ -56,9 +56,9 @@ declare class InternalDocumentStorage {
 	_read(): Promise<MemCache>;
 	_patch(documentKey: string, document: CacheFileDocument, updatedResources: Map<string, ExistingResourceObject>): Promise<void>;
 	getDocument(key: DocumentIdentifier): Promise<CacheDocument | null>;
-	putDocument(document: CacheFileDocument, resourceCollector: (resourceIdentifier: ExistingRecordIdentifier) => ExistingResourceObject): Promise<void>;
-	_getResources(document: ResourceDataDocument<ExistingRecordIdentifier>, resourceCollector: (resourceIdentifier: ExistingRecordIdentifier) => ExistingResourceObject, resources?: Map<string, ExistingResourceObject>): Map<string, ExistingResourceObject>;
-	putResources(document: ResourceDataDocument<ExistingRecordIdentifier>, resourceCollector: (resourceIdentifier: ExistingRecordIdentifier) => ExistingResourceObject): Promise<void>;
+	putDocument(document: CacheFileDocument, resourceCollector: (resourceIdentifier: PersistedResourceKey) => ExistingResourceObject): Promise<void>;
+	_getResources(document: ResourceDataDocument, resourceCollector: (resourceIdentifier: PersistedResourceKey) => ExistingResourceObject, resources?: Map<string, ExistingResourceObject>): Map<string, ExistingResourceObject>;
+	putResources(document: ResourceDataDocument, resourceCollector: (resourceIdentifier: PersistedResourceKey) => ExistingResourceObject): Promise<void>;
 	clear(reset?: boolean): Promise<void>;
 }
 /**
@@ -83,8 +83,8 @@ export declare class DocumentStorage {
 	readonly _storage: InternalDocumentStorage;
 	constructor(options?: Partial<DocumentStorageOptions>);
 	getDocument(key: DocumentIdentifier): Promise<CacheDocument | null>;
-	putDocument(document: CacheFileDocument, resourceCollector: (resourceIdentifier: ExistingRecordIdentifier) => ExistingResourceObject): Promise<void>;
-	putResources(document: ResourceDataDocument<ExistingRecordIdentifier>, resourceCollector: (resourceIdentifier: ExistingRecordIdentifier) => ExistingResourceObject): Promise<void>;
+	putDocument(document: CacheFileDocument, resourceCollector: (resourceIdentifier: PersistedResourceKey) => ExistingResourceObject): Promise<void>;
+	putResources(document: ResourceDataDocument, resourceCollector: (resourceIdentifier: PersistedResourceKey) => ExistingResourceObject): Promise<void>;
 	clear(reset?: boolean): Promise<void>;
 }
 export {};

package/dist/data-worker.js

@@ -1,4 +1,5 @@
 import { D as DocumentStorage } from "./index-CGCX7hY2.js";
+import { assertPrivateStore } from '@warp-drive/core/store/-private';
 import { SkipCache } from '@warp-drive/core/types/request';
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
 const WorkerScope = globalThis.SharedWorkerGlobalScope;
@@ -204,7 +205,7 @@ const CacheHandler = {
     const {
       store
     } = context.request;
-    const identifier = store.identifierCache.getOrCreateDocumentIdentifier(context.request);
+    const identifier = store.cacheKeyManager.getOrCreateDocumentIdentifier(context.request);
     const peeked = identifier ? store.cache.peekRequest(identifier) : null;
     if (identifier && !peeked) {
       // if we are using persisted cache, we should attempt to populate the in-memory cache now
@@ -257,6 +258,7 @@ function maybeUpdateObjects(store, document) {
       data
     });
   } else {
+    // @ts-expect-error FIXME investigate why document.data won't accept the signature
     const data = document.data ? store.cache.peek(document.data) : null;
     return Object.assign({}, document, {
       data
@@ -296,7 +298,7 @@ function updateCacheForSuccess(store, request, document) {
   } else {
     response = store.cache.put(document);
     if (response.lid) {
-      const identifier = store.identifierCache.getOrCreateDocumentIdentifier(request);
+      const identifier = store.cacheKeyManager.getOrCreateDocumentIdentifier(request);
       const full = store.cache.peekRequest(identifier);
       maybeUpdatePersistedCache(store, full);
     }
@@ -305,6 +307,7 @@ function updateCacheForSuccess(store, request, document) {
 }
 function handleFetchSuccess(store, request, identifier, document) {
   let response;
+  assertPrivateStore(store);
   store._join(() => {
     response = updateCacheForSuccess(store, request, document);
   });
@@ -321,7 +324,7 @@ function updateCacheForError(store, request, error) {
     const record = request.data?.record || request.records?.[0];
     store.cache.commitWasRejected(record, errors);
   } else {
-    const identifier = store.identifierCache.getOrCreateDocumentIdentifier(request);
+    const identifier = store.cacheKeyManager.getOrCreateDocumentIdentifier(request);
     if (identifier) {
       maybeUpdatePersistedCache(store, error);
     }
@@ -332,6 +335,7 @@ function handleFetchError(store, request, identifier, error) {
   if (request.signal?.aborted) {
     throw error;
   }
+  assertPrivateStore(store);
   let response;
   store._join(() => {
     response = updateCacheForError(store, request, error);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@warp-drive/experiments",
   "description": "Experimental features for EmberData/WarpDrive",
-  "version": "0.2.5-alpha.8",
+  "version": "0.2.5-beta.0",
   "license": "MIT",
   "author": "Chris Thoburn <runspired@users.noreply.github.com>",
   "repository": {
@@ -12,10 +12,6 @@
   "homepage": "https://github.com/emberjs/data",
   "bugs": "https://github.com/emberjs/data/issues",
   "exports": {
-    "./persisted-cache": {
-      "types": "./declarations/persisted-cache.d.ts",
-      "default": "./dist/persisted-cache.js"
-    },
     "./document-storage": {
       "types": "./declarations/document-storage.d.ts",
       "default": "./dist/document-storage.js"
@@ -48,7 +44,7 @@
   ],
   "peerDependencies": {
     "@sqlite.org/sqlite-wasm": "3.46.0-build2",
-    "@warp-drive/core": "5.7.0-alpha.8"
+    "@warp-drive/core": "5.7.0-beta.0"
   },
   "peerDependenciesMeta": {
     "@sqlite.org/sqlite-wasm": {
@@ -56,18 +52,18 @@
     }
   },
   "dependencies": {
-    "@embroider/macros": "^1.16.12"
+    "@embroider/macros": "^1.18.1"
   },
   "devDependencies": {
-    "@babel/core": "^7.26.10",
-    "@babel/plugin-transform-typescript": "^7.27.0",
-    "@babel/preset-env": "^7.26.9",
-    "@babel/preset-typescript": "^7.27.0",
-    "@warp-drive/internal-config": "5.7.0-alpha.8",
-    "@warp-drive/core": "5.7.0-alpha.8",
+    "@babel/core": "^7.28.3",
+    "@babel/plugin-transform-typescript": "^7.28.0",
+    "@babel/preset-env": "^7.28.3",
+    "@babel/preset-typescript": "^7.27.1",
+    "@warp-drive/internal-config": "5.7.0-beta.0",
+    "@warp-drive/core": "5.7.0-beta.0",
     "@sqlite.org/sqlite-wasm": "3.46.0-build2",
-    "typescript": "^5.8.3",
-    "vite": "^7.0.0"
+    "typescript": "^5.9.2",
+    "vite": "^7.1.3"
   },
   "volta": {
     "extends": "../../package.json"

package/declarations/persisted-cache/cache.d.ts

@@ -1,465 +0,0 @@
-import type { Cache, ChangedAttributesHash, RelationshipDiff } from "@warp-drive/core/types/cache";
-import type { ResourceBlob } from "@warp-drive/core/types/cache/aliases";
-import type { Change } from "@warp-drive/core/types/cache/change";
-import type { Mutation } from "@warp-drive/core/types/cache/mutations";
-import type { Operation } from "@warp-drive/core/types/cache/operations";
-import type { CollectionRelationship, ResourceRelationship } from "@warp-drive/core/types/cache/relationship";
-import type { StableDocumentIdentifier, StableRecordIdentifier } from "@warp-drive/core/types/identifier";
-import type { Value } from "@warp-drive/core/types/json/raw";
-import type { TypeFromInstanceOrString } from "@warp-drive/core/types/record";
-import type { RequestContext, StructuredDataDocument, StructuredDocument } from "@warp-drive/core/types/request";
-import type { ResourceDocument, SingleResourceDataDocument } from "@warp-drive/core/types/spec/document";
-import type { ApiError } from "@warp-drive/core/types/spec/error";
-/**
-* The PersistedCache wraps a Cache to enhance it with
-* Persisted Storage capabilities.
-*
-* @class PersistedCache
-* @internal
-*/
-export declare class PersistedCache implements Cache {
-	_cache: Cache;
-	_db: IDBDatabase;
-	version: "2";
-	constructor(cache: Cache, db: IDBDatabase);
-	// Cache Management
-	// ================
-	/**
-	* Cache the response to a request
-	*
-	* Unlike `store.push` which has UPSERT
-	* semantics, `put` has `replace` semantics similar to
-	* the `http` method `PUT`
-	*
-	* the individually cacheabl
-	* e resource data it may contain
-	* should upsert, but the document data surrounding it should
-	* fully replace any existing information
-	*
-	* Note that in order to support inserting arbitrary data
-	* to the cache that did not originate from a request `put`
-	* should expect to sometimes encounter a document with only
-	* a `content` member and therefor must not assume the existence
-	* of `request` and `response` on the document.
-	*
-	* @param {StructuredDocument} doc
-	* @return {ResourceDocument}
-	* @internal
-	*/
-	put<T>(doc: StructuredDocument<T> | {
-		content: T;
-	}): ResourceDocument;
-	/**
-	* Perform an operation on the cache to update the remote state.
-	*
-	* Note: currently the only valid operation is a MergeOperation
-	* which occurs when a collision of identifiers is detected.
-	*
-	* @internal
-	* @param op the operation to perform
-	* @return {void}
-	*/
-	patch(op: Operation): void;
-	/**
-	* Update resource data with a local mutation. Currently supports operations
-	* on relationships only.
-	*
-	* @internal
-	* @param mutation
-	*/
-	mutate(mutation: Mutation): void;
-	/**
-	* Peek resource data from the Cache.
-	*
-	* In development, if the return value
-	* is JSON the return value
-	* will be deep-cloned and deep-frozen
-	* to prevent mutation thereby enforcing cache
-	* Immutability.
-	*
-	* This form of peek is useful for implementations
-	* that want to feed raw-data from cache to the UI
-	* or which want to interact with a blob of data
-	* directly from the presentation cache.
-	*
-	* An implementation might want to do this because
-	* de-referencing records which read from their own
-	* blob is generally safer because the record does
-	* not require retainining connections to the Store
-	* and Cache to present data on a per-field basis.
-	*
-	* This generally takes the place of `getAttr` as
-	* an API and may even take the place of `getRelationship`
-	* depending on implementation specifics, though this
-	* latter usage is less recommended due to the advantages
-	* of the Graph handling necessary entanglements and
-	* notifications for relational data.
-	*
-	* @internal
-	* @param {StableRecordIdentifier | StableDocumentIdentifier} identifier
-	* @return {ResourceDocument | ResourceBlob | null} the known resource data
-	*/
-	peek<T = unknown>(identifier: StableRecordIdentifier<TypeFromInstanceOrString<T>>): T | null;
-	peek(identifier: StableDocumentIdentifier): ResourceDocument | null;
-	/**
-	* Peek resource data from the Cache.
-	*
-	* In development, if the return value
-	* is JSON the return value
-	* will be deep-cloned and deep-frozen
-	* to prevent mutation thereby enforcing cache
-	* Immutability.
-	*
-	* This form of peek is useful for implementations
-	* that want to feed raw-data from cache to the UI
-	* or which want to interact with a blob of data
-	* directly from the presentation cache.
-	*
-	* An implementation might want to do this because
-	* de-referencing records which read from their own
-	* blob is generally safer because the record does
-	* not require retainining connections to the Store
-	* and Cache to present data on a per-field basis.
-	*
-	* This generally takes the place of `getAttr` as
-	* an API and may even take the place of `getRelationship`
-	* depending on implementation specifics, though this
-	* latter usage is less recommended due to the advantages
-	* of the Graph handling necessary entanglements and
-	* notifications for relational data.
-	*
-	* @internal
-	* @param {StableRecordIdentifier | StableDocumentIdentifier} identifier
-	* @return {ResourceDocument | ResourceBlob | null} the known resource data
-	*/
-	peekRemoteState<T = unknown>(identifier: StableRecordIdentifier<TypeFromInstanceOrString<T>>): T | null;
-	peekRemoteState(identifier: StableDocumentIdentifier): ResourceDocument | null;
-	/**
-	* Peek the Cache for the existing request data associated with
-	* a cacheable request
-	*
-	* @param {StableDocumentIdentifier}
-	* @return {StableDocumentIdentifier | null}
-	* @internal
-	*/
-	peekRequest(identifier: StableDocumentIdentifier): StructuredDocument<ResourceDocument> | null;
-	/**
-	* Push resource data from a remote source into the cache for this identifier
-	*
-	* @internal
-	* @param identifier
-	* @param data
-	* @param hasRecord
-	* @return {void | string[]} if `hasRecord` is true then calculated key changes should be returned
-	*/
-	upsert(identifier: StableRecordIdentifier, data: ResourceBlob, hasRecord: boolean): void | string[];
-	// Cache Forking Support
-	// =====================
-	/**
-	* Create a fork of the cache from the current state.
-	*
-	* Applications should typically not call this method themselves,
-	* preferring instead to fork at the Store level, which will
-	* utilize this method to fork the cache.
-	*
-	* @internal
-	* @return {Promise<Cache>}
-	*/
-	fork(): Promise<Cache>;
-	/**
-	* Merge a fork back into a parent Cache.
-	*
-	* Applications should typically not call this method themselves,
-	* preferring instead to merge at the Store level, which will
-	* utilize this method to merge the caches.
-	*
-	* @param {Cache} cache
-	* @internal
-	* @return {Promise<void>}
-	*/
-	merge(cache: Cache): Promise<void>;
-	/**
-	* Generate the list of changes applied to all
-	* record in the store.
-	*
-	* Each individual resource or document that has
-	* been mutated should be described as an individual
-	* `Change` entry in the returned array.
-	*
-	* A `Change` is described by an object containing up to
-	* three properties: (1) the `identifier` of the entity that
-	* changed; (2) the `op` code of that change being one of
-	* `upsert` or `remove`, and if the op is `upsert` a `patch`
-	* containing the data to merge into the cache for the given
-	* entity.
-	*
-	* This `patch` is opaque to the Store but should be understood
-	* by the Cache and may expect to be utilized by an Adapter
-	* when generating data during a `save` operation.
-	*
-	* It is generally recommended that the `patch` contain only
-	* the updated state, ignoring fields that are unchanged
-	*
-	* ```ts
-	* interface Change {
-	*  identifier: StableRecordIdentifier | StableDocumentIdentifier;
-	*  op: 'upsert' | 'remove';
-	*  patch?: unknown;
-	* }
-	* ```
-	*
-	* @internal
-	*/
-	diff(): Promise<Change[]>;
-	// SSR Support
-	// ===========
-	/**
-	* Serialize the entire contents of the Cache into a Stream
-	* which may be fed back into a new instance of the same Cache
-	* via `cache.hydrate`.
-	*
-	* @return {Promise<ReadableStream>}
-	* @internal
-	*/
-	dump(): Promise<ReadableStream<unknown>>;
-	/**
-	* hydrate a Cache from a Stream with content previously serialized
-	* from another instance of the same Cache, resolving when hydration
-	* is complete.
-	*
-	* This method should expect to be called both in the context of restoring
-	* the Cache during application rehydration after SSR **AND** at unknown
-	* times during the lifetime of an already booted application when it is
-	* desired to bulk-load additional information into the cache. This latter
-	* behavior supports optimizing pre/fetching of data for route transitions
-	* via data-only SSR modes.
-	*
-	* @param {ReadableStream} stream
-	* @return {Promise<void>}
-	* @internal
-	*/
-	hydrate(stream: ReadableStream<unknown>): Promise<void>;
-	// Cache
-	// =====
-	// Resource Support
-	// ================
-	/**
-	* [LIFECYLCE] Signal to the cache that a new record has been instantiated on the client
-	*
-	* It returns properties from options that should be set on the record during the create
-	* process. This return value behavior is deprecated.
-	*
-	* @internal
-	* @param identifier
-	* @param options
-	*/
-	clientDidCreate(identifier: StableRecordIdentifier, options?: Record<string, unknown>): Record<string, unknown>;
-	/**
-	* [LIFECYCLE] Signals to the cache that a resource
-	* will be part of a save transaction.
-	*
-	* @internal
-	* @param identifier
-	*/
-	willCommit(identifier: StableRecordIdentifier, context: RequestContext): void;
-	/**
-	* [LIFECYCLE] Signals to the cache that a resource
-	* was successfully updated as part of a save transaction.
-	*
-	* @internal
-	* @param identifier
-	* @param data
-	*/
-	didCommit(identifier: StableRecordIdentifier, result: StructuredDataDocument<unknown>): SingleResourceDataDocument;
-	/**
-	* [LIFECYCLE] Signals to the cache that a resource
-	* was update via a save transaction failed.
-	*
-	* @internal
-	* @param identifier
-	* @param errors
-	*/
-	commitWasRejected(identifier: StableRecordIdentifier, errors?: ApiError[]): void;
-	/**
-	* [LIFECYCLE] Signals to the cache that all data for a resource
-	* should be cleared.
-	*
-	* @internal
-	* @param identifier
-	*/
-	unloadRecord(identifier: StableRecordIdentifier): void;
-	// Granular Resource Data APIs
-	// ===========================
-	/**
-	* Retrieve the data for an attribute from the cache
-	*
-	* @internal
-	* @param identifier
-	* @param propertyName
-	* @return {unknown}
-	*/
-	getAttr(identifier: StableRecordIdentifier, field: string): Value | undefined;
-	/**
-	* Retrieve the remote state for an attribute from the cache
-	*
-	* @internal
-	* @param identifier
-	* @param propertyName
-	* @return {unknown}
-	*/
-	getRemoteAttr(identifier: StableRecordIdentifier, field: string): Value | undefined;
-	/**
-	* Mutate the data for an attribute in the cache
-	*
-	* @internal
-	* @param identifier
-	* @param propertyName
-	* @param value
-	*/
-	setAttr(identifier: StableRecordIdentifier, propertyName: string, value: Value): void;
-	/**
-	* Query the cache for the changed attributes of a resource.
-	*
-	* @internal
-	* @param identifier
-	* @return
-	*/
-	changedAttrs(identifier: StableRecordIdentifier): ChangedAttributesHash;
-	/**
-	* Query the cache for whether any mutated attributes exist
-	*
-	* @internal
-	* @param identifier
-	* @return {Boolean}
-	*/
-	hasChangedAttrs(identifier: StableRecordIdentifier): boolean;
-	/**
-	* Tell the cache to discard any uncommitted mutations to attributes
-	*
-	* @internal
-	* @param identifier
-	* @return the names of attributes that were restored
-	*/
-	rollbackAttrs(identifier: StableRecordIdentifier): string[];
-	/**
-	* Query the cache for the changes to relationships of a resource.
-	*
-	* Returns a map of relationship names to RelationshipDiff objects.
-	*
-	* ```ts
-	* type RelationshipDiff =
-	| {
-	kind: 'collection';
-	remoteState: StableRecordIdentifier[];
-	additions: Set<StableRecordIdentifier>;
-	removals: Set<StableRecordIdentifier>;
-	localState: StableRecordIdentifier[];
-	reordered: boolean;
-	}
-	| {
-	kind: 'resource';
-	remoteState: StableRecordIdentifier | null;
-	localState: StableRecordIdentifier | null;
-	};
-	```
-	*
-	* @public
-	* @param {StableRecordIdentifier} identifier
-	* @return {Map<string, RelationshipDiff>}
-	*/
-	changedRelationships(identifier: StableRecordIdentifier): Map<string, RelationshipDiff>;
-	/**
-	* Query the cache for whether any mutated attributes exist
-	*
-	* @public
-	* @param {StableRecordIdentifier} identifier
-	* @return {Boolean}
-	*/
-	hasChangedRelationships(identifier: StableRecordIdentifier): boolean;
-	/**
-	* Tell the cache to discard any uncommitted mutations to relationships.
-	*
-	* This will also discard the change on any appropriate inverses.
-	*
-	* This method is a candidate to become a mutation
-	*
-	* @public
-	* @param {StableRecordIdentifier} identifier
-	* @return {String[]} the names of relationships that were restored
-	*/
-	rollbackRelationships(identifier: StableRecordIdentifier): string[];
-	// Relationships
-	// =============
-	/**
-	* Query the cache for the current state of a relationship property
-	*
-	* @internal
-	* @param identifier
-	* @param propertyName
-	* @return resource relationship object
-	*/
-	getRelationship(identifier: StableRecordIdentifier, field: string, isCollection?: boolean): ResourceRelationship | CollectionRelationship;
-	/**
-	* Query the remote state for the current state of a relationship property
-	*
-	* @internal
-	* @param identifier
-	* @param propertyName
-	* @return resource relationship object
-	*/
-	getRemoteRelationship(identifier: StableRecordIdentifier, field: string, isCollection?: boolean): ResourceRelationship | CollectionRelationship;
-	// Resource State
-	// ===============
-	/**
-	* Update the cache state for the given resource to be marked as locally deleted,
-	* or remove such a mark.
-	*
-	* @internal
-	* @param identifier
-	* @param isDeleted
-	*/
-	setIsDeleted(identifier: StableRecordIdentifier, isDeleted: boolean): void;
-	/**
-	* Query the cache for any validation errors applicable to the given resource.
-	*
-	* @internal
-	* @param identifier
-	* @return
-	*/
-	getErrors(identifier: StableRecordIdentifier): ApiError[];
-	/**
-	* Query the cache for whether a given resource has any available data
-	*
-	* @internal
-	* @param identifier
-	* @return {Boolean}
-	*/
-	isEmpty(identifier: StableRecordIdentifier): boolean;
-	/**
-	* Query the cache for whether a given resource was created locally and not
-	* yet persisted.
-	*
-	* @internal
-	* @param identifier
-	* @return {Boolean}
-	*/
-	isNew(identifier: StableRecordIdentifier): boolean;
-	/**
-	* Query the cache for whether a given resource is marked as deleted (but not
-	* necessarily persisted yet).
-	*
-	* @internal
-	* @param identifier
-	* @return {Boolean}
-	*/
-	isDeleted(identifier: StableRecordIdentifier): boolean;
-	/**
-	* Query the cache for whether a given resource has been deleted and that deletion
-	* has also been persisted.
-	*
-	* @internal
-	* @param identifier
-	* @return {Boolean}
-	*/
-	isDeletionCommitted(identifier: StableRecordIdentifier): boolean;
-}

package/declarations/persisted-cache.d.ts

@@ -1 +0,0 @@
-export { PersistedCache } from "./persisted-cache/cache.js";

package/dist/persisted-cache.js

@@ -1,588 +0,0 @@
-/**
- * The PersistedCache wraps a Cache to enhance it with
- * Persisted Storage capabilities.
- *
- * @class PersistedCache
- * @internal
- */
-class PersistedCache {
-  constructor(cache, db) {
-    this.version = '2';
-    this._cache = cache;
-    this._db = db;
-  }
-
-  // Cache Management
-  // ================
-
-  /**
-   * Cache the response to a request
-   *
-   * Unlike `store.push` which has UPSERT
-   * semantics, `put` has `replace` semantics similar to
-   * the `http` method `PUT`
-   *
-   * the individually cacheabl
-   * e resource data it may contain
-   * should upsert, but the document data surrounding it should
-   * fully replace any existing information
-   *
-   * Note that in order to support inserting arbitrary data
-   * to the cache that did not originate from a request `put`
-   * should expect to sometimes encounter a document with only
-   * a `content` member and therefor must not assume the existence
-   * of `request` and `response` on the document.
-   *
-   * @param {StructuredDocument} doc
-   * @return {ResourceDocument}
-   * @internal
-   */
-  put(doc) {
-    const result = this._cache.put(doc);
-    if (!result.lid) {
-      return result;
-    }
-    const transaction = this._db.transaction(['request', 'resource'], 'readwrite', {
-      durability: 'relaxed'
-    });
-    const request = this._cache.peekRequest({
-      lid: result.lid
-    });
-    const requests = transaction.objectStore('request');
-    const resources = transaction.objectStore('resource');
-    requests.put(request);
-    if ('data' in result && result.data) {
-      const resourceData = Array.isArray(result.data) ? result.data : [result.data];
-      resourceData.forEach(identifier => {
-        resources.put(this._cache.peek(identifier), identifier.lid);
-      });
-    }
-    if ('included' in result && result.included) {
-      const included = result.included;
-      included.forEach(identifier => {
-        resources.put(this._cache.peek(identifier), identifier.lid);
-      });
-    }
-    return result;
-  }
-
-  /**
-   * Perform an operation on the cache to update the remote state.
-   *
-   * Note: currently the only valid operation is a MergeOperation
-   * which occurs when a collision of identifiers is detected.
-   *
-   * @internal
-   * @param op the operation to perform
-   * @return {void}
-   */
-  patch(op) {
-    this._cache.patch(op);
-  }
-
-  /**
-   * Update resource data with a local mutation. Currently supports operations
-   * on relationships only.
-   *
-   * @internal
-   * @param mutation
-   */
-  mutate(mutation) {
-    this._cache.mutate(mutation);
-  }
-
-  /**
-   * Peek resource data from the Cache.
-   *
-   * In development, if the return value
-   * is JSON the return value
-   * will be deep-cloned and deep-frozen
-   * to prevent mutation thereby enforcing cache
-   * Immutability.
-   *
-   * This form of peek is useful for implementations
-   * that want to feed raw-data from cache to the UI
-   * or which want to interact with a blob of data
-   * directly from the presentation cache.
-   *
-   * An implementation might want to do this because
-   * de-referencing records which read from their own
-   * blob is generally safer because the record does
-   * not require retainining connections to the Store
-   * and Cache to present data on a per-field basis.
-   *
-   * This generally takes the place of `getAttr` as
-   * an API and may even take the place of `getRelationship`
-   * depending on implementation specifics, though this
-   * latter usage is less recommended due to the advantages
-   * of the Graph handling necessary entanglements and
-   * notifications for relational data.
-   *
-   * @internal
-   * @param {StableRecordIdentifier | StableDocumentIdentifier} identifier
-   * @return {ResourceDocument | ResourceBlob | null} the known resource data
-   */
-
-  peek(identifier) {
-    return this._cache.peek(identifier);
-  }
-
-  /**
-   * Peek resource data from the Cache.
-   *
-   * In development, if the return value
-   * is JSON the return value
-   * will be deep-cloned and deep-frozen
-   * to prevent mutation thereby enforcing cache
-   * Immutability.
-   *
-   * This form of peek is useful for implementations
-   * that want to feed raw-data from cache to the UI
-   * or which want to interact with a blob of data
-   * directly from the presentation cache.
-   *
-   * An implementation might want to do this because
-   * de-referencing records which read from their own
-   * blob is generally safer because the record does
-   * not require retainining connections to the Store
-   * and Cache to present data on a per-field basis.
-   *
-   * This generally takes the place of `getAttr` as
-   * an API and may even take the place of `getRelationship`
-   * depending on implementation specifics, though this
-   * latter usage is less recommended due to the advantages
-   * of the Graph handling necessary entanglements and
-   * notifications for relational data.
-   *
-   * @internal
-   * @param {StableRecordIdentifier | StableDocumentIdentifier} identifier
-   * @return {ResourceDocument | ResourceBlob | null} the known resource data
-   */
-
-  peekRemoteState(identifier) {
-    return this._cache.peekRemoteState(identifier);
-  }
-
-  /**
-   * Peek the Cache for the existing request data associated with
-   * a cacheable request
-   *
-   * @param {StableDocumentIdentifier}
-   * @return {StableDocumentIdentifier | null}
-   * @internal
-   */
-  peekRequest(identifier) {
-    return this._cache.peekRequest(identifier);
-  }
-
-  /**
-   * Push resource data from a remote source into the cache for this identifier
-   *
-   * @internal
-   * @param identifier
-   * @param data
-   * @param hasRecord
-   * @return {void | string[]} if `hasRecord` is true then calculated key changes should be returned
-   */
-  upsert(identifier, data, hasRecord) {
-    return this._cache.upsert(identifier, data, hasRecord);
-  }
-
-  // Cache Forking Support
-  // =====================
-
-  /**
-   * Create a fork of the cache from the current state.
-   *
-   * Applications should typically not call this method themselves,
-   * preferring instead to fork at the Store level, which will
-   * utilize this method to fork the cache.
-   *
-   * @internal
-   * @return {Promise<Cache>}
-   */
-  fork() {
-    return this._cache.fork();
-  }
-
-  /**
-   * Merge a fork back into a parent Cache.
-   *
-   * Applications should typically not call this method themselves,
-   * preferring instead to merge at the Store level, which will
-   * utilize this method to merge the caches.
-   *
-   * @param {Cache} cache
-   * @internal
-   * @return {Promise<void>}
-   */
-  merge(cache) {
-    return this._cache.merge(cache);
-  }
-
-  /**
-   * Generate the list of changes applied to all
-   * record in the store.
-   *
-   * Each individual resource or document that has
-   * been mutated should be described as an individual
-   * `Change` entry in the returned array.
-   *
-   * A `Change` is described by an object containing up to
-   * three properties: (1) the `identifier` of the entity that
-   * changed; (2) the `op` code of that change being one of
-   * `upsert` or `remove`, and if the op is `upsert` a `patch`
-   * containing the data to merge into the cache for the given
-   * entity.
-   *
-   * This `patch` is opaque to the Store but should be understood
-   * by the Cache and may expect to be utilized by an Adapter
-   * when generating data during a `save` operation.
-   *
-   * It is generally recommended that the `patch` contain only
-   * the updated state, ignoring fields that are unchanged
-   *
-   * ```ts
-   * interface Change {
-   *  identifier: StableRecordIdentifier | StableDocumentIdentifier;
-   *  op: 'upsert' | 'remove';
-   *  patch?: unknown;
-   * }
-   * ```
-   *
-   * @internal
-   */
-  diff() {
-    return this._cache.diff();
-  }
-
-  // SSR Support
-  // ===========
-
-  /**
-   * Serialize the entire contents of the Cache into a Stream
-   * which may be fed back into a new instance of the same Cache
-   * via `cache.hydrate`.
-   *
-   * @return {Promise<ReadableStream>}
-   * @internal
-   */
-  dump() {
-    return this._cache.dump();
-  }
-
-  /**
-   * hydrate a Cache from a Stream with content previously serialized
-   * from another instance of the same Cache, resolving when hydration
-   * is complete.
-   *
-   * This method should expect to be called both in the context of restoring
-   * the Cache during application rehydration after SSR **AND** at unknown
-   * times during the lifetime of an already booted application when it is
-   * desired to bulk-load additional information into the cache. This latter
-   * behavior supports optimizing pre/fetching of data for route transitions
-   * via data-only SSR modes.
-   *
-   * @param {ReadableStream} stream
-   * @return {Promise<void>}
-   * @internal
-   */
-  hydrate(stream) {
-    return this._cache.hydrate(stream);
-  }
-
-  // Cache
-  // =====
-
-  // Resource Support
-  // ================
-
-  /**
-   * [LIFECYLCE] Signal to the cache that a new record has been instantiated on the client
-   *
-   * It returns properties from options that should be set on the record during the create
-   * process. This return value behavior is deprecated.
-   *
-   * @internal
-   * @param identifier
-   * @param options
-   */
-  clientDidCreate(identifier, options) {
-    return this._cache.clientDidCreate(identifier, options);
-  }
-
-  /**
-   * [LIFECYCLE] Signals to the cache that a resource
-   * will be part of a save transaction.
-   *
-   * @internal
-   * @param identifier
-   */
-  willCommit(identifier, context) {
-    this._cache.willCommit(identifier, context);
-  }
-
-  /**
-   * [LIFECYCLE] Signals to the cache that a resource
-   * was successfully updated as part of a save transaction.
-   *
-   * @internal
-   * @param identifier
-   * @param data
-   */
-  didCommit(identifier, result) {
-    return this._cache.didCommit(identifier, result);
-  }
-
-  /**
-   * [LIFECYCLE] Signals to the cache that a resource
-   * was update via a save transaction failed.
-   *
-   * @internal
-   * @param identifier
-   * @param errors
-   */
-  commitWasRejected(identifier, errors) {
-    this._cache.commitWasRejected(identifier, errors);
-  }
-
-  /**
-   * [LIFECYCLE] Signals to the cache that all data for a resource
-   * should be cleared.
-   *
-   * @internal
-   * @param identifier
-   */
-  unloadRecord(identifier) {
-    this._cache.unloadRecord(identifier);
-  }
-
-  // Granular Resource Data APIs
-  // ===========================
-
-  /**
-   * Retrieve the data for an attribute from the cache
-   *
-   * @internal
-   * @param identifier
-   * @param propertyName
-   * @return {unknown}
-   */
-  getAttr(identifier, field) {
-    return this._cache.getAttr(identifier, field);
-  }
-
-  /**
-   * Retrieve the remote state for an attribute from the cache
-   *
-   * @internal
-   * @param identifier
-   * @param propertyName
-   * @return {unknown}
-   */
-  getRemoteAttr(identifier, field) {
-    return this._cache.getRemoteAttr(identifier, field);
-  }
-
-  /**
-   * Mutate the data for an attribute in the cache
-   *
-   * @internal
-   * @param identifier
-   * @param propertyName
-   * @param value
-   */
-  setAttr(identifier, propertyName, value) {
-    this._cache.setAttr(identifier, propertyName, value);
-  }
-
-  /**
-   * Query the cache for the changed attributes of a resource.
-   *
-   * @internal
-   * @param identifier
-   * @return
-   */
-  changedAttrs(identifier) {
-    return this._cache.changedAttrs(identifier);
-  }
-
-  /**
-   * Query the cache for whether any mutated attributes exist
-   *
-   * @internal
-   * @param identifier
-   * @return {Boolean}
-   */
-  hasChangedAttrs(identifier) {
-    return this._cache.hasChangedAttrs(identifier);
-  }
-
-  /**
-   * Tell the cache to discard any uncommitted mutations to attributes
-   *
-   * @internal
-   * @param identifier
-   * @return the names of attributes that were restored
-   */
-  rollbackAttrs(identifier) {
-    return this._cache.rollbackAttrs(identifier);
-  }
-
-  /**
-   * Query the cache for the changes to relationships of a resource.
-   *
-   * Returns a map of relationship names to RelationshipDiff objects.
-   *
-   * ```ts
-   * type RelationshipDiff =
-  | {
-      kind: 'collection';
-      remoteState: StableRecordIdentifier[];
-      additions: Set<StableRecordIdentifier>;
-      removals: Set<StableRecordIdentifier>;
-      localState: StableRecordIdentifier[];
-      reordered: boolean;
-    }
-  | {
-      kind: 'resource';
-      remoteState: StableRecordIdentifier | null;
-      localState: StableRecordIdentifier | null;
-    };
-    ```
-   *
-   * @public
-   * @param {StableRecordIdentifier} identifier
-   * @return {Map<string, RelationshipDiff>}
-   */
-  changedRelationships(identifier) {
-    return this._cache.changedRelationships(identifier);
-  }
-
-  /**
-   * Query the cache for whether any mutated attributes exist
-   *
-   * @public
-   * @param {StableRecordIdentifier} identifier
-   * @return {Boolean}
-   */
-  hasChangedRelationships(identifier) {
-    return this._cache.hasChangedRelationships(identifier);
-  }
-
-  /**
-   * Tell the cache to discard any uncommitted mutations to relationships.
-   *
-   * This will also discard the change on any appropriate inverses.
-   *
-   * This method is a candidate to become a mutation
-   *
-   * @public
-   * @param {StableRecordIdentifier} identifier
-   * @return {String[]} the names of relationships that were restored
-   */
-  rollbackRelationships(identifier) {
-    return this._cache.rollbackRelationships(identifier);
-  }
-
-  // Relationships
-  // =============
-
-  /**
-   * Query the cache for the current state of a relationship property
-   *
-   * @internal
-   * @param identifier
-   * @param propertyName
-   * @return resource relationship object
-   */
-  getRelationship(identifier, field, isCollection) {
-    return this._cache.getRelationship(identifier, field, isCollection);
-  }
-
-  /**
-   * Query the remote state for the current state of a relationship property
-   *
-   * @internal
-   * @param identifier
-   * @param propertyName
-   * @return resource relationship object
-   */
-  getRemoteRelationship(identifier, field, isCollection) {
-    return this._cache.getRemoteRelationship(identifier, field, isCollection);
-  }
-
-  // Resource State
-  // ===============
-
-  /**
-   * Update the cache state for the given resource to be marked as locally deleted,
-   * or remove such a mark.
-   *
-   * @internal
-   * @param identifier
-   * @param isDeleted
-   */
-  setIsDeleted(identifier, isDeleted) {
-    this._cache.setIsDeleted(identifier, isDeleted);
-  }
-
-  /**
-   * Query the cache for any validation errors applicable to the given resource.
-   *
-   * @internal
-   * @param identifier
-   * @return
-   */
-  getErrors(identifier) {
-    return this._cache.getErrors(identifier);
-  }
-
-  /**
-   * Query the cache for whether a given resource has any available data
-   *
-   * @internal
-   * @param identifier
-   * @return {Boolean}
-   */
-  isEmpty(identifier) {
-    return this._cache.isEmpty(identifier);
-  }
-
-  /**
-   * Query the cache for whether a given resource was created locally and not
-   * yet persisted.
-   *
-   * @internal
-   * @param identifier
-   * @return {Boolean}
-   */
-  isNew(identifier) {
-    return this._cache.isNew(identifier);
-  }
-
-  /**
-   * Query the cache for whether a given resource is marked as deleted (but not
-   * necessarily persisted yet).
-   *
-   * @internal
-   * @param identifier
-   * @return {Boolean}
-   */
-  isDeleted(identifier) {
-    return this._cache.isDeleted(identifier);
-  }
-
-  /**
-   * Query the cache for whether a given resource has been deleted and that deletion
-   * has also been persisted.
-   *
-   * @internal
-   * @param identifier
-   * @return {Boolean}
-   */
-  isDeletionCommitted(identifier) {
-    return this._cache.isDeletionCommitted(identifier);
-  }
-}
-export { PersistedCache };