@verdant-web/store 2.0.1

package/src/queries2/BaseQuery.ts

@@ -0,0 +1,149 @@
+import { EventSubscriber } from '@verdant-web/common';
+import { filterResultSet } from './utils.js';
+import { Entity } from '../reactives/Entity.js';
+import { Disposable } from '../utils/Disposable.js';
+import { Context } from '../context.js';
+import { Resolvable } from '../utils/Resolvable.js';
+
+export type BaseQueryEvents = {
+	change: (value: any) => void;
+};
+
+export type BaseQueryOptions<T> = {
+	context: Context;
+	initial: T;
+	collection: string;
+	key: string;
+	shouldUpdate?: (updatedCollections: string[]) => boolean;
+};
+
+export type QueryStatus = 'initial' | 'running' | 'ready';
+
+export const ON_ALL_UNSUBSCRIBED = Symbol('ON_ALL_UNSUBSCRIBED');
+export const UPDATE = Symbol('UPDATE');
+
+export abstract class BaseQuery<T> extends Disposable {
+	private _rawValue;
+	private _value;
+
+	private _events;
+	private _internalUnsubscribes: (() => void)[] = [];
+	private _allUnsubscribedHandler?: (query: BaseQuery<T>) => void;
+	private _status: QueryStatus = 'initial';
+	private _executionPromise: Promise<T> | null = null;
+
+	protected context;
+
+	readonly collection;
+	readonly key;
+
+	constructor({
+		initial,
+		context,
+		collection,
+		key,
+		shouldUpdate,
+	}: BaseQueryOptions<T>) {
+		super();
+		this._rawValue = initial;
+		this._value = initial;
+		this._events = new EventSubscriber<BaseQueryEvents>(
+			(event: keyof BaseQueryEvents) => {
+				if (event === 'change') this._allUnsubscribedHandler?.(this);
+			},
+		);
+		this.context = context;
+		this.key = key;
+		this.collection = collection;
+		const shouldUpdateFn =
+			shouldUpdate ||
+			((collections: string[]) => collections.includes(collection));
+		this.addDispose(
+			this.context.entityEvents.subscribe(
+				'collectionsChanged',
+				(collections) => {
+					if (shouldUpdateFn(collections)) {
+						this.context.log('info', 'Updating query', this.key);
+						this.execute();
+					}
+				},
+			),
+		);
+	}
+
+	get current() {
+		return this._value;
+	}
+
+	get resolved() {
+		if (this.status === 'ready') return Promise.resolve(this._value);
+		return this._executionPromise ?? this.execute();
+	}
+
+	get subscribed() {
+		return this._events.totalSubscriberCount() > 0;
+	}
+
+	get status() {
+		return this._status;
+	}
+
+	subscribe = (callback: (value: T) => void) => {
+		// accessing for side effects... eh
+		this.resolved;
+		return this._events.subscribe('change', callback);
+	};
+
+	protected setValue = (value: T) => {
+		this._rawValue = value;
+		this.subscribeToDeleteAndRestore(this._rawValue);
+		this._value = filterResultSet(value);
+		this._status = 'ready';
+		this._events.emit('change', this._value);
+	};
+
+	// re-applies filtering if results have changed
+	protected refreshValue = () => {
+		this.setValue(this._rawValue);
+	};
+
+	private subscribeToDeleteAndRestore = (value: T) => {
+		while (this._internalUnsubscribes.length) {
+			this._internalUnsubscribes.pop()?.();
+		}
+
+		if (Array.isArray(value)) {
+			value.forEach((entity: any) => {
+				if (entity instanceof Entity) {
+					this._internalUnsubscribes.push(
+						entity.subscribe('delete', this.refreshValue),
+					);
+					this._internalUnsubscribes.push(
+						entity.subscribe('restore', this.refreshValue),
+					);
+				}
+			});
+		} else if (value instanceof Entity) {
+			this._internalUnsubscribes.push(
+				value.subscribe('delete', this.refreshValue),
+			);
+			this._internalUnsubscribes.push(
+				value.subscribe('restore', () => {
+					this.refreshValue();
+				}),
+			);
+		}
+	};
+
+	execute = () => {
+		this.context.log('debug', 'Executing query', this.key);
+		this._status = 'running';
+		this._executionPromise = this.run().then(() => this._value);
+		return this._executionPromise;
+	};
+	protected abstract run(): Promise<void>;
+
+	[ON_ALL_UNSUBSCRIBED] = (handler: (query: BaseQuery<T>) => void) => {
+		this._allUnsubscribedHandler = handler;
+	};
+}

