@verdant-web/store 3.12.1 → 4.0.0-next.0

package/src/metadata/OperationsStore.ts

@@ -1,332 +0,0 @@
-import {
-	createCompoundIndexValue,
-	createLowerBoundIndexValue,
-	createUpperBoundIndexValue,
-	getOidRoot,
-	ObjectIdentifier,
-	Operation,
-	assert,
-} from '@verdant-web/common';
-import { IDBService } from '../IDBService.js';
-import { isAbortError } from '../idb.js';
-
-export type ClientOperation = Operation & {
-	isLocal: boolean;
-};
-
-export type StoredClientOperation = ClientOperation & {
-	oid_timestamp: string;
-	l_t: string;
-	d_t: string;
-};
-
-export class OperationsStore extends IDBService {
-	constructor(db: IDBDatabase, opts: { log?: (...args: any[]) => void }) {
-		super(db, opts);
-	}
-	/**
-	 * Iterates over every patch for the root and every sub-object
-	 * of a given document. Optionally limit by timestamp.
-	 */
-	iterateOverAllOperationsForDocument = async (
-		oid: ObjectIdentifier,
-		iterator: (patch: StoredClientOperation, store: IDBObjectStore) => void,
-		{
-			to,
-			from,
-			after,
-			mode = 'readonly',
-			transaction: providedTx,
-		}: {
-			to?: string;
-			from?: string;
-			after?: string;
-			mode?: 'readwrite' | 'readonly';
-			transaction?: IDBTransaction;
-		} = {},
-	): Promise<void> => {
-		const transaction =
-			providedTx ||
-			this.createTransaction(['operations'], {
-				mode,
-			});
-		const store = transaction.objectStore('operations');
-		const index = store.index('d_t');
-
-		const startTimestamp = from || after;
-		const start = startTimestamp
-			? createCompoundIndexValue(oid, startTimestamp)
-			: createLowerBoundIndexValue(oid);
-		const end = to
-			? createCompoundIndexValue(oid, to)
-			: createUpperBoundIndexValue(oid);
-
-		const range = IDBKeyRange.bound(start, end, !!after, false);
-
-		const request = index.openCursor(range, 'next');
-		return new Promise<void>((resolve, reject) => {
-			let previousTimestamp: string | undefined;
-			request.onsuccess = (event) => {
-				const cursor = request.result;
-				if (cursor) {
-					const value = cursor.value as StoredClientOperation;
-					assert(value.oid.startsWith(oid));
-					assert(
-						previousTimestamp === undefined ||
-							previousTimestamp <= value.timestamp,
-						`expected ${previousTimestamp} <= ${value.timestamp}`,
-					);
-
-					iterator(value, store);
-					previousTimestamp = value.timestamp;
-					cursor.continue();
-				} else {
-					resolve();
-				}
-			};
-			request.onerror = (event) => {
-				if (isAbortError(request.error)) {
-					resolve();
-					return;
-				} else {
-					reject(request.error);
-				}
-			};
-		});
-	};
-
-	iterateOverAllOperationsForEntity = async (
-		oid: ObjectIdentifier,
-		iterator: (patch: StoredClientOperation, store: IDBObjectStore) => void,
-		{
-			after,
-			to,
-			mode,
-			transaction: providedTx,
-		}: {
-			after?: string;
-			to?: string;
-			mode?: 'readwrite' | 'readonly';
-			transaction?: IDBTransaction;
-		},
-	): Promise<void> => {
-		const transaction =
-			providedTx || this.createTransaction(['operations'], { mode });
-		const store = transaction.objectStore('operations');
-
-		const start = after
-			? createCompoundIndexValue(oid, after)
-			: createLowerBoundIndexValue(oid);
-		const end = to
-			? createCompoundIndexValue(oid, to)
-			: createUpperBoundIndexValue(oid);
-
-		const range = IDBKeyRange.bound(start, end, !!after, false);
-
-		const request = store.openCursor(range, 'next');
-		return new Promise<void>((resolve, reject) => {
-			let previousTimestamp: string | undefined;
-			request.onsuccess = (event) => {
-				const cursor = request.result;
-				if (cursor) {
-					const value = cursor.value as StoredClientOperation;
-					assert(value.oid.startsWith(oid));
-					assert(
-						previousTimestamp === undefined ||
-							previousTimestamp <= value.timestamp,
-						`expected ${previousTimestamp} <= ${value.timestamp}`,
-					);
-
-					iterator(value, store);
-					previousTimestamp = value.timestamp;
-					cursor.continue();
-				} else {
-					resolve();
-				}
-			};
-			request.onerror = (event) => {
-				if (isAbortError(request.error)) {
-					resolve();
-				} else {
-					reject(request.error);
-				}
-			};
-		});
-	};
-
-	iterateOverAllOperationsForCollection = async (
-		collection: string,
-		iterator: (patch: StoredClientOperation, store: IDBObjectStore) => void,
-		{
-			after,
-			to,
-			mode,
-			transaction: providedTx,
-		}: {
-			after?: string;
-			to?: string;
-			mode?: 'readwrite' | 'readonly';
-			transaction?: IDBTransaction;
-		},
-	): Promise<void> => {
-		const transaction =
-			providedTx || this.createTransaction(['operations'], { mode });
-
-		return this.iterate(
-			'operations',
-			(store) => {
-				return store.openCursor(
-					IDBKeyRange.bound(collection, collection + '\uffff', false, false),
-					'next',
-				);
-			},
-			iterator,
-			{ mode, transaction },
-		);
-	};
-
-	iterateOverAllLocalOperations = async (
-		iterator: (patch: ClientOperation, store: IDBObjectStore) => void,
-		{
-			before,
-			after,
-			mode = 'readonly',
-			transaction: providedTx,
-		}: {
-			before?: string | null;
-			after?: string | null;
-			mode?: 'readwrite' | 'readonly';
-			transaction?: IDBTransaction;
-		},
-	): Promise<void> => {
-		const transaction =
-			providedTx || this.createTransaction(['operations'], { mode });
-		const store = transaction.objectStore('operations');
-		const index = store.index('l_t');
-
-		const start = after
-			? createCompoundIndexValue(true, after)
-			: createLowerBoundIndexValue(true);
-		const end = before
-			? createCompoundIndexValue(true, before)
-			: createUpperBoundIndexValue(true);
-
-		const range = IDBKeyRange.bound(start, end, !!after, true);
-
-		const request = index.openCursor(range, 'next');
-		return new Promise<void>((resolve, reject) => {
-			let previousTimestamp: string | undefined;
-			request.onsuccess = (event) => {
-				const cursor = request.result;
-				if (cursor) {
-					const value = cursor.value as StoredClientOperation;
-					assert(
-						previousTimestamp === undefined ||
-							previousTimestamp <= value.timestamp,
-						`expected ${previousTimestamp} <= ${value.timestamp}`,
-					);
-
-					iterator(value, store);
-					previousTimestamp = value.timestamp;
-					cursor.continue();
-				} else {
-					resolve();
-				}
-			};
-			request.onerror = (event) => {
-				if (isAbortError(request.error)) {
-					resolve();
-				} else {
-					reject(request.error);
-				}
-			};
-		});
-	};
-
-	iterateOverAllOperations = async (
-		iterator: (patch: ClientOperation, store: IDBObjectStore) => void,
-		{
-			before,
-			transaction,
-			mode,
-			from,
-		}: {
-			/** Ending timestamp, exclusive */
-			before?: string | null;
-			/** Starting timestamp, inclusive */
-			from?: string | null;
-			transaction?: IDBTransaction;
-			mode?: 'readwrite' | 'readonly';
-		},
-	): Promise<void> => {
-		await this.iterate(
-			'operations',
-			(store) => {
-				const start = from ? createLowerBoundIndexValue(from) : undefined;
-				const end = before ? createUpperBoundIndexValue(before) : undefined;
-
-				const range =
-					start && end
-						? IDBKeyRange.bound(start, end, false, true)
-						: start
-						? IDBKeyRange.lowerBound(start, false)
-						: end
-						? IDBKeyRange.upperBound(end, true)
-						: undefined;
-				const index = store.index('timestamp');
-				return index.openCursor(range, 'next');
-			},
-			iterator,
-			{ mode, transaction },
-		);
-	};
-
-	/**
-	 * Adds a set of patches to the database.
-	 * @returns a list of affected root document OIDs.
-	 */
-	addOperations = async (
-		patches: ClientOperation[],
-		{ transaction }: { transaction?: IDBTransaction } = {},
-	): Promise<ObjectIdentifier[]> => {
-		return this.insert(patches.map(this.addCompoundIndexes), { transaction });
-	};
-
-	private addCompoundIndexes = (
-		patch: ClientOperation,
-	): StoredClientOperation => {
-		return {
-			...patch,
-			oid_timestamp: createCompoundIndexValue(
-				patch.oid,
-				patch.timestamp,
-			) as string,
-			l_t: createCompoundIndexValue(patch.isLocal, patch.timestamp) as string,
-			d_t: createCompoundIndexValue(
-				getOidRoot(patch.oid),
-				patch.timestamp,
-			) as string,
-		};
-	};
-
-	private insert = async (
-		operations: StoredClientOperation[],
-		{ transaction }: { transaction?: IDBTransaction },
-	): Promise<ObjectIdentifier[]> => {
-		const affected = new Set<ObjectIdentifier>();
-		await this.runAll(
-			'operations',
-			(store) =>
-				operations.map((op) => {
-					affected.add(getOidRoot(op.oid));
-					return store.put(op);
-				}),
-			{ mode: 'readwrite', transaction },
-		);
-		return Array.from(affected);
-	};
-
-	reset = () => {
-		return this.clear('operations');
-	};
-}

