@verdant-web/store 2.0.1

package/src/DocumentManager.ts

@@ -0,0 +1,95 @@
+import {
+	addFieldDefaults,
+	assert,
+	assignOid,
+	createOid,
+	diffToPatches,
+	SchemaCollection,
+	StorageCollectionSchema,
+	StorageDocument,
+	StorageFieldSchema,
+	StorageFieldsSchema,
+	StorageSchema,
+} from '@verdant-web/common';
+import { ObjectEntity } from './reactives/Entity.js';
+import { EntityStore } from './reactives/EntityStore.js';
+import { Metadata } from './metadata/Metadata.js';
+
+/**
+ * Exposes functionality for creating documents,
+ * the only mutation which is available as an entry
+ * point in the storage system.
+ */
+export class DocumentManager<Schema extends StorageSchema<any>> {
+	constructor(
+		private meta: Metadata,
+		private schema: Schema,
+		private entities: EntityStore,
+	) {}
+
+	private getOid = (collection: string, init: any) => {
+		const primaryKeyName = this.schema.collections[collection]
+			.primaryKey as Exclude<
+			keyof StorageDocument<SchemaCollection<Schema, any>>,
+			symbol
+		>;
+		const primaryKey = init[primaryKeyName];
+		assert(
+			primaryKey,
+			`Document must have a primary key: ${primaryKeyName.toString()} (got: ${JSON.stringify(
+				init,
+			)})`,
+		);
+		return createOid(collection, primaryKey, []);
+	};
+
+	private addDefaults = (collectionName: string, init: any) => {
+		const collection = this.schema.collections[
+			collectionName
+		] as StorageCollectionSchema;
+		return addFieldDefaults(collection, init);
+	};
+
+	create = async (
+		collection: string,
+		init: any,
+		options: { undoable?: boolean } = {},
+	) => {
+		const defaulted = this.addDefaults(collection, init);
+		const oid = this.getOid(collection, defaulted);
+		// documents are always objects at the root
+		return this.entities.create(defaulted, oid, options) as any;
+	};
+
+	delete = async (
+		collection: string,
+		primaryKey: string,
+		options: { undoable?: boolean } = {},
+	) => {
+		const oid = createOid(collection, primaryKey, []);
+		return this.entities.delete(oid, options);
+	};
+
+	deleteAll = async (
+		ids: [string, string][],
+		options: { undoable?: boolean } = {},
+	) => {
+		return this.entities.deleteAll(
+			ids.map(([collection, primaryKey]) =>
+				createOid(collection, primaryKey, []),
+			),
+			options,
+		);
+	};
+
+	deleteAllFromCollection = async (
+		collection: string,
+		ids: string[],
+		options: { undoable?: boolean } = {},
+	) => {
+		return this.entities.deleteAll(
+			ids.map((primaryKey) => createOid(collection, primaryKey, [])),
+			options,
+		);
+	};
+}

package/src/IDBService.ts

@@ -0,0 +1,64 @@
+import { storeRequestPromise } from './idb.js';
+
+export class IDBService {
+	constructor(protected readonly db: IDBDatabase) {}
+
+	createTransaction = (
+		storeNames: string[],
+		mode: 'readonly' | 'readwrite',
+	) => {
+		return this.db.transaction(storeNames, mode);
+	};
+
+	run = async <T>(
+		storeName: string,
+		getRequest: (store: IDBObjectStore) => IDBRequest<T>,
+		mode: 'readonly' | 'readwrite' = 'readonly',
+		transaction?: IDBTransaction,
+	): Promise<T> => {
+		const tx = transaction || this.db.transaction(storeName, mode);
+		const store = tx.objectStore(storeName);
+		const request = getRequest(store);
+		return storeRequestPromise<T>(request);
+	};
+
+	runAll = async <T>(
+		storeName: string,
+		getRequests: (store: IDBObjectStore) => IDBRequest<T>[],
+		mode: 'readonly' | 'readwrite' = 'readonly',
+		transaction?: IDBTransaction,
+	): Promise<T[]> => {
+		const tx = transaction || this.db.transaction(storeName, mode);
+		const store = tx.objectStore(storeName);
+		const requests = getRequests(store);
+		return Promise.all(requests.map(storeRequestPromise));
+	};
+
+	iterate = async <T>(
+		storeName: string,
+		getRequest: (store: IDBObjectStore) => IDBRequest,
+		iterator: (value: T, store: IDBObjectStore) => void,
+		mode: 'readonly' | 'readwrite' = 'readonly',
+		transaction?: IDBTransaction,
+	): Promise<void> => {
+		const tx = transaction || this.db.transaction(storeName, mode);
+		const store = tx.objectStore(storeName);
+		const request = getRequest(store);
+		return new Promise<void>((resolve, reject) => {
+			request.onsuccess = (event) => {
+				const cursor = request.result;
+				if (cursor) {
+					iterator(cursor.value, store);
+					cursor.continue();
+				} else {
+					resolve();
+				}
+			};
+			request.onerror = reject;
+		});
+	};
+
+	clear = (storeName: string) => {
+		return this.run(storeName, (store) => store.clear(), 'readwrite');
+	};
+}