package/src/queries2/CollectionQueries.ts

@@ -0,0 +1,174 @@
+import { CollectionFilter, hashObject } from '@verdant-web/common';
+import { Context } from '../context.js';
+import { EntityStore } from '../reactives/EntityStore.js';
+import { GetQuery } from './GetQuery.js';
+import { QueryCache } from './QueryCache.js';
+import { FindOneQuery } from './FindOneQuery.js';
+import { FindPageQuery } from './FindPageQuery.js';
+import { FindInfiniteQuery } from './FindInfiniteQuery.js';
+import { FindAllQuery } from './FindAllQuery.js';
+import { DocumentManager } from '../DocumentManager.js';
+import cuid from 'cuid';
+import { ObjectEntity } from '../index.js';
+
+export class CollectionQueries<
+	T extends ObjectEntity<any, any>,
+	Init,
+	Filter extends CollectionFilter,
+> {
+	private cache;
+	private collection;
+	private hydrate: (oid: string) => Promise<T>;
+	private context;
+	private documentManager;
+
+	put: (init: Init, options?: { undoable?: boolean }) => Promise<T>;
+	delete: (id: string, options?: { undoable?: boolean }) => Promise<void>;
+	deleteAll: (ids: string[], options?: { undoable?: boolean }) => Promise<void>;
+
+	constructor({
+		collection,
+		cache,
+		entities,
+		context,
+		documentManager,
+	}: {
+		collection: string;
+		cache: QueryCache;
+		entities: EntityStore;
+		context: Context;
+		documentManager: DocumentManager<any>;
+	}) {
+		this.cache = cache;
+		this.collection = collection;
+		this.hydrate = entities.get as any;
+		this.context = context;
+		this.documentManager = documentManager;
+
+		this.put = this.documentManager.create.bind(
+			this.documentManager,
+			this.collection,
+		);
+		this.delete = this.documentManager.delete.bind(
+			this.documentManager,
+			this.collection,
+		);
+		this.deleteAll = this.documentManager.deleteAllFromCollection.bind(
+			this.documentManager,
+			this.collection,
+		);
+	}
+
+	private serializeIndex = (index?: CollectionFilter) => {
+		if (!index) return '';
+		return hashObject(index);
+	};
+
+	get = (id: string) => {
+		const key = `get:${this.collection}:${id}`;
+		return this.cache.getOrSet(
+			key,
+			() =>
+				new GetQuery<T>({
+					id,
+					collection: this.collection,
+					hydrate: this.hydrate,
+					context: this.context,
+					key,
+				}),
+		);
+	};
+
+	findOne = ({
+		index,
+		key: providedKey,
+	}: { index?: Filter; key?: string } = {}) => {
+		const key =
+			providedKey || `findOne:${this.collection}:${this.serializeIndex(index)}`;
+		return this.cache.getOrSet(
+			key,
+			() =>
+				new FindOneQuery<T>({
+					index,
+					collection: this.collection,
+					hydrate: this.hydrate,
+					context: this.context,
+					key,
+				}),
+		);
+	};
+
+	findAll = ({
+		index,
+		key: providedKey,
+	}: { index?: Filter; key?: string } = {}) => {
+		const key =
+			providedKey || `findAll:${this.collection}:${this.serializeIndex(index)}`;
+		return this.cache.getOrSet(
+			key,
+			() =>
+				new FindAllQuery<T>({
+					index,
+					collection: this.collection,
+					hydrate: this.hydrate,
+					context: this.context,
+					key,
+				}),
+		);
+	};
+
+	findPage = ({
+		index,
+		pageSize,
+		page,
+		key: providedKey,
+	}: {
+		index?: Filter;
+		pageSize: number;
+		page: number;
+		key?: string;
+	}) => {
+		const key =
+			providedKey ||
+			`findPage:${this.collection}:${this.serializeIndex(index)}:${pageSize}`;
+		return this.cache.set(
+			new FindPageQuery<T>({
+				index,
+				collection: this.collection,
+				hydrate: this.hydrate,
+				context: this.context,
+				key,
+				pageSize,
+				page,
+			}),
+		);
+	};
+
+	findAllInfinite = ({
+		index,
+		pageSize,
+		key: providedKey,
+	}: {
+		index?: Filter;
+		pageSize: number;
+		key?: string;
+	}) => {
+		const key =
+			providedKey ||
+			`findAllInfinite:${this.collection}:${this.serializeIndex(
+				index,
+			)}:${pageSize}`;
+		return this.cache.getOrSet(
+			key,
+			() =>
+				new FindInfiniteQuery<T>({
+					index,
+					collection: this.collection,
+					hydrate: this.hydrate,
+					context: this.context,
+					key,
+					pageSize,
+				}),
+		);
+	};
+}

