@procedures/store 0.2.2 → 0.3.0

package/dist/storage/hybrid.d.ts

@@ -1,48 +1,76 @@
 /**
  * Hybrid Storage Implementation
  *
- * Combines local cache (InMemoryStorage) with remote persistence (ApiStorage).
- * Provides fast local reads with remote backup and sync.
+ * A local copy (an `InMemoryStorage`, or the `local` storage that the application gives) in
+ * front of a remote `CollectionStorage` (often an `ApiStorage`). The storage has four modes, and
+ * `setMode()` changes the mode while the storage operates (roadmap R28):
  *
- * Features:
- * - Local cache for fast reads, with a remote read on a miss
- * - Write-through or write-back strategies
- * - Automatic sync on initialization
- * - Conflict resolution
- * - Offline operation queue
+ * | Mode | Reads | Writes | Remote calls |
+ * |---|---|---|---|
+ * | `local-only` | the local copy | the local copy and the queue | none |
+ * | `write-through` | the local copy, the remote on a miss | the local copy, then the remote | yes |
+ * | `write-back` | the local copy, the remote on a miss | the local copy and the queue, a timer sends it | yes |
+ * | `remote-only` | the remote | the remote | yes, and no local copy |
+ *
+ * - The queue is durable through the `queueStore` that the application gives.
+ * - A sync asks for the changes since a version when the remote has `getChangesSince`.
+ * - With `versionOf`, a conflict is a change on both sides, and `conflictResolution` decides.
+ * - `pullInterval` keeps the local copy fresh.
  */
 import type { CollectionStorage, StorageMetadata } from "@procedures/collections";
+import { type Duration } from "@procedures/client";
+import { type QueueStore } from "./queue.js";
 /**
  * Conflict resolution strategy.
  */
 export type ConflictResolution = "local" | "remote" | "merge" | "error";
 /**
  * Write strategy for hybrid storage.
+ * @deprecated Use `HybridMode`: the strategies are two of its modes.
  */
 export type WriteStrategy = "write-through" | "write-back";
