origin-snapshot 0.1.1 → 0.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "origin-snapshot",
-	"version": "0.1.1",
+	"version": "0.1.2",
 	"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,36 +36,31 @@ 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 };
 }
 
 /**
@@ -74,17 +69,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();
+		}
+	}
 }
 
 /**
@@ -93,50 +88,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);
 }
 
 /**
@@ -144,12 +139,10 @@ 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));
 }
 
 /**
@@ -159,65 +152,63 @@ 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.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));
-  });
+	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);
+	});
 }