@verdant-web/store 2.8.4 → 3.0.0-next.0

package/src/queries/CollectionQueries.ts

@@ -1,6 +1,6 @@
 import { CollectionFilter, hashObject } from '@verdant-web/common';
 import { Context } from '../context.js';
-import { EntityStore } from '../entities/EntityStore.js';
+import { EntityStore } from '../entities/2/EntityStore.js';
 import { GetQuery } from './GetQuery.js';
 import { QueryCache } from './QueryCache.js';
 import { FindOneQuery } from './FindOneQuery.js';
@@ -22,7 +22,7 @@ export class CollectionQueries<
 	private context;
 	private documentManager;
 
-	put: (init: Init, options?: { undoable?: boolean }) => Promise<T>;
+	put: (init: Init) => Promise<T>;
 	delete: (id: string, options?: { undoable?: boolean }) => Promise<void>;
 	deleteAll: (ids: string[], options?: { undoable?: boolean }) => Promise<void>;
 
@@ -41,7 +41,7 @@ export class CollectionQueries<
 	}) {
 		this.cache = cache;
 		this.collection = collection;
-		this.hydrate = entities.get as any;
+		this.hydrate = entities.hydrate as any;
 		this.context = context;
 		this.documentManager = documentManager;
 

package/src/queries/FindAllQuery.ts

@@ -29,6 +29,10 @@ export class FindAllQuery<T> extends BaseQuery<T[]> {
 			index: this.index,
 			context: this.context,
 		});
+		this.context.log(
+			'debug',
+			`FindAllQuery: ${oids.length} oids found: ${oids}`,
+		);
 		this.setValue(await Promise.all(oids.map(this.hydrate)));
 	};
 

package/src/queries/QueryCache.ts

@@ -53,4 +53,9 @@ export class QueryCache extends Disposable {
 			}
 		}, this._evictionTime);
 	};
+
+	dropAll = () => {
+		this._cache.forEach((query) => query.dispose());
+		this._cache.clear();
+	};
 }

package/src/queries/QueryableStorage.ts

@@ -0,0 +1,107 @@
+import {
+	ObjectIdentifier,
+	decomposeOid,
+	getIndexValues,
+} from '@verdant-web/common';
+import { IDBService } from '../IDBService.js';
+import { Context } from '../context.js';
+import { storeRequestPromise } from '../idb.js';
+
+export class QueryableStorage extends IDBService {
+	private ctx;
+
+	constructor({ ctx }: { ctx: Context }) {
+		super(ctx.documentDb, { log: ctx.log });
+		this.ctx = ctx;
+		this.addDispose(
+			this.ctx.internalEvents.subscribe('documentDbChanged', (db) => {
+				this.db = db;
+			}),
+		);
+	}
+
+	/**
+	 * DELETES EVERYTHING IN THE QUERYABLE DATABASE
+	 */
+	reset = async () => {
+		const allCollections = Object.keys(this.ctx.schema.collections);
+		const tx = this.ctx.documentDb.transaction(allCollections, 'readwrite');
+		await Promise.all(
+			allCollections.map((collection) => {
+				const store = tx.objectStore(collection);
+				return storeRequestPromise(store.clear());
+			}),
+		);
+		// notify queries to re-run now.
+		this.ctx.entityEvents.emit('collectionsChanged', allCollections);
+		this.ctx.log('info', '💨 Reset queryable storage');
+	};
+
+	saveEntities = async (
+		entities: { oid: ObjectIdentifier; getSnapshot: () => any }[],
+		opts?: { abort?: AbortSignal },
+	) => {
+		if (entities.length === 0) {
+			return;
+		}
+
+		const collections = Array.from(
+			new Set(entities.map((e) => decomposeOid(e.oid).collection)),
+		);
+		const options = {
+			transaction: this.createTransaction(collections, {
+				mode: 'readwrite',
+				abort: opts?.abort,
+			}),
+		};
+		await Promise.all(
+			entities.map(async (e) => {
+				const snapshot = e.getSnapshot();
+				try {
+					await this.saveDocument(e.oid, snapshot, options);
+				} catch (err) {
+					this.ctx.log(
+						'error',
+						`Error saving document ${e.oid} (${JSON.stringify(snapshot)})`,
+						err,
+					);
+					if (err instanceof Error) {
+						throw err;
+					} else {
+						throw new Error('Unknown error saving document');
+					}
+				}
+			}),
+		);
+		options.transaction.commit();
+		this.ctx.entityEvents.emit('collectionsChanged', collections);
+		for (const entity of entities) {
+			this.ctx.entityEvents.emit('documentChanged', entity.oid);
+		}
+	};
+
+	private saveDocument = async (
+		oid: ObjectIdentifier,
+		doc: any,
+		{ transaction }: { transaction?: IDBTransaction },
+	) => {
+		this.ctx.log('debug', `Saving document indexes for querying ${oid}`, doc);
+		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);
+			await this.run(collection, (store) => store.put(indexes), {
+				mode: 'readwrite',
+				transaction,
+			});
+			this.ctx.log('debug', `Saved document indexes for querying ${oid}`, doc);
+		}
+	};
+}

