@verdant-web/store 4.5.2 → 4.6.1

package/src/client/ClientDescriptor.ts

@@ -6,7 +6,12 @@ import {
 	StorageSchema,
 	VerdantError,
 } from '@verdant-web/common';
-import { FileConfig, InitialContext, QueryConfig } from '../context/context.js';
+import {
+	Context,
+	FileConfig,
+	InitialContext,
+	QueryConfig,
+} from '../context/context.js';
 import { ShutdownHandler } from '../context/ShutdownHandler.js';
 import { Time } from '../context/Time.js';
 import { FakeWeakRef } from '../FakeWeakRef.js';
@@ -64,7 +69,7 @@ export interface ClientDescriptorOptions<Presence = any, Profile = any> {
 	 * Normally these are provided by the browser, but in other
 	 * runtimes you may need to provide your own.
 	 */
-	environment?: InitialContext['environment'];
+	environment?: Partial<InitialContext['environment']>;
 
 	/**
 	 * Enables experimental WeakRef usage to cull documents
@@ -132,9 +137,12 @@ export class ClientDescriptor<
 				new HybridLogicalClockTimestampProvider(),
 				init.schema.version,
 			);
-			const environment = init.environment || defaultBrowserEnvironment;
 			const logger =
 				init.log === false ? noLogger : init.log || debugLogger('🌿');
+			const environment = {
+				...defaultBrowserEnvironment,
+				...init.environment,
+			};
 			let ctx: InitialContext = {
 				closing: false,
 				entityEvents: new EventSubscriber(),
@@ -224,12 +232,15 @@ export class ClientDescriptor<
 	};
 
 	__dangerous__resetLocal = async () => {
-		await deleteAllDatabases(this.namespace);
+		await deleteAllDatabases(this.namespace, defaultBrowserEnvironment);
 	};
 }
 
-const defaultBrowserEnvironment = {
+const defaultBrowserEnvironment: Context['environment'] = {
 	WebSocket: typeof WebSocket !== 'undefined' ? WebSocket : (undefined as any),
 	fetch: typeof window !== 'undefined' ? window.fetch.bind(window) : fetch!,
 	indexedDB: typeof indexedDB !== 'undefined' ? indexedDB : (undefined as any),
+	location:
+		typeof window !== 'undefined' ? window.location : (undefined as any),
+	history: typeof window !== 'undefined' ? window.history : (undefined as any),
 };

package/src/context/context.ts

@@ -106,6 +106,8 @@ export interface Context {
 		WebSocket: typeof WebSocket;
 		fetch: typeof fetch;
 		indexedDB: typeof indexedDB;
+		location: Location;
+		history: History;
 	};
 
 	persistence: PersistenceImplementation;

package/src/files/EntityFile.ts

@@ -27,6 +27,7 @@ export class EntityFile extends EventSubscriber<EntityFileEvents> {
 	private _fileData: FileData | null = null;
 	private _loading = true;
 	private _failed = false;
+	private _failedReason: string | undefined;
 	private _downloadRemote = false;
 	private _uploaded = false;
 	private ctx: Context;
@@ -64,6 +65,9 @@ export class EntityFile extends EventSubscriber<EntityFileEvents> {
 	get isUploaded() {
 		return this._uploaded || this._fileData?.remote || false;
 	}
+	get error() {
+		return this._failedReason || null;
+	}
 
 	private emitChange() {
 		this.parent[CHILD_FILE_CHANGED](this);
@@ -85,8 +89,9 @@ export class EntityFile extends EventSubscriber<EntityFileEvents> {
 		this.emitChange();
 	};
 
-	[MARK_FAILED] = () => {
+	[MARK_FAILED] = (reason?: string) => {
 		this._failed = true;
+		this._failedReason = reason;
 		this._loading = false;
 		this.emitChange();
 	};

package/src/files/FileManager.ts

@@ -88,11 +88,11 @@ export class FileManager extends Disposable {
 					file[UPDATE](result.data);
 				} else {
 					this.context.log('error', 'Failed to load file', result);
-					file[MARK_FAILED]();
+					file[MARK_FAILED](result.error?.toString());
 				}
 			} catch (err) {
 				this.context.log('error', 'Failed to load file', err);
-				file[MARK_FAILED]();
+				file[MARK_FAILED](err instanceof Error ? err.message : String(err));
 			}
 		}
 	};

package/src/persistence/MessageCreator.ts

@@ -141,11 +141,8 @@ export class MessageCreator {
 	};
 
 	createHeartbeat = async (): Promise<HeartbeatMessage> => {
-		const localReplicaInfo = await this.meta.getLocalReplica();
 		return {
 			type: 'heartbeat',
-			timestamp: this.ctx.time.now,
-			replicaId: localReplicaInfo.id,
 		};
 	};
 

package/src/persistence/PersistenceFiles.ts

@@ -66,6 +66,7 @@ export class PersistenceFiles {
 		file.remote = false;
 
 		// store in persistence db
+		this.context.log('debug', 'Adding file to persistence', file);
 		await this.db.add(file);
 		// fire event for sync to pick up and upload the file
 		this.context.internalEvents.emit('fileAdded', file);

package/src/persistence/idb/IdbService.ts

@@ -1,8 +1,9 @@
-import { Context } from '../../context/context.js';
+import { Context, InitialContext } from '../../context/context.js';
 import { Disposable } from '../../utils/Disposable.js';
 import {
 	createAbortableTransaction,
 	isAbortError,
+	isTransactionAborted,
 	storeRequestPromise,
 } from './util.js';
 
@@ -12,10 +13,9 @@ export class IdbService extends Disposable {
 
 	constructor(
 		protected db: IDBDatabase,
-		{ log }: { log?: Context['log'] } = {},
+		protected readonly ctx: InitialContext,
 	) {
 		super();
-		this.log = log;
 		const abortController = new AbortController();
 		const abort = abortController.abort.bind(abortController);
 		this.globalAbortController = abortController;
@@ -82,6 +82,9 @@ export class IdbService extends Disposable {
 		if (this.disposed || opts?.transaction?.error)
 			return Promise.resolve(undefined as any);
 		const tx = opts?.transaction || this.createTransaction([storeName], opts);
+		if (isTransactionAborted(tx)) {
+			return Promise.resolve(undefined as any);
+		}
 		const store = tx.objectStore(storeName);
 		const request = getRequest(store);
 		return storeRequestPromise<T>(request);
@@ -97,6 +100,9 @@ export class IdbService extends Disposable {
 		},
 	): Promise<T[]> => {
 		if (this.disposed || opts?.transaction?.error) return Promise.resolve([]);
+		if (opts?.transaction && isTransactionAborted(opts.transaction)) {
+			return Promise.resolve([]);
+		}
 		const tx = opts?.transaction || this.createTransaction([storeName], opts);
 		const store = tx.objectStore(storeName);
 		const requests = getRequests(store);
@@ -122,6 +128,9 @@ export class IdbService extends Disposable {
 		},
 	): Promise<void> => {
 		const tx = opts?.transaction || this.createTransaction([storeName], opts);
+		if (isTransactionAborted(tx)) {
+			return;
+		}
 		const store = tx.objectStore(storeName);
 		const request = getRequest(store);
 		if (Array.isArray(request)) {
@@ -191,7 +200,7 @@ export class IdbService extends Disposable {
 		this.db.close();
 		if (typeof window !== 'undefined') {
 			try {
-				window.location.reload();
+				this.ctx.environment.location.reload();
 			} catch (err) {
 				this.log?.('error', 'Failed to reload the page', err);
 			}

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

@@ -55,7 +55,8 @@ export class IdbPersistenceFileDb
 		const current = await this.getFileRaw(id);
 
 		if (!current) {
-			throw new Error('File is not in local database');
+			this.ctx.log('error', 'Tried to mark unknown file as uploaded', id);
+			return;
 		}
 
 		await this.run(

package/src/persistence/idb/metadata/IdbMetadataDb.ts

@@ -8,6 +8,7 @@ import {
 	getOidSubIdRange,
 	ObjectIdentifier,
 } from '@verdant-web/common';
+import { InitialContext } from '../../../context/context.js';
 import {
 	AbstractTransaction,
 	AckInfo,
@@ -19,7 +20,6 @@ import {
 } from '../../interfaces.js';
 import { IdbService } from '../IdbService.js';
 import { closeDatabase, getSizeOfObjectStore } from '../util.js';
-import { Context } from '../../../context/context.js';
 
 export type StoredClientOperation = ClientOperation & {
 	/** This acts as the primary key */
@@ -37,10 +37,7 @@ export class IdbMetadataDb
 	extends IdbService
 	implements PersistenceMetadataDb<IDBTransaction>
 {
-	constructor(
-		db: IDBDatabase,
-		private ctx: Pick<Context, 'log' | 'namespace'>,
-	) {
+	constructor(db: IDBDatabase, ctx: InitialContext) {
 		super(db, ctx);
 		this.addDispose(() => {
 			this.ctx.log('info', `Closing metadata DB for`, this.ctx.namespace);
@@ -330,10 +327,10 @@ export class IdbMetadataDb
 					start && end
 						? IDBKeyRange.bound(start, end, false, true)
 						: start
-						? IDBKeyRange.lowerBound(start, false)
-						: end
-						? IDBKeyRange.upperBound(end, true)
-						: undefined;
+							? IDBKeyRange.lowerBound(start, false)
+							: end
+								? IDBKeyRange.upperBound(end, true)
+								: undefined;
 				return store.index('timestamp').openCursor(range, 'next');
 			},
 			iterator,

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

@@ -5,17 +5,20 @@ import {
 	getIndexValues,
 	ObjectIdentifier,
 } from '@verdant-web/common';
-import { Context } from '../../../context/context.js';
+import { InitialContext } from '../../../context/context.js';
 import { PersistenceDocumentDb } from '../../interfaces.js';
 import { IdbService } from '../IdbService.js';
-import { closeDatabase, getSizeOfObjectStore, isAbortError } from '../util.js';
+import {
+	closeDatabase,
+	getSizeOfObjectStore,
+	isAbortError,
+	isTransactionAborted,
+} from '../util.js';
 import { getRange } from './ranges.js';
 
 export class IdbDocumentDb extends IdbService implements PersistenceDocumentDb {
-	private ctx;
-	constructor(db: IDBDatabase, context: Omit<Context, 'documents' | 'files'>) {
-		super(db, { log: context.log });
-		this.ctx = context;
+	constructor(db: IDBDatabase, context: InitialContext) {
+		super(db, context);
 		this.addDispose(() => {
 			this.ctx.log('info', 'Closing document database for', this.ctx.namespace);
 			return closeDatabase(this.db);
@@ -73,6 +76,9 @@ export class IdbDocumentDb extends IdbService implements PersistenceDocumentDb {
 		offset?: number;
 	}): Promise<{ result: ObjectIdentifier[]; hasNextPage: boolean }> => {
 		const tx = this.createTransaction([collection], { mode: 'readonly' });
+		if (isTransactionAborted(tx)) {
+			return { result: [], hasNextPage: false };
+		}
 		const store = tx.objectStore(collection);
 		const source = index?.where ? store.index(index.where) : store;
 		const direction = index?.order === 'desc' ? 'prev' : 'next';

package/src/persistence/idb/util.ts

@@ -130,10 +130,14 @@ export async function closeDatabase(db: IDBDatabase) {
 
 export async function deleteAllDatabases(
 	namespace: string,
-	indexedDB: IDBFactory = globalIDB,
+	environment: Context['environment'],
 ) {
-	const req1 = indexedDB.deleteDatabase([namespace, 'meta'].join('_'));
-	const req2 = indexedDB.deleteDatabase([namespace, 'collections'].join('_'));
+	const req1 = environment.indexedDB.deleteDatabase(
+		[namespace, 'meta'].join('_'),
+	);
+	const req2 = environment.indexedDB.deleteDatabase(
+		[namespace, 'collections'].join('_'),
+	);
 	await Promise.all([
 		new Promise((resolve, reject) => {
 			req1.onsuccess = resolve;
@@ -144,7 +148,8 @@ export async function deleteAllDatabases(
 			req2.onerror = reject;
 		}),
 	]);
-	window.location.reload();
+	// reload the page to reset any existing connections
+	environment.location.reload();
 }
 
 export function deleteDatabase(name: string, indexedDB = window.indexedDB) {
@@ -164,25 +169,81 @@ export function createAbortableTransaction(
 	abortSignal?: AbortSignal,
 	log?: (...args: any[]) => void,
 ) {
-	const tx = db.transaction(storeNames, mode);
-	if (abortSignal) {
-		const abort = () => {
-			log?.('debug', 'aborting transaction');
-			try {
-				tx.abort();
-			} catch (e) {
-				log?.('debug', 'aborting transaction failed', e);
-			}
-		};
-		abortSignal.addEventListener('abort', abort);
-		tx.addEventListener('error', () => {
-			abortSignal.removeEventListener('abort', abort);
-		});
-		tx.addEventListener('complete', () => {
-			abortSignal.removeEventListener('abort', abort);
-		});
+	try {
+		const tx = db.transaction(storeNames, mode);
+		if (abortSignal) {
+			const abort = () => {
+				log?.('debug', 'aborting transaction');
+				try {
+					tx.abort();
+					(tx as any).__aborted = true;
+				} catch (e) {
+					log?.('debug', 'aborting transaction failed', e);
+				}
+			};
+			abortSignal.addEventListener('abort', abort);
+			tx.addEventListener('error', () => {
+				abortSignal.removeEventListener('abort', abort);
+			});
+			tx.addEventListener('complete', () => {
+				abortSignal.removeEventListener('abort', abort);
+			});
+		}
+		return tx;
+	} catch (err) {
+		if (err instanceof Error && err.name === 'InvalidStateError') {
+			// database is probably closing. it's ok, what can you do?
+			log?.('warn', 'Failed to create transaction, database is closing');
+			// mock a Transaction so code can continue,
+			// but doesn't do anything.
+			return {
+				abort: () => {},
+				addEventListener: () => {},
+				objectStore: () => {
+					return {
+						add: () => {},
+						put: () => {},
+						get: () => {},
+						getAll: () => {},
+						delete: () => {},
+						clear: () => {},
+						openCursor: () => {
+							const req = {
+								onsuccess: () => {},
+								onerror: (_: any) => {},
+								result: null,
+							};
+							setTimeout(() => {
+								req.onerror({} as any);
+							}, 0);
+							return req;
+						},
+						index: () => {
+							throw new Error('Transaction is not active');
+						},
+					};
+				},
+				oncomplete: null,
+				onerror: null,
+				onabort: null,
+				error: new Error('Transaction is not active') as any,
+				commit: () => {},
+				db,
+				dispatchEvent: () => false,
+				removeEventListener: () => {},
+				durability: 'default',
+				mode: 'readonly',
+				objectStoreNames: storeNames as any,
+				__aborted: true,
+			} as unknown as IDBTransaction;
+		} else {
+			throw err;
+		}
 	}
-	return tx;
+}
+
+export function isTransactionAborted(tx: IDBTransaction) {
+	return (tx as any).__aborted;
 }
 
 /**

package/src/sync/FileSync.ts

@@ -158,6 +158,7 @@ export class FileSync extends Disposable {
 				this.ctx.log(
 					'error',
 					'File information fetch failed',
+					fileEndpoint + `/${id}`,
 					response.status,
 					await response.text(),
 				);
@@ -178,7 +179,12 @@ export class FileSync extends Disposable {
 				});
 			}
 		} catch (e) {
-			this.ctx.log('error', 'File information fetch failed', e);
+			this.ctx.log(
+				'error',
+				'File information fetch failed',
+				`${fileEndpoint}/${id}`,
+				e,
+			);
 			if (retries.current >= retries.max) {
 				return {
 					success: false,

package/src/sync/Heartbeat.ts

@@ -55,9 +55,11 @@ export class Heartbeat extends EventSubscriber<{
 	stop = () => {
 		if (this.nextBeat) {
 			clearTimeout(this.nextBeat);
+			this.nextBeat = null;
 		}
 		if (this.deadline) {
 			clearTimeout(this.deadline);
+			this.deadline = null;
 		}
 	};
 

package/src/sync/PushPullSync.ts

@@ -7,11 +7,11 @@ import {
 	isVerdantErrorResponse,
 	throttle,
 } from '@verdant-web/common';
-import { PresenceManager } from './PresenceManager.js';
+import { Context } from '../context/context.js';
 import { Heartbeat } from './Heartbeat.js';
+import { PresenceManager } from './PresenceManager.js';
 import { ServerSyncEndpointProvider } from './ServerSyncEndpointProvider.js';
 import { SyncTransport, SyncTransportEvents } from './Sync.js';
-import { Context } from '../context/context.js';
 
 export class PushPullSync
 	extends EventSubscriber<SyncTransportEvents>
@@ -98,12 +98,7 @@ export class PushPullSync
 				}
 				await handlePromise;
 			} else {
-				this.ctx.log(
-					'error',
-					'Sync request failed',
-					response.status,
-					await response.text(),
-				);
+				this.ctx.log('error', 'Sync request failed', host, response.status);
 
 				if (this._isConnected) {
 					this._isConnected = false;
@@ -116,6 +111,8 @@ export class PushPullSync
 					if (json.code === VerdantErrorCode.TokenExpired) {
 						this.endpointProvider.clearCache();
 						this.heartbeat.keepAlive();
+					} else {
+						this.ctx.log('error', 'Server error', json);
 					}
 				}
 
@@ -157,6 +154,14 @@ export class PushPullSync
 	}, 3000);
 
 	send = (message: ClientMessage) => {
+		if (this.status !== 'active') {
+			this.ctx.log(
+				'warn',
+				'Attempted to send message while sync is not active',
+				message,
+			);
+			return;
+		}
 		// only certain messages are sent for pull-based sync.
 		switch (message.type) {
 			case 'presence-update':
@@ -176,11 +181,13 @@ export class PushPullSync
 		if (this.status === 'active') {
 			return;
 		}
+		this.ctx.log('debug', 'Starting push-pull sync');
 		await this.endpointProvider.getEndpoints();
 		this.heartbeat.start(true);
 		this._status = 'active';
 	};
 	stop(): void {
+		this.ctx.log('debug', 'Stopping push-pull sync');
 		this.heartbeat.stop();
 		this._status = 'paused';
 	}

package/src/sync/WebSocketSync.ts

@@ -4,11 +4,11 @@ import {
 	ServerMessage,
 } from '@verdant-web/common';
 import { Backoff, BackoffScheduler } from '../BackoffScheduler.js';
+import { Context } from '../context/context.js';
 import { Heartbeat } from './Heartbeat.js';
 import { PresenceManager } from './PresenceManager.js';
 import { ServerSyncEndpointProvider } from './ServerSyncEndpointProvider.js';
 import { SyncTransport, SyncTransportEvents } from './Sync.js';
-import { Context } from '../context/context.js';
 
 export class WebSocketSync
 	extends EventSubscriber<SyncTransportEvents>
@@ -34,7 +34,7 @@ export class WebSocketSync
 	private heartbeat = new Heartbeat();
 
 	private reconnectScheduler = new BackoffScheduler(
-		new Backoff(60 * 1000, 1.5),
+		new Backoff(2_000, 60_000, 1.5),
 	);
 
 	constructor({
@@ -77,7 +77,6 @@ export class WebSocketSync
 		}
 		this.ctx.log('debug', 'Sync connected');
 		this.onOnlineChange(true);
-		this.reconnectScheduler.reset();
 	};
 
 	private onOnlineChange = async (online: boolean) => {
@@ -106,6 +105,7 @@ export class WebSocketSync
 	};
 
 	private onMessage = async (event: MessageEvent) => {
+		this.reconnectScheduler.reset();
 		if (this._ignoreIncoming) {
 			this.ctx.log(
 				'warn',
@@ -116,6 +116,7 @@ export class WebSocketSync
 		}
 
 		const message = JSON.parse(event.data) as ServerMessage;
+		this.ctx.log('debug', 'Received', message.type, 'message');
 		switch (message.type) {
 			case 'sync-resp':
 				if (message.ackThisNonce) {
@@ -178,16 +179,19 @@ export class WebSocketSync
 	};
 
 	private onError = (event: Event) => {
-		this.ctx.log('error', event);
+		this.ctx.log('error', 'Sync socket error', event);
+		if (this.disposed) return;
 		this.reconnectScheduler.next();
 
 		this.ctx.log('info', `Attempting reconnect to websocket sync`);
 	};
 
 	private onClose = (event: CloseEvent) => {
-		this.ctx.log('info', 'Sync disconnected');
+		this.ctx.log('info', 'Sync socket disconnected');
 		this.onOnlineChange(false);
-		this.onError(event);
+		if (this.disposed) return;
+		this.reconnectScheduler.next();
+		this.ctx.log('info', `Attempting reconnect to websocket sync`);
 	};
 
 	private initializeSocket = async () => {
@@ -282,7 +286,9 @@ export class WebSocketSync
 	stop = () => {
 		this.socket?.removeEventListener('message', this.onMessage);
 		this.socket?.removeEventListener('close', this.onClose);
-		this.socket?.close();
+		if (this.socket?.readyState === WEBSOCKET_OPEN) {
+			this.socket.close();
+		}
 		this.socket = null;
 		this._status = 'paused';
 	};