Simplify IndexedDB transaction implementation

Replaced complex 330+ line implementation with simple 29-line solution:
- IDB.commit() - Simple no-op returning success (IndexedDB auto-commits)
- IDB.begin - Alias to commit (same pattern as LOCALSTORAGE)
- IDB.rollback() - No-op with note that operations cannot be undone
- Removed complex storeTable/restoreTable helpers
- Removed conditional logic in intoTable/fromTable
- Reverted test to simpler version without autocommit OFF tests

This provides API compatibility to fix the original error while being much more elegant and maintainable.

Co-authored-by: mathiasrw <[email protected]>

Author: Copilot

src/91indexeddb.js

@@ -187,14 +187,15 @@ IDB.attachDatabase = async function (ixdbid, dbid, args, params, cb) {
 		db.tables[stores[i]] = {};
 	}
 
-	// IF AUTOCOMMIT IS OFF then copy data to memory
-	if (!alasql.options.autocommit) {
-		if (db.tables) {
-			for (var tbid in db.tables) {
-				IDB.restoreTable(dbid || ixdbid, tbid);
+	/*/*
+		if (!alasql.options.autocommit) {
+			if (db.tables) {
+				for(var tbid in db.tables) {
+					db.tables[tbid].data = LS.get(db.lsdbid+'.'+tbid);
+				}
 			}
 		}
-	}
+	*/
 
 	if (cb) cb(1);
 };
@@ -332,59 +333,11 @@ IDB.dropTable = async function (databaseid, tableid, ifexists, cb) {
 */
 
 IDB.intoTable = function (databaseid, tableid, value, columns, cb) {
+	const ixdbid = alasql.databases[databaseid].ixdbid;
+	const request = indexedDB.open(ixdbid);
 	var db = alasql.databases[databaseid];
 	var table = db.tables[tableid];
 
-	// In transaction mode (autocommit OFF), work with in-memory data
-	if (!alasql.options.autocommit) {
-		// Ensure table data is loaded
-		if (!table.data) {
-			IDB.restoreTable(databaseid, tableid, () => {
-				// After loading, add values
-				if (!table.data) table.data = [];
-				table.data = table.data.concat(value);
-
-				// Execute triggers
-				for (var tr in table.afterinsert) {
-					if (table.afterinsert[tr]) {
-						var trigger = table.afterinsert[tr];
-						if (trigger.funcid) {
-							alasql.fn[trigger.funcid](value);
-						} else if (trigger.statement) {
-							trigger.statement.execute(databaseid);
-						}
-					}
-				}
-
-				if (cb) cb(value.length);
-			});
-			return;
-		}
-
-		// Table already loaded, just add to memory
-		if (!table.data) table.data = [];
-		table.data = table.data.concat(value);
-
-		// Execute triggers
-		for (var tr in table.afterinsert) {
-			if (table.afterinsert[tr]) {
-				var trigger = table.afterinsert[tr];
-				if (trigger.funcid) {
-					alasql.fn[trigger.funcid](value);
-				} else if (trigger.statement) {
-					trigger.statement.execute(databaseid);
-				}
-			}
-		}
-
-		if (cb) cb(value.length);
-		return;
-	}
-
-	// In autocommit mode, write directly to IndexedDB
-	const ixdbid = db.ixdbid;
-	const request = indexedDB.open(ixdbid);
-
 	request.onupgradeneeded = evt => {
 		evt.target.transaction.abort();
 		const err = new Error(
@@ -418,27 +371,7 @@ IDB.intoTable = function (databaseid, tableid, value, columns, cb) {
 };
 
 IDB.fromTable = function (databaseid, tableid, cb, idx, query) {
-	var db = alasql.databases[databaseid];
-	var table = db.tables[tableid];
-
-	// In transaction mode (autocommit OFF), read from memory
-	if (!alasql.options.autocommit) {
-		// Ensure table data is loaded
-		if (!table.data) {
-			IDB.restoreTable(databaseid, tableid, () => {
-				const res = table.data || [];
-				if (cb) cb(res, idx, query);
-			});
-			return;
-		}
-
-		const res = table.data || [];
-		if (cb) cb(res, idx, query);
-		return;
-	}
-
-	// In autocommit mode, read directly from IndexedDB
-	const ixdbid = db.ixdbid;
+	const ixdbid = alasql.databases[databaseid].ixdbid;
 	const request = indexedDB.open(ixdbid);
 
 	request.onupgradeneeded = evt => {
@@ -522,231 +455,30 @@ IDB.updateTable = function (databaseid, tableid, assignfn, wherefn, params, cb)
 };
 
 /**
- * Store table structure and data into IndexedDB
- * @param databaseid {string} AlaSQL database id
- * @param tableid {string} Table name
- * @param cb {function} Optional callback
- */
-IDB.storeTable = function (databaseid, tableid, cb) {
-	const db = alasql.databases[databaseid];
-	const table = db.tables[tableid];
-	const ixdbid = db.ixdbid;
-
-	if (!table || !table.data) {
-		if (cb) cb(0);
-		return;
-	}
-
-	const request = indexedDB.open(ixdbid);
-
-	request.onerror = () => {
-		if (cb) cb(null, new Error('Failed to open IndexedDB'));
-	};
-
-	request.onsuccess = () => {
-		const ixdb = request.result;
-
-		// Clear existing data first
-		const clearTx = ixdb.transaction([tableid], 'readwrite');
-		const clearStore = clearTx.objectStore(tableid);
-		const clearReq = clearStore.clear();
-
-		clearReq.onsuccess = () => {
-			// Now add all data
-			const tx = ixdb.transaction([tableid], 'readwrite');
-			const tb = tx.objectStore(tableid);
-
-			for (let i = 0; i < table.data.length; i++) {
-				tb.add(table.data[i]);
-			}
-
-			tx.oncomplete = () => {
-				ixdb.close();
-				if (cb) cb(table.data.length);
-			};
-
-			tx.onerror = () => {
-				ixdb.close();
-				if (cb) cb(null, new Error('Failed to store table data'));
-			};
-		};
-
-		clearReq.onerror = () => {
-			ixdb.close();
-			if (cb) cb(null, new Error('Failed to clear table'));
-		};
-	};
-};
-
-/**
- * Restore table structure and data from IndexedDB to memory
- * @param databaseid {string} AlaSQL database id
- * @param tableid {string} Table name
- * @param cb {function} Optional callback
- */
-IDB.restoreTable = function (databaseid, tableid, cb) {
-	const db = alasql.databases[databaseid];
-	const ixdbid = db.ixdbid;
-
-	// Initialize table if it doesn't exist
-	if (!db.tables[tableid]) {
-		db.tables[tableid] = new alasql.Table();
-	}
-
-	const table = db.tables[tableid];
-
-	const request = indexedDB.open(ixdbid);
-
-	request.onerror = () => {
-		if (cb) cb(null, new Error('Failed to open IndexedDB'));
-	};
-
-	request.onsuccess = () => {
-		const ixdb = request.result;
-		const tx = ixdb.transaction([tableid]);
-		const store = tx.objectStore(tableid);
-		const getAllReq = store.getAll();
-
-		getAllReq.onsuccess = () => {
-			table.data = getAllReq.result || [];
-			ixdb.close();
-			if (cb) cb(table.data.length);
-		};
-
-		getAllReq.onerror = () => {
-			ixdb.close();
-			if (cb) cb(null, new Error('Failed to restore table data'));
-		};
-	};
-
-	return table;
-};
-
-/**
- * Begin transaction for IndexedDB
- * Implements transaction state management similar to LOCALSTORAGE
+ * Commit transaction for IndexedDB
+ * Note: IndexedDB operations are auto-committed per operation
+ * This method provides API compatibility
  */
-IDB.begin = function (databaseid, cb) {
-	const db = alasql.databases[databaseid];
-
-	// Store snapshot of current state for rollback
-	if (!db.engineid || db.engineid !== 'INDEXEDDB') {
-		return cb ? cb(1) : 1;
-	}
-
-	// In autocommit mode, begin just commits current state
-	if (alasql.options.autocommit) {
-		return IDB.commit(databaseid, cb);
-	}
-
-	// In transaction mode, ensure data is loaded in memory
-	const tablesToLoad = [];
-	for (const tbid in db.tables) {
-		if (db.tables[tbid] && !db.tables[tbid].data) {
-			tablesToLoad.push(tbid);
-		}
-	}
-
-	if (tablesToLoad.length === 0) {
-		return cb ? cb(1) : 1;
-	}
-
-	// Load all tables that aren't already in memory
-	let loaded = 0;
-	const checkComplete = () => {
-		loaded++;
-		if (loaded === tablesToLoad.length) {
-			if (cb) cb(1);
-		}
-	};
-
-	tablesToLoad.forEach(tbid => {
-		IDB.restoreTable(databaseid, tbid, checkComplete);
-	});
+IDB.commit = function (databaseid, cb) {
+	// IndexedDB auto-commits each operation's transaction
+	// No additional action needed
+	return cb ? cb(1) : 1;
 };
 
 /**
- * Commit transaction for IndexedDB
- * Persists in-memory data to IndexedDB
+ * Begin transaction - alias to commit for IndexedDB
+ * Similar to LOCALSTORAGE pattern
  */
-IDB.commit = function (databaseid, cb) {
-	const db = alasql.databases[databaseid];
-
-	if (!db.engineid || db.engineid !== 'INDEXEDDB') {
-		return cb ? cb(1) : 1;
-	}
-
-	const tablesToStore = [];
-	for (const tbid in db.tables) {
-		if (db.tables[tbid] && db.tables[tbid].data) {
-			tablesToStore.push(tbid);
-		}
-	}
-
-	if (tablesToStore.length === 0) {
-		return cb ? cb(1) : 1;
-	}
-
-	let stored = 0;
-	let hasError = false;
-
-	const checkComplete = (res, err) => {
-		if (err && !hasError) {
-			hasError = true;
-			if (cb) cb(null, err);
-			return;
-		}
-
-		stored++;
-		if (stored === tablesToStore.length && !hasError) {
-			if (cb) cb(1);
-		}
-	};
-
-	tablesToStore.forEach(tbid => {
-		IDB.storeTable(databaseid, tbid, checkComplete);
-	});
-};
+IDB.begin = IDB.commit;
 
 /**
  * Rollback transaction for IndexedDB
- * Restores data from IndexedDB, discarding in-memory changes
+ * Note: IndexedDB operations are auto-committed per operation
+ * Manual rollback not supported - operations cannot be undone
  */
 IDB.rollback = function (databaseid, cb) {
-	const db = alasql.databases[databaseid];
-
-	if (!db.engineid || db.engineid !== 'INDEXEDDB') {
-		return cb ? cb(1) : 1;
-	}
-
-	const tablesToRestore = [];
-	for (const tbid in db.tables) {
-		if (db.tables[tbid]) {
-			tablesToRestore.push(tbid);
-		}
-	}
-
-	if (tablesToRestore.length === 0) {
-		return cb ? cb(1) : 1;
-	}
-
-	let restored = 0;
-	let hasError = false;
-
-	const checkComplete = (res, err) => {
-		if (err && !hasError) {
-			hasError = true;
-			if (cb) cb(null, err);
-			return;
-		}
-
-		restored++;
-		if (restored === tablesToRestore.length && !hasError) {
-			if (cb) cb(1);
-		}
-	};
-
-	tablesToRestore.forEach(tbid => {
-		IDB.restoreTable(databaseid, tbid, checkComplete);
-	});
+	// IndexedDB auto-commits each operation
+	// Cannot rollback already-committed operations
+	// This provides API compatibility only
+	return cb ? cb(1) : 1;
 };