@warp-drive-mirror/json-api 5.10.0-alpha.0 → 5.10.0-alpha.10

package/dist/index.d.ts

@@ -12,19 +12,109 @@ import { CollectionResourceDataDocument, ResourceDocument, ResourceErrorDocument
 import { ApiError } from "@warp-drive-mirror/core/types/spec/error";
 import { CollectionResourceDocument, ExistingResourceObject, ResourceObject, SingleResourceDocument } from "@warp-drive-mirror/core/types/spec/json-api-raw";
 //#region src/-private/cache.d.ts
+/** One attributes hash on a {@link CachedResource}: a **layer** a projection is read through. */
+type AttrHash = Record<string, Value | undefined>;
+/**
+ * The cache's entry for a single resource: its id, its attribute values split
+ * across four **layers**, and the flags tracking where it sits in the
+ * create/update/delete lifecycle.
+ *
+ * A **projection** answers "what is this field's value" by reading a stack of
+ * layers top-down; the first layer holding the field wins. The two projections,
+ * with their resolution orders:
+ *
+ * - **remote state**, what the _immutable_ record reads:
+ *   {@link RESOLUTION_ORDER_REMOTE_STATE}
+ * - **local state**, what an _editable_ copy reads:
+ *   {@link RESOLUTION_ORDER_LOCAL_STATE}
+ *
+ * Local state is remote state with the uncommitted mutations laid over it. The
+ * guides call those mutations "the diff"; here they are simply the top layers of
+ * local state, {@link CachedResource.localAttrs | localAttrs} and
+ * {@link CachedResource.inflightAttrs | inflightAttrs}.
+ *
+ * A field is **dirty** while `localAttrs` or `inflightAttrs` holds it. A save
+ * **commits** the mutation: `didCommit` merges the in-flight values into
+ * `remoteAttrs` and removes them from `inflightAttrs`. A push carrying the same
+ * value as a pending edit in `localAttrs` has the same effect on that edit: the
+ * server already holds it, so it is removed from `localAttrs`. "Same value" is
+ * decided by the field's schema: a schema-object with an identity hash compares
+ * by that hash, everything else by reference.
+ *
+ * Thus, a dirty field reads as mutated for local readers only, and goes on doing
+ * so while its save is in flight.
+ *
+ * @internal
+ */
 interface CachedResource {
+  /** The resource's id, once one is known. */
   id: string | null;
-  remoteAttrs: Record<string, Value | undefined> | null;
-  localAttrs: Record<string, Value | undefined> | null;
-  defaultAttrs: Record<string, Value | undefined> | null;
-  inflightAttrs: Record<string, Value | undefined> | null;
-  changes: Record<string, [Value | undefined, Value]> | null;
+  /**
+   * The top layer of local state: uncommitted mutations, held apart from remote
+   * state. Any field with an entry here is dirty. Along with `inflightAttrs`,
+   * this is what the guides call "the diff".
+   *
+   * Starting a save moves these into `inflightAttrs`, so any further
+   * mutation accumulates here afresh without disturbing the request already
+   * in flight.
+   */
+  localAttrs: AttrHash | null;
+  /**
+   * The middle layer of local state: the mutations an in-progress save is
+   * carrying.
+   *
+   * Completing a save merges these into
+   * {@link CachedResource.remoteAttrs | remoteAttrs} and clears this —
+   * committing them. A rejected save moves them back into `localAttrs`
+   * instead, without overwriting any newer edit made while it was in flight.
+   */
+  inflightAttrs: AttrHash | null;
+  /** The top layer of remote state and the data layer beneath local state: the last known persisted values. */
+  remoteAttrs: AttrHash | null;
+  /**
+   * The bottom layer of both projections, consulted for fields no other layer
+   * holds. Only one kind of schema default is stored here: the result of a
+   * legacy `defaultValue()` *function*, memoized because the function returns a
+   * fresh value per call and the record must keep reading the same one. A
+   * primitive `options.defaultValue` or a transformation's `defaultValue()` is
+   * recomputed on every read instead. Never committed; an entry is dropped once
+   * the field gets a real value, whether from a local edit or from a merge into
+   * `remoteAttrs`.
+   */
+  defaultAttrs: AttrHash | null;
+  /**
+   * Errors from the most recent rejected save. A successful commit clears
+   * them.
+   */
   errors: ApiError[] | null;
+  /**
+   * Whether this record was created locally and has never been persisted.
+   *
+   * A payload arriving for it (or a successful commit) clears the flag.
+   */
   isNew: boolean;
+  /**
+   * Whether this record is marked for deletion. Records the intent only;
+   * see {@link CachedResource.isDeletionCommitted | isDeletionCommitted} for
+   * whether the server has acted on it.
+   */
   isDeleted: boolean;
+  /**
+   * Whether the deletion is final: the server acknowledged it, or the record
+   * was never persisted and has been rolled back.
+   *
+   * Tracked separately from {@link CachedResource.isDeleted | isDeleted}
+   * because the two imply different cleanup: a *committed* deletion has already
+   * been announced as removed, so unloading the record must not announce it a
+   * second time.
+   */
   isDeletionCommitted: boolean;
   /**
-   * debugging only
+   * The relationship state a save is carrying, retained so `DEBUG` builds can
+   * assert the response agrees with what was sent. Only populated in `DEBUG`
+   * builds, and only while the
+   * `DEPRECATE_RELATIONSHIP_REMOTE_UPDATE_CLEARING_LOCAL_STATE` deprecation is
+   * resolved.
    *
    * @internal
    */
@@ -52,7 +142,7 @@ interface CachedResource {
  *
  * @public
  */
-declare class JSONAPICache implements Cache {
+export declare class JSONAPICache implements Cache {
   /**
    * The Cache Version that this implementation implements.
    *
@@ -73,9 +163,9 @@ declare class JSONAPICache implements Cache {
   /**
    * Cache the response to a request
    *
-   * Implements `Cache.put`.
+   * Implements {@link Cache.put | Cache.put}.
    *
-   * Expects a StructuredDocument whose `content` member is a JsonApiDocument.
+   * Expects a {@link StructuredDocument} whose `content` member is a JsonApiDocument.
    *
    * ```js
    * cache.put({
@@ -123,6 +213,16 @@ declare class JSONAPICache implements Cache {
    * Update the "remote" or "canonical" (persisted) state of the Cache
    * by merging new information into the existing state.
    *
+   * @example
+   * ```ts
+   * cache.patch({
+   *   op: 'update',
+   *   record: identifier,
+   *   field: 'name',
+   *   value: 'Chris',
+   * });
+   * ```
+   *
    * @category Cache Management
    * @public
    * @param op the operation or list of operations to perform
@@ -131,6 +231,16 @@ declare class JSONAPICache implements Cache {
   /**
    * Update the "local" or "current" (unpersisted) state of the Cache
    *
+   * @example
+   * ```ts
+   * cache.mutate({
+   *   op: 'replaceRelatedRecord',
+   *   record: identifier,
+   *   field: 'author',
+   *   value: authorIdentifier,
+   * });
+   * ```
+   *
    * @category Cache Management
    * @public
    */
@@ -155,8 +265,8 @@ declare class JSONAPICache implements Cache {
    * 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`
+   * This generally takes the place of {@link JSONAPICache.getAttr | getAttr} as
+   * an API and may even take the place of {@link JSONAPICache.getRelationship | getRelationship}
    * depending on implementation specifics, though this
    * latter usage is less recommended due to the advantages
    * of the Graph handling necessary entanglements and
@@ -171,6 +281,12 @@ declare class JSONAPICache implements Cache {
    * the various internal WarpDrive bookkeeping fields.
    * :::
    *
+   * @example
+   * ```ts
+   * const resource = cache.peek(identifier);
+   * const document = cache.peek(requestKey);
+   * ```
+   *
    * @category Cache Management
    * @public
    */
@@ -179,6 +295,12 @@ declare class JSONAPICache implements Cache {
   /**
    * Peek the remote resource data from the Cache.
    *
+   * @example
+   * ```ts
+   * const resource = cache.peekRemoteState(identifier);
+   * const document = cache.peekRemoteState(requestKey);
+   * ```
+   *
    * @category Cache Management
    * @public
    */
@@ -188,9 +310,14 @@ declare class JSONAPICache implements Cache {
    * Peek the Cache for the existing request data associated with
    * a cacheable request.
    *
-   * This is effectively the reverse of `put` for a request in
+   * This is effectively the reverse of {@link JSONAPICache.put | put} for a request in
    * that it will return the the request, response, and content
-   * whereas `peek` will return just the `content`.
+   * whereas {@link JSONAPICache.peek | peek} will return just the `content`.
+   *
+   * @example
+   * ```ts
+   * const doc = cache.peekRequest(requestKey);
+   * ```
    *
    * @category Cache Management
    * @public
@@ -199,9 +326,20 @@ declare class JSONAPICache implements Cache {
   /**
    * Push resource data from a remote source into the cache for this identifier
    *
+   * @example
+   * ```ts
+   * cache.upsert(identifier, {
+   *   type: 'user',
+   *   id: '1',
+   *   attributes: { name: 'Chris' },
+   * });
+   * ```
+   *
    * @category Cache Management
    * @public
-   * @return if `calculateChanges` is true then calculated key changes should be returned
+   * @return when `calculateChanges` is true, the names of the attributes whose persisted value
+   *   this push changed (the same keys the `'remote'` channel is notified with), or `undefined`
+   *   when none did. Otherwise `void`.
    */
   upsert(identifier: ResourceKey, data: ExistingResourceObject, calculateChanges?: boolean): void | string[];
   /**
@@ -232,7 +370,7 @@ declare class JSONAPICache implements Cache {
    *
    * Each individual resource or document that has
    * been mutated should be described as an individual
-   * `Change` entry in the returned array.
+   * {@link 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
@@ -291,6 +429,11 @@ declare class JSONAPICache implements Cache {
    * It returns properties from options that should be set on the record during the create
    * process. This return value behavior is deprecated.
    *
+   * @example
+   * ```ts
+   * cache.clientDidCreate(identifier, { name: 'Chris' });
+   * ```
+   *
    * @category Resource Lifecycle
    * @public
    */
@@ -299,6 +442,11 @@ declare class JSONAPICache implements Cache {
    * [LIFECYCLE] Signals to the cache that a resource
    * will be part of a save transaction.
    *
+   * @example
+   * ```ts
+   * cache.willCommit(identifier, context);
+   * ```
+   *
    * @category Resource Lifecycle
    * @public
    */
@@ -307,16 +455,26 @@ declare class JSONAPICache implements Cache {
    * [LIFECYCLE] Signals to the cache that a resource
    * was successfully updated as part of a save transaction.
    *
+   * @example
+   * ```ts
+   * cache.didCommit(identifier, result);
+   * ```
+   *
    * @category Resource Lifecycle
    * @public
    */
-  didCommit(committedIdentifier: ResourceKey, result: StructuredDataDocument<SingleResourceDataDocument> | null): SingleResourceDataDocument;
-  didCommit(committedIdentifier: ResourceKey[], result: StructuredDataDocument<SingleResourceDataDocument> | null): SingleResourceDataDocument;
-  didCommit(committedIdentifier: ResourceKey[], result: StructuredDataDocument<CollectionResourceDataDocument> | null): CollectionResourceDataDocument;
+  didCommit(committedIdentifier: ResourceKey, result: StructuredDataDocument<SingleResourceDataDocument<ExistingResourceObject, ExistingResourceObject>> | null): SingleResourceDataDocument;
+  didCommit(committedIdentifier: ResourceKey[], result: StructuredDataDocument<SingleResourceDataDocument<ExistingResourceObject, ExistingResourceObject>> | null): SingleResourceDataDocument;
+  didCommit(committedIdentifier: ResourceKey[], result: StructuredDataDocument<CollectionResourceDataDocument<ExistingResourceObject>> | null): CollectionResourceDataDocument;
   /**
    * [LIFECYCLE] Signals to the cache that a resource
    * was update via a save transaction failed.
    *
+   * @example
+   * ```ts
+   * cache.commitWasRejected(identifier, errors);
+   * ```
+   *
    * @category Resource Lifecycle
    * @public
    */
@@ -327,6 +485,11 @@ declare class JSONAPICache implements Cache {
    *
    * This method is a candidate to become a mutation
    *
+   * @example
+   * ```ts
+   * cache.unloadRecord(identifier);
+   * ```
+   *
    * @category Resource Lifecycle
    * @public
    */
@@ -335,6 +498,12 @@ declare class JSONAPICache implements Cache {
    * Retrieve the data for an attribute from the cache
    * with local mutations applied.
    *
+   * @example
+   * ```ts
+   * const name = cache.getAttr(identifier, 'name');
+   * const zip = cache.getAttr(identifier, ['address', 'zip']);
+   * ```
+   *
    * @category Resource Data
    * @public
    */
@@ -342,6 +511,11 @@ declare class JSONAPICache implements Cache {
   /**
    * Retrieve the remote data for an attribute from the cache
    *
+   * @example
+   * ```ts
+   * const name = cache.getRemoteAttr(identifier, 'name');
+   * ```
+   *
    * @category Resource Data
    * @public
    */
@@ -351,12 +525,35 @@ declare class JSONAPICache implements Cache {
    *
    * This method is a candidate to become a mutation
    *
+   * @example
+   * ```ts
+   * cache.setAttr(identifier, 'name', 'Chris');
+   * ```
+   *
    * @category Resource Data
    * @public
    */
   setAttr(identifier: ResourceKey, attr: string | string[], value: Value): void;
   /**
-   * Query the cache for the changed attributes of a resource.
+   * Query the cache for the changed attributes of a resource: every unsaved
+   * mutation, as a `[before, after]` pair per field.
+   *
+   * `before` is the value the mutation replaces, which is not always the
+   * persisted one. A mutation a save is carrying replaces remote state; an edit
+   * made while that save is in flight replaces the in-flight value. So this is
+   * what saving from here would change, which is what `serializePatch` and the
+   * legacy `Snapshot` consume, rather than a diff against persisted state.
+   *
+   * Derived from the layers on each call, so it is always consistent with
+   * {@link JSONAPICache.getAttr | getAttr} and
+   * {@link JSONAPICache.rollbackAttrs | rollbackAttrs}. Dirtiness does not go
+   * through here; see {@link JSONAPICache.hasChangedAttrs | hasChangedAttrs}.
+   *
+   * @example
+   * ```ts
+   * const changes = cache.changedAttrs(identifier);
+   * // { name: ['Igor', 'Chris'] }
+   * ```
    *
    * @category Resource Data
    * @public
@@ -366,6 +563,13 @@ declare class JSONAPICache implements Cache {
   /**
    * Query the cache for whether any mutated attributes exist
    *
+   * @example
+   * ```ts
+   * if (cache.hasChangedAttrs(identifier)) {
+   *   // ...
+   * }
+   * ```
+   *
    * @category Resource Data
    * @public
    */
@@ -375,6 +579,11 @@ declare class JSONAPICache implements Cache {
    *
    * This method is a candidate to become a mutation
    *
+   * @example
+   * ```ts
+   * const restoredKeys = cache.rollbackAttrs(identifier);
+   * ```
+   *
    * @category Resource Data
    * @public
    * @return the names of fields that were restored
@@ -383,7 +592,7 @@ declare class JSONAPICache implements Cache {
   /**
 	* Query the cache for the changes to relationships of a resource.
 	*
-	* Returns a map of relationship names to RelationshipDiff objects.
+	* Returns a map of relationship names to {@link RelationshipDiff} objects.
 	*
 	* ```ts
 	* type RelationshipDiff =
@@ -402,6 +611,12 @@ declare class JSONAPICache implements Cache {
 	};
 	```
 	*
+	* @example
+	* ```ts
+	* const diffs = cache.changedRelationships(identifier);
+	* const comments = diffs.get('comments');
+	* ```
+	*
 	* @category Resource Data
 	* @public
 	*/
@@ -409,6 +624,13 @@ declare class JSONAPICache implements Cache {
   /**
    * Query the cache for whether any mutated relationships exist
    *
+   * @example
+   * ```ts
+   * if (cache.hasChangedRelationships(identifier)) {
+   *   // ...
+   * }
+   * ```
+   *
    * @category Resource Data
    * @public
    */
@@ -420,6 +642,11 @@ declare class JSONAPICache implements Cache {
    *
    * This method is a candidate to become a mutation
    *
+   * @example
+   * ```ts
+   * const restoredFields = cache.rollbackRelationships(identifier);
+   * ```
+   *
    * @category Resource Data
    * @public
    * @return the names of relationships that were restored
@@ -428,6 +655,11 @@ declare class JSONAPICache implements Cache {
   /**
    * Query the cache for the current state of a relationship property
    *
+   * @example
+   * ```ts
+   * const relationship = cache.getRelationship(identifier, 'comments');
+   * ```
+   *
    * @category Resource Data
    * @public
    * @return resource relationship object
@@ -436,6 +668,11 @@ declare class JSONAPICache implements Cache {
   /**
    * Query the cache for the remote state of a relationship property
    *
+   * @example
+   * ```ts
+   * const relationship = cache.getRemoteRelationship(identifier, 'comments');
+   * ```
+   *
    * @category Resource Data
    * @public
    * @return resource relationship object
@@ -447,6 +684,11 @@ declare class JSONAPICache implements Cache {
    *
    * This method is a candidate to become a mutation
    *
+   * @example
+   * ```ts
+   * cache.setIsDeleted(identifier, true);
+   * ```
+   *
    * @category Resource State
    * @public
    */
@@ -454,6 +696,11 @@ declare class JSONAPICache implements Cache {
   /**
    * Query the cache for any validation errors applicable to the given resource.
    *
+   * @example
+   * ```ts
+   * const errors = cache.getErrors(identifier);
+   * ```
+   *
    * @category Resource State
    * @public
    */
@@ -461,6 +708,13 @@ declare class JSONAPICache implements Cache {
   /**
    * Query the cache for whether a given resource has any available data
    *
+   * @example
+   * ```ts
+   * if (cache.isEmpty(identifier)) {
+   *   // ...
+   * }
+   * ```
+   *
    * @category Resource State
    * @public
    */
@@ -469,6 +723,13 @@ declare class JSONAPICache implements Cache {
    * Query the cache for whether a given resource was created locally and not
    * yet persisted.
    *
+   * @example
+   * ```ts
+   * if (cache.isNew(identifier)) {
+   *   // ...
+   * }
+   * ```
+   *
    * @category Resource State
    * @public
    */
@@ -477,6 +738,13 @@ declare class JSONAPICache implements Cache {
    * Query the cache for whether a given resource is marked as deleted (but not
    * necessarily persisted yet).
    *
+   * @example
+   * ```ts
+   * if (cache.isDeleted(identifier)) {
+   *   // ...
+   * }
+   * ```
+   *
    * @category Resource State
    * @public
    */
@@ -485,6 +753,13 @@ declare class JSONAPICache implements Cache {
    * Query the cache for whether a given resource has been deleted and that deletion
    * has also been persisted.
    *
+   * @example
+   * ```ts
+   * if (cache.isDeletionCommitted(identifier)) {
+   *   // ...
+   * }
+   * ```
+   *
    * @category Resource State
    * @public
    */
@@ -511,5 +786,4 @@ declare class JSONAPICache implements Cache {
   __peek(identifier: ResourceKey, allowDestroyed: boolean): CachedResource;
 }
 //#endregion
-export { JSONAPICache };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/-private/cache.ts"],"mappings":";;;;;;;;;;;;;;UAkFU;EACR;EACA,aAAa,eAAe;EAC5B,YAAY,eAAe;EAC3B,cAAc,eAAe;EAC7B,eAAe,eAAe;EAC9B,SAAS,gBAAgB,mBAAmB;EAC5C,QAAQ;EACR;EACA;EACA;;;;;;EAOA,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;cAwCb,wBAAwB;;;;;;EAMnC;;EAGA,eAAuB;;EAEvB,SAAiB,IAAI,aAAa;;EAElC,kBAA0B,IAAI,aAAa;;EAE3C,aAAqB,YAAY,mBAAmB;;EAEpD,SAAiB;EAEjB,YAAY,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkD1B,IAAI,UAAU,wBAAwB,KAAK,uBAAuB,KAAK;EACvE,IAAI,UAAU,4BAA4B,KAAK,uBAAuB,KAAK;EAC3E,IAAI,UAAU,uBAAuB,KAAK,wBAAwB,KAAK;EACvE,IAAI,UAAU,sBAAsB,KAAK,uBAAuB,KAAK;;UA6G7D;;UAMA;;UAMA;;UAMA;;;;;;;;;EAoER,MAAM,IAAI,YAAY;;;;;;;EA4BtB,OAAO,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2DjB,KAAK,YAAY,cAAc;EAC/B,KAAK,YAAY,aAAa;;;;;;;EAgE9B,gBAAgB,YAAY,cAAc;EAC1C,gBAAgB,YAAY,aAAa;;;;;;;;;;;;EAmEzC,YAAY,YAAY,aAAa,mBAAmB;;;;;;;;EAWxD,OAAO,YAAY,aAAa,MAAM,wBAAwB;;;;;;;;;;;EA6B9D,QAAQ,QAAQ;;;;;;;;;;;EAchB,MAAM,QAAQ,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqCtB,QAAQ,QAAQ;;;;;;;;;EAgBhB,QAAQ,QAAQ;;;;;;;;;;;;;;;;EAmBhB,QAAQ,QAAQ,0BAA0B;;;;;;;;;;EAiB1C,gBAAgB,YAAY,aAAa,UAAU,eAAe,SAAS;;;;;;;;EA8E3E,WAAW,YAAY,cAAc,eAAe,UAAU;;;;;;;;EAiB9D,UACE,qBAAqB,aACrB,QAAQ,uBAAuB,qCAC9B;EACH,UACE,qBAAqB,eACrB,QAAQ,uBAAuB,qCAC9B;EACH,UACE,qBAAqB,eACrB,QAAQ,uBAAuB,yCAC9B;;;;;;;;EAyEH,kBAAkB,YAAY,cAAc,eAAe,SAAS;;;;;;;;;;EAoBpE,aAAa,YAAY;;;;;;;;EAkFzB,QAAQ,YAAY,aAAa,0BAA0B;;;;;;;EAuE3D,cAAc,YAAY,aAAa,0BAA0B;;;;;;;;;EAmEjE,QAAQ,YAAY,aAAa,yBAAyB,OAAO;;;;;;;;EAuHjE,aAAa,YAAY,cAAc;;;;;;;EAuBvC,gBAAgB,YAAY;;;;;;;;;;EA4B5B,cAAc,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;EA+D1B,qBAAqB,YAAY,cAAc,YAAY;;;;;;;EAU3D,wBAAwB,YAAY;;;;;;;;;;;;EAepC,sBAAsB,YAAY;;;;;;;;EAiBlC,gBAAgB,YAAY,aAAa,gBAAgB,uBAAuB;;;;;;;;EAWhF,sBAAsB,YAAY,aAAa,gBAAgB,uBAAuB;;;;;;;;;;EAiBtF,aAAa,YAAY,aAAa;;;;;;;EAatC,UAAU,YAAY,cAAc;;;;;;;EAUpC,QAAQ,YAAY;;;;;;;;EAYpB,MAAM,YAAY;;;;;;;;EAYlB,UAAU,YAAY;;;;;;;;EAYtB,oBAAoB,YAAY;;;;;;EAUhC,aAAa,YAAY,cAAc;;;;;;;EAavC,WAAW,YAAY,aAAa,0BAA0B;;;;;;;EAc9D,OAAO,YAAY,aAAa,0BAA0B"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/-private/cache.ts"],"mappings":"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"}