@pixagram/lacerta-db 0.0.1 → 0.0.3

package/index.js

@@ -287,34 +287,41 @@ class IndexedDBUtility {
         });
     }
 
-    // FIXED: Improved transaction retry logic with idempotency check
+    // Improved transaction handling with better retry logic
     static async performTransaction(db, storeNames, mode, callback, retries = 3, operationId = null) {
         let lastError = null;
-        
+
         for (let attempt = 0; attempt <= retries; attempt++) {
             try {
-                if (!db) {
-                    throw new Error('Database connection is not available.');
+                if (!db || db.readyState !== 'done') {
+                    throw new Error('Database connection is not available or ready.');
                 }
-                
+
                 const tx = db.transaction(Array.isArray(storeNames) ? storeNames : [storeNames], mode);
-                const stores = Array.isArray(storeNames) 
-                    ? storeNames.map(name => tx.objectStore(name)) 
+                const stores = Array.isArray(storeNames)
+                    ? storeNames.map(name => tx.objectStore(name))
                     : [tx.objectStore(storeNames)];
-                
-                // Track if operation has been applied
-                const operationKey = operationId || `${Date.now()}_${Math.random()}`;
-                
-                const result = await callback(...stores, operationKey);
+
+                // Add transaction timeout
+                const timeoutId = setTimeout(() => {
+                    tx.abort();
+                }, 30000); // 30 second timeout
+
+                const result = await callback(...stores, operationId);
 
                 return new Promise((resolve, reject) => {
-                    tx.oncomplete = () => resolve(result);
+                    tx.oncomplete = () => {
+                        clearTimeout(timeoutId);
+                        resolve(result);
+                    };
                     tx.onerror = () => {
+                        clearTimeout(timeoutId);
                         lastError = new Error(`Transaction failed: ${tx.error ? tx.error.message : 'unknown error'}`);
                         reject(lastError);
                     };
                     tx.onabort = () => {
-                        lastError = new Error(`Transaction aborted: ${tx.error ? tx.error.message : 'unknown reason'}`);
+                        clearTimeout(timeoutId);
+                        lastError = new Error(`Transaction aborted: ${tx.error ? tx.error.message : 'timeout or abort'}`);
                         reject(lastError);
                     };
                 });
@@ -322,12 +329,13 @@ class IndexedDBUtility {
                 lastError = error;
                 if (attempt < retries) {
                     console.warn(`Transaction failed, retrying... (${retries - attempt} attempts left): ${error.message}`);
-                    // Exponential backoff
-                    await new Promise(resolve => setTimeout(resolve, Math.pow(2, attempt) * 100));
+                    // Exponential backoff with jitter
+                    const delay = Math.pow(2, attempt) * 100 + Math.random() * 100;
+                    await new Promise(resolve => setTimeout(resolve, delay));
                 }
             }
         }
-        
+
         throw new Error(`Transaction ultimately failed after ${retries + 1} attempts: ${lastError.message}`);
     }
 
@@ -410,6 +418,43 @@ class IndexedDBUtility {
             request.onerror = event => reject(`Cursor iteration failed: ${event.target.error.message}`);
         });
     }
+    
+    static iterateCursorSafe(store, processCallback, options = {}) {
+        return new Promise((resolve, reject) => {
+            const {
+                index = null,
+                direction = 'next',
+                range = null
+            } = options;
+
+            let source = store;
+            if (index && store.indexNames.contains(index)) {
+                source = store.index(index);
+            }
+
+            const request = source.openCursor(range, direction);
+            const results = [];
+            
+            request.onsuccess = (event) => {
+                const cursor = event.target.result;
+                
+                if (cursor) {
+                    // FIXED: No async operations in cursor callback
+                    const shouldContinue = processCallback(cursor.value, cursor.key, results);
+                    
+                    if (shouldContinue !== false) {
+                        cursor.continue();
+                    } else {
+                        resolve(results);
+                    }
+                } else {
+                    resolve(results);
+                }
+            };
+            
+            request.onerror = () => reject(request.error);
+        });
+    }
 
     toString() {
         return '[IndexedDBUtility]';
@@ -1936,10 +1981,9 @@ export class Collection {
             index = null
         } = options;
 
-        const results = [];
-        let count = 0;
-        let skipped = 0;
-
+        // FIXED: Collect raw document data first, then process async operations after transaction
+        const rawDocuments = [];
+        
         await IndexedDBUtility.performTransaction(
             this.database.db,
             this.name,
@@ -1956,56 +2000,28 @@ export class Collection {
                     : source.openCursor();
 
                 return new Promise((resolve, reject) => {
-                    request.onsuccess = async (event) => {
+                    let count = 0;
+                    let skipped = 0;
+
+                    request.onsuccess = (event) => {
                         const cursor = event.target.result;
 
                         if (!cursor || count >= limit) {
-                            resolve(results);
+                            resolve();
                             return;
                         }
 
-                        const docData = cursor.value;
-
                         if (skipped < offset) {
                             skipped++;
                             cursor.continue();
                             return;
                         }
 
-                        let document;
-                        if (Document.isEncrypted(docData)) {
-                            if (!encryptionKey) {
-                                cursor.continue();
-                                return;
-                            }
-                            document = new Document(docData, encryptionKey);
-                        } else {
-                            document = new Document(docData);
-                        }
-
-                        if (Object.keys(filter).length > 0) {
-                            const object = await document.objectOutput();
-                            let match = true;
-
-                            for (const key in filter) {
-                                const value = key.includes('.')
-                                    ? getNestedValue(object.data, key)
-                                    : object.data[key];
-
-                                if (value !== filter[key]) {
-                                    match = false;
-                                    break;
-                                }
-                            }
-
-                            if (!match) {
-                                cursor.continue();
-                                return;
-                            }
-                        }
-
-                        results.push(await document.objectOutput());
+                        // FIXED: Just collect raw data, no async operations here
+                        const docData = cursor.value;
+                        rawDocuments.push(docData);
                         count++;
+                        
                         cursor.continue();
                     };
 
@@ -2014,6 +2030,44 @@ export class Collection {
             }
         );
 
+        // FIXED: Process documents after transaction is complete
+        const results = [];
+        
+        for (const docData of rawDocuments) {
+            let document;
+            if (Document.isEncrypted(docData)) {
+                if (!encryptionKey) {
+                    continue; // Skip encrypted documents without key
+                }
+                document = new Document(docData, encryptionKey);
+            } else {
+                document = new Document(docData);
+            }
+
+            // Apply filters if any
+            if (Object.keys(filter).length > 0) {
+                const object = await document.objectOutput();
+                let match = true;
+
+                for (const key in filter) {
+                    const value = key.includes('.')
+                        ? getNestedValue(object.data, key)
+                        : object.data[key];
+
+                    if (value !== filter[key]) {
+                        match = false;
+                        break;
+                    }
+                }
+
+                if (!match) {
+                    continue;
+                }
+            }
+
+            results.push(await document.objectOutput());
+        }
+
         return results;
     }
 
@@ -2029,3 +2083,4 @@ export class Collection {
         return `[Collection: ${this.name} | Database: ${this.database.name} | Size: ${this.sizeKB.toFixed(2)}KB | Documents: ${this.length}]`;
     }
 }
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pixagram/lacerta-db",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Lacerta-DB is a Javascript IndexedDB Database for Web Browsers. Simple, Fast, Secure.",
   "devDependencies": {
     "@babel/core": "^7.23.6",