origin-snapshot 0.1.0 → 0.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "origin-snapshot",
-	"version": "0.1.0",
+	"version": "0.1.1",
 	"description": "Export and restore a browser origin's localStorage, sessionStorage, IndexedDB, and OPFS as a single gzip-compressed snapshot file.",
 	"keywords": [
 		"localstorage",

package/src/storage/indexeddb.js

@@ -1,4 +1,4 @@
-import { serializeValue, deserializeValue } from '../serialize.js';
+import { serializeValue, deserializeValue } from "../serialize.js";
 
 /**
  * @param {Array<Blob | Uint8Array>} bin
@@ -6,28 +6,28 @@ import { serializeValue, deserializeValue } from '../serialize.js';
  * @returns {Promise<object[]>}
  */
 export async function dumpDatabases(bin, names) {
-	let list = names;
-	if (!list) {
-		list =
-			typeof indexedDB.databases === 'function'
-				? (await indexedDB.databases()).map((d) => d.name).filter(Boolean)
-				: [];
-	}
-
-	const dump = [];
-	for (const name of list) {
-		const db = await openExisting(name);
-		try {
-			const stores = [];
-			for (const storeName of [...db.objectStoreNames]) {
-				stores.push(await dumpStore(db, storeName, bin));
-			}
-			dump.push({ name: db.name, version: db.version, stores });
-		} finally {
-			db.close();
-		}
-	}
-	return dump;
+  let list = names;
+  if (!list) {
+    list =
+      typeof indexedDB.databases === "function"
+        ? (await indexedDB.databases()).map((d) => d.name).filter(Boolean)
+        : [];
+  }
+
+  const dump = [];
+  for (const name of list) {
+    const db = await openExisting(name);
+    try {
+      const stores = [];
+      for (const storeName of [...db.objectStoreNames]) {
+        stores.push(await dumpStore(db, storeName, bin));
+      }
+      dump.push({ name: db.name, version: db.version, stores });
+    } finally {
+      db.close();
+    }
+  }
+  return dump;
 }
 
 /**
@@ -36,31 +36,36 @@ export async function dumpDatabases(bin, names) {
  * @param {Array<Blob | Uint8Array>} bin
  */
 async function dumpStore(db, storeName, bin) {
-	const tx = db.transaction(storeName, 'readonly');
-	const store = tx.objectStore(storeName);
-
-	const schema = {
-		name: storeName,
-		keyPath: store.keyPath, 
-		autoIncrement: store.autoIncrement,
-		indexes: [...store.indexNames].map((iname) => {
-			const ix = store.index(iname);
-			return { name: iname, keyPath: ix.keyPath, unique: ix.unique, multiEntry: ix.multiEntry };
-		})
-	};
-
-	const outOfLine = store.keyPath === null;
-	const values = await request(store.getAll());
-	const keys = outOfLine ? await request(store.getAllKeys()) : null;
-
-	const records = values.map((value, i) => {
-		const rec = { value: serializeValue(value, bin) };
-		if (outOfLine) rec.key = serializeValue(keys[i], bin);
-		return rec;
-	});
-
-	await transactionDone(tx);
-	return { ...schema, records };
+  const tx = db.transaction(storeName, "readonly");
+  const store = tx.objectStore(storeName);
+
+  const schema = {
+    name: storeName,
+    keyPath: store.keyPath,
+    autoIncrement: store.autoIncrement,
+    indexes: [...store.indexNames].map((iname) => {
+      const ix = store.index(iname);
+      return {
+        name: iname,
+        keyPath: ix.keyPath,
+        unique: ix.unique,
+        multiEntry: ix.multiEntry,
+      };
+    }),
+  };
+
+  const outOfLine = store.keyPath === null;
+  const values = await request(store.getAll());
+  const keys = outOfLine ? await request(store.getAllKeys()) : null;
+
+  const records = values.map((value, i) => {
+    const rec = { value: serializeValue(value, bin) };
+    if (outOfLine) rec.key = serializeValue(keys[i], bin);
+    return rec;
+  });
+
+  await transactionDone(tx);
+  return { ...schema, records };
 }
 
 /**
@@ -69,17 +74,17 @@ async function dumpStore(db, storeName, bin) {
  * @param {{ clear?: boolean }} [options]
  */
 export async function restoreDatabases(dump, bin, { clear = true } = {}) {
-	for (const dbInfo of dump) {
-		if (clear) await deleteDatabase(dbInfo.name);
-		const db = await openForRestore(dbInfo, clear);
-		try {
-			for (const storeInfo of dbInfo.stores) {
-				await restoreStore(db, storeInfo, bin);
-			}
-		} finally {
-			db.close();
-		}
-	}
+  for (const dbInfo of dump) {
+    if (clear) await deleteDatabase(dbInfo.name);
+    const db = await openForRestore(dbInfo, clear);
+    try {
+      for (const storeInfo of dbInfo.stores) {
+        await restoreStore(db, storeInfo, bin);
+      }
+    } finally {
+      db.close();
+    }
+  }
 }
 
 /**
@@ -88,50 +93,50 @@ export async function restoreDatabases(dump, bin, { clear = true } = {}) {
  * @param {Uint8Array[]} bin
  */
 async function restoreStore(db, storeInfo, bin) {
-	const tx = db.transaction(storeInfo.name, 'readwrite');
-	const store = tx.objectStore(storeInfo.name);
-	const inline = storeInfo.keyPath !== null;
+  const tx = db.transaction(storeInfo.name, "readwrite");
+  const store = tx.objectStore(storeInfo.name);
+  const inline = storeInfo.keyPath !== null;
 
-	for (const rec of storeInfo.records) {
-		const value = deserializeValue(rec.value, bin);
-		if (inline) store.put(value);
-		else store.put(value, deserializeValue(rec.key, bin));
-	}
+  for (const rec of storeInfo.records) {
+    const value = deserializeValue(rec.value, bin);
+    if (inline) store.put(value);
+    else store.put(value, deserializeValue(rec.key, bin));
+  }
 
-	await transactionDone(tx);
+  await transactionDone(tx);
 }
 
 /** @param {string} name */
 function openExisting(name) {
-	return new Promise((resolve, reject) => {
-		const open = indexedDB.open(name);
-		open.onsuccess = () => {
-			const db = open.result;
-			db.onversionchange = () => db.close();
-			resolve(db);
-		};
-		open.onerror = () => reject(open.error);
-	});
+  return new Promise((resolve, reject) => {
+    const open = indexedDB.open(name);
+    open.onsuccess = () => {
+      const db = open.result;
+      db.onversionchange = () => db.close();
+      resolve(db);
+    };
+    open.onerror = () => reject(open.error);
+  });
 }
 
 /**
  *
  * @param {any} dbInfo
- * @param {boolean} wasCleared 
+ * @param {boolean} wasCleared
  * @returns {Promise<IDBDatabase>}
  */
 async function openForRestore(dbInfo, wasCleared) {
-	if (wasCleared) {
-		return openAndUpgrade(dbInfo.name, dbInfo.version || 1, dbInfo.stores);
-	}
+  if (wasCleared) {
+    return openAndUpgrade(dbInfo.name, dbInfo.version || 1, dbInfo.stores);
+  }
 
-	const current = await openExisting(dbInfo.name);
-	const needsUpgrade = dbInfo.stores.some((s) => !hasSchema(current, s));
-	if (!needsUpgrade) return current;
+  const current = await openExisting(dbInfo.name);
+  const needsUpgrade = dbInfo.stores.some((s) => !hasSchema(current, s));
+  if (!needsUpgrade) return current;
 
-	const targetVersion = Math.max(current.version + 1, dbInfo.version || 1);
-	current.close();
-	return openAndUpgrade(dbInfo.name, targetVersion, dbInfo.stores);
+  const targetVersion = Math.max(current.version + 1, dbInfo.version || 1);
+  current.close();
+  return openAndUpgrade(dbInfo.name, targetVersion, dbInfo.stores);
 }
 
 /**
@@ -139,10 +144,12 @@ async function openForRestore(dbInfo, wasCleared) {
  * @param {any} storeInfo
  */
 function hasSchema(db, storeInfo) {
-	if (!db.objectStoreNames.contains(storeInfo.name)) return false;
-	if (storeInfo.indexes.length === 0) return true;
-	const store = db.transaction(storeInfo.name, 'readonly').objectStore(storeInfo.name);
-	return storeInfo.indexes.every((ix) => store.indexNames.contains(ix.name));
+  if (!db.objectStoreNames.contains(storeInfo.name)) return false;
+  if (storeInfo.indexes.length === 0) return true;
+  const store = db
+    .transaction(storeInfo.name, "readonly")
+    .objectStore(storeInfo.name);
+  return storeInfo.indexes.every((ix) => store.indexNames.contains(ix.name));
 }
 
 /**
@@ -152,60 +159,65 @@ function hasSchema(db, storeInfo) {
  * @returns {Promise<IDBDatabase>}
  */
 function openAndUpgrade(name, version, stores) {
-	return new Promise((resolve, reject) => {
-		const open = indexedDB.open(name, version);
-		open.onupgradeneeded = () => {
-			const db = open.result;
-			const tx = open.transaction; 
-			for (const s of stores) {
-				const store = db.objectStoreNames.contains(s.name)
-					? tx.objectStore(s.name)
-					: db.createObjectStore(s.name, { keyPath: s.keyPath, autoIncrement: s.autoIncrement });
-				for (const ix of s.indexes) {
-					if (!store.indexNames.contains(ix.name)) {
-						store.createIndex(ix.name, ix.keyPath, {
-							unique: ix.unique,
-							multiEntry: ix.multiEntry
-						});
-					}
-				}
-			}
-		};
-		open.onsuccess = () => resolve(open.result);
-		open.onerror = () => reject(open.er		open.onblocked = () => reject(blockedError(name));
-	});
+  return new Promise((resolve, reject) => {
+    const open = indexedDB.open(name, version);
+    open.onupgradeneeded = () => {
+      const db = open.result;
+      const tx = open.transaction;
+      for (const s of stores) {
+        const store = db.objectStoreNames.contains(s.name)
+          ? tx.objectStore(s.name)
+          : db.createObjectStore(s.name, {
+              keyPath: s.keyPath,
+              autoIncrement: s.autoIncrement,
+            });
+        for (const ix of s.indexes) {
+          if (!store.indexNames.contains(ix.name)) {
+            store.createIndex(ix.name, ix.keyPath, {
+              unique: ix.unique,
+              multiEntry: ix.multiEntry,
+            });
+          }
+        }
+      }
+    };
+    open.onsuccess = () => resolve(open.result);
+    open.onerror = () => reject(open.error);
+    // A blocked upgrade never fires success/error on its own — fail fast with an
+    // actionable error instead of leaving the restore hung forever.
+    open.onblocked = () => reject(blockedError(name));
+  });
 }
-
 /** @param {string} name */
 function deleteDatabase(name) {
-	return new Promise((resolve, reject) => {
-		const req = indexedDB.deleteDatabase(name);
-		req.onsuccess = () => resolve(undefined);
-		req.onerror = () => reject(req.error);
-		req.onblocked = () => reject(blockedError(name));
-	});
+  return new Promise((resolve, reject) => {
+    const req = indexedDB.deleteDatabase(name);
+    req.onsuccess = () => resolve(undefined);
+    req.onerror = () => reject(req.error);
+    req.onblocked = () => reject(blockedError(name));
+  });
 }
 
 /** @param {string} name */
 function blockedError(name) {
-	return new DOMException(
-		`IndexedDB "${name}" is blocked by another open connection — close other tabs on this origin and retry`,
-		'InvalidStateError'
-	);
+  return new DOMException(
+    `IndexedDB "${name}" is blocked by another open connection — close other tabs on this origin and retry`,
+    "InvalidStateError",
+  );
 }
 
 /** @param {IDBRequest} req */
 function request(req) {
-	return new Promise((resolve, reject) => {
-		req.onsuccess = () => resolve(req.result);
-		req.onerror = () => reject(req.error);
-	});
+  return new Promise((resolve, reject) => {
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+  });
 }
 
 /** @param {IDBTransaction} tx */
 function transactionDone(tx) {
-	return new Promise((resolve, reject) => {
-		tx.oncomplete = () => resolve(undefined);
-		tx.onabort = tx.onerror = () => reject(tx.error);
-	});
+  return new Promise((resolve, reject) => {
+    tx.oncomplete = () => resolve(undefined);
+    tx.onabort = tx.onerror = () => reject(tx.error);
+  });
 }