@verdant-web/store 2.0.1

package/src/metadata/BaselinesStore.ts

@@ -0,0 +1,140 @@
+import {
+	DocumentBaseline,
+	getOidRange,
+	ObjectIdentifier,
+} from '@verdant-web/common';
+import { IDBService } from '../IDBService.js';
+
+export class BaselinesStore extends IDBService {
+	constructor(db: IDBDatabase) {
+		super(db);
+	}
+
+	getAllForDocument = async (
+		oid: ObjectIdentifier,
+		{
+			mode = 'readonly',
+			transaction,
+		}: { mode?: 'readwrite' | 'readonly'; transaction?: IDBTransaction } = {},
+	) => {
+		const baselines: DocumentBaseline[] = [];
+		await this.iterateOverAllForDocument(
+			oid,
+			(baseline) => {
+				baselines.push(baseline);
+			},
+			{ mode, transaction },
+		);
+		return baselines;
+	};
+	iterateOverAllForDocument = async (
+		oid: ObjectIdentifier,
+		iterator: (baseline: DocumentBaseline, store: IDBObjectStore) => void,
+		{
+			mode = 'readonly',
+			transaction,
+		}: { mode?: 'readwrite' | 'readonly'; transaction?: IDBTransaction } = {},
+	) => {
+		return this.iterate(
+			'baselines',
+			(store) => {
+				const [start, end] = getOidRange(oid);
+				return store.openCursor(IDBKeyRange.bound(start, end, false, false));
+			},
+			iterator,
+			mode,
+			transaction,
+		);
+	};
+
+	getAllForMultipleDocuments = async (
+		docOids: string[],
+		{ mode = 'readonly' }: { mode?: 'readwrite' | 'readonly' } = {},
+	) => {
+		const result = await this.runAll<DocumentBaseline[]>(
+			'baselines',
+			(store) => {
+				return docOids.map((oid) => {
+					const [start, end] = getOidRange(oid);
+					return store.getAll(IDBKeyRange.bound(start, end, false, false));
+				});
+			},
+			mode,
+		);
+		return result.flat();
+	};
+
+	getAllSince = async (
+		timestamp: string | null,
+		{ mode = 'readonly' }: { mode?: 'readwrite' | 'readonly' } = {},
+	) => {
+		return this.run<DocumentBaseline[]>(
+			'baselines',
+			(store) => {
+				const range = timestamp
+					? IDBKeyRange.lowerBound(timestamp, true)
+					: undefined;
+				const index = store.index('timestamp');
+				return index.getAll(range);
+			},
+			mode,
+		);
+	};
+
+	get = async (
+		oid: ObjectIdentifier,
+		{
+			transaction,
+			mode = 'readonly',
+		}: { transaction?: IDBTransaction; mode?: 'readwrite' | 'readonly' } = {},
+	) => {
+		return this.run<DocumentBaseline>(
+			'baselines',
+			(store) => store.get(oid),
+			mode,
+			transaction,
+		);
+	};
+
+	set = async <T>(
+		baseline: DocumentBaseline<T>,
+		{ transaction }: { transaction?: IDBTransaction } = {},
+	) => {
+		await this.run(
+			'baselines',
+			(store) => store.put(baseline),
+			'readwrite',
+			transaction,
+		);
+	};
+
+	setAll = async <T>(
+		baselines: DocumentBaseline<T>[],
+		{ transaction }: { transaction?: IDBTransaction } = {},
+	) => {
+		await this.runAll(
+			'baselines',
+			(store) => {
+				return baselines.map((baseline) => store.put(baseline));
+			},
+			'readwrite',
+			transaction,
+		);
+	};
+
+	reset = () => {
+		return this.clear('baselines');
+	};
+
+	delete = async (
+		oid: ObjectIdentifier,
+		{ transaction }: { transaction?: IDBTransaction },
+	) => {
+		await this.run(
+			'baselines',
+			(store) => store.delete(oid),
+			'readwrite',
+			transaction,
+		);
+	};
+}

package/src/metadata/LocalReplicaStore.ts

@@ -0,0 +1,60 @@
+import cuid from 'cuid';
+import { IDBService } from '../IDBService.js';
+
+export type LocalReplicaInfo = {
+	type: 'localReplicaInfo';
+	id: string;
+	ackedLogicalTime: string | null;
+	lastSyncedLogicalTime: string | null;
+};
+
+export class LocalReplicaStore extends IDBService {
+	private cached: LocalReplicaInfo | undefined;
+
+	get = async ({ transaction }: { transaction?: IDBTransaction } = {}) => {
+		if (this.cached) {
+			return this.cached;
+		}
+
+		const lookup = await this.run<LocalReplicaInfo>(
+			'info',
+			(store) => store.get('localReplicaInfo'),
+			undefined,
+			transaction,
+		);
+
+		if (!lookup) {
+			// create our own replica info now
+			const replicaId = cuid();
+			const replicaInfo: LocalReplicaInfo = {
+				type: 'localReplicaInfo',
+				id: replicaId,
+				ackedLogicalTime: null,
+				lastSyncedLogicalTime: null,
+			};
+			await this.run('info', (store) => store.put(replicaInfo), 'readwrite');
+			this.cached = replicaInfo;
+			return replicaInfo;
+		}
+
+		this.cached = lookup;
+		return lookup;
+	};
+
+	update = async (
+		data: Partial<LocalReplicaInfo>,
+		{ transaction }: { transaction?: IDBTransaction } = {},
+	) => {
+		const localReplicaInfo = await this.get({ transaction });
+		Object.assign(localReplicaInfo, data);
+		await this.run('info', (store) => store.put(localReplicaInfo), 'readwrite');
+		this.cached = localReplicaInfo;
+	};
+
+	reset = async () => {
+		const localInfo = await this.get();
+		localInfo.ackedLogicalTime = null;
+		localInfo.lastSyncedLogicalTime = null;
+		await this.run('info', (store) => store.put(localInfo), 'readwrite');
+	};
+}