+/**
+ * The mode of a `HybridStorage` (roadmap R28).
+ *
+ * - `local-only`: the storage makes no remote call. Each write goes to the local copy and to the
+ *   queue, so a later switch to a remote mode sends it.
+ * - `write-through`: each write goes to the local copy, then to the remote.
+ * - `write-back`: each write goes to the local copy and to the queue. A timer sends the queue.
+ * - `remote-only`: each read and each write goes to the remote. The storage keeps no local copy.
+ */
+export type HybridMode = "local-only" | "write-through" | "write-back" | "remote-only";
 /**
  * Hybrid storage configuration options.
  */
 export interface HybridStorageOptions {
     /**
-     * Write strategy
-     * - write-through: Write to both local and remote immediately
-     * - write-back: Write to local immediately, sync to remote later
+     * The first mode. `setMode()` changes it later.
      * @default "write-through"
      */
+    mode?: HybridMode;
+    /**
+     * The first mode, with its old name. `mode` comes first when both are given.
+     * @deprecated Use `mode`.
+     */
     writeStrategy?: WriteStrategy;
     /**
      * Conflict resolution strategy
      * - local: Local changes win
      * - remote: Remote changes win
      * - merge: Custom merge function (requires mergeFn)
-     * - error: Throw error on conflict
+     * - error: The sync throws `ConflictError` with the ids, and changes nothing for them
+     *
+     * With `versionOf`, a conflict is a queued local write of an id whose remote version changed
+     * after the last version that the storage saw. A queued write of an id without a known remote
+     * version wins. Without `versionOf`, a conflict is a local value that differs from the remote
+     * value, with no queued write: a queued write always wins.
      * @default "remote"
      */
     conflictResolution?: ConflictResolution;
     /**
      * Custom merge function for conflict resolution.
-     * Only used when conflictResolution is "merge".
+     * Only used when conflictResolution is "merge". A conflict where one side deleted the item
+     * keeps the local side.
      *
      * @param local - Local version
      * @param remote - Remote version
@@ -55,28 +83,126 @@ export interface HybridStorageOptions {
      */
     keyOf?: (item: any) => string | undefined;
     /**
-     * Automatic sync interval in milliseconds (for write-back mode).
-     * Set to 0 to disable automatic sync.
-     * @default 5000 (5 seconds)
+     * The version of an item, for example its ETag or a revision field (roadmap R28). The sync
+     * compares the versions, not the JSON of the values. A remote change of an id with a queued
+     * local write is a conflict.
      */
-    syncInterval?: number;
+    versionOf?: (item: any) => string | undefined;
     /**
-     * Initialize by syncing from remote on construction.
+     * Automatic sync interval (for write-back mode), for example `seconds(5)`.
+     * Set to 0 to disable automatic sync. In write-through mode, it is also the delay before the
+     * storage sends the queue after a failure (5 seconds when it is 0).
+     * @default 5 seconds
+     */
+    syncInterval?: Duration;
+    /**
+     * The interval of the periodic pull, for example `minutes(1)` (roadmap R28). A pull reads the
+     * remote changes into the local copy in the modes `write-through` and `write-back`.
+     * @default no periodic pull
+     */
+    pullInterval?: Duration;
+    /**
+     * Initialize by syncing from remote on construction: send the loaded queue, then read the
+     * remote. The mode `local-only` makes no remote call.
      * @default true
      */
     syncOnInit?: boolean;
     /**
-     * Maximum offline operations to queue.
+     * Maximum offline operations to queue. A full queue refuses the next write.
      * @default 1000
      */
     maxOfflineOps?: number;
     /**
-     * Enable offline operation queue.
-     * When remote is unavailable, operations are queued and retried.
+     * The queue of the write-through mode.
+     * In write-through mode, a write that the remote cannot take stays in the local cache and the
+     * queue, and the write throws `PendingWriteError`. A timer sends the queue later.
+     * Without the queue, the write is undone in the local cache and the write throws.
+     * The modes `write-back` and `local-only` always use the queue.
      * @default true
      */
     offlineQueue?: boolean;
+    /**
+     * The store that keeps the queue (roadmap R28). A new storage with the same store loads the
+     * queue again and sends it. `FileQueueStore` of `@procedures/store/file-queue` keeps it in a
+     * file.
+     * @default a new `MemoryQueueStore`
+     */
+    queueStore?: QueueStore;
+    /**
+     * True when an error of the remote means "not available now", so the write can wait in the
+     * queue. Another error (a refusal of the remote) undoes the write. The default: an error with
+     * `retryable: true`, or an error without a `code`.
+     */
+    isUnavailable?: (error: unknown) => boolean;
+    /**
+     * The storage of the local copy (roadmap R45). A durable storage, for example `SqliteStorage`
+     * of `@procedures/sqlite`, keeps the local copy after a restart. Then a new storage in
+     * `local-only` mode reads the items of the last run. Give it with a durable `queueStore`.
+     * `close()` closes it.
+     * @default a new `InMemoryStorage`
+     */
+    local?: LocalCopyStorage<any>;
 }
