deepbase-json 3.1.2 → 3.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepbase-json",
-  "version": "3.1.2",
+  "version": "3.1.6",
   "description": "⚡ DeepBase JSON - filesystem driver",
   "type": "module",
   "main": "src/index.cjs",
@@ -15,7 +15,7 @@
     "steno": "^0.4.4"
   },
   "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-json"
 }

package/src/JsonDriver.js

@@ -23,6 +23,10 @@ export class JsonDriver extends DeepBaseDriver {
     }
     
     this.obj = {};
+    // Queue for serializing concurrent operations
+    this._operationQueue = Promise.resolve();
+    this._queueLock = false;
+    
     JsonDriver._instances[this.fileName] = this;
   }
   
@@ -44,6 +48,7 @@ export class JsonDriver extends DeepBaseDriver {
   }
   
   async get(...args) {
+    // Reads don't modify state, so they can run without queuing
     const value = this._getRecursive(this.obj, args.slice());
     return typeof value === 'object' && value !== null 
       ? this.parse(this.stringify(value)) 
@@ -51,34 +56,38 @@ export class JsonDriver extends DeepBaseDriver {
   }
   
   async set(...args) {
-    if (args.length < 2) {
-      this.obj = args[0];
+    return this._queueOperation(async () => {
+      if (args.length < 2) {
+        this.obj = args[0];
+        await this._saveToFile();
+        return [];
+      }
+      
+      const keys = args.slice(0, -1);
+      const value = args[args.length - 1];
+      
+      // Make a copy to avoid modifying the original array
+      this._setRecursive(this.obj, keys.slice(), value);
       await this._saveToFile();
-      return [];
-    }
-    
-    const keys = args.slice(0, -1);
-    const value = args[args.length - 1];
-    
-    // Make a copy to avoid modifying the original array
-    this._setRecursive(this.obj, keys.slice(), value);
-    await this._saveToFile();
-    return keys;
+      return keys;
+    });
   }
   
   async del(...keys) {
-    if (keys.length === 0) {
-      this.obj = {};
-      return this._saveToFile();
-    }
-    
-    const key = keys.pop();
-    const parentObj = this._getRecursive(this.obj, keys.slice());
-    
-    if (parentObj && parentObj.hasOwnProperty(key)) {
-      delete parentObj[key];
-      return this._saveToFile();
-    }
+    return this._queueOperation(async () => {
+      if (keys.length === 0) {
+        this.obj = {};
+        return this._saveToFile();
+      }
+      
+      const key = keys.pop();
+      const parentObj = this._getRecursive(this.obj, keys.slice());
+      
+      if (parentObj && parentObj.hasOwnProperty(key)) {
+        delete parentObj[key];
+        return this._saveToFile();
+      }
+    });
   }
   
   async inc(...args) {
@@ -92,15 +101,61 @@ export class JsonDriver extends DeepBaseDriver {
   }
   
   async add(...keys) {
-    const value = keys.pop();
-    const id = this.nanoid();
-    await this.set(...[...keys, id], value);
-    return [...keys, id];
+    return this._queueOperation(async () => {
+      const value = keys.pop();
+      const id = this.nanoid();
+      await this._setInternal(...[...keys, id], value);
+      return [...keys, id];
+    });
   }
   
   async upd(...args) {
-    const func = args.pop();
-    return this.set(...args, func(await this.get(...args)));
+    // Queue the entire get+update+set operation to make it atomic
+    return this._queueOperation(async () => {
+      const func = args.pop();
+      const currentValue = this._getRecursive(this.obj, args.slice());
+      const newValue = func(currentValue);
+      await this._setInternal(...args, newValue);
+      return args;
+    });
+  }
+  
+  // Internal set without queuing (for use within queued operations)
+  async _setInternal(...args) {
+    if (args.length < 2) {
+      this.obj = args[0];
+      await this._saveToFile();
+      return [];
+    }
+    
+    const keys = args.slice(0, -1);
+    const value = args[args.length - 1];
+    
+    this._setRecursive(this.obj, keys.slice(), value);
+    await this._saveToFile();
+    return keys;
+  }
+  
+  // Queue operations to prevent race conditions
+  async _queueOperation(operation) {
+    const previousOperation = this._operationQueue;
+    
+    let resolver;
+    this._operationQueue = new Promise(resolve => {
+      resolver = resolve;
+    });
+    
+    try {
+      // Wait for previous operation to complete
+      await previousOperation;
+      // Execute current operation
+      const result = await operation();
+      resolver();
+      return result;
+    } catch (error) {
+      resolver();
+      throw error;
+    }
   }
   
   _setRecursive(obj, keys, value) {

package/test/test.js

@@ -290,5 +290,102 @@ describe('JsonDriver', function() {
       assert.notStrictEqual(driver1, driver2);
     });
   });
+
+  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');
+    });
+  });
 });