@verdant-web/store 2.7.7-next.0 → 2.7.8

package/dist/esm/metadata/openMetadataDatabase.js

@@ -1,215 +1,215 @@
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-import { replaceLegacyOidsInObject } from '@verdant-web/common';
-import { closeDatabase, storeRequestPromise } from '../idb.js';
-const migrations = [version1, version2, version3, version4, version5];
-export function openMetadataDatabase({ indexedDB = window.indexedDB, namespace, log, metadataVersion = 5, }) {
-    return new Promise((resolve, reject) => {
-        const request = indexedDB.open(`${namespace}_meta`, metadataVersion);
-        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);
-            }
-            await new Promise((resolve, reject) => {
-                tx.addEventListener('complete', resolve);
-                tx.addEventListener('error', reject);
-            });
-            if (!event.oldVersion) {
-                wasInitialized = true;
-            }
-        };
-        request.onerror = () => {
-            console.error('Error opening database', request.error);
-            reject(request.error);
-        };
-        request.onsuccess = () => {
-            resolve({ db: request.result, wasInitialized });
-        };
-    });
-}
-export async function openWIPMetadataDatabase({ wipNamespace, namespace, indexedDB, log, metadataVersion, }) {
-    const result = await openMetadataDatabase({
-        namespace: wipNamespace,
-        indexedDB,
-        log,
-        metadataVersion,
-    });
-    // this WIP database was already set up.
-    if (!result.wasInitialized) {
-        return result;
-    }
-    log === null || log === void 0 ? void 0 : log('debug', 'Beginning copy of production metadata database to WIP');
-    // copy all data from production metadata database
-    const { db: prodDb } = await openMetadataDatabase({
-        namespace,
-        indexedDB,
-        log,
-        metadataVersion,
-    });
-    const tx = prodDb.transaction(['baselines', 'operations', 'info'], 'readonly');
-    const [baselines, operations, info] = await Promise.all([
-        storeRequestPromise(tx.objectStore('baselines').getAll()),
-        storeRequestPromise(tx.objectStore('operations').getAll()),
-        storeRequestPromise(tx.objectStore('info').getAll()),
-    ]);
-    const wipTx = result.db.transaction(['baselines', 'operations', 'info'], 'readwrite');
-    const wipBaselines = wipTx.objectStore('baselines');
-    const wipOperations = wipTx.objectStore('operations');
-    const wipInfo = wipTx.objectStore('info');
-    for (const baseline of baselines) {
-        wipBaselines.put(baseline);
-    }
-    for (const operation of operations) {
-        wipOperations.put(operation);
-    }
-    for (const infoItem of info) {
-        wipInfo.put(infoItem);
-    }
-    await new Promise((resolve, reject) => {
-        wipTx.oncomplete = () => {
-            resolve();
-        };
-        wipTx.onerror = (event) => {
-            reject(event);
-        };
-        wipTx.onabort = (event) => {
-            reject(event);
-        };
-    });
-    await closeDatabase(prodDb);
-    log === null || log === void 0 ? void 0 : log('debug', 'Finished copy of production metadata database to WIP. Copied:', baselines.length, 'baselines,', operations.length, 'operations');
-    return result;
-}
-async function version1(db, tx) {
-    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, tx) {
-    const operations = tx.objectStore('operations');
-    await new Promise((resolve, reject) => {
-        const cursorReq = operations.openCursor();
-        cursorReq.onsuccess = () => {
-            // rename the consolidated fields
-            const cursor = cursorReq.result;
-            if (cursor) {
-                const _a = cursor.value, { isLocal_timestamp, documentOid_timestamp } = _a, value = __rest(_a, ["isLocal_timestamp", "documentOid_timestamp"]);
-                cursor.update(Object.assign(Object.assign({}, 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, tx) {
-    const operations = tx.objectStore('operations');
-    operations.createIndex('timestamp', 'timestamp');
-}
-async function version4(db, tx) {
-    const files = db.createObjectStore('files', {
-        keyPath: 'id',
-    });
-    files.createIndex('remote', 'remote');
-    files.createIndex('deletedAt', 'deletedAt');
-}
-async function version5(db, tx) {
-    // rewrites all baselines and operations to replace legacy OIDs
-    // with new ones.
-    const operations = tx.objectStore('operations');
-    await new Promise((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((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);
-        };
-    });
-}
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { replaceLegacyOidsInObject } from '@verdant-web/common';
+import { closeDatabase, storeRequestPromise } from '../idb.js';
+const migrations = [version1, version2, version3, version4, version5];
+export function openMetadataDatabase({ indexedDB = window.indexedDB, namespace, log, metadataVersion = 5, }) {
+    return new Promise((resolve, reject) => {
+        const request = indexedDB.open(`${namespace}_meta`, metadataVersion);
+        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);
+            }
+            await new Promise((resolve, reject) => {
+                tx.addEventListener('complete', resolve);
+                tx.addEventListener('error', reject);
+            });
+            if (!event.oldVersion) {
+                wasInitialized = true;
+            }
+        };
+        request.onerror = () => {
+            console.error('Error opening database', request.error);
+            reject(request.error);
+        };
+        request.onsuccess = () => {
+            resolve({ db: request.result, wasInitialized });
+        };
+    });
+}
+export async function openWIPMetadataDatabase({ wipNamespace, namespace, indexedDB, log, metadataVersion, }) {
+    const result = await openMetadataDatabase({
+        namespace: wipNamespace,
+        indexedDB,
+        log,
+        metadataVersion,
+    });
+    // this WIP database was already set up.
+    if (!result.wasInitialized) {
+        return result;
+    }
+    log === null || log === void 0 ? void 0 : log('debug', 'Beginning copy of production metadata database to WIP');
+    // copy all data from production metadata database
+    const { db: prodDb } = await openMetadataDatabase({
+        namespace,
+        indexedDB,
+        log,
+        metadataVersion,
+    });
+    const tx = prodDb.transaction(['baselines', 'operations', 'info'], 'readonly');
+    const [baselines, operations, info] = await Promise.all([
+        storeRequestPromise(tx.objectStore('baselines').getAll()),
+        storeRequestPromise(tx.objectStore('operations').getAll()),
+        storeRequestPromise(tx.objectStore('info').getAll()),
+    ]);
+    const wipTx = result.db.transaction(['baselines', 'operations', 'info'], 'readwrite');
+    const wipBaselines = wipTx.objectStore('baselines');
+    const wipOperations = wipTx.objectStore('operations');
+    const wipInfo = wipTx.objectStore('info');
+    for (const baseline of baselines) {
+        wipBaselines.put(baseline);
+    }
+    for (const operation of operations) {
+        wipOperations.put(operation);
+    }
+    for (const infoItem of info) {
+        wipInfo.put(infoItem);
+    }
+    await new Promise((resolve, reject) => {
+        wipTx.oncomplete = () => {
+            resolve();
+        };
+        wipTx.onerror = (event) => {
+            reject(event);
+        };
+        wipTx.onabort = (event) => {
+            reject(event);
+        };
+    });
+    await closeDatabase(prodDb);
+    log === null || log === void 0 ? void 0 : log('debug', 'Finished copy of production metadata database to WIP. Copied:', baselines.length, 'baselines,', operations.length, 'operations');
+    return result;
+}
+async function version1(db, tx) {
+    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, tx) {
+    const operations = tx.objectStore('operations');
+    await new Promise((resolve, reject) => {
+        const cursorReq = operations.openCursor();
+        cursorReq.onsuccess = () => {
+            // rename the consolidated fields
+            const cursor = cursorReq.result;
+            if (cursor) {
+                const _a = cursor.value, { isLocal_timestamp, documentOid_timestamp } = _a, value = __rest(_a, ["isLocal_timestamp", "documentOid_timestamp"]);
+                cursor.update(Object.assign(Object.assign({}, 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, tx) {
+    const operations = tx.objectStore('operations');
+    operations.createIndex('timestamp', 'timestamp');
+}
+async function version4(db, tx) {
+    const files = db.createObjectStore('files', {
+        keyPath: 'id',
+    });
+    files.createIndex('remote', 'remote');
+    files.createIndex('deletedAt', 'deletedAt');
+}
+async function version5(db, tx) {
+    // rewrites all baselines and operations to replace legacy OIDs
+    // with new ones.
+    const operations = tx.objectStore('operations');
+    await new Promise((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((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);
+        };
+    });
+}
 //# sourceMappingURL=openMetadataDatabase.js.map

package/dist/esm/migration/db.d.ts

@@ -1,8 +1,8 @@
-export declare function getDatabaseVersion(indexedDB: IDBFactory, namespace: string, version: number, log?: (...args: any[]) => void): Promise<number>;
-export declare function closeDatabase(db: IDBDatabase): Promise<void>;
-/**
- * Upgrades the database to the given version, using the given upgrader function.
- */
-export declare function upgradeDatabase(indexedDb: IDBFactory, namespace: string, version: number, upgrader: (transaction: IDBTransaction, db: IDBDatabase, event: IDBVersionChangeEvent) => void, log?: (...args: any[]) => void): Promise<void>;
-export declare function acquireLock(namespace: string, procedure: () => Promise<void>): Promise<void>;
-export declare function openDatabase(indexedDb: IDBFactory, namespace: string, version: number, log?: (...args: any[]) => void): Promise<IDBDatabase>;
+export declare function getDatabaseVersion(indexedDB: IDBFactory, namespace: string, version: number, log?: (...args: any[]) => void): Promise<number>;
+export declare function closeDatabase(db: IDBDatabase): Promise<void>;
+/**
+ * Upgrades the database to the given version, using the given upgrader function.
+ */
+export declare function upgradeDatabase(indexedDb: IDBFactory, namespace: string, version: number, upgrader: (transaction: IDBTransaction, db: IDBDatabase, event: IDBVersionChangeEvent) => void, log?: (...args: any[]) => void): Promise<void>;
+export declare function acquireLock(namespace: string, procedure: () => Promise<void>): Promise<void>;
+export declare function openDatabase(indexedDb: IDBFactory, namespace: string, version: number, log?: (...args: any[]) => void): Promise<IDBDatabase>;

package/dist/esm/migration/db.js

@@ -1,104 +1,104 @@
-export async function getDatabaseVersion(indexedDB, namespace, version, log) {
-    function openAndGetVersion(resolve, reject) {
-        let currentVersion;
-        let database;
-        const request = indexedDB.open([namespace, 'collections'].join('_'), version);
-        request.onupgradeneeded = async (event) => {
-            currentVersion = event.oldVersion;
-            const transaction = request.transaction;
-            database = request.result;
-            transaction.abort();
-        };
-        request.onsuccess = (event) => {
-            resolve([request.result.version, request.result]);
-        };
-        request.onblocked = (event) => {
-            // retry if blocked
-            log === null || log === void 0 ? void 0 : log('Database blocked, waiting...');
-            // setTimeout(() => {
-            // 	openAndGetVersion(resolve, reject);
-            // }, 200);
-        };
-        request.onerror = (event) => {
-            // FIXME: this fails if the code is older than the local database
-            resolve([currentVersion, database]);
-        };
-    }
-    const [currentVersion, db] = await new Promise(openAndGetVersion);
-    await closeDatabase(db);
-    return currentVersion;
-}
-export async function closeDatabase(db) {
-    db.close();
-    // FIXME: this isn't right!!!!
-    await new Promise((resolve) => resolve());
-}
-/**
- * Upgrades the database to the given version, using the given upgrader function.
- */
-export async function upgradeDatabase(indexedDb, namespace, version, upgrader, log) {
-    function openAndUpgrade(resolve, reject) {
-        const request = indexedDb.open([namespace, 'collections'].join('_'), version);
-        let wasUpgraded = false;
-        request.onupgradeneeded = (event) => {
-            const transaction = request.transaction;
-            upgrader(transaction, request.result, event);
-            wasUpgraded = true;
-        };
-        request.onsuccess = (event) => {
-            request.result.close();
-            if (wasUpgraded) {
-                resolve();
-            }
-            else {
-                reject(new Error('Database was not upgraded when a version change was expected'));
-            }
-        };
-        request.onerror = (event) => {
-            reject(request.error || new Error('Unknown error'));
-        };
-        request.onblocked = (event) => {
-            log === null || log === void 0 ? void 0 : log('Database upgrade blocked, waiting...');
-            // setTimeout(() => {
-            // 	openAndUpgrade(resolve, reject);
-            // }, 200);
-        };
-    }
-    return new Promise(openAndUpgrade);
-}
-export async function acquireLock(namespace, procedure) {
-    if (typeof navigator !== 'undefined' && navigator.locks) {
-        await navigator.locks.request(`verdant_migration_${namespace}`, procedure);
-    }
-    else {
-        // TODO: is there a fallback?
-        await procedure();
-    }
-}
-export async function openDatabase(indexedDb, namespace, version, log) {
-    log === null || log === void 0 ? void 0 : log('debug', 'Opening database', namespace, 'at version', version);
-    const db = await new Promise((resolve, reject) => {
-        const request = indexedDb.open([namespace, 'collections'].join('_'), version);
-        request.onupgradeneeded = async (event) => {
-            const transaction = request.transaction;
-            transaction.abort();
-            log === null || log === void 0 ? void 0 : log('error', 'Database upgrade needed, but not expected', 'Expected', version, 'Got', request.result.version);
-            reject(request.error ||
-                new Error(`Migration error: database version changed unexpectedly when reading current data. Expected ${version}, got ${request.result.version}`));
-        };
-        request.onsuccess = (event) => {
-            resolve(request.result);
-        };
-        request.onblocked = (event) => {
-            reject(new Error('Migration error: database blocked'));
-        };
-        request.onerror = (event) => {
-            reject(new Error('Migration error: database error'));
-        };
-    });
-    db.addEventListener('versionchange', (event) => {
-        db.close();
-    });
-    return db;
-}
+export async function getDatabaseVersion(indexedDB, namespace, version, log) {
+    function openAndGetVersion(resolve, reject) {
+        let currentVersion;
+        let database;
+        const request = indexedDB.open([namespace, 'collections'].join('_'), version);
+        request.onupgradeneeded = async (event) => {
+            currentVersion = event.oldVersion;
+            const transaction = request.transaction;
+            database = request.result;
+            transaction.abort();
+        };
+        request.onsuccess = (event) => {
+            resolve([request.result.version, request.result]);
+        };
+        request.onblocked = (event) => {
+            // retry if blocked
+            log === null || log === void 0 ? void 0 : log('Database blocked, waiting...');
+            // setTimeout(() => {
+            // 	openAndGetVersion(resolve, reject);
+            // }, 200);
+        };
+        request.onerror = (event) => {
+            // FIXME: this fails if the code is older than the local database
+            resolve([currentVersion, database]);
+        };
+    }
+    const [currentVersion, db] = await new Promise(openAndGetVersion);
+    await closeDatabase(db);
+    return currentVersion;
+}
+export async function closeDatabase(db) {
+    db.close();
+    // FIXME: this isn't right!!!!
+    await new Promise((resolve) => resolve());
+}
+/**
+ * Upgrades the database to the given version, using the given upgrader function.
+ */
+export async function upgradeDatabase(indexedDb, namespace, version, upgrader, log) {
+    function openAndUpgrade(resolve, reject) {
+        const request = indexedDb.open([namespace, 'collections'].join('_'), version);
+        let wasUpgraded = false;
+        request.onupgradeneeded = (event) => {
+            const transaction = request.transaction;
+            upgrader(transaction, request.result, event);
+            wasUpgraded = true;
+        };
+        request.onsuccess = (event) => {
+            request.result.close();
+            if (wasUpgraded) {
+                resolve();
+            }
+            else {
+                reject(new Error('Database was not upgraded when a version change was expected'));
+            }
+        };
+        request.onerror = (event) => {
+            reject(request.error || new Error('Unknown error'));
+        };
+        request.onblocked = (event) => {
+            log === null || log === void 0 ? void 0 : log('Database upgrade blocked, waiting...');
+            // setTimeout(() => {
+            // 	openAndUpgrade(resolve, reject);
+            // }, 200);
+        };
+    }
+    return new Promise(openAndUpgrade);
+}
+export async function acquireLock(namespace, procedure) {
+    if (typeof navigator !== 'undefined' && navigator.locks) {
+        await navigator.locks.request(`verdant_migration_${namespace}`, procedure);
+    }
+    else {
+        // TODO: is there a fallback?
+        await procedure();
+    }
+}
+export async function openDatabase(indexedDb, namespace, version, log) {
+    log === null || log === void 0 ? void 0 : log('debug', 'Opening database', namespace, 'at version', version);
+    const db = await new Promise((resolve, reject) => {
+        const request = indexedDb.open([namespace, 'collections'].join('_'), version);
+        request.onupgradeneeded = async (event) => {
+            const transaction = request.transaction;
+            transaction.abort();
+            log === null || log === void 0 ? void 0 : log('error', 'Database upgrade needed, but not expected', 'Expected', version, 'Got', request.result.version);
+            reject(request.error ||
+                new Error(`Migration error: database version changed unexpectedly when reading current data. Expected ${version}, got ${request.result.version}`));
+        };
+        request.onsuccess = (event) => {
+            resolve(request.result);
+        };
+        request.onblocked = (event) => {
+            reject(new Error('Migration error: database blocked'));
+        };
+        request.onerror = (event) => {
+            reject(new Error('Migration error: database error'));
+        };
+    });
+    db.addEventListener('versionchange', (event) => {
+        db.close();
+    });
+    return db;
+}
 //# sourceMappingURL=db.js.map