package/src/metadata/SchemaStore.ts

@@ -1,47 +0,0 @@
-import { StorageSchema } from '@verdant-web/common';
-import { storeRequestPromise } from '../idb.js';
-
-type StoredSchema = {
-	type: 'schema';
-	schema: string;
-};
-
-export class SchemaStore {
-	private cached: StorageSchema<any> | null = null;
-
-	constructor(
-		private readonly db: IDBDatabase,
-		public readonly currentVersion: number,
-	) {}
-
-	get = async (): Promise<StorageSchema<any> | null> => {
-		if (this.cached) {
-			return this.cached;
-		}
-
-		const db = this.db;
-		const transaction = db.transaction('info', 'readonly');
-		const store = transaction.objectStore('info');
-		const request = store.get('schema');
-		const value = (await storeRequestPromise(request)) as
-			| StoredSchema
-			| undefined;
-		if (!value) {
-			return null;
-		}
-		this.cached = JSON.parse(value.schema);
-		return this.cached;
-	};
-
-	set = async (schema: StorageSchema<any>): Promise<void> => {
-		const db = this.db;
-		const transaction = db.transaction('info', 'readwrite');
-		const store = transaction.objectStore('info');
-		const request = store.put({
-			type: 'schema',
-			schema: JSON.stringify(schema),
-		} as StoredSchema);
-		this.cached = schema;
-		await storeRequestPromise(request);
-	};
-}

