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

package/dist/cjs/metadata/openMetadataDatabase.js

@@ -1,220 +1,220 @@
-"use strict";
-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;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.openWIPMetadataDatabase = exports.openMetadataDatabase = void 0;
-const common_1 = require("@verdant-web/common");
-const idb_js_1 = require("../idb.js");
-const migrations = [version1, version2, version3, version4, version5];
-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 });
-        };
-    });
-}
-exports.openMetadataDatabase = openMetadataDatabase;
-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([
-        (0, idb_js_1.storeRequestPromise)(tx.objectStore('baselines').getAll()),
-        (0, idb_js_1.storeRequestPromise)(tx.objectStore('operations').getAll()),
-        (0, idb_js_1.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 (0, idb_js_1.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;
-}
-exports.openWIPMetadataDatabase = openWIPMetadataDatabase;
-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 = (0, common_1.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 = (0, common_1.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);
-        };
-    });
-}
+"use strict";
+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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openWIPMetadataDatabase = exports.openMetadataDatabase = void 0;
+const common_1 = require("@verdant-web/common");
+const idb_js_1 = require("../idb.js");
+const migrations = [version1, version2, version3, version4, version5];
+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 });
+        };
+    });
+}
+exports.openMetadataDatabase = openMetadataDatabase;
+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([
+        (0, idb_js_1.storeRequestPromise)(tx.objectStore('baselines').getAll()),
+        (0, idb_js_1.storeRequestPromise)(tx.objectStore('operations').getAll()),
+        (0, idb_js_1.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 (0, idb_js_1.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;
+}
+exports.openWIPMetadataDatabase = openWIPMetadataDatabase;
+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 = (0, common_1.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 = (0, common_1.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/cjs/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>;