@orkestrel/indexeddb 0.0.1 → 0.0.2

package/dist/src/browser/index.js

@@ -1,3 +1,4 @@
+import { isArray, isRecord } from "@orkestrel/contract";
 //#region src/browser/constants.ts
 /**
 * Native `DOMException.name` → our {@link IndexedDBErrorCode}.
@@ -13,9 +14,11 @@ var ERROR_CODES = Object.freeze({
 	AbortError: "ABORTED",
 	NotFoundError: "NOT_FOUND",
 	DataError: "DATA",
+	DataCloneError: "DATA",
 	VersionError: "UPGRADE",
 	TransactionInactiveError: "INACTIVE",
-	InvalidStateError: "INVALID"
+	InvalidStateError: "INVALID",
+	ReadOnlyError: "READONLY"
 });
 //#endregion
 //#region src/browser/errors.ts
@@ -54,99 +57,6 @@ var IndexedDBError = class extends Error {
 function isIndexedDBError(value) {
 	return value instanceof IndexedDBError;
 }
-Object.freeze([
-	"null",
-	"boolean",
-	"object",
-	"array",
-	"number",
-	"integer",
-	"string"
-]);
-/**
-* Determine whether a value is a non-null object.
-*
-* @remarks
-* `true` for arrays, class instances, plain objects, `Map`, `Set`, etc. — use
-* {@link isRecord} when you need a plain-record check.
-*/
-function isObject(value) {
-	return typeof value === "object" && value !== null;
-}
-/**
-* Determine whether a value is a plain record (object literal or null-prototype),
-* not an array or class instance.
-*
-* @remarks
-* Use instead of {@link isObject} to distinguish a plain `{}` /
-* `Object.create(null)` from arrays, `Date`, `Map`, etc. The prototype-chain
-* test is realm-agnostic: rather than comparing against the current realm's
-* `Object.prototype` (which a plain object from another `vm.Context`, iframe,
-* or worker would fail), it accepts any value whose prototype is `null`, OR
-* whose prototype's own prototype is `null` — the shape every plain object
-* has in every realm, since `Object.prototype` itself always sits one step
-* above `null`. Arrays and class instances are still rejected: an array's
-* prototype chain runs through `Array.prototype` before `null`, and a class
-* instance's runs through the class's own prototype. The whole body runs
-* inside `attempt` (AGENTS §14) so a revoked `Proxy` or a hostile
-* `getPrototypeOf` trap cannot escape as a thrown error.
-*/
-function isRecord(value) {
-	const outcome = attempt(() => {
-		if (!isObject(value) || isArray(value)) return false;
-		const prototype = Object.getPrototypeOf(value);
-		return prototype === null || Object.getPrototypeOf(prototype) === null;
-	});
-	return outcome.success && outcome.value;
-}
-/** Determine whether a value is an array. */
-function isArray(value) {
-	return Array.isArray(value);
-}
-/**
-* Invoke a callback and capture its outcome as a {@link Result}, never letting
-* a throw escape.
-*
-* @remarks
-* The single sanctioned never-throw boundary for the guards (AGENTS §14). The
-* `whereOf`, `lazyOf`, and `transformOf` combinators invoke caller-supplied
-* callbacks *inside* a guard body, yet a guard must NEVER throw — it returns a
-* `boolean`. This converts a throwing callback into a `Failure` so the
-* surrounding guard can treat it as a non-match instead of propagating the
-* exception, written once and shared rather than copy-pasted as ad-hoc
-* `try`/`catch`.
-*
-* @param callback - The callback to invoke with no arguments
-* @returns A `Success` carrying the return value, or a `Failure` carrying the
-*          thrown reason normalised to an `Error`
-*
-* @example
-* ```ts
-* const outcome = attempt(() => predicate(value))
-* return outcome.success && outcome.value
-* ```
-*/
-function attempt(callback) {
-	try {
-		return {
-			success: true,
-			value: callback()
-		};
-	} catch (reason) {
-		if (reason instanceof Error) return {
-			success: false,
-			error: reason
-		};
-		let message = "Unknown thrown value";
-		try {
-			message = String(reason);
-		} catch {}
-		return {
-			success: false,
-			error: new Error(message)
-		};
-	}
-}
 //#endregion
 //#region src/browser/helpers.ts
 /**
@@ -270,6 +180,26 @@ async function hasKey(source, key) {
 	return await promisifyRequest(guardSync(() => source.count(key))) > 0;
 }
 /**
+* Create a secondary index on a store from its {@link IndexDefinition}.
+*
+* @remarks
+* The shared index-DDL leaf used both by the built-in create-missing-stores pass
+* (`IndexedDBDatabase`'s internal store creation) and by an upgrade's
+* `context.index`: translate the definition's `path` to a native key path and
+* `unique` / `multiple` to `unique` / `multiEntry`, then issue `createIndex`.
+* Versionchange-only — `store` must be inside an active upgrade transaction.
+*
+* @param store - The object store to add the index to
+* @param definition - The index to create
+*/
+function createIndex(store, definition) {
+	const keyPath = typeof definition.path === "string" ? definition.path : [...definition.path];
+	store.createIndex(definition.name, keyPath, {
+		unique: definition.unique ?? false,
+		multiEntry: definition.multiple ?? false
+	});
+}
+/**
 * Key-range builders — the wrapper's filter vocabulary.
 *
 * @remarks
@@ -717,14 +647,14 @@ var IndexedDBTransaction = class {
 		return new IndexedDBTransactionStore(this.#transaction.objectStore(name));
 	}
 	abort() {
-		if (this.#finished) throw new IndexedDBError("ABORTED", "Cannot abort an already-finished transaction");
-		this.#transaction.abort();
+		if (this.#finished) throw new IndexedDBError("INACTIVE", "Cannot abort an already-finished transaction");
+		guardSync(() => this.#transaction.abort());
 		this.#active = false;
 		this.#finished = true;
 	}
 	commit() {
-		if (this.#finished) throw new IndexedDBError("ABORTED", "Cannot commit an already-finished transaction");
-		this.#transaction.commit();
+		if (this.#finished) throw new IndexedDBError("INACTIVE", "Cannot commit an already-finished transaction");
+		guardSync(() => this.#transaction.commit());
 	}
 };
 //#endregion
@@ -814,13 +744,15 @@ var IndexedDBDatabase = class {
 		const names = isArray(stores) ? [...stores] : [stores];
 		const native = guardSync(() => database.transaction(names, mode));
 		const tx = new IndexedDBTransaction(native);
+		const settled = promisifyTransaction(native);
 		try {
 			await scope(tx);
-			await promisifyTransaction(native);
+			await settled;
 		} catch (error) {
 			if (tx.active) try {
 				tx.abort();
 			} catch {}
+			settled.catch(() => {});
 			throw error;
 		}
 	}
@@ -835,6 +767,7 @@ var IndexedDBDatabase = class {
 		}
 		database.onclose = () => {
 			this.#database = void 0;
+			this.#opening = void 0;
 		};
 		database.onversionchange = () => {
 			database.close();
@@ -853,7 +786,7 @@ var IndexedDBDatabase = class {
 				for (const [name, definition] of Object.entries(this.#stores)) if (!database.objectStoreNames.contains(name)) this.#createStore(database, name, definition);
 				if (this.#upgrade !== void 0) {
 					const transaction = request.transaction;
-					if (transaction !== null) {
+					if (transaction !== null) try {
 						const result = this.#upgrade(this.#context(database, transaction, event));
 						if (result !== void 0) result.catch((error) => {
 							upgradeError = error;
@@ -861,6 +794,11 @@ var IndexedDBDatabase = class {
 								transaction.abort();
 							} catch {}
 						});
+					} catch (error) {
+						upgradeError = error;
+						try {
+							transaction.abort();
+						} catch {}
 					}
 				}
 			};
@@ -879,25 +817,25 @@ var IndexedDBDatabase = class {
 			version: event.newVersion ?? database.version,
 			stores: Array.from(database.objectStoreNames),
 			create: (name, definition) => {
-				this.#createStore(database, name, definition);
+				guardSync(() => this.#createStore(database, name, definition));
 			},
 			drop: (name) => {
-				database.deleteObjectStore(name);
+				guardSync(() => database.deleteObjectStore(name));
+			},
+			store: (name) => new IndexedDBTransactionStore(guardSync(() => transaction.objectStore(name))),
+			index: (store, definition) => {
+				guardSync(() => createIndex(transaction.objectStore(store), definition));
 			},
-			store: (name) => new IndexedDBTransactionStore(transaction.objectStore(name))
+			deindex: (store, name) => {
+				guardSync(() => transaction.objectStore(store).deleteIndex(name));
+			}
 		};
 	}
 	#createStore(database, name, definition) {
 		const options = { autoIncrement: definition.increment ?? false };
 		if (definition.path !== void 0) options.keyPath = typeof definition.path === "string" ? definition.path : [...definition.path];
 		const store = database.createObjectStore(name, options);
-		for (const index of definition.indexes ?? []) {
-			const keyPath = typeof index.path === "string" ? index.path : [...index.path];
-			store.createIndex(index.name, keyPath, {
-				unique: index.unique ?? false,
-				multiEntry: index.multiple ?? false
-			});
-		}
+		for (const index of definition.indexes ?? []) createIndex(store, index);
 	}
 };
 //#endregion
@@ -917,7 +855,7 @@ var IndexedDBDatabase = class {
 *
 * @example
 * ```ts
-* import { createIndexedDBDatabase, range } from '@src/browser'
+* import { createIndexedDBDatabase, range } from '@orkestrel/indexeddb'
 *
 * const db = createIndexedDBDatabase({
 * 	name: 'app',
@@ -934,6 +872,6 @@ function createIndexedDBDatabase(options) {
 	return new IndexedDBDatabase(options);
 }
 //#endregion
-export { ERROR_CODES, IndexedDBCursor, IndexedDBDatabase, IndexedDBError, IndexedDBIndex, IndexedDBStore, IndexedDBTransaction, IndexedDBTransactionStore, createIndexedDBDatabase, guardSync, hasKey, isIndexedDBError, isIndexedDBSupported, promisifyRequest, promisifyTransaction, range, readRecord, readRecords, wrapError };
+export { ERROR_CODES, IndexedDBCursor, IndexedDBDatabase, IndexedDBError, IndexedDBIndex, IndexedDBStore, IndexedDBTransaction, IndexedDBTransactionStore, createIndex, createIndexedDBDatabase, guardSync, hasKey, isIndexedDBError, isIndexedDBSupported, promisifyRequest, promisifyTransaction, range, readRecord, readRecords, wrapError };
 
 //# sourceMappingURL=index.js.map