package/src/UndoHistory.ts

@@ -0,0 +1,52 @@
+import { EventSubscriber } from '@verdant-web/common';
+
+type Undoable = () => Undoable | Promise<Undoable>;
+
+export class UndoHistory extends EventSubscriber<{ change: () => void }> {
+	private _undoable: Undoable[] = [];
+	private _undone: Undoable[] = [];
+
+	get canUndo() {
+		return this._undoable.length > 0;
+	}
+	get canRedo() {
+		return this._undone.length > 0;
+	}
+
+	undo = async () => {
+		const next = this._undoable.pop();
+		if (next) {
+			this._undone.push(await next());
+			this.emit('change');
+			return true;
+		}
+		return false;
+	};
+
+	redo = async () => {
+		const next = this._undone.pop();
+		if (next) {
+			this._undoable.push(await next());
+			this.emit('change');
+			return true;
+		}
+		return false;
+	};
+
+	addUndo = (undoPoint: Undoable) => {
+		this._undoable.push(undoPoint);
+		this._undone = [];
+		this.emit('change');
+	};
+
+	addRedo = (redoPoint: Undoable) => {
+		this._undone.push(redoPoint);
+		this.emit('change');
+	};
+
+	clear = () => {
+		this._undoable = [];
+		this._undone = [];
+		this.emit('change');
+	};
+}

package/src/__tests__/batching.test.ts

@@ -0,0 +1,55 @@
+import { describe, it, expect, vi, MockedFunction } from 'vitest';
+import { createTestStorage } from './fixtures/testStorage.js';
+
+describe('batching operations', () => {
+	it('should allow multiple runs with manual flush', async () => {
+		const storage = await createTestStorage();
+
+		const item = await storage.todos.put({
+			content: 'hello world',
+			category: 'general',
+			attachments: [
+				{
+					name: 'thing',
+				},
+			],
+		});
+
+		// disable timeout for manual control
+		const batch = storage.batch({ timeout: null });
+
+		batch.run(() => {
+			item.set('content', 'hello world 2');
+			item.set('category', 'never');
+		});
+
+		// fake some async work
+		await new Promise((resolve) => setTimeout(resolve, 200));
+
+		batch.run(() => {
+			item.set('content', 'hello world 3');
+			item.set('category', 'general');
+			item.get('attachments').push({ name: 'other thing' });
+		});
+
+		await batch.flush();
+
+		expect(item.get('content')).toBe('hello world 3');
+		expect(item.get('category')).toBe('general');
+		expect(item.get('attachments').length).toBe(2);
+
+		expect(storage.undoHistory.canUndo).toBe(true);
+
+		await storage.undoHistory.undo();
+
+		expect(item.get('content')).toBe('hello world');
+		expect(item.get('category')).toBe('general');
+		expect(item.get('attachments').length).toBe(1);
+
+		// the next undo will undo the creation
+		await storage.undoHistory.undo();
+		expect(storage.undoHistory.canUndo).toBe(false);
+
+		expect(item.deleted).toBe(true);
+	});
+});