@verdant-web/store 4.1.2 → 4.1.4

package/src/persistence/PersistenceFiles.ts

@@ -65,10 +65,10 @@ export class PersistenceFiles {
 		// and must be uploaded, even if it is cloned from an uploaded file.
 		file.remote = false;
 
-		// fire event for processing immediately
-		this.context.internalEvents.emit('fileAdded', file);
 		// store in persistence db
 		await this.db.add(file);
+		// fire event for sync to pick up and upload the file
+		this.context.internalEvents.emit('fileAdded', file);
 		this.context.globalEvents.emit('fileSaved', file);
 		this.context.log(
 			'debug',
@@ -79,10 +79,10 @@ export class PersistenceFiles {
 			file.file
 				? 'with binary file'
 				: file.url
-				? 'with url'
-				: file.localPath
-				? 'with local path'
-				: 'with no data',
+					? 'with url'
+					: file.localPath
+						? 'with local path'
+						: 'with no data',
 		);
 		return file;
 	};
@@ -206,6 +206,11 @@ export class PersistenceFiles {
 					}, 1000);
 				});
 			} else {
+				this.context.log(
+					'error',
+					`Failed to download file after ${maxRetries} retries`,
+					err,
+				);
 				throw new Error(`Failed to download file after ${maxRetries} retries`, {
 					cause: err,
 				});

package/src/persistence/idb/files/IdbPersistenceFileDb.ts

@@ -1,4 +1,5 @@
 import { FileData } from '@verdant-web/common';
+import { Context } from '../../../internal.js';
 import {
 	AbstractTransaction,
 	PersistedFileData,
@@ -6,7 +7,6 @@ import {
 } from '../../interfaces.js';
 import { IdbService } from '../IdbService.js';
 import { getAllFromObjectStores, getSizeOfObjectStore } from '../util.js';
-import { Context } from '../../../internal.js';
 
 /**
  * When stored in IDB, replace the file blob with an array buffer
@@ -24,9 +24,7 @@ export class IdbPersistenceFileDb
 	extends IdbService
 	implements PersistenceFileDb
 {
-	add = async (
-		file: FileData,
-	): Promise<void> => {
+	add = async (file: FileData): Promise<void> => {
 		let buffer = file.file ? await fileToArrayBuffer(file.file) : undefined;
 
 		await this.run(
@@ -50,6 +48,10 @@ export class IdbPersistenceFileDb
 		);
 	};
 	markUploaded = async (id: string): Promise<void> => {
+		if (this.disposed) {
+			return;
+		}
+
 		const current = await this.getFileRaw(id);
 
 		if (!current) {
@@ -185,19 +187,21 @@ export class IdbPersistenceFileDb
 		if (file.url) {
 			const response = await ctx.environment.fetch(file.url);
 			if (!response.ok) {
-				throw new Error(`Failed to download file: ${response.statusText}`);
+				throw new Error(
+					`Failed to download file ${file.url}: ${response.statusText}`,
+				);
 			}
 			return response.blob();
 		}
 		throw new Error('File is missing url, file, and localPath');
-	}
+	};
 
 	private hydrateFileData = (raw: StoredFileData): PersistedFileData => {
 		(raw as any).remote = raw.remote === 'true';
 		const buffer = raw.buffer;
 		delete raw.buffer;
 		(raw as unknown as FileData).file = buffer
-			? arrayBufferToBlob(buffer, raw.type)
+			? arrayBufferToBlob(buffer, raw.type, raw.name)
 			: undefined;
 		return raw as unknown as PersistedFileData;
 	};
@@ -206,6 +210,9 @@ export class IdbPersistenceFileDb
 		id: string,
 		{ transaction }: { transaction?: AbstractTransaction } = {},
 	): Promise<StoredFileData | undefined> => {
+		if (this.disposed) {
+			return undefined;
+		}
 		const raw = await this.run<StoredFileData>(
 			'files',
 			(store) => {
@@ -220,8 +227,14 @@ export class IdbPersistenceFileDb
 	};
 }
 
-export function arrayBufferToBlob(buffer: ArrayBuffer, type: string) {
-	return new Blob([buffer], { type });
+export function arrayBufferToBlob(
+	buffer: ArrayBuffer,
+	type: string,
+	name?: string,
+) {
+	return new File([new Blob([buffer], { type })], name ?? 'blob', {
+		type,
+	});
 }
 
 function fileToArrayBuffer(file: File | Blob): Promise<ArrayBuffer> {

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,