@verdant-web/store 4.1.1 → 4.1.3

package/src/persistence/idb/queries/IdbDocumentDb.ts

@@ -8,8 +8,8 @@ import {
 import { Context } from '../../../context/context.js';
 import { PersistenceDocumentDb } from '../../interfaces.js';
 import { IdbService } from '../IdbService.js';
-import { getRange } from './ranges.js';
 import { closeDatabase, getSizeOfObjectStore, isAbortError } from '../util.js';
+import { getRange } from './ranges.js';
 
 export class IdbDocumentDb extends IdbService implements PersistenceDocumentDb {
 	private ctx;
@@ -149,7 +149,7 @@ export class IdbDocumentDb extends IdbService implements PersistenceDocumentDb {
 			}),
 		};
 
-		await Promise.all(
+		const results = await Promise.allSettled(
 			entities.map(async (e) => {
 				const snapshot = e.getSnapshot();
 				try {
@@ -168,6 +168,26 @@ export class IdbDocumentDb extends IdbService implements PersistenceDocumentDb {
 				}
 			}),
 		);
+
+		const failures = results.filter((r) => r.status === 'rejected');
+		if (failures.length) {
+			// in the case of a failure to save a document, it doesn't quite make sense to cancel or rollback whatever is
+			// currently happening. when restoring imports, etc, this makes the app stuck. if only a few docs failed, maybe
+			// there's some data corruption somewhere, but we can just lose those without affecting the rest of the data.
+			if (failures.length === results.length) {
+				// but if ALL of them failed, that's trouble...
+				throw new Error(
+					'Failed to save any documents. Something must be quite wrong.',
+				);
+			}
+			this.ctx.log(
+				'error',
+				'Failed to save documents:',
+				failures,
+				". See logs above. This only affects querying these documents. Let's hope a future attempt will correct them...",
+			);
+		}
+
 		options.transaction.commit();
 	};
 
@@ -190,22 +210,27 @@ export class IdbDocumentDb extends IdbService implements PersistenceDocumentDb {
 	) => {
 		this.ctx.log('debug', `Saving document indexes for querying ${oid}`);
 		const { collection, id } = decomposeOid(oid);
-		if (!doc) {
-			await this.run(collection, (store) => store.delete(id), {
-				mode: 'readwrite',
-				transaction,
-			});
-			this.ctx.log('debug', `Deleted document indexes for querying ${oid}`);
-		} else {
-			const schema = this.ctx.schema.collections[collection];
-			// no need to validate before storing; the entity's snapshot is already validated.
-			const indexes = getIndexValues(schema, doc);
-			indexes['@@@snapshot'] = JSON.stringify(doc);
-			await this.run(collection, (store) => store.put(indexes), {
-				mode: 'readwrite',
-				transaction,
-			});
-			this.ctx.log('debug', `Save complete for ${oid}`, indexes);
+		try {
+			if (!doc) {
+				await this.run(collection, (store) => store.delete(id), {
+					mode: 'readwrite',
+					transaction,
+				});
+				this.ctx.log('debug', `Deleted document indexes for querying ${oid}`);
+			} else {
+				const schema = this.ctx.schema.collections[collection];
+				// no need to validate before storing; the entity's snapshot is already validated.
+				const indexes = getIndexValues(schema, doc);
+				indexes['@@@snapshot'] = JSON.stringify(doc);
+				await this.run(collection, (store) => store.put(indexes), {
+					mode: 'readwrite',
+					transaction,
+				});
+				this.ctx.log('debug', `Save complete for ${oid}`, indexes);
+			}
+		} catch (err) {
+			this.ctx.log('error', `Error saving document ${oid}`, err);
+			throw err;
 		}
 	};
 }

package/src/persistence/persistence.ts

@@ -1,12 +1,12 @@
 import { EventSubscriber, getOidRoot, VerdantError } from '@verdant-web/common';
 import { Context, InitialContext } from '../context/context.js';
+import { ShutdownHandler } from '../context/ShutdownHandler.js';
 import { getWipNamespace } from '../utils/wip.js';
 import { ExportedData } from './interfaces.js';
+import { migrate } from './migration/migrate.js';
 import { PersistenceFiles } from './PersistenceFiles.js';
 import { PersistenceMetadata } from './PersistenceMetadata.js';
 import { PersistenceDocuments } from './PersistenceQueries.js';
-import { migrate } from './migration/migrate.js';
-import { ShutdownHandler } from '../context/ShutdownHandler.js';
 
 export async function initializePersistence(
 	ctx: InitialContext,
@@ -130,6 +130,8 @@ export async function importPersistence(
 		originalNamespace: importedNamespace,
 		// no-op entity events -- don't need to inform queries of changes.
 		entityEvents: new EventSubscriber(),
+		internalEvents: new EventSubscriber(),
+		globalEvents: new EventSubscriber(),
 		config: {
 			...ctx.config,
 			persistence: {

package/src/queries/BaseQuery.ts

@@ -57,7 +57,9 @@ export abstract class BaseQuery<T> extends Disposable {
 		this.isListQuery = Array.isArray(initial);
 		this._events = new EventSubscriber<BaseQueryEvents>(
 			(event: keyof BaseQueryEvents) => {
-				if (event === 'change') this._allUnsubscribedHandler?.(this);
+				if (event === 'change') {
+					this._allUnsubscribedHandler?.(this);
+				}
 			},
 		);
 		this.context = context;

package/src/queries/QueryCache.ts

@@ -6,6 +6,8 @@ export class QueryCache extends Disposable {
 	private _cache: Map<string, BaseQuery<any>> = new Map();
 	private _evictionTime;
 	private context;
+	/** A set of query keys to keep alive even if they unsubscribe */
+	private _holds = new Set<string>();
 
 	constructor({
 		evictionTime = 5 * 1000,
@@ -26,13 +28,22 @@ export class QueryCache extends Disposable {
 		);
 	}
 
+	get activeKeys() {
+		return Array.from(this._cache.keys());
+	}
+
 	get<T extends BaseQuery<any>>(key: string): T | null {
 		return (this._cache.get(key) as T) || null;
 	}
 
 	set<V extends BaseQuery<any>>(value: V) {
 		this._cache.set(value.key, value);
-		value[ON_ALL_UNSUBSCRIBED](this.onQueryUnsubscribed);
+		value[ON_ALL_UNSUBSCRIBED](this.enqueueQueryEviction);
+		// immediately enqueue a check to see if this query should be evicted --
+		// this basically gives code X seconds to subscribe to the query before
+		// it gets evicted.
+		this.enqueueQueryEviction(value);
+
 		return value;
 	}
 
@@ -50,13 +61,24 @@ export class QueryCache extends Disposable {
 		return this.set(create());
 	}
 
-	private onQueryUnsubscribed = (query: BaseQuery<any>) => {
+	private enqueueQueryEviction = (query: BaseQuery<any>) => {
 		setTimeout(() => {
 			if (query.subscribed) return;
+
+			if (this._holds.has(query.key)) {
+				this.context.log(
+					'debug',
+					'QueryCache: keepAlive hold on query preserves after unsubscribe',
+					query.key,
+				);
+				return;
+			}
+
 			// double check before evicting... possible the cache
 			// got a different version of this query.
 			if (this._cache.get(query.key) === query) {
 				this._cache.delete(query.key);
+				this.context.log('debug', 'QueryCache: evicted query', query.key);
 			}
 		}, this._evictionTime);
 	};
@@ -81,4 +103,36 @@ export class QueryCache extends Disposable {
 		);
 		this._cache.forEach((q) => q.execute());
 	};
+
+	keepAlive(key: string) {
+		this._holds.add(key);
+		this.context.log('debug', 'QueryCache: keepAlive', key);
+	}
+
+	dropKeepAlive(key: string) {
+		this._holds.delete(key);
+		const cached = this.get(key);
+		if (!cached) return;
+		if (!cached.subscribed) {
+			this.context.log(
+				'debug',
+				'QueryCache: dropKeepAlive on unsubscribed query; queuing eviction',
+				key,
+			);
+			this.enqueueQueryEviction(cached);
+		}
+	}
+
+	get keepAlives() {
+		return this._holds;
+	}
 }
+
+export type PublicQueryCacheAPI = Pick<
+	QueryCache,
+	| 'keepAlive'
+	| 'dropKeepAlive'
+	| 'keepAlives'
+	| 'forceRefreshAll'
+	| 'activeKeys'
+>;

package/src/sync/FileSync.ts

@@ -1,7 +1,7 @@
 import { FileData } from '@verdant-web/common';
-import { ServerSyncEndpointProvider } from './ServerSyncEndpointProvider.js';
 import { Context } from '../context/context.js';
 import { Disposable } from '../utils/Disposable.js';
+import { ServerSyncEndpointProvider } from './ServerSyncEndpointProvider.js';
 
 export interface FileUploadResult {
 	success: boolean;
@@ -42,7 +42,6 @@ export class FileSync extends Disposable {
 		this.ctx.log('debug', 'Uploading file', data.id, data.name);
 		try {
 			await this.uploadFile(data);
-			this.ctx.internalEvents.emit(`fileUploaded:${data.id}`, data);
 		} catch (e) {
 			this.ctx.log('error', 'File upload failed', e);
 		}
@@ -83,6 +82,8 @@ export class FileSync extends Disposable {
 			);
 
 			if (response.ok) {
+				this.ctx.internalEvents.emit(`fileUploaded:${data.id}`, data);
+				this.ctx.internalEvents.emit('fileUploaded', data);
 				this.ctx.log('info', 'File upload successful');
 				return {
 					success: true,