@warp-drive-mirror/experiments 0.2.4-alpha.1 → 0.2.4-alpha.12

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

@@ -0,0 +1,450 @@
+import type { Cache, ChangedAttributesHash, RelationshipDiff } from '@warp-drive-mirror/core/types/cache';
+import type { ResourceBlob } from '@warp-drive-mirror/core/types/cache/aliases';
+import type { Change } from '@warp-drive-mirror/core/types/cache/change';
+import type { Mutation } from '@warp-drive-mirror/core/types/cache/mutations';
+import type { Operation } from '@warp-drive-mirror/core/types/cache/operations';
+import type { CollectionRelationship, ResourceRelationship } from '@warp-drive-mirror/core/types/cache/relationship';
+import type { StableDocumentIdentifier, StableRecordIdentifier } from '@warp-drive-mirror/core/types/identifier';
+import type { Value } from '@warp-drive-mirror/core/types/json/raw';
+import type { TypeFromInstanceOrString } from '@warp-drive-mirror/core/types/record';
+import type { RequestContext, StructuredDataDocument, StructuredDocument } from '@warp-drive-mirror/core/types/request';
+import type { ResourceDocument, SingleResourceDataDocument } from '@warp-drive-mirror/core/types/spec/document';
+import type { ApiError } from '@warp-drive-mirror/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 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[];
+    /**
+     * 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[]>;
+    /**
+     * 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>;
+    /**
+     * [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;
+    /**
+     * 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[];
+    /**
+     * 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;
+    /**
+     * 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;
+}
+//# sourceMappingURL=cache.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../src/persisted-cache/cache.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,21 @@
+import type { ExistingRecordIdentifier } from '@warp-drive-mirror/core/types/identifier';
+import type { StructuredDocument } from '@warp-drive-mirror/core/types/request';
+import type { ResourceDocument } from '@warp-drive-mirror/core/types/spec/document';
+import type { ExistingResourceObject } from '@warp-drive-mirror/core/types/spec/json-api-raw';
+/**
+ * Retrieve the configured IndexedDB database instance
+ *
+ */
+export declare function getCache(): Promise<IDBDatabase>;
+/**
+ * Retrieve a previously cached request from the IndexedDB database
+ * if one exists.
+ *
+ * If the request is found, the associated resources will also be
+ * loaded from the cache and added to the response.
+ *
+ * If any resource is not found in the cache, the result will be null.
+ *
+ */
+export declare function getCachedRequest(db: IDBDatabase, lid: string): Promise<StructuredDocument<ResourceDocument<ExistingResourceObject & ExistingRecordIdentifier>> | null>;
+//# sourceMappingURL=db.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"db.d.ts","sourceRoot":"","sources":["../../src/persisted-cache/db.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,mCAAmC,CAAC;AAClF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AACzE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sCAAsC,CAAC;AAC7E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,0CAA0C,CAAC;AASvF;;;GAGG;AACH,wBAAsB,QAAQ,IAAI,OAAO,CAAC,WAAW,CAAC,CAgBrD;AA0ED;;;;;;;;;GASG;AACH,wBAAsB,gBAAgB,CACpC,EAAE,EAAE,WAAW,EACf,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,kBAAkB,CAAC,gBAAgB,CAAC,sBAAsB,GAAG,wBAAwB,CAAC,CAAC,GAAG,IAAI,CAAC,CAiEzG"}

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

@@ -0,0 +1,10 @@
+import type { StoreRequestContext } from '@warp-drive-mirror/core';
+import type { Future, Handler, NextFn } from '@warp-drive-mirror/core/request';
+import type { StructuredDataDocument } from '@warp-drive-mirror/core/types/request';
+/**
+ * A Handler that resolves requests from the persisted cache.
+ */
+export declare class PersistedFetch implements Handler {
+    request<T>(context: StoreRequestContext, next: NextFn<T>): Future<T> | Promise<StructuredDataDocument<T>>;
+}
+//# sourceMappingURL=fetch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fetch.d.ts","sourceRoot":"","sources":["../../src/persisted-cache/fetch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAS,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AACnE,OAAO,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,0BAA0B,CAAC;AAExE,OAAO,KAAK,EAEV,sBAAsB,EAEvB,MAAM,gCAAgC,CAAC;AAKxC;;GAEG;AACH,qBAAa,cAAe,YAAW,OAAO;IAC5C,OAAO,CAAC,CAAC,EAAE,OAAO,EAAE,mBAAmB,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAAC,CAAC,CAAC;CAsE1G"}

package/declarations/persisted-cache.d.ts

@@ -0,0 +1,2 @@
+export { PersistedCache } from './persisted-cache/cache';
+//# sourceMappingURL=persisted-cache.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"persisted-cache.d.ts","sourceRoot":"","sources":["../src/persisted-cache.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC"}

package/declarations/worker-fetch.d.ts

@@ -0,0 +1,2 @@
+export { WorkerFetch } from './data-worker/fetch';
+//# sourceMappingURL=worker-fetch.d.ts.map

package/declarations/worker-fetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-fetch.d.ts","sourceRoot":"","sources":["../src/worker-fetch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/data-worker.js

@@ -1,5 +1,5 @@
 import { D as DocumentStorage } from "./index-CGCX7hY2.js";
-import { SkipCache } from '@warp-drive-mirror/core-types/request';
+import { SkipCache } from '@warp-drive-mirror/core/types/request';
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
 const WorkerScope = globalThis.SharedWorkerGlobalScope;
 class DataWorker {
@@ -194,7 +194,6 @@ function cloneError(error) {
  * A simplified CacheHandler that hydrates ResourceDataDocuments from the cache
  * with their referenced resources.
  *
- * @typedoc
  */
 const CacheHandler = {
   request(context, next) {