package/src/queries2/FindAllQuery.ts

@@ -0,0 +1,34 @@
+import { CollectionFilter } from '@verdant-web/common';
+import { Context } from '../context.js';
+import { findAllOids } from './dbQueries.js';
+import { BaseQuery, BaseQueryOptions } from './BaseQuery.js';
+
+export class FindAllQuery<T> extends BaseQuery<T[]> {
+	private index;
+	private hydrate;
+
+	constructor({
+		index,
+		hydrate,
+		...rest
+	}: {
+		index?: CollectionFilter;
+		hydrate: (oid: string) => Promise<T>;
+	} & Omit<BaseQueryOptions<T[]>, 'initial'>) {
+		super({
+			initial: [],
+			...rest,
+		});
+		this.index = index;
+		this.hydrate = hydrate;
+	}
+
+	protected run = async () => {
+		const oids = await findAllOids({
+			collection: this.collection,
+			index: this.index,
+			context: this.context,
+		});
+		this.setValue(await Promise.all(oids.map(this.hydrate)));
+	};
+}

package/src/queries2/FindInfiniteQuery.ts

@@ -0,0 +1,66 @@
+import { CollectionFilter } from '@verdant-web/common';
+import { BaseQuery, BaseQueryOptions } from './BaseQuery.js';
+import { findPageOfOids } from './dbQueries.js';
+
+export class FindInfiniteQuery<T> extends BaseQuery<T[]> {
+	private index;
+	private hydrate;
+	private _upToPage = 1;
+	private _pageSize: number;
+	private _hasNextPage: boolean = false;
+
+	get pageSize() {
+		return this._pageSize;
+	}
+
+	get hasMore() {
+		return this._hasNextPage;
+	}
+
+	constructor({
+		hydrate,
+		pageSize,
+		index,
+		...rest
+	}: {
+		hydrate: (oid: string) => Promise<T>;
+		pageSize: number;
+		index?: CollectionFilter;
+	} & Omit<BaseQueryOptions<T[]>, 'initial'>) {
+		super({
+			initial: [],
+			...rest,
+		});
+		this.index = index;
+		this.hydrate = hydrate;
+		this._pageSize = pageSize;
+	}
+
+	protected run = async () => {
+		const { result, hasNextPage } = await findPageOfOids({
+			collection: this.collection,
+			context: this.context,
+			limit: this._pageSize * this._upToPage,
+			offset: 0,
+			index: this.index,
+		});
+		this._hasNextPage = hasNextPage;
+		this.setValue(await Promise.all(result.map(this.hydrate)));
+	};
+
+	public loadMore = async () => {
+		const { result, hasNextPage } = await findPageOfOids({
+			collection: this.collection,
+			context: this.context,
+			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))),
+		]);
+	};
+}

package/src/queries2/FindOneQuery.ts

@@ -0,0 +1,34 @@
+import { CollectionFilter } from '@verdant-web/common';
+import { Context } from '../context.js';
+import { BaseQuery, BaseQueryOptions } from './BaseQuery.js';
+import { findOneOid } from './dbQueries.js';
+
+export class FindOneQuery<T> extends BaseQuery<T | null> {
+	private index;
+	private hydrate;
+
+	constructor({
+		index,
+		hydrate,
+		...rest
+	}: {
+		index?: CollectionFilter;
+		hydrate: (oid: string) => Promise<T>;
+	} & Omit<BaseQueryOptions<T | null>, 'initial'>) {
+		super({
+			initial: null,
+			...rest,
+		});
+		this.index = index;
+		this.hydrate = hydrate;
+	}
+
+	protected run = async () => {
+		const oid = await findOneOid({
+			collection: this.collection,
+			index: this.index,
+			context: this.context,
+		});
+		this.setValue(oid ? await this.hydrate(oid) : null);
+	};
+}