package/src/metadata/MessageCreator.ts

@@ -0,0 +1,153 @@
+import {
+	AckMessage,
+	DocumentBaseline,
+	getOidRoot,
+	HeartbeatMessage,
+	ObjectIdentifier,
+	Operation,
+	OperationMessage,
+	PresenceUpdateMessage,
+	SyncAckMessage,
+	SyncMessage,
+} from '@verdant-web/common';
+
+import { Metadata } from './Metadata.js';
+
+export class MessageCreator {
+	constructor(private meta: Metadata) {}
+
+	createOperation = async (
+		init: Pick<OperationMessage, 'operations'> & {
+			timestamp?: string;
+		},
+	): Promise<OperationMessage> => {
+		const localInfo = await this.meta.localReplica.get();
+		return {
+			type: 'op',
+			timestamp: this.meta.now,
+			replicaId: localInfo.id,
+			operations: init.operations.map((op) => ({
+				data: op.data,
+				oid: op.oid,
+				timestamp: op.timestamp,
+			})),
+		};
+	};
+
+	createMigrationOperation = async ({
+		targetVersion,
+		...init
+	}: Pick<OperationMessage, 'operations'> & {
+		targetVersion: number;
+	}): Promise<OperationMessage> => {
+		const localInfo = await this.meta.localReplica.get();
+		return {
+			type: 'op',
+			operations: init.operations.map((op) => ({
+				...op,
+				timestamp: this.meta.time.zero(targetVersion),
+			})),
+			timestamp: this.meta.time.zero(targetVersion),
+			replicaId: localInfo.id,
+		};
+	};
+
+	/**
+	 * @param since - override local understanding of last sync time
+	 */
+	createSyncStep1 = async (since?: string | null): Promise<SyncMessage> => {
+		const localReplicaInfo = await this.meta.localReplica.get();
+
+		const provideChangesSince =
+			since === null ? null : localReplicaInfo.lastSyncedLogicalTime;
+
+		// collect all of our operations that are newer than the server's last operation
+		// if server replica isn't stored, we're syncing for the first time.
+		const operations: Operation[] = [];
+		const affectedDocs = new Set<ObjectIdentifier>();
+
+		// FIXME: this branch gives bad vibes. should we always
+		// send all operations from other replicas too? is there
+		// ever a case where we have a "since" timestamp and there
+		// are foreign ops that match it?
+		if (provideChangesSince) {
+			await this.meta.operations.iterateOverAllLocalOperations(
+				(patch) => {
+					operations.push({
+						data: patch.data,
+						oid: patch.oid,
+						timestamp: patch.timestamp,
+					});
+					affectedDocs.add(getOidRoot(patch.oid));
+				},
+				{
+					after: provideChangesSince,
+					// block on writes to prevent race conditions
+					mode: 'readwrite',
+				},
+			);
+		} else {
+			// if providing the whole history, don't limit to only local
+			// operations
+			await this.meta.operations.iterateOverAllOperations(
+				(patch) => {
+					operations.push({
+						data: patch.data,
+						oid: patch.oid,
+						timestamp: patch.timestamp,
+					});
+					affectedDocs.add(getOidRoot(patch.oid));
+				},
+				{
+					mode: 'readwrite',
+				},
+			);
+		}
+		// we only need to send baselines if we've never synced before
+		let baselines: DocumentBaseline[] = [];
+		if (!provideChangesSince) {
+			baselines = await this.meta.baselines.getAllSince('');
+		}
+
+		return {
+			type: 'sync',
+			schemaVersion: this.meta.schema.currentVersion,
+			timestamp: this.meta.now,
+			replicaId: localReplicaInfo.id,
+			resyncAll: !localReplicaInfo.lastSyncedLogicalTime,
+			operations,
+			baselines,
+			since: provideChangesSince,
+		};
+	};
+
+	createPresenceUpdate = async (
+		presence: any,
+	): Promise<PresenceUpdateMessage> => {
+		const localReplicaInfo = await this.meta.localReplica.get();
+		return {
+			type: 'presence-update',
+			presence,
+			replicaId: localReplicaInfo.id,
+		};
+	};
+
+	createHeartbeat = async (): Promise<HeartbeatMessage> => {
+		const localReplicaInfo = await this.meta.localReplica.get();
+		return {
+			type: 'heartbeat',
+			timestamp: this.meta.now,
+			replicaId: localReplicaInfo.id,
+		};
+	};
+
+	createAck = async (nonce: string): Promise<AckMessage> => {
+		const localReplicaInfo = await this.meta.localReplica.get();
+		return {
+			type: 'ack',
+			timestamp: this.meta.now,
+			replicaId: localReplicaInfo.id,
+			nonce,
+		};
+	};
+}