@verdant-web/store 5.4.0 → 5.4.3

package/src/queries/FindAllQuery.ts

@@ -27,18 +27,20 @@ export class FindAllQuery<T> extends BaseQuery<T[]> {
 	}
 
 	protected run = async () => {
-		const { result: oids } = await (
-			await this.context.documents
-		).findAllOids({
-			collection: this.collection,
-			index: this.index,
-			limit: this.limit,
-		});
+		const { result: oids } = await this.measureSweep(async () =>
+			(await this.context.documents).findAllOids({
+				collection: this.collection,
+				index: this.index,
+				limit: this.limit,
+			}),
+		);
 		this.context.log(
 			'debug',
 			`FindAllQuery: ${oids.length} oids found: ${oids}`,
 		);
-		this.setValue(await Promise.all(oids.map(this.hydrate)));
+		this.setValue(
+			await this.measureHydration(() => Promise.all(oids.map(this.hydrate))),
+		);
 	};
 
 	[UPDATE] = (index: CollectionFilter | undefined) => {

package/src/queries/FindInfiniteQuery.ts

@@ -37,32 +37,36 @@ export class FindInfiniteQuery<T> extends BaseQuery<T[]> {
 	}
 
 	protected run = async () => {
-		const { result, hasNextPage } = await (
-			await this.context.documents
-		).findAllOids({
-			collection: this.collection,
-			limit: this._pageSize * this._upToPage,
-			offset: 0,
-			index: this.index,
-		});
+		const { result, hasNextPage } = await this.measureSweep(async () =>
+			(await this.context.documents).findAllOids({
+				collection: this.collection,
+				limit: this._pageSize * this._upToPage,
+				offset: 0,
+				index: this.index,
+			}),
+		);
 		this._hasNextPage = hasNextPage;
-		this.setValue(await Promise.all(result.map(this.hydrate)));
+		this.setValue(
+			await this.measureHydration(() => Promise.all(result.map(this.hydrate))),
+		);
 	};
 
 	public loadMore = async () => {
-		const { result, hasNextPage } = await (
-			await this.context.documents
-		).findAllOids({
-			collection: this.collection,
-			limit: this._pageSize,
-			offset: this._pageSize * this._upToPage,
-			index: this.index,
-		});
+		const { result, hasNextPage } = await this.measureSweep(async () =>
+			(await this.context.documents).findAllOids({
+				collection: this.collection,
+				limit: this._pageSize,
+				offset: this._pageSize * this._upToPage,
+				index: this.index,
+			}),
+		);
 		this._hasNextPage = hasNextPage;
 		this._upToPage++;
 		this.setValue([
 			...this.current,
-			...(await Promise.all(result.map(this.hydrate))),
+			...(await this.measureHydration(() =>
+				Promise.all(result.map(this.hydrate)),
+			)),
 		]);
 	};
 

package/src/queries/FindOneQuery.ts

@@ -23,13 +23,15 @@ export class FindOneQuery<T> extends BaseQuery<T | null> {
 	}
 
 	protected run = async () => {
-		const oid = await (
-			await this.context.documents
-		).findOneOid({
-			collection: this.collection,
-			index: this.index,
-		});
-		this.setValue(oid ? await this.hydrate(oid) : null);
+		const oid = await this.measureSweep(async () =>
+			(await this.context.documents).findOneOid({
+				collection: this.collection,
+				index: this.index,
+			}),
+		);
+		this.setValue(
+			oid ? await this.measureHydration(() => this.hydrate(oid)) : null,
+		);
 	};
 
 	[UPDATE] = (index: CollectionFilter | undefined) => {

package/src/queries/FindPageQuery.ts

@@ -48,16 +48,18 @@ export class FindPageQuery<T> extends BaseQuery<T[]> {
 	}
 
 	protected run = async () => {
-		const { result, hasNextPage } = await (
-			await this.context.documents
-		).findAllOids({
-			collection: this.collection,
-			index: this.index,
-			limit: this._pageSize,
-			offset: this._page * this._pageSize,
-		});
+		const { result, hasNextPage } = await this.measureSweep(async () =>
+			(await this.context.documents).findAllOids({
+				collection: this.collection,
+				index: this.index,
+				limit: this._pageSize,
+				offset: this._page * this._pageSize,
+			}),
+		);
 		this._hasNextPage = hasNextPage;
-		this.setValue(await Promise.all(result.map(this.hydrate)));
+		this.setValue(
+			await this.measureHydration(() => Promise.all(result.map(this.hydrate))),
+		);
 	};
 
 	nextPage = async () => {

package/src/queries/GetQuery.ts

@@ -22,7 +22,7 @@ export class GetQuery<T> extends BaseQuery<T | null> {
 	}
 
 	protected run = async () => {
-		const value = await this.hydrate(this.oid);
+		const value = await this.measureHydration(() => this.hydrate(this.oid));
 		this.setValue(value);
 	};
 }

package/src/queries/QueryCache.ts

@@ -1,6 +1,7 @@
 import { Context } from '../context/context.js';
 import { Disposable } from '../utils/Disposable.js';
 import { BaseQuery, ON_ALL_UNSUBSCRIBED } from './BaseQuery.js';
+import { QueryDiagnostic, QueryDiagnostics } from './diagnostics.js';
 
 export class QueryCache extends Disposable {
 	private _cache: Map<string, BaseQuery<any>> = new Map();
@@ -8,6 +9,7 @@ export class QueryCache extends Disposable {
 	private context;
 	/** A set of query keys to keep alive even if they unsubscribe */
 	private _holds = new Set<string>();
+	private _inactiveDiagnostics = new Map<string, QueryDiagnostic>();
 
 	constructor({
 		evictionTime = 5 * 1000,
@@ -38,6 +40,7 @@ export class QueryCache extends Disposable {
 
 	set<V extends BaseQuery<any>>(value: V) {
 		this._cache.set(value.key, value);
+		this._inactiveDiagnostics.delete(value.key);
 		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
@@ -47,6 +50,15 @@ export class QueryCache extends Disposable {
 		return value;
 	}
 
+	get diagnostics(): QueryDiagnostics {
+		return {
+			queries: [
+				...this._cache.values().map((query) => query.getDiagnostic(true)),
+				...this._inactiveDiagnostics.values(),
+			],
+		};
+	}
+
 	getOrSet<V extends BaseQuery<any>>(
 		key: string,
 		create: () => V,
@@ -78,19 +90,23 @@ export class QueryCache extends Disposable {
 			// got a different version of this query.
 			if (this._cache.get(query.key) === query) {
 				this._cache.delete(query.key);
+				this._inactiveDiagnostics.set(query.key, query.getDiagnostic(false));
 				this.context.log('debug', 'QueryCache: evicted query', query.key);
 			}
 		}, this._evictionTime);
 	};
 
-	dropAll = () => {
+		dropAll = () => {
 		this.context.log(
 			'debug',
 			'QueryCache: drop all',
 			this._cache.size,
 			'queries',
 		);
-		this._cache.forEach((query) => query.dispose());
+		this._cache.forEach((query) => {
+			this._inactiveDiagnostics.set(query.key, query.getDiagnostic(false));
+			query.dispose();
+		});
 		this._cache.clear();
 	};
 
@@ -135,4 +151,5 @@ export type PublicQueryCacheAPI = Pick<
 	| 'keepAlives'
 	| 'forceRefreshAll'
 	| 'activeKeys'
+	| 'diagnostics'
 >;

package/src/queries/diagnostics.ts

@@ -0,0 +1,38 @@
+import { Entity } from '../entities/Entity.js';
+import type { QueryStatus } from './BaseQuery.js';
+
+export type QueryTiming = {
+	sweep: number | null;
+	hydration: number | null;
+	total: number | null;
+};
+
+export type QueryRun = QueryTiming & {
+	startedAt: number;
+};
+
+export type QueryDiagnostic = {
+	key: string;
+	startedAt: number | null;
+	collection: string;
+	type: string;
+	status: QueryStatus;
+	active: boolean;
+	result: unknown;
+	timing: QueryTiming;
+	runs: QueryRun[];
+};
+
+export type QueryDiagnostics = {
+	queries: QueryDiagnostic[];
+};
+
+export const getDiagnosticResult = (value: unknown): unknown => {
+	if (Array.isArray(value)) {
+		return value.map(getDiagnosticResult);
+	}
+	if (value instanceof Entity) {
+		return value.getSnapshot();
+	}
+	return value;
+};

package/src/queries/ranges.ts

@@ -46,15 +46,14 @@ const rangeIndexToIdbKeyRange = (filter: RangeCollectionIndexFilter) => {
 };
 
 const compoundIndexToIdbKeyRange = (
-	// FIXME:
-	schema: any,
+	schema: StorageSchema,
 	collection: string,
 	filter: CollectionCompoundIndexFilter,
 ) => {
 	// validate the usage of the compound index:
 	// - all match fields must be contiguous at the start of the compound order
 	const indexDefinition =
-		schema.collections[collection].compounds[filter.where];
+		schema.collections[collection].compounds?.[filter.where];
 	assert(
 		indexDefinition,
 		`Index ${filter.where} does not exist on collection ${collection}`,

package/src/sync/WebSocketSync.ts

@@ -314,6 +314,8 @@ export class WebSocketSync
 		await this.sendDisconnecting();
 		this.socket?.removeEventListener('message', this.onMessage);
 		this.socket?.removeEventListener('close', this.onClose);
+		this.socket?.removeEventListener('error', this.onError);
+		this.socket?.removeEventListener('open', this.onOpen);
 		if (this.socket?.readyState === WEBSOCKET_OPEN) {
 			this.socket.close();
 		}