package/src/queries2/FindPageQuery.ts

@@ -0,0 +1,80 @@
+import { CollectionFilter } from '@verdant-web/common';
+import { BaseQuery, BaseQueryOptions } from './BaseQuery.js';
+import { findPageOfOids } from './dbQueries.js';
+
+export class FindPageQuery<T> extends BaseQuery<T[]> {
+	private index;
+	private hydrate;
+	private _pageSize: number;
+	private _page: number;
+	private _hasNextPage: boolean = false;
+
+	get pageSize() {
+		return this._pageSize;
+	}
+
+	get page() {
+		return this._page;
+	}
+
+	get hasNextPage() {
+		return this._hasNextPage;
+	}
+
+	get hasPreviousPage() {
+		return this._page > 0;
+	}
+
+	constructor({
+		index,
+		hydrate,
+		pageSize,
+		page,
+		...rest
+	}: {
+		index?: CollectionFilter;
+		hydrate: (oid: string) => Promise<T>;
+		pageSize: number;
+		page: number;
+	} & Omit<BaseQueryOptions<T[]>, 'initial'>) {
+		super({
+			initial: [],
+			...rest,
+		});
+		this.index = index;
+		this.hydrate = hydrate;
+		this._pageSize = pageSize;
+		this._page = page;
+	}
+
+	protected run = async () => {
+		const { result, hasNextPage } = await findPageOfOids({
+			collection: this.collection,
+			index: this.index,
+			context: this.context,
+			limit: this._pageSize,
+			offset: this._page * this._pageSize,
+		});
+		this._hasNextPage = hasNextPage;
+		this.setValue(await Promise.all(result.map(this.hydrate)));
+	};
+
+	nextPage = async () => {
+		if (!this.hasNextPage) return;
+
+		this._page++;
+		await this.run();
+	};
+
+	previousPage = async () => {
+		if (this._page === 0) return;
+
+		this._page--;
+		await this.run();
+	};
+
+	setPage = async (page: number) => {
+		this._page = page;
+		await this.run();
+	};
+}

package/src/queries2/GetQuery.ts

@@ -0,0 +1,28 @@
+import { createOid } from '@verdant-web/common';
+import { BaseQuery, BaseQueryOptions } from './BaseQuery.js';
+
+export class GetQuery<T> extends BaseQuery<T | null> {
+	private hydrate;
+	private oid;
+
+	constructor({
+		id,
+		hydrate,
+		...rest
+	}: {
+		id: string;
+		hydrate: (oid: string) => Promise<T>;
+	} & Omit<BaseQueryOptions<T | null>, 'initial'>) {
+		super({
+			initial: null,
+			...rest,
+		});
+		this.oid = createOid(rest.collection, id, []);
+		this.hydrate = hydrate;
+	}
+
+	protected run = async () => {
+		const value = await this.hydrate(this.oid);
+		this.setValue(value);
+	};
+}

package/src/queries2/QueryCache.ts

@@ -0,0 +1,49 @@
+import { Context } from '../context.js';
+import { Disposable } from '../utils/Disposable.js';
+import { BaseQuery, ON_ALL_UNSUBSCRIBED } from './BaseQuery.js';
+
+export class QueryCache extends Disposable {
+	private _cache: Map<string, BaseQuery<any>> = new Map();
+	private _evictionTime;
+	private context;
+
+	constructor({
+		evictionTime = 5 * 1000,
+		context,
+	}: {
+		evictionTime?: number;
+		context: Context;
+	}) {
+		super();
+
+		this._evictionTime = evictionTime;
+		this.context = context;
+	}
+
+	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);
+		return value;
+	}
+
+	getOrSet<V extends BaseQuery<any>>(key: string, create: () => V) {
+		const existing = this.get<V>(key);
+		if (existing) return existing;
+		return this.set(create());
+	}
+
+	private onQueryUnsubscribed = (query: BaseQuery<any>) => {
+		setTimeout(() => {
+			if (query.subscribed) 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._evictionTime);
+	};
+}