@rocicorp/zero 1.11.0-canary.14 → 1.11.0-canary.16

package/out/replicache/src/replicache-impl.js

@@ -174,15 +174,23 @@ var ReplicacheImpl = class {
 	#zero;
 	#closeAbortController = new AbortController();
 	/**
-	* Aborted on close AND on a storage failure after the open. The store-using
-	* background processes (heartbeat, client and client-group GC, database
-	* collection, mutation recovery, the new-client channel's store read) run
-	* on this signal, so the first detected failure stops them instead of
-	* letting each retry the fault at its interval and log `Error running.`
-	* every time. A failure during the open moves the stores onto memory
-	* instead, where they keep running.
+	* Aborted on close, on a storage failure after the open, and by
+	* {@link stopPersist}. `persist()`, the persist scheduler and the
+	* store-writing background processes (heartbeat, client and client-group
+	* GC, database collection, mutation recovery) stop on this signal, so the
+	* first detected failure stops them instead of letting each retry the
+	* fault at its interval and log `Error running.` every time. A failure
+	* during the open moves the stores onto memory instead, where they keep
+	* running.
 	*/
-	#storeProcessesAbortController = new AbortController();
+	#persistAbortController = new AbortController();
+	/**
+	* Aborted on close, on a storage failure after the open, and by
+	* {@link stopRefresh}. `refresh()`, the refresh scheduler and the
+	* store-reading background process (the new-client channel's store read)
+	* stop on this signal.
+	*/
+	#refreshAbortController = new AbortController();
 	#persistLock = new Lock();
 	#enableScheduledPersist;
 	#enableScheduledRefresh;
@@ -248,7 +256,8 @@ var ReplicacheImpl = class {
 	* instance. A read that needs a chunk the in-memory dag has not loaded from
 	* the store yet, or has since evicted from its cache, still goes to the
 	* store and fails the way any store read does; that failure reaches its
-	* caller and is not reclassified here. An invalid ref count reported while
+	* caller, and is reported here as well, whichever caller it was (a query,
+	* a mutation, a poke, a background process). An invalid ref count reported while
 	* the store is failing with `cannot-open` or `io-error` is NOT treated as
 	* corruption (the database is not dropped and {@link onClientStateNotFound}
 	* is not called), because a store that cannot complete a read or write is
@@ -258,8 +267,10 @@ var ReplicacheImpl = class {
 	*
 	* After the open, the failure is detected when a transaction on the store
 	* fails to begin or to commit, whichever caller ran it (`persist()`, the
-	* heartbeat, garbage collection, ...), and when `persist()` or `refresh()`
-	* fails. The background maintenance processes (heartbeat, client and
+	* heartbeat, garbage collection, ...), when `persist()` or `refresh()`
+	* fails, when the in-memory dag fails to load a chunk from the store for
+	* any caller, and when a background process fails on a store read inside
+	* its transaction. The background maintenance processes (heartbeat, client and
 	* client-group GC, database collection, mutation recovery) stop on it
 	* instead of retrying against the store at their interval.
 	*
@@ -274,6 +285,18 @@ var ReplicacheImpl = class {
 	*/
 	#storageFailure;
 	/**
+	* The last persist queued on the persist lock, if any, so
+	* {@link stopPersist} can wait for it. The lock runs persists in order, so
+	* this one settles after every persist queued before it. Settled to
+	* `undefined` rather than left rejected.
+	*/
+	#persistInFlight;
+	/**
+	* The refresh currently running, if any, so {@link stopRefresh} can wait
+	* for it. Settled to `undefined` rather than left rejected.
+	*/
+	#refreshInFlight;
+	/**
 	* `onUpdateNeeded` is called when a code update is needed.
 	*
 	* A code update can be needed because:
@@ -325,7 +348,10 @@ var ReplicacheImpl = class {
 			name,
 			"replicache version": version
 		});
-		this.#closeAbortController.signal.addEventListener("abort", () => this.#storeProcessesAbortController.abort(), { once: true });
+		this.#closeAbortController.signal.addEventListener("abort", () => {
+			this.#persistAbortController.abort();
+			this.#refreshAbortController.abort();
+		}, { once: true });
 		this.#subscriptions = new SubscriptionsManagerImpl(this.#queryInternal, this.#lc, this.#closeAbortController.signal);
 		const kvStoreProvider = new MemFallbackStoreProvider(getKVStoreProvider(this.#lc, options.kvStore), (failure) => this.#onMemFallBack(failure), (failure) => this.#handleStorageFailure(failure));
 		this.#kvStoreProvider = kvStoreProvider;
@@ -333,7 +359,7 @@ var ReplicacheImpl = class {
 		this.#perKVStore = perKVStore;
 		this.#idbDatabases = new IDBDatabasesStore(kvStoreProvider.create);
 		this.perdag = new StoreImpl(perKVStore, newRandomHash, assertHash, this.#onInvalidRefCount);
-		this.memdag = new LazyStore(this.perdag, LAZY_STORE_SOURCE_CHUNK_CACHE_SIZE_LIMIT, newRandomHash, assertHash);
+		this.memdag = new LazyStore(this.perdag, LAZY_STORE_SOURCE_CHUNK_CACHE_SIZE_LIMIT, newRandomHash, assertHash, void 0, this.#reportStorageFailure);
 		const readyResolver = resolver();
 		this.#ready = readyResolver.promise;
 		const { minDelayMs = 30, maxDelayMs = MAX_DELAY_MS } = requestOptions;
@@ -387,14 +413,14 @@ var ReplicacheImpl = class {
 			this.pull().catch(noop);
 			this.push().catch(noop);
 		}
-		const { signal } = this.#storeProcessesAbortController;
+		const { signal } = this.#persistAbortController;
 		startHeartbeats(clientID, this.perdag, () => {
 			this.#clientStateNotFoundOnClient(clientID);
-		}, HEARTBEAT_INTERVAL, this.#lc, signal);
-		initClientGC(clientID, this.perdag, clientMaxAgeMs, GC_INTERVAL, onClientsDeleted, this.#lc, signal);
-		initCollectIDBDatabases(this.#idbDatabases, this.#kvStoreProvider, COLLECT_IDB_INTERVAL, INITIAL_COLLECT_IDB_DELAY, 2 * clientMaxAgeMs, enableMutationRecovery, onClientsDeleted, this.#lc, signal, (name, createKVStore) => new StoreImpl(createKVStore(name), newRandomHash, assertHash, name === this.idbName ? this.#onInvalidRefCount : void 0));
-		initClientGroupGC(this.perdag, enableMutationRecovery, this.#lc, signal);
-		initNewClientChannel(this.name, this.idbName, signal, client.clientGroupID, isNewClientGroup, () => {
+		}, HEARTBEAT_INTERVAL, this.#lc, signal, this.#reportStorageFailure);
+		initClientGC(clientID, this.perdag, clientMaxAgeMs, GC_INTERVAL, onClientsDeleted, this.#lc, signal, this.#reportStorageFailure);
+		initCollectIDBDatabases(this.#idbDatabases, this.#kvStoreProvider, COLLECT_IDB_INTERVAL, INITIAL_COLLECT_IDB_DELAY, 2 * clientMaxAgeMs, enableMutationRecovery, onClientsDeleted, this.#lc, signal, (name, createKVStore) => new StoreImpl(createKVStore(name), newRandomHash, assertHash, name === this.idbName ? this.#onInvalidRefCount : void 0), this.#reportStorageFailure);
+		initClientGroupGC(this.perdag, enableMutationRecovery, this.#lc, signal, this.#reportStorageFailure);
+		initNewClientChannel(this.name, this.idbName, this.#refreshAbortController.signal, client.clientGroupID, isNewClientGroup, () => {
 			this.#fireOnUpdateNeeded(updateNeededReasonNewClientGroup);
 		}, this.perdag);
 		setIntervalWithSignal(() => this.recoverMutations(), RECOVER_MUTATIONS_INTERVAL_MS, signal);
@@ -716,10 +742,10 @@ var ReplicacheImpl = class {
 		};
 	}
 	persist() {
-		return this.#persistLock.withLock(async () => {
+		const run = this.#persistLock.withLock(async () => {
 			const { clientID } = this;
 			await this.#ready;
-			if (this.#closed || this.#storageFailure) return;
+			if (this.#closed || this.#storageFailure || this.#persistAbortController.signal.aborted) return;
 			try {
 				await persistDD31(this.#lc, clientID, this.memdag, this.perdag, this.#mutatorRegistry, () => this.#closed, 7, this.#zero?.getTxData);
 			} catch (e) {
@@ -742,11 +768,18 @@ var ReplicacheImpl = class {
 				clientGroupID
 			});
 		});
+		this.#persistInFlight = run.catch(noop);
+		return run;
+	}
+	refresh() {
+		const run = this.#refresh();
+		this.#refreshInFlight = run.catch(noop);
+		return run;
 	}
-	async refresh() {
+	async #refresh() {
 		await this.#ready;
 		const { clientID } = this;
-		if (this.#closed || this.#storageFailure || !this.#enableRefresh()) return;
+		if (this.#closed || this.#storageFailure || this.#refreshAbortController.signal.aborted || !this.#enableRefresh()) return;
 		let refreshResult;
 		try {
 			refreshResult = await refresh(this.#lc, this.memdag, this.perdag, clientID, this.#mutatorRegistry, this.#subscriptions, () => this.closed, 7, this.#zero);
@@ -777,6 +810,15 @@ var ReplicacheImpl = class {
 	*/
 	#corruptDatabaseRecovery;
 	/**
+	* Handed to the in-memory dag and the background processes, which have no
+	* other way to reach this instance when a store read inside them fails.
+	* Skipped while closing: a read that fails because the store was closed
+	* under it is not a storage failure of the instance.
+	*/
+	#reportStorageFailure = (failure) => {
+		if (!this.#closed) this.#handleStorageFailure(failure);
+	};
+	/**
 	* A storage failure after the open. Records the first one, stops the
 	* store-using background processes, logs it once and tells the app. Later
 	* failures of the same instance are the same fault and are not reported
@@ -785,7 +827,8 @@ var ReplicacheImpl = class {
 	#handleStorageFailure(failure) {
 		if (this.#storageFailure !== void 0) return;
 		this.#storageFailure = failure;
-		this.#storeProcessesAbortController.abort();
+		this.#persistAbortController.abort();
+		this.#refreshAbortController.abort();
 		this.#lc.warn?.(`Local store storage failed (${failure.kind}) for ${this.idbName}; persistence is stopped for this instance`, failure);
 		this.#fireOnStorageFailure(failure);
 	}
@@ -879,6 +922,40 @@ var ReplicacheImpl = class {
 		await this.disableClientGroup();
 		this.#fireOnClientStateNotFound();
 	}
+	/**
+	* Stops every write to the local store, for an instance whose database is
+	* about to be dropped from under it: the store-writing background
+	* processes (heartbeat, GC, collection, mutation recovery) are aborted, a
+	* `persist()` already in flight is waited for, and every later `persist()`
+	* — scheduled or explicit — is a no-op. Mutations keep running against the in-memory
+	* dag until the app replaces the instance (see `onClientStateNotFound`).
+	*
+	* Use together with {@link stopRefresh} before dropping the database, so
+	* the drop's own footprint — `database is closed` from the next scheduled
+	* persist and the background processes — is not logged as errors against a
+	* store that was deleted on purpose.
+	*/
+	async stopPersist() {
+		this.#persistAbortController.abort();
+		await this.#persistInFlight;
+	}
+	/**
+	* Stops every refresh from the local store, for an instance whose database
+	* is about to be dropped from under it: the store-reading background
+	* process (the new-client channel) is aborted, a `refresh()` already in
+	* flight is waited for, and every later `refresh()` / `runRefresh()` —
+	* scheduled or explicit — is a no-op. Queries keep running against the
+	* in-memory dag until the app replaces the instance (see
+	* `onClientStateNotFound`).
+	*
+	* Use together with {@link stopPersist} before dropping the database, so
+	* the run loop's refresh after a connect error does not run into the
+	* dropped store and log `database is closed` as an error.
+	*/
+	async stopRefresh() {
+		this.#refreshAbortController.abort();
+		await this.#refreshInFlight;
+	}
 	async disableClientGroup() {
 		const clientGroupID = await this.#clientGroupIDPromise;
 		assert(clientGroupID, "Expected clientGroupID to be defined");
@@ -890,7 +967,7 @@ var ReplicacheImpl = class {
 		this.onUpdateNeeded?.(reason);
 	}
 	async #schedulePersist() {
-		if (!this.#enableScheduledPersist || this.#storageFailure) return;
+		if (!this.#enableScheduledPersist || this.#storageFailure || this.#persistAbortController.signal.aborted) return;
 		await this.#schedule("persist", this.#persistScheduler);
 	}
 	async #handlePersist(persistInfo) {
@@ -899,7 +976,7 @@ var ReplicacheImpl = class {
 		if (persistInfo.clientGroupID === clientGroupID) this.#scheduleRefresh();
 	}
 	async #scheduleRefresh() {
-		if (!this.#enableScheduledRefresh || this.#storageFailure) return;
+		if (!this.#enableScheduledRefresh || this.#storageFailure || this.#refreshAbortController.signal.aborted) return;
 		await this.#schedule("refresh from storage", this.#refreshScheduler);
 	}
 	async #schedule(name, scheduler) {
@@ -1058,7 +1135,7 @@ var ReplicacheImpl = class {
 		return ex;
 	}
 	recoverMutations() {
-		if (this.#storeProcessesAbortController.signal.aborted) return promiseFalse;
+		if (this.#persistAbortController.signal.aborted) return promiseFalse;
 	}
 	/**
 	* List of pending mutations. The order of this is from oldest to newest.