deepbase-sqlite 3.1.2 → 3.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepbase-sqlite",
-  "version": "3.1.2",
+  "version": "3.1.6",
   "description": "⚡ DeepBase SQLite - SQLite database driver",
   "type": "module",
   "main": "src/index.cjs",
@@ -15,7 +15,7 @@
     "better-sqlite3": "^11.8.1"
   },
   "peerDependencies": {
-    "deepbase": "^3.1.2"
+    "deepbase": "^3.1.6"
   },
   "scripts": {
     "test": "mocha test/test.js"
@@ -42,5 +42,5 @@
   "bugs": {
     "url": "https://github.com/clasen/DeepBase/issues"
   },
-  "homepage": "https://github.com/clasen/DeepBase#readme"
+  "homepage": "https://github.com/clasen/DeepBase/tree/main/packages/driver-sqlite"
 }

package/src/SqliteDriver.js

@@ -57,6 +57,10 @@ export class SqliteDriver extends DeepBaseDriver {
   }
   
   async get(...args) {
+    return this._getSync(args);
+  }
+  
+  _getSync(args) {
     if (args.length === 0) {
       // Get root object
       return this._getRootObject();
@@ -106,14 +110,23 @@ export class SqliteDriver extends DeepBaseDriver {
       return [];
     }
     
+    return this._setSync(args);
+  }
+  
+  _setSync(args) {
     const keys = args.slice(0, -1);
     const value = args[args.length - 1];
     const key = this._pathToKey(keys);
     
-    // Check if any parent path exists as an object that needs to be expanded
-    this._expandParentObjects(keys);
+    // Use transaction to make expansion and set atomic
+    const transaction = this.db.transaction(() => {
+      // Check if any parent path exists as an object that needs to be expanded
+      this._expandParentObjects(keys);
+      
+      this.setStmt.run(key, JSON.stringify(value));
+    });
     
-    this.setStmt.run(key, JSON.stringify(value));
+    transaction();
     return keys;
   }
   
@@ -126,12 +139,17 @@ export class SqliteDriver extends DeepBaseDriver {
     
     const key = this._pathToKey(keys);
     
-    // Delete the key itself
-    this.delStmt.run(key);
+    // Use transaction to make deletion atomic
+    const transaction = this.db.transaction(() => {
+      // Delete the key itself
+      this.delStmt.run(key);
+      
+      // Delete all children
+      const childKey = key + '.';
+      this.db.prepare('DELETE FROM deepbase WHERE key LIKE ?').run(childKey + '%');
+    });
     
-    // Delete all children
-    const childKey = key + '.';
-    this.db.prepare('DELETE FROM deepbase WHERE key LIKE ?').run(childKey + '%');
+    transaction();
   }
   
   async inc(...args) {
@@ -153,7 +171,17 @@ export class SqliteDriver extends DeepBaseDriver {
   
   async upd(...args) {
     const func = args.pop();
-    return this.set(...args, func(await this.get(...args)));
+    const keys = args;
+    
+    // Use transaction to make get+set atomic
+    const transaction = this.db.transaction(() => {
+      const currentValue = this._getSync(keys);
+      const newValue = func(currentValue);
+      this._setSync([...keys, newValue]);
+      return keys;
+    });
+    
+    return transaction();
   }
   
   _getRootObject() {

package/test/test.js

@@ -500,6 +500,103 @@ describe('SqliteDriver', function() {
       });
     });
   });
+
+  describe('Race Conditions', function() {
+    it('should handle 100 concurrent increments correctly', async function() {
+      this.timeout(5000);
+      
+      await db.set('counter', 0);
+      
+      // Run 100 concurrent increments
+      const promises = Array.from({ length: 100 }, () => db.inc('counter', 1));
+      await Promise.all(promises);
+      
+      const result = await db.get('counter');
+      assert.strictEqual(result, 100, 'All increments should be applied atomically');
+    });
+
+    it('should handle concurrent read-modify-write operations', async function() {
+      this.timeout(5000);
+      
+      await db.set('data', { counter: 0, items: [] });
+      
+      // Run 50 concurrent updates that read, modify, and write
+      const promises = Array.from({ length: 50 }, (_, i) =>
+        db.upd('data', (current) => ({
+          counter: current.counter + 1,
+          items: [...current.items, `item-${current.counter}`]
+        }))
+      );
+      
+      await Promise.all(promises);
+      
+      const finalData = await db.get('data');
+      assert.strictEqual(finalData.counter, 50, 'Counter should be exactly 50');
+      assert.strictEqual(finalData.items.length, 50, 'Should have exactly 50 items');
+      
+      // Check that all items have unique values
+      const uniqueItems = new Set(finalData.items);
+      assert.strictEqual(uniqueItems.size, 50, 'All items should be unique');
+    });
+
+    it('should handle concurrent sets on different keys', async function() {
+      this.timeout(5000);
+      
+      // Run 50 concurrent set operations on different keys
+      const promises = Array.from({ length: 50 }, (_, i) =>
+        db.set('users', `user${i}`, { name: `User ${i}`, value: i })
+      );
+      
+      await Promise.all(promises);
+      
+      // Verify all keys exist and have correct values
+      const users = await db.get('users');
+      assert.strictEqual(Object.keys(users).length, 50, 'Should have 50 users');
+      
+      for (let i = 0; i < 50; i++) {
+        assert.deepStrictEqual(
+          users[`user${i}`],
+          { name: `User ${i}`, value: i },
+          `User ${i} should have correct data`
+        );
+      }
+    });
+
+    it('should handle concurrent add operations with unique IDs', async function() {
+      this.timeout(5000);
+      
+      await db.set('items', {});
+      
+      // Run 50 concurrent add operations
+      const promises = Array.from({ length: 50 }, (_, i) =>
+        db.add('items', { value: i })
+      );
+      
+      const results = await Promise.all(promises);
+      
+      // Verify all items were added with unique IDs
+      const items = await db.get('items');
+      assert.strictEqual(Object.keys(items).length, 50, 'Should have 50 items');
+      
+      // Check that all IDs are unique
+      const ids = results.map(r => r[r.length - 1]);
+      const uniqueIds = new Set(ids);
+      assert.strictEqual(uniqueIds.size, 50, 'All IDs should be unique');
+    });
+
+    it('should handle concurrent decrements correctly', async function() {
+      this.timeout(5000);
+      
+      await db.set('inventory', 1000);
+      
+      // Run 100 concurrent decrements
+      const promises = Array.from({ length: 100 }, () => db.dec('inventory', 5));
+      await Promise.all(promises);
+      
+      const result = await db.get('inventory');
+      assert.strictEqual(result, 500, 'All decrements should be applied atomically');
+    });
+  });
 });