package/src/queries/dbQueries.ts

@@ -1,6 +1,7 @@
 import { CollectionFilter, createOid } from '@verdant-web/common';
 import { Context } from '../context.js';
 import { getRange } from './ranges.js';
+import { isAbortError } from '../idb.js';
 
 function getStore(db: IDBDatabase, collection: string, write?: boolean) {
 	return db
@@ -18,7 +19,7 @@ export async function findOneOid({
 	context: Context;
 }) {
 	const store = getStore(context.documentDb, collection);
-	const source = index ? store.index(index.where) : store;
+	const source = index?.where ? store.index(index.where) : store;
 	const range = getRange(context.schema, collection, index);
 	const direction = index?.order === 'desc' ? 'prev' : 'next';
 	const request = source.openCursor(range, direction);
@@ -39,6 +40,8 @@ export async function findOneOid({
 					request.error,
 				);
 				resolve(null);
+			} else if (isAbortError(request.error)) {
+				resolve(null);
 			} else {
 				reject(request.error);
 			}
@@ -57,7 +60,7 @@ export async function findAllOids({
 	context: Context;
 }) {
 	const store = getStore(context.documentDb, collection);
-	const source = index ? store.index(index.where) : store;
+	const source = index?.where ? store.index(index.where) : store;
 	const range = getRange(context.schema, collection, index);
 	const direction = index?.order === 'desc' ? 'prev' : 'next';
 	const request = source.openCursor(range, direction);
@@ -80,6 +83,8 @@ export async function findAllOids({
 					request.error,
 				);
 				resolve([]);
+			} else if (isAbortError(request.error)) {
+				resolve([]);
 			} else {
 				reject(request.error);
 			}
@@ -102,7 +107,7 @@ export async function findPageOfOids({
 	offset?: number;
 }) {
 	const store = getStore(context.documentDb, collection);
-	const source = index ? store.index(index.where) : store;
+	const source = index?.where ? store.index(index.where) : store;
 	const range = getRange(context.schema, collection, index);
 	const direction = index?.order === 'desc' ? 'prev' : 'next';
 	const request = source.openCursor(range, direction);
@@ -141,6 +146,8 @@ export async function findPageOfOids({
 					request.error,
 				);
 				resolve([]);
+			} else if (isAbortError(request.error)) {
+				resolve([]);
 			} else {
 				reject(request.error);
 			}

package/src/queries/utils.ts

@@ -1,5 +1,5 @@
 import { CollectionIndexFilter, hashObject } from '@verdant-web/common';
-import { Entity } from '../entities/Entity.js';
+import { Entity } from '../entities/2/Entity.js';
 
 function existsFilter<T>(x: T | null): x is T {
 	return x !== null;

package/src/sync/FileSync.ts

@@ -14,6 +14,7 @@ export type FilePullResult =
 	| {
 			success: false;
 			retry: boolean;
+			error?: any;
 	  };
 
 export class FileSync {
@@ -117,6 +118,7 @@ export class FileSync {
 			this.log('error', 'File information fetch failed', e);
 			return {
 				success: false,
+				error: e,
 				retry: true,
 			};
 		}

package/src/sync/PushPullSync.ts

@@ -152,11 +152,18 @@ export class PushPullSync
 		this._status = 'paused';
 	}
 
-	dispose = () => {};
+	destroy = () => {
+		this.dispose();
+		this.stop();
+	};
 	reconnect(): void {
 		this.heartbeat.start(true);
 	}
 
+	ignoreIncoming(): void {
+		this.stop();
+	}
+
 	// on a heartbeat, do a sync
 	private onHeartbeat = async () => {
 		// for HTTP sync we send presence first, so that the sync-resp message

package/src/sync/Sync.ts

@@ -40,9 +40,10 @@ export interface SyncTransport {
 	send(message: ClientMessage): void;
 
 	start(): void;
+	ignoreIncoming(): void;
 	stop(): void;
 
-	dispose(): void;
+	destroy(): void;
 
 	reconnect(): void;
 
@@ -71,7 +72,9 @@ export class NoSync<Presence = any, Profile = any>
 
 	public stop(): void {}
 
-	public dispose = () => {};
+	public ignoreIncoming(): void {}
+
+	public destroy = () => {};
 
 	public reconnect(): void {}
 
@@ -285,7 +288,7 @@ export class ServerSync<Presence = any, Profile = any>
 					}, 1000);
 				}
 			};
-			let switchoverTimeout: NodeJS.Timer;
+			let switchoverTimeout: NodeJS.Timeout;
 			this.presence.subscribe('peersChanged', decideIfUpgrade);
 			if (automaticTransportSelection !== 'peers-only') {
 				this.presence.subscribe('selfChanged', decideIfUpgrade);
@@ -453,9 +456,14 @@ export class ServerSync<Presence = any, Profile = any>
 		return this.activeSync.stop();
 	};
 
-	public dispose = () => {
-		this.webSocketSync.dispose();
-		this.pushPullSync.dispose();
+	public ignoreIncoming(): void {
+		this.activeSync.ignoreIncoming();
+	}
+
+	public destroy = () => {
+		this.dispose();
+		this.webSocketSync.destroy();
+		this.pushPullSync.destroy();
 	};
 
 	public reconnect = () => {

package/src/sync/WebSocketSync.ts

@@ -21,10 +21,13 @@ export class WebSocketSync
 	private connectQueue: ClientMessage[] = [];
 	// messages awaiting sync response to send
 	private syncQueue: ClientMessage[] = [];
+	// messages waiting for sync to finish
+	private incomingQueue: ServerMessage[] = [];
 	private endpointProvider;
 	private _status: 'active' | 'paused' = 'paused';
 	private synced = false;
 	private hasStartedSync = false;
+	private _ignoreIncoming = false;
 
 	readonly mode = 'realtime';
 	private log = (...args: any[]) => {};
@@ -75,6 +78,9 @@ export class WebSocketSync
 
 	private onOnlineChange = async (online: boolean) => {
 		this.log('Socket online change', online);
+		if (this.disposed) {
+			return;
+		}
 		if (!online) {
 			this.hasStartedSync = false;
 			this.synced = false;
@@ -95,6 +101,14 @@ export class WebSocketSync
 	};
 
 	private onMessage = async (event: MessageEvent) => {
+		if (this._ignoreIncoming) {
+			this.log(
+				'Ignoring incoming message (ignore incoming flag set)',
+				event.data,
+			);
+			return;
+		}
+
 		const message = JSON.parse(event.data) as ServerMessage;
 		switch (message.type) {
 			case 'sync-resp':
@@ -107,22 +121,39 @@ export class WebSocketSync
 				this.hasStartedSync = true;
 				this.synced = true;
 				if (this.syncQueue.length) {
-					for (const msg of this.syncQueue) {
-						this.send(msg);
+					if (message.overwriteLocalData) {
+						this.log(
+							'warn',
+							'Overwriting local data - dropping outgoing message queue',
+						);
+						this.syncQueue = [];
+					} else {
+						for (const msg of this.syncQueue) {
+							this.send(msg);
+						}
+						this.syncQueue = [];
 					}
-					this.syncQueue = [];
 				}
+				this.emit('message', message);
+				if (this.incomingQueue.length) {
+					for (const msg of this.incomingQueue) {
+						this.emit('message', msg);
+					}
+					this.incomingQueue = [];
+				}
+				break;
 			case 'need-since':
 			case 'presence-changed':
 			case 'presence-offline':
 				this.emit('message', message);
 				break;
 			case 'op-re':
-				if (!this.hasStartedSync) {
+				if (!this.synced) {
 					this.log(
-						`Skipping op-re message because sync hasn't started yet`,
+						`Enqueueing op-re message because sync hasn't finished yet`,
 						message,
 					);
+					this.incomingQueue.push(message);
 					break;
 				}
 				this.emit('message', message);
@@ -215,10 +246,9 @@ export class WebSocketSync
 		}
 	};
 
-	dispose = () => {
-		this.socket?.removeEventListener('message', this.onMessage);
-		this.socket?.removeEventListener('close', this.onClose);
-		this.socket?.close();
+	destroy = () => {
+		this.dispose();
+		this.stop();
 	};
 
 	start = () => {
@@ -230,11 +260,18 @@ export class WebSocketSync
 	};
 
 	stop = () => {
-		this.dispose();
+		this.socket?.removeEventListener('message', this.onMessage);
+		this.socket?.removeEventListener('close', this.onClose);
+		this.socket?.close();
 		this.socket = null;
 		this._status = 'paused';
 	};
 
+	ignoreIncoming(): void {
+		this.incomingQueue = [];
+		this._ignoreIncoming = true;
+	}
+
 	get isConnected() {
 		return this.socket?.readyState === WebSocket.OPEN;
 	}