package/src/migration/errors.ts

@@ -1,7 +0,0 @@
-export class MigrationPathError extends Error {
-	readonly name = 'MigrationPathError';
-
-	constructor(public readonly message: string) {
-		super(message);
-	}
-}

package/src/migration/openWIPDatabase.ts

@@ -1,97 +0,0 @@
-import { Migration } from '@verdant-web/common';
-import { Metadata } from '../metadata/Metadata.js';
-import { copyAll, getDatabaseVersion, openDatabase } from './db.js';
-import { runMigrations } from './migrations.js';
-import { getMigrationPath } from './paths.js';
-import { OpenDocumentDbContext } from './types.js';
-
-const globalIDB =
-	typeof window !== 'undefined' ? window.indexedDB : (undefined as any);
-
-export async function openWIPDatabase({
-	version,
-	indexedDB = globalIDB,
-	migrations,
-	meta,
-	context,
-	wipNamespace,
-}: {
-	version: number;
-	migrations: Migration<any>[];
-	indexedDB?: IDBFactory;
-	meta: Metadata;
-	context: OpenDocumentDbContext;
-	wipNamespace: string;
-}) {
-	context.log('debug', 'Opening WIP database', wipNamespace);
-	const currentWIPVersion = await getDatabaseVersion(
-		indexedDB,
-		wipNamespace,
-		version,
-		context.log,
-	);
-
-	if (currentWIPVersion === version) {
-		context.log('info', `WIP schema is up-to-date; not refreshing database`);
-	} else {
-		context.log('info', `WIP schema is out-of-date; refreshing database`);
-
-		// first we need to copy the data from the production database to the WIP database
-		// at the current (non-wip) version.
-
-		const initialToRun = getMigrationPath({
-			currentVersion: currentWIPVersion,
-			targetVersion: version - 1,
-			migrations,
-		});
-
-		if (initialToRun.length > 0) {
-			await runMigrations({
-				context,
-				toRun: initialToRun,
-				meta,
-				indexedDB,
-				namespace: wipNamespace,
-			});
-
-			// now, we copy the data from the main database.
-			const mainDatabase = await openDatabase({
-				indexedDB,
-				namespace: context.namespace,
-				version: version - 1,
-				context,
-			});
-
-			const wipDatabase = await openDatabase({
-				indexedDB,
-				namespace: wipNamespace,
-				version: version - 1,
-				context,
-			});
-			await copyAll(mainDatabase, wipDatabase);
-		}
-
-		const toRun = getMigrationPath({
-			currentVersion: version - 1,
-			targetVersion: version,
-			migrations,
-		});
-
-		if (toRun.length > 0) {
-			await runMigrations({
-				context,
-				toRun,
-				meta,
-				indexedDB,
-				namespace: wipNamespace,
-			});
-		}
-	}
-
-	return openDatabase({
-		indexedDB,
-		namespace: wipNamespace,
-		version,
-		context,
-	});
-}

package/src/migration/types.ts

@@ -1,4 +0,0 @@
-import { Context } from '../context.js';
-
-/** During migration, only a partial context is available */
-export type OpenDocumentDbContext = Omit<Context, 'documentDb'>;

package/src/queries/QueryableStorage.ts

@@ -1,122 +0,0 @@
-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.createTransaction(allCollections, { mode: '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;
-		}
-
-		let collections = Array.from(
-			new Set(entities.map((e) => decomposeOid(e.oid).collection)),
-		);
-		// we could theoretically receive entities from old schema versions which no
-		// longer have collections. We should ignore these. If we don't, the transaction
-		// will fail, because the object store doesn't exist.
-		const toRemove = collections.filter((c) => !this.ctx.schema.collections[c]);
-		if (toRemove.length > 0) {
-			this.ctx.log(
-				'warn',
-				`Ignoring entities from collections that no longer exist: ${toRemove.join(
-					', ',
-				)}`,
-			);
-			const withRemoved = new Set(collections);
-			toRemove.forEach((c) => withRemoved.delete(c));
-			collections = Array.from(withRemoved);
-		}
-		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);
-		}
-	};
-}