@verdant-web/store 2.7.6 → 2.7.7

package/src/__tests__/legacyOids.test.ts

@@ -1,9 +1,6 @@
-// import { IDBFactory } from 'fake-indexeddb';
-
 import {
 	HybridLogicalClockTimestampProvider,
 	OperationPatch,
-	createCompoundIndexValue,
 	getIndexValues,
 	makeObjectRef,
 } from '@verdant-web/common';
@@ -11,67 +8,213 @@ import { storeRequestPromise } from '../idb.js';
 import { openMetadataDatabase } from '../metadata/openMetadataDatabase.js';
 import { createTestStorage, todoCollection } from './fixtures/testStorage.js';
 import { describe, expect, it } from 'vitest';
+import { OperationsStore } from '../metadata/OperationsStore.js';
+import { BaselinesStore } from '../metadata/BaselinesStore.js';
 
 const idb = new IDBFactory();
 
 async function seedDatabaseAndCreateClient() {
-	const client1 = await createTestStorage({ idb });
+	const client1 = await createTestStorage({ idb, metadataVersion: 4 });
 	await client1.close();
 	const { db } = await openMetadataDatabase({
 		indexedDB: idb,
 		namespace: 'test',
+		metadataVersion: 4,
 	});
+	expect(db.version).toBe(4);
 	const tx = db.transaction(['baselines', 'operations'], 'readwrite');
 	const clock = new HybridLogicalClockTimestampProvider();
-	const results = await Promise.all(
-		[
-			tx.objectStore('baselines').put({
-				oid: 'todos/a',
-				snapshot: {
-					id: 'a',
-					content: 'item a',
-					tags: makeObjectRef('todos/a.tags:foo'),
-					done: false,
-					category: 'default',
-					attachments: makeObjectRef('todos/a.attachments:bar'),
-				},
-				timestamp: clock.now(1),
-			}),
-			tx.objectStore('baselines').put({
-				oid: 'todos/a.tags:foo',
-				snapshot: ['tag1'],
-				timestamp: clock.now(1),
-			}),
-			tx.objectStore('baselines').put({
-				oid: 'todos/a.attachments:bar',
-				snapshot: [makeObjectRef('todos/a.attachments.#:baz')],
-				timestamp: clock.now(1),
-			}),
-			tx.objectStore('baselines').put({
-				oid: 'todos/a.attachments.#:baz',
-				snapshot: {
-					name: 'baz',
-					test: 1,
-				},
-				timestamp: clock.now(1),
-			}),
-			(() => {
-				const ts = clock.now(1);
-				return tx.objectStore('operations').put({
+	const ops = new OperationsStore(db);
+	const baselines = new BaselinesStore(db);
+	await Promise.all([
+		baselines.setAll(
+			[
+				{
+					oid: 'weirds/b.objectMap.one:ghi',
+					snapshot: { content: 'ghi' },
+					timestamp: clock.now(1),
+				},
+				{
+					oid: 'weirds/b.objectMap.two:jkl',
+					snapshot: { content: 'jkl' },
+					timestamp: clock.now(1),
+				},
+				{
+					oid: 'weirds/b.map:abc',
+					snapshot: {},
+					timestamp: clock.now(1),
+				},
+				{
+					oid: 'weirds/b.objectMap:def',
+					snapshot: {
+						one: makeObjectRef('weirds/b.objectMap.one:ghi'),
+						two: makeObjectRef('weirds/b.objectMap.two:jkl'),
+					},
+					timestamp: clock.now(1),
+				},
+				{
+					oid: 'weirds/b.weird.ok:opq',
+					snapshot: {
+						message: 'ok',
+					},
+					timestamp: clock.now(1),
+				},
+				{
+					oid: 'weirds/b.weird.cool:rst',
+					snapshot: {
+						message: 'cool',
+					},
+					timestamp: clock.now(1),
+				},
+				{
+					oid: 'weirds/b.weird.list.#:xyz',
+					snapshot: {
+						name: 'xyz',
+						test: 1,
+					},
+					timestamp: clock.now(1),
+				},
+				{
+					oid: 'weirds/b.weird.list.#:123',
+					snapshot: {
+						name: '123',
+						test: 2,
+					},
+					timestamp: clock.now(1),
+				},
+				{
+					oid: 'weirds/b.weird.list:uvw',
+					snapshot: [
+						makeObjectRef('weirds/b/weird.list.#:xyz'),
+						makeObjectRef('weirds/b/weird.list.#:123'),
+					],
+					timestamp: clock.now(1),
+				},
+				{
+					oid: 'weirds/b.weird:lmn',
+					snapshot: {
+						ok: makeObjectRef('weirds/b.weird.ok:opq'),
+						cool: makeObjectRef('weirds/b.weird.cool:rst'),
+						list: makeObjectRef('weirds/b.weird.list:uvw'),
+					},
+					timestamp: clock.now(1),
+				},
+				{
+					oid: 'weirds/b',
+					snapshot: {
+						id: 'b',
+						map: makeObjectRef('weirds/b.map:abc'),
+						objectMap: makeObjectRef('weirds/b.objectMap:def'),
+						weird: makeObjectRef('weirds/b.weird:lmn'),
+					},
+					timestamp: clock.now(1),
+				},
+				{
+					oid: 'todos/a.attachments.#:baz',
+					snapshot: {
+						name: 'baz',
+						test: 1,
+					},
+					timestamp: clock.now(1),
+				},
+				{
+					oid: 'todos/a.attachments.#:qux',
+					snapshot: {
+						name: 'qux',
+						test: 2,
+					},
+					timestamp: clock.now(1),
+				},
+				{
+					oid: 'todos/a.attachments:bar',
+					snapshot: [
+						makeObjectRef('todos/a.attachments.#:baz'),
+						makeObjectRef('todos/a.attachments.#:qux'),
+					],
+					timestamp: clock.now(1),
+				},
+				{
+					oid: 'todos/a.tags:foo',
+					snapshot: ['tag1'],
+					timestamp: clock.now(1),
+				},
+				{
+					oid: 'todos/a',
+					snapshot: {
+						id: 'a',
+						content: 'item a',
+						tags: makeObjectRef('todos/a.tags:foo'),
+						done: false,
+						category: 'default',
+						attachments: makeObjectRef('todos/a.attachments:bar'),
+					},
+					timestamp: clock.now(1),
+				},
+			],
+			{ transaction: tx },
+		),
+		ops.addOperations(
+			[
+				// trying to cover all types of operations which use refs here
+				{
 					oid: 'todos/a.tags:foo',
-					timestamp: ts,
+					timestamp: clock.now(1),
 					data: {
 						op: 'list-push',
 						value: 'tag2',
 					} as OperationPatch,
 					isLocal: true,
-					oid_timestamp: createCompoundIndexValue('todos/a.tags:foo', ts),
-					l_t: createCompoundIndexValue(true, ts),
-					d_t: createCompoundIndexValue('todos/a', ts),
-				});
-			})(),
-		].map(storeRequestPromise),
-	);
+				},
+				{
+					oid: 'todos/a.attachments.#:bin',
+					timestamp: clock.now(1),
+					data: {
+						op: 'initialize',
+						value: {
+							name: 'bin',
+							test: 2,
+						},
+					},
+					isLocal: true,
+				},
+				{
+					oid: 'todos/a.attachments:bar',
+					timestamp: clock.now(1),
+					data: {
+						op: 'list-push',
+						value: makeObjectRef('todos/a.attachments.#:bin'),
+					},
+					isLocal: true,
+				},
+				{
+					oid: 'todos/a.attachments:bar',
+					timestamp: clock.now(1),
+					isLocal: true,
+					data: {
+						op: 'list-remove',
+						value: makeObjectRef('todos/a.attachments.#:baz'),
+					},
+				},
+				{
+					oid: 'weirds/b.objectMap:def',
+					timestamp: clock.now(1),
+					data: {
+						op: 'delete',
+					},
+					isLocal: true,
+				},
+				{
+					oid: 'weirds/b.weird.list:uvw',
+					timestamp: clock.now(1),
+					data: {
+						op: 'delete',
+					},
+					isLocal: true,
+				},
+			],
+			{ transaction: tx },
+		),
+	]);
 	db.close();
 	// documents are a little trickier.
 	const docDbReq = idb.open('test_collections', 1);
@@ -108,18 +251,41 @@ describe('clients with stored legacy oids', () => {
 	it('can still function', async () => {
 		const client = await seedDatabaseAndCreateClient();
 		const todo = await client.todos.get('a').resolved;
+		const weird = await client.weirds.get('b').resolved;
+
+		// first: does the data look right?
 		expect(todo.getSnapshot()).toMatchObject({
 			id: 'a',
 			content: 'item a',
 			tags: ['tag1', 'tag2'],
+			done: false,
 			category: 'default',
 			attachments: [
 				{
-					name: 'baz',
-					test: 1,
+					name: 'qux',
+					test: 2,
+				},
+				{
+					name: 'bin',
+					test: 2,
 				},
 			],
 		});
+		expect(weird.getSnapshot()).toMatchObject({
+			id: 'b',
+			map: {},
+			objectMap: null,
+			weird: {
+				list: null,
+				cool: {
+					message: 'cool',
+				},
+				ok: {
+					message: 'ok',
+				},
+			},
+		});
+
 		todo.get('attachments').push({
 			name: 'qux',
 		});
@@ -144,5 +310,30 @@ describe('clients with stored legacy oids', () => {
 			  },
 			]
 		`);
+
+		weird.get('weird').set('another', 'bar');
+		weird.get('weird').set('list', ['a', 'b', 'c']);
+		weird.get('weird').delete('cool');
+		weird.get('map').set('foo', 'bar');
+		expect(weird.getSnapshot()).toMatchInlineSnapshot(`
+			{
+			  "id": "b",
+			  "map": {
+			    "foo": "bar",
+			  },
+			  "objectMap": null,
+			  "weird": {
+			    "another": "bar",
+			    "list": [
+			      "a",
+			      "b",
+			      "c",
+			    ],
+			    "ok": {
+			      "message": "ok",
+			    },
+			  },
+			}
+		`);
 	});
 });

package/src/client/ClientDescriptor.ts

@@ -24,6 +24,7 @@ import {
 	getAllDatabaseNamesAndVersions,
 } from '../idb.js';
 import { FakeWeakRef } from '../FakeWeakRef.js';
+import { METADATA_VERSION_KEY } from './constants.js';
 
 export interface ClientDescriptorOptions<Presence = any, Profile = any> {
 	/** The schema used to create this client */
@@ -67,6 +68,9 @@ export interface ClientDescriptorOptions<Presence = any, Profile = any> {
 	 * before turning it on.
 	 */
 	EXPERIMENTAL_weakRefs?: boolean;
+
+	// not for public use
+	[METADATA_VERSION_KEY]?: number;
 }
 
 /**
@@ -136,10 +140,12 @@ export class ClientDescriptor<
 	};
 
 	private initializeDatabases = async (init: ClientDescriptorOptions) => {
+		const metadataVersion = init[METADATA_VERSION_KEY];
 		const { db: metaDb } = await openMetadataDatabase({
 			indexedDB: init.indexedDb,
 			log: init.log,
 			namespace: init.namespace,
+			metadataVersion,
 		});
 
 		const context: Omit<Context, 'documentDb'> = {

package/src/client/constants.ts

@@ -0,0 +1 @@
+export const METADATA_VERSION_KEY = Symbol('metadataVersion');

package/src/metadata/openMetadataDatabase.ts

@@ -1,19 +1,22 @@
+import { replaceLegacyOidsInObject } from '@verdant-web/common';
 import { closeDatabase, storeRequestPromise } from '../idb.js';
 
-const migrations = [version1, version2, version3, version4];
+const migrations = [version1, version2, version3, version4, version5];
 
 export function openMetadataDatabase({
 	indexedDB = window.indexedDB,
 	namespace,
 	log,
+	metadataVersion = 5,
 }: {
 	indexedDB?: IDBFactory;
 	namespace: string;
 	log?: (...args: any[]) => void;
+	metadataVersion?: number;
 }): Promise<{ wasInitialized: boolean; db: IDBDatabase }> {
 	return new Promise<{ wasInitialized: boolean; db: IDBDatabase }>(
 		(resolve, reject) => {
-			const request = indexedDB.open(`${namespace}_meta`, 4);
+			const request = indexedDB.open(`${namespace}_meta`, metadataVersion);
 			let wasInitialized = false;
 			request.onupgradeneeded = async (event) => {
 				const db = request.result;
@@ -24,6 +27,11 @@ export function openMetadataDatabase({
 					await migration(db, tx);
 				}
 
+				await new Promise((resolve, reject) => {
+					tx.addEventListener('complete', resolve);
+					tx.addEventListener('error', reject);
+				});
+
 				if (!event.oldVersion) {
 					wasInitialized = true;
 				}
@@ -44,16 +52,19 @@ export async function openWIPMetadataDatabase({
 	namespace,
 	indexedDB,
 	log,
+	metadataVersion,
 }: {
 	indexedDB?: IDBFactory;
 	namespace: string;
 	wipNamespace: string;
 	log?: (...args: any[]) => void;
+	metadataVersion?: number;
 }): Promise<{ wasInitialized: boolean; db: IDBDatabase }> {
 	const result = await openMetadataDatabase({
 		namespace: wipNamespace,
 		indexedDB,
 		log,
+		metadataVersion,
 	});
 
 	// this WIP database was already set up.
@@ -67,6 +78,7 @@ export async function openWIPMetadataDatabase({
 		namespace,
 		indexedDB,
 		log,
+		metadataVersion,
 	});
 
 	const tx = prodDb.transaction(
@@ -195,3 +207,54 @@ async function version4(db: IDBDatabase, tx: IDBTransaction) {
 	files.createIndex('remote', 'remote');
 	files.createIndex('deletedAt', 'deletedAt');
 }
+
+async function version5(db: IDBDatabase, tx: IDBTransaction) {
+	// rewrites all baselines and operations to replace legacy OIDs
+	// with new ones.
+	const operations = tx.objectStore('operations');
+	await new Promise<void>((resolve, reject) => {
+		const cursorReq = operations.openCursor();
+		cursorReq.onsuccess = () => {
+			const cursor = cursorReq.result;
+			if (cursor) {
+				const converted = replaceLegacyOidsInObject(cursor.value);
+				// conversion may change the primary key, so we need to put the
+				// object back to the store
+				if (converted.oid_timestamp !== cursor.primaryKey) {
+					cursor.delete();
+					operations.put(converted);
+				} else {
+					cursor.update(converted);
+				}
+				cursor.continue();
+			} else {
+				resolve();
+			}
+		};
+		cursorReq.onerror = (event) => {
+			reject(cursorReq.error);
+		};
+	});
+	const baselines = tx.objectStore('baselines');
+	await new Promise<void>((resolve, reject) => {
+		const cursorReq = baselines.openCursor();
+		cursorReq.onsuccess = () => {
+			const cursor = cursorReq.result;
+			if (cursor) {
+				const converted = replaceLegacyOidsInObject(cursor.value);
+				if (converted.oid !== cursor.primaryKey) {
+					cursor.delete();
+					baselines.put(converted);
+				} else {
+					cursor.update(converted);
+				}
+				cursor.continue();
+			} else {
+				resolve();
+			}
+		};
+		cursorReq.onerror = (event) => {
+			reject(cursorReq.error);
+		};
+	});
+}

package/src/sync/Sync.ts

@@ -6,6 +6,7 @@ import {
 	Operation,
 	ReplicaType,
 	ServerMessage,
+	replaceLegacyOidsInObject,
 } from '@verdant-web/common';
 import { Metadata } from '../metadata/Metadata.js';
 import { HANDLE_MESSAGE, PresenceManager } from './PresenceManager.js';