+/**
+ * The remote did not take a write of the write-through mode. The write is in the local cache and
+ * in the queue, and the storage sends it later (roadmap R2). `cause` is the error of the remote.
+ */
+export declare class PendingWriteError extends Error {
+    readonly name = "PendingWriteError";
+    readonly code = "WRITE_PENDING";
+    readonly pending = true;
+    constructor(operation: string, cause: unknown);
+}
+/** The queue of operations is full, so the storage refuses the write (roadmap R2). */
+export declare class QueueFullError extends Error {
+    readonly name = "QueueFullError";
+    readonly code = "QUEUE_FULL";
+    constructor(max: number);
+}
+/** The remote gave items without a key, so a sync cannot know which local items to keep. */
+export declare class MissingKeysError extends Error {
+    readonly name = "MissingKeysError";
+    readonly code = "MISSING_KEYS";
+    constructor(count: number);
+}
+/**
+ * The queue store failed (roadmap R28). A write that the store did not keep is undone and not
+ * acknowledged. A storage whose store cannot load refuses each operation.
+ */
+export declare class QueueStoreError extends Error {
+    readonly name = "QueueStoreError";
+    readonly code = "QUEUE_STORE";
+    constructor(action: "load" | "write", cause: unknown);
+}
+/**
+ * The sync found conflicts and `conflictResolution` is "error" (roadmap R28). The local values and
+ * their queued writes stay. `ids` are the ids of the conflicts.
+ */
+export declare class ConflictError extends Error {
+    readonly ids: string[];
+    readonly name = "ConflictError";
+    readonly code = "SYNC_CONFLICT";
+    constructor(ids: string[]);
+}
+/**
+ * `setMode()` could not change the mode (roadmap R28). The mode did not change. `cause` is the
+ * error of the flush or of the sync.
+ */
+export declare class ModeSwitchError extends Error {
+    readonly from: HybridMode;
+    readonly to: HybridMode;
+    readonly name = "ModeSwitchError";
+    readonly code = "MODE_SWITCH_FAILED";
+    constructor(from: HybridMode, to: HybridMode, cause: unknown);
+}
+/**
+ * A storage for the local copy of a `HybridStorage` (roadmap R45): a collection storage that gives
+ * its entries. A durable one, for example `SqliteStorage` of `@procedures/sqlite`, keeps the local
+ * copy after a restart.
+ */
+export type LocalCopyStorage<T> = CollectionStorage<T> & {
+    getEntries(): Promise<Array<[string, T]>>;
+};
 /**
  * Hybrid storage combining local cache with remote persistence.
  *
@@ -88,9 +214,9 @@ export interface HybridStorageOptions {
  *
  * const remote = new ApiStorage(client, { collection: "users" });
  * const hybrid = new HybridStorage(remote, {
- *   writeStrategy: "write-through",
+ *   mode: "write-through",
  *   conflictResolution: "remote",
- *   syncInterval: 5000
+ *   syncInterval: seconds(5)
  * });
  *
  * // Fast local reads
@@ -98,44 +224,136 @@ export interface HybridStorageOptions {
  *
  * // Writes go to both local and remote
  * await hybrid.set("123", { name: "John" });
+ *
+ * // Offline: no remote call. The writes wait in the queue.
+ * await hybrid.setMode("local-only");
+ * // Online again: the switch sends the queue, then syncs the local copy
+ * await hybrid.setMode("write-through");
  * ```
  */
 export declare class HybridStorage<T> implements CollectionStorage<T> {
-    private local;
-    private remote;
+    private readonly local;
+    private readonly remote;
+    private readonly queueStore;
     private options;
+    private mode;
     private offlineOps;
+    /** The operations in `offlineOps` that the queue store does not have yet */
+    private readonly unpersisted;
+    /** True when the queue store can differ from `offlineOps`: a failed write, or sent operations */
+    private storeDirty;
+    /** The calls of the queue store, one at a time */
+    private storeChain;
+    /** The push timer of the write-back mode */
     private syncTimer;
+    /** The periodic pull */
+    private pullTimer;
+    /** True while pushQueue sends the queue: the first operation can be on its way */
+    private pushing;
+    /** The timer that sends the queue of the write-through mode after a failure */
+    private drainTimer;
+    /** The load of the queue. The writes wait for it. */
+    private readonly loaded;
+    /** The load and the first sync. The reads wait for it, so a read never sees an empty cache by mistake. */
+    private readonly ready;
+    /** The error of the load (of the queue store, or of the local copy): the storage refuses each operation */
+    private loadError;
+    /** A mode switch that runs. The operations wait for it. */
+    private gate;
+    /** The operations that run, and the switches that wait for them to end */
+    private active;
+    private idleWaiters;
     private isOnline;
+    private closed;
     /** A counter of local writes for each id, so a sync does not restore an older remote value */
     private readonly writeVersions;
     private clearVersion;
     /** The running sync: syncs run one at a time */
     private syncChain;
+    /** The remote version of the last delta pull */
+    private cursor;
+    /** True when the remote has `getChangesSince` but its server does not know `changes` */
+    private changesUnsupported;
+    /** With `versionOf`: the last known remote version of each id. `null`: the remote has no item. */
+    private readonly bases;
     private stats;
     constructor(remote: CollectionStorage<T>, options?: HybridStorageOptions);
+    /** The mode of the storage now. */
+    getMode(): HybridMode;
+    /**
+     * This method changes the mode while the storage operates (roadmap R28).
+     *
+     * - The switch waits for the operations that run. The operations that start later wait for
+     *   the switch. Switches and syncs run one at a time.
+     * - A switch to a remote mode sends the queue first. A switch to `local-only` makes no remote
+     *   call: the queue stays until the next remote mode.
+     * - A switch to `remote-only` drops the local copy, after the queue reached the remote.
+     * - A switch from `local-only` or `remote-only` to a mode with a local copy syncs the local
+     *   copy. The reads wait for the sync.
+     * - When the flush or the sync fails, the mode does not change, and the switch throws
+     *   `ModeSwitchError`.
+     */
+    setMode(mode: HybridMode): Promise<void>;
+    private switchTo;
+    /** This method drops the local copy. A read in flight does not fill it again. */
+    private dropLocal;
+    /** This method makes the local copy from the queue only, before a full sync. */
+    private rebuildLocal;
+    /** This method starts and stops the timers for the mode. */
+    private updateTimers;
     /**
      * The local item, or else the remote item (which the cache then keeps). When the remote
-     * cannot answer, the storage is offline and the result is undefined.
+     * cannot answer, the storage is offline and the result is undefined. In `local-only` mode, a
+     * miss is undefined. In `remote-only` mode, the remote answers, and its error passes through.
      */
     get(id: string): Promise<T | undefined>;
     getAll(): Promise<T[]>;
+    /** Every item with its id. */
+    getEntries(): Promise<Array<[string, T]>>;
     find(predicate: (item: T) => boolean): Promise<T[]>;
     has(id: string): Promise<boolean>;
     size(): Promise<number>;
+    getBatch(ids: string[]): Promise<Map<string, T>>;
+    /** A read of the remote-only mode. A queue that a restart loaded reaches the remote first. */
+    private remoteRead;
     set(id: string, value: T): Promise<void>;
     delete(id: string): Promise<boolean>;
     clear(): Promise<void>;
     setBatch(items: Array<[string, T]>): Promise<void>;
     deleteBatch(ids: string[]): Promise<number>;
-    getBatch(ids: string[]): Promise<Map<string, T>>;
     /**
-     * Sync all data from remote to local.
-     * Handles conflicts according to conflict resolution strategy.
+     * One write, in the mode of the storage. The result is the result of the local copy, or of the
+     * remote in `remote-only` mode.
+     *
+     * - `remote-only`: the remote only. Its error passes through.
+     * - `write-back` and `local-only`: the local copy and the queue. A full queue refuses the write
+     *   before the local change. The queue store keeps the operation before the write ends.
+     * - `write-through`, the remote refuses the write: the local change is undone, and the error
+     *   of the remote passes through.
+     * - `write-through`, the remote is not available: with the queue, the write waits in it, a timer
+     *   sends it later, and the write throws `PendingWriteError`. Without the queue, or with a full
+     *   queue, the local change is undone.
      *
-     * - Each remote item goes into the cache under `keyOf(item)`.
+     * Before, a failed write-through stayed in the local cache and in the queue, no timer sent the
+     * queue, a second try queued the operation again, and a full queue dropped the oldest operation
+     * without a word (roadmap R2).
+     */
+    private write;
+    /**
+     * The local values of the ids before a write, and a function that puts them back. It puts back
+     * only the ids that no later write changed.
+     */
+    private snapshot;
+    /**
+     * Sync from the remote to the local copy, in the modes `write-through` and `write-back`. The
+     * other modes have no local copy to sync (`remote-only`) or make no remote call (`local-only`):
+     * the call does nothing.
+     *
+     * - The sync asks for the changes since the version of the last sync when the remote has
+     *   `getChangesSince`. Else it reads all entries.
+     * - Each remote item goes into the cache under its id.
      * - A local item that the remote does not have is removed, unless a queued local operation
-     *   changes it (the remote deleted it).
+     *   changes it.
      * - An id that a local write changed during the sync keeps the local value: the remote value
      *   is older.
      * - Syncs run one at a time.
@@ -144,43 +362,138 @@ export declare class HybridStorage<T> implements CollectionStorage<T> {
     /**
      * Sync all pending offline operations to remote.
      * Processes queued operations in order. When one fails, it and the later operations stay in
-     * the queue: the operations that reached the remote are not sent again.
+     * the queue: the operations that reached the remote are not sent again. In `local-only` mode,
+     * the call does nothing.
      */
     syncToRemote(): Promise<void>;
+    /**
+     * This method sends the queue to the remote (roadmap R28). `ProcedureServer.useStorage` uses it. In
+     * `local-only` mode, it sends nothing: the queue waits for a remote mode.
+     */
+    flush(): Promise<void>;
     /**
      * Force a full sync (both directions).
      */
     sync(): Promise<void>;
+    /**
+     * This method stops the timers, sends the queue (not in `local-only` mode), and closes the remote and the
+     * local copy. The queue store keeps the operations that the remote did not take. A durable local
+     * copy keeps its items.
+     */
     close(): Promise<void>;
     getMetadata(): Promise<StorageMetadata>;
+    /**
+     * This method starts a public operation: after the load of the queue (a write) or the first sync (a read),
+     * and never during a mode switch.
+     */
+    private run;
+    /** A promise that resolves when no operation runs. */
+    private idle;
+    /** This method loads the queue, and puts its writes in the local copy. */
+    private loadQueue;
+    /** The first sync: send the loaded queue, then read the remote. */
+    private initialSync;
+    /** This method applies a queued operation to the local copy. */
+    private applyToLocal;
+    /**
+     * One pull. `full`: ask for all items (after the local copy was dropped).
+     *
+     * - The versions of the local writes at the start: a write during the pull keeps its value.
+     * - The cursor moves only after a pull without conflicts, so a conflict of the "error" policy
+     *   comes again at the next pull.
+     */
     private pullRemote;
+    /**
+     * The remote changes: since the cursor from `getChangesSince` when the remote has it, or else
+     * all entries.
+     */
+    private fetchChanges;
+    /** This method applies one remote item. It gives true when the queue changed. */
+    private pullItem;
+    /** This method applies one remote delete. It gives true when the queue changed. */
+    private pullDelete;
+    /**
+     * A queued local write of an id whose remote version changed: a conflict, and the policy
+     * decides. True when the queue changed.
+     */
+    private resolvePending;
+    /**
+     * This method removes an id from the queued operations. It gives false when a queued clear touches it: nothing
+     * changes then.
+     */
+    private dropQueued;
+    /**
+     * The remote items with their ids: from `getEntries()` when the remote has it, or else from
+     * `getAll()` and `keyOf`. An item without a key stops the sync before any change. Before, the
+     * sync skipped such items and then deleted each local item that the remote list did not have,
+     * so the remote list without ids emptied the cache (roadmap R2).
+     */
+    private remoteEntries;
+    /**
+     * This method sends the queue. The operations that reached the remote leave the queue. The queue store
+     * gets the change at the end.
+     */
     private pushQueue;
     /** Run syncs one at a time. */
     private serialize;
-    private localIds;
     private bump;
-    private versionOf;
+    /** The count of local writes of an id: it changes with each write and each clear. */
+    private writeKey;
+    private versionOfItem;
+    /** This method records the remote version of an id that the storage read. */
+    private noteBase;
+    /** This method records the remote versions after a write reached the remote. */
+    private noteRemoteWrite;
+    /**
+     * This method puts in the operation the remote version that it changes, for each id: the version that an
+     * older queued operation of the id writes, or else the known remote version. A storage that
+     * loads the queue after a restart takes the version of the first operation of each id.
+     */
+    private attachBase;
+    /** The remote version of an id after the queued operations, or undefined when it is not known. */
+    private expectedBase;
     private hasPendingOp;
     /**
      * Resolve conflict between local and remote versions.
      */
     private resolveConflict;
     /**
-     * Queue operation for later sync.
+     * This method puts an operation in the queue, then in the queue store. The write ends only after the store
+     * kept it. When the store fails, the operation leaves the queue, the local change is undone,
+     * and the write throws `QueueStoreError`.
+     *
+     * A set or a delete of one id replaces the queued set or delete of that id, when no later
+     * operation touches the id: a second try of a write does not queue it two times.
      */
-    private queueOperation;
+    private enqueue;
     /**
-     * Execute a queued operation against remote storage.
+     * This method writes one operation to the queue store: an append when the store holds each operation
+     * before it, or else the whole queue. On a failure, `rollback` removes the operation from the
+     * queue before the next call of the store.
      */
-    private executeOperation;
+    private persist;
+    /** This method writes the whole queue to the queue store when the store can differ from the queue. */
+    private persistAll;
     /**
-     * Handle remote operation failure.
+     * Before a write goes to the remote directly, the queue store must not hold a sent operation:
+     * after a restart, it would replace this newer write.
      */
-    private handleRemoteFailure;
+    private ensureStoreClean;
+    /** The index of the queued operation that `op` replaces, or -1. */
+    private replaceableIndex;
+    /** True when the queue can take the operation. */
+    private hasQueueRoom;
+    /** A full queue refuses the write. Before, it dropped the oldest operation (roadmap R2). */
+    private ensureQueueRoom;
     /**
-     * Start periodic background sync.
+     * In write-through mode, a timer sends the queue after a failure, and again after each failed
+     * send, until the queue is empty.
      */
-    private startPeriodicSync;
+    private scheduleDrain;
+    /**
+     * Execute a queued operation against remote storage.
+     */
+    private executeOperation;
     /**
      * Get current online status.
      */

package/dist/storage/hybrid.d.ts.map

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