@verdant-web/store 2.0.1

package/src/metadata/OperationsStore.ts

@@ -0,0 +1,268 @@
+import {
+	createCompoundIndexValue,
+	createLowerBoundIndexValue,
+	createUpperBoundIndexValue,
+	getOidRoot,
+	ObjectIdentifier,
+	Operation,
+	assert,
+} from '@verdant-web/common';
+import { IDBService } from '../IDBService.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 {
+	/**
+	 * 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.db.transaction('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) => {
+				reject(event);
+			};
+		});
+	};
+
+	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.db.transaction('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) => {
+				reject(event);
+			};
+		});
+	};
+
+	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.db.transaction('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) => {
+				reject(event);
+			};
+		});
+	};
+
+	iterateOverAllOperations = async (
+		iterator: (patch: ClientOperation, store: IDBObjectStore) => void,
+		{
+			before,
+			transaction,
+			mode,
+		}: {
+			before?: string | null;
+			transaction?: IDBTransaction;
+			mode?: 'readwrite' | 'readonly';
+		},
+	): Promise<void> => {
+		await this.iterate(
+			'operations',
+			(store) => {
+				const end = before ? createUpperBoundIndexValue(before) : undefined;
+
+				const range = 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);
+				}),
+			'readwrite',
+			transaction,
+		);
+		return Array.from(affected);
+	};
+
+	reset = () => {
+		return this.clear('operations');
+	};
+}

package/src/metadata/SchemaStore.ts

@@ -0,0 +1,47 @@
+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/metadata/openMetadataDatabase.ts

@@ -0,0 +1,114 @@
+const migrations = [version1, version2, version3, version4];
+
+export function openMetadataDatabase(
+	namespace: string,
+	{
+		indexedDB = window.indexedDB,
+		databaseName,
+		log,
+	}: {
+		indexedDB?: IDBFactory;
+		databaseName: string;
+		log?: (...args: any[]) => void;
+	},
+): Promise<{ wasInitialized: boolean; db: IDBDatabase }> {
+	return new Promise<{ wasInitialized: boolean; db: IDBDatabase }>(
+		(resolve, reject) => {
+			const request = indexedDB.open(databaseName, 4);
+			let wasInitialized = false;
+			request.onupgradeneeded = async (event) => {
+				const db = request.result;
+				const tx = request.transaction!;
+
+				const toRun = migrations.slice(event.oldVersion);
+				for (const migration of toRun) {
+					await migration(db, tx);
+				}
+
+				if (!event.oldVersion) {
+					wasInitialized = true;
+				}
+			};
+			request.onerror = () => {
+				console.error('Error opening database', request.error);
+				reject(request.error);
+			};
+			request.onsuccess = () => {
+				resolve({ db: request.result, wasInitialized });
+			};
+		},
+	);
+}
+
+async function version1(db: IDBDatabase, tx: IDBTransaction) {
+	const baselinesStore = db.createObjectStore('baselines', {
+		keyPath: 'oid',
+	});
+	const operationsStore = db.createObjectStore('operations', {
+		keyPath: 'oid_timestamp',
+	});
+	const infoStore = db.createObjectStore('info', { keyPath: 'type' });
+	baselinesStore.createIndex('timestamp', 'timestamp');
+	operationsStore.createIndex('isLocal_timestamp', 'isLocal_timestamp');
+	operationsStore.createIndex('documentOid_timestamp', 'documentOid_timestamp');
+}
+
+/**
+ * 1 -> 2 changes:
+ *
+ * Consolidate compound index names:
+ *
+ * Operations:
+ * - isLocal_timestamp -> l_t
+ * - documentOid_timestamp -> d_t
+ */
+async function version2(db: IDBDatabase, tx: IDBTransaction) {
+	const operations = tx.objectStore('operations');
+	await new Promise<void>((resolve, reject) => {
+		const cursorReq = operations.openCursor();
+		cursorReq.onsuccess = () => {
+			// rename the consolidated fields
+			const cursor = cursorReq.result;
+			if (cursor) {
+				const { isLocal_timestamp, documentOid_timestamp, ...value } =
+					cursor.value;
+				cursor.update({
+					...value,
+					l_t: isLocal_timestamp,
+					d_t: documentOid_timestamp,
+				});
+				cursor.continue();
+			} else {
+				resolve();
+			}
+		};
+		cursorReq.onerror = (event) => {
+			reject(cursorReq.error);
+		};
+	});
+	// remove the old indexes
+	operations.deleteIndex('isLocal_timestamp');
+	operations.deleteIndex('documentOid_timestamp');
+	// create the new indexes
+	operations.createIndex('l_t', 'l_t', { unique: false });
+	operations.createIndex('o_t', 'o_t', { unique: false });
+	operations.createIndex('d_t', 'd_t', { unique: false });
+}
+
+/**
+ * 2 -> 3 changes:
+ *
+ * Add timestamp index to operations
+ */
+async function version3(db: IDBDatabase, tx: IDBTransaction) {
+	const operations = tx.objectStore('operations');
+	operations.createIndex('timestamp', 'timestamp');
+}
+
+async function version4(db: IDBDatabase, tx: IDBTransaction) {
+	const files = db.createObjectStore('files', {
+		keyPath: 'id',
+	});
+	files.createIndex('remote', 'remote');
+	files.createIndex('deletedAt', 'deletedAt');
+}