deepbase-redis 3.1.0 → 3.1.4

package/README.md

@@ -1,6 +1,6 @@
 # deepbase-redis
 
-Redis Stack driver for DeepBase.
+Vanilla Redis driver for DeepBase (no modules required).
 
 ## Installation
 
@@ -10,23 +10,23 @@ npm install deepbase deepbase-redis
 
 ## Prerequisites
 
-Requires Redis Stack (includes RedisJSON module):
+Requires standard Redis (no modules needed):
 
 ```bash
-docker run -d -p 6379:6379 --name redis redis/redis-stack-server:latest
+docker run -d -p 6379:6379 --name redis redis:latest
 ```
 
-**Note:** Standard Redis won't work - you need Redis Stack for JSON support.
+**Note:** This driver works with vanilla Redis. For RedisJSON support, use `deepbase-redis-json` instead.
 
 ## Description
 
-Stores data in Redis using the RedisJSON module. Perfect for:
+Stores data in Redis using standard string operations with JSON serialization. Perfect for:
 
 - ✅ High-performance caching
 - ✅ Real-time applications
 - ✅ Session storage
-- ✅ Fast reads and writes
-- ✅ In-memory speed with persistence
+- ✅ Works with any Redis installation
+- ✅ No modules required
 
 ## Usage
 
@@ -58,28 +58,51 @@ new RedisDriver({
 
 ## Data Structure
 
-Data is stored as Redis JSON keys:
+Data is stored as JSON strings in Redis:
 
 ```javascript
 // Keys created
-myapp:users     -> { alice: {...}, bob: {...} }
-myapp:config    -> { theme: "dark", lang: "en" }
+myapp:users     -> '{"alice": {...}, "bob": {...}}'
+myapp:config    -> '{"theme": "dark", "lang": "en"}'
 ```
 
+## Differences from deepbase-redis-json
+
+This vanilla driver:
+- ✅ Works with any Redis installation
+- ✅ No modules required
+- ✅ Simpler deployment
+- ❌ No atomic JSON path operations
+- ❌ Entire values must be read/written
+
+The RedisJSON driver (`deepbase-redis-json`):
+- ✅ Atomic JSON path operations
+- ✅ More efficient for large nested objects
+- ❌ Requires Redis Stack or RedisJSON module
+
 ## Features
 
-### RedisJSON Support
+### JSON Serialization
+
+Uses standard JSON serialization:
+
+```javascript
+await db.set('users', 'alice', { name: 'Alice', age: 30 });
+// Stored as: '{"alice": {"name": "Alice", "age": 30}}'
+```
 
-Uses Redis JSON module for native JSON operations:
+### Nested Operations
+
+Supports nested path operations:
 
 ```javascript
 await db.set('users', 'alice', 'address', { city: 'NYC' });
-// Stored at JSON path: $.alice.address
+// Reads full object, modifies, and writes back
 ```
 
-### Atomic Increment
+### Increment/Decrement
 
-Uses Redis `JSON.NUMINCRBY` for atomic operations:
+Basic increment operations:
 
 ```javascript
 await db.inc('stats', 'views', 1);
@@ -95,30 +118,6 @@ const allUsers = await db.get('users');
 // Scans all keys matching prefix
 ```
 
-## Three-Tier Architecture
-
-Use Redis as a cache layer:
-
-```javascript
-import DeepBase from '@deepbase/core';
-import MongoDriver from 'deepbase-mongodb';
-import { JsonDriver } from 'deepbase';
-import RedisDriver from '@deepbase/redis';
-
-const db = new DeepBase([
-  new MongoDriver({ url: 'mongodb://localhost:27017' }),  // Primary
-  new JsonDriver({ path: './backup' }),                   // Backup
-  new RedisDriver({ url: 'redis://localhost:6379' })      // Cache
-], {
-  writeAll: true,           // Write to all three
-  readFirst: true,          // Read from MongoDB first
-  failOnPrimaryError: false // Fallback through layers
-});
-```
-
-**Read priority**: MongoDB → JSON → Redis
-**Write replication**: All three updated simultaneously
-
 ## Connection String Formats
 
 ```javascript
@@ -145,7 +144,7 @@ Redis is extremely fast:
 - **Reads**: Sub-millisecond response times
 - **Writes**: Thousands of operations per second
 - **In-memory**: Data stored in RAM with optional persistence
-- **Atomic operations**: Lock-free increments and updates
+- **Simple**: No complex JSON path operations
 
 ## Use Cases
 
@@ -159,7 +158,6 @@ await sessions.set(sessionId, 'user', userData);
 ```javascript
 const stats = new DeepBase(new RedisDriver({ prefix: 'stats' }));
 await stats.inc('page', 'views', 1);
-await stats.inc('page', 'unique_visitors', 1);
 ```
 
 ### Cache Layer
@@ -168,21 +166,19 @@ const cache = new DeepBase([
   new RedisDriver({ prefix: 'cache' }),
   new MongoDriver({ url: '...' })
 ]);
-
-// Fast reads from Redis, persistent in MongoDB
 ```
 
 ## Best Practices
 
 1. **Use as cache layer** - Not as primary storage
-2. **Set appropriate TTLs** - Expire old data
+2. **Small to medium objects** - Full objects are read/written
 3. **Monitor memory usage** - Redis is in-memory
 4. **Enable persistence** - RDB or AOF for durability
 5. **Use with persistent drivers** - MongoDB or JSON backup
 
 ## Persistence Options
 
-Redis Stack supports:
+Redis supports:
 - **RDB**: Periodic snapshots
 - **AOF**: Append-only file for durability
 
@@ -190,7 +186,7 @@ Configure in Redis:
 ```bash
 docker run -d -p 6379:6379 \
   -v redis-data:/data \
-  redis/redis-stack-server:latest \
+  redis:latest \
   --appendonly yes
 ```
 
@@ -205,6 +201,20 @@ try {
 }
 ```
 
+## When to Use
+
+**Use `deepbase-redis` (this driver) when:**
+- You have standard Redis
+- You want simple deployment
+- Your objects are small to medium sized
+- You don't need atomic JSON operations
+
+**Use `deepbase-redis-json` when:**
+- You have Redis Stack
+- You need atomic JSON path operations
+- You work with large nested objects
+- You want optimal performance for partial updates
+
 ## License
 
 MIT - Copyright (c) Martin Clasen

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "deepbase-redis",
-  "version": "3.1.0",
-  "description": "⚡ DeepBase Redis Stack - driver",
+  "version": "3.1.4",
+  "description": "⚡ DeepBase Redis (vanilla) - driver",
   "type": "module",
   "main": "src/index.cjs",
   "module": "src/index.js",
@@ -15,7 +15,7 @@
     "redis": "^4.7.0"
   },
   "peerDependencies": {
-    "deepbase": "^3.1.0"
+    "deepbase": "^3.1.4"
   },
   "scripts": {
     "test": "mocha test/test.js"
@@ -30,8 +30,7 @@
   "keywords": [
     "deepbase",
     "redis",
-    "redis-stack",
-    "redis-json",
+    "vanilla",
     "driver",
     "database",
     "persist",

package/src/RedisDriver.js

@@ -9,6 +9,7 @@ export class RedisDriver extends DeepBaseDriver {
     this.url = url || "redis://localhost:6379";
     
     this.client = createClient({ url: this.url });
+    this._locks = new Map(); // Lock map for concurrent operations on same key
   }
   
   async connect() {
@@ -30,15 +31,45 @@ export class RedisDriver extends DeepBaseDriver {
     }
     
     const key = args.shift();
-    const path = args.length == 0 ? "." : this._pathToKey(args);
+    const redisKey = this.name + ":" + key;
     
     try {
-      return await this.client.json.get(this.name + ":" + key, { path });
+      const value = await this.client.get(redisKey);
+      if (value === null) return null;
+      
+      let data = JSON.parse(value);
+      
+      // Navigate through nested path if provided
+      for (let pathKey of args) {
+        if (data === null || data === undefined) return null;
+        data = data[pathKey];
+      }
+      
+      return data;
     } catch (error) {
       return null;
     }
   }
   
+  async _acquireLock(key) {
+    // Wait for any pending operation on this key to complete
+    while (this._locks.has(key)) {
+      await this._locks.get(key);
+    }
+    
+    // Create a new lock for this operation
+    let releaseLock;
+    const lockPromise = new Promise(resolve => {
+      releaseLock = resolve;
+    });
+    
+    this._locks.set(key, lockPromise);
+    return () => {
+      this._locks.delete(key);
+      releaseLock();
+    };
+  }
+
   async set(...args) {
     if (args.length < 2) return;
     
@@ -46,8 +77,49 @@ export class RedisDriver extends DeepBaseDriver {
     const value = args[args.length - 1];
     
     const key = keys.shift();
-    const keyPath = keys.length == 0 ? "." : this._pathToKey(keys);
-    await this._set(key, keyPath, value);
+    const redisKey = this.name + ":" + key;
+    
+    if (keys.length === 0) {
+      // Direct set
+      if (value === undefined) {
+        await this.client.del(redisKey);
+      } else {
+        await this.client.set(redisKey, JSON.stringify(value));
+      }
+    } else {
+      // Nested set - serialize operations on same key to prevent race conditions
+      const releaseLock = await this._acquireLock(redisKey);
+      
+      try {
+        const current = await this.client.get(redisKey);
+        let data = current ? JSON.parse(current) : {};
+        
+        if (typeof data !== 'object' || Array.isArray(data)) {
+          data = {};
+        }
+        
+        // Navigate and set nested value
+        let current_obj = data;
+        for (let i = 0; i < keys.length - 1; i++) {
+          const pathKey = keys[i];
+          if (!current_obj[pathKey] || typeof current_obj[pathKey] !== 'object') {
+            current_obj[pathKey] = {};
+          }
+          current_obj = current_obj[pathKey];
+        }
+        
+        const lastKey = keys[keys.length - 1];
+        if (value === undefined) {
+          delete current_obj[lastKey];
+        } else {
+          current_obj[lastKey] = value;
+        }
+        
+        await this.client.set(redisKey, JSON.stringify(data));
+      } finally {
+        releaseLock();
+      }
+    }
     
     return args.slice(0, -1);
   }
@@ -55,14 +127,18 @@ export class RedisDriver extends DeepBaseDriver {
   async inc(...args) {
     const i = args.pop();
     const key = args.shift();
-    const path = args.length == 0 ? "." : this._pathToKey(args);
     
-    try {
-      await this.client.json.numIncrBy(this.name + ":" + key, path, i);
-      return [key, ...args];
-    } catch (error) {
+    if (args.length === 0) {
+      // Direct increment on root level
+      const redisKey = this.name + ":" + key;
+      const value = await this.client.get(redisKey);
+      const num = value ? JSON.parse(value) : 0;
+      await this.client.set(redisKey, JSON.stringify(num + i));
+      return [key];
+    } else {
+      // Nested increment
       args.unshift(key);
-      return this.upd(...args, n => n + i);
+      return this.upd(...args, n => (n || 0) + i);
     }
   }
   
@@ -81,8 +157,29 @@ export class RedisDriver extends DeepBaseDriver {
     }
     
     const key = args.shift();
-    const path = args.length == 0 ? "." : this._pathToKey(args);
-    await this.client.json.del(this.name + ":" + key, path);
+    const redisKey = this.name + ":" + key;
+    
+    if (args.length === 0) {
+      // Delete entire key
+      await this.client.del(redisKey);
+    } else {
+      // Delete nested path
+      let data = await this.get(key);
+      if (data === null) return [key, ...args];
+      
+      // Navigate and delete nested value
+      let current = data;
+      for (let i = 0; i < args.length - 1; i++) {
+        const pathKey = args[i];
+        if (!current[pathKey]) return [key, ...args];
+        current = current[pathKey];
+      }
+      
+      const lastKey = args[args.length - 1];
+      delete current[lastKey];
+      
+      await this.client.set(redisKey, JSON.stringify(data));
+    }
     
     return [key, ...args];
   }
@@ -99,26 +196,8 @@ export class RedisDriver extends DeepBaseDriver {
     return this.set(...args, func(await this.get(...args)));
   }
   
-  async _set(key, path, value) {
-    if (value === undefined) {
-      await this.client.json.del(this.name + ":" + key, path);
-      return;
-    }
-    
-    try {
-      await this.client.json.set(this.name + ":" + key, path, value);
-    } catch (error) {
-      const keys = this._keyToPath(path);
-      keys.pop();
-      const keyPath = keys.length == 0 ? "." : this._pathToKey(keys);
-      await this._set(key, keyPath, {});
-      await this._set(key, path, value);
-    }
-  }
-  
   async _zeroKeys() {
     const scan = {
-      TYPE: "ReJSON-RL",
       MATCH: this.name + ":*",
       COUNT: 1000,
     };
@@ -133,4 +212,3 @@ export class RedisDriver extends DeepBaseDriver {
 }
 
 export default RedisDriver;
-

package/test/test.js

@@ -86,6 +86,66 @@ describe('RedisDriver', function() {
     });
   });
 
+  describe('Keys with Dots', function() {
+    it('should handle keys containing dots', async function() {
+      const setResult = await db.set('value', 'martin.clasen@gmail.com', 1);
+      
+      assert.strictEqual(setResult.length, 2);
+      assert.strictEqual(setResult[0], 'value');
+      assert.strictEqual(setResult[1], 'martin.clasen@gmail.com');
+      
+      const getValue = await db.get('value');
+      assert.strictEqual(getValue['martin.clasen@gmail.com'], 1);
+    });
+
+    it('should handle keys with multiple dots', async function() {
+      await db.set('config', 'api.prod.endpoint', 'https://api.example.com');
+      const endpoint = await db.get('config', 'api.prod.endpoint');
+      assert.strictEqual(endpoint, 'https://api.example.com');
+    });
+
+    it('should handle nested paths with dots in keys', async function() {
+      await db.set('users', 'john.doe@example.com', 'name', 'John Doe');
+      await db.set('users', 'john.doe@example.com', 'age', 30);
+      
+      const user = await db.get('users', 'john.doe@example.com');
+      assert.strictEqual(user.name, 'John Doe');
+      assert.strictEqual(user.age, 30);
+    });
+
+    it('should handle dots in first level keys', async function() {
+      await db.set('config.prod', 'value', 100);
+      const configProd = await db.get('config.prod');
+      assert.strictEqual(configProd.value, 100);
+    });
+
+    it('should distinguish between dots in keys and path separators', async function() {
+      // Set a regular nested path
+      await db.set('users', 'alice', 'email', 'alice@example.com');
+      
+      // Set a key with dots at the same level
+      await db.set('users', 'john.doe@company.com', 'email', 'john@work.com');
+      
+      const users = await db.get('users');
+      assert.strictEqual(users.alice.email, 'alice@example.com');
+      assert.strictEqual(users['john.doe@company.com'].email, 'john@work.com');
+      assert.strictEqual(Object.keys(users).length, 2);
+    });
+
+    it('should delete keys containing dots', async function() {
+      await db.set('emails', 'user.name@domain.com', 'verified', true);
+      await db.set('emails', 'other@email.com', 'verified', false);
+      
+      await db.del('emails', 'user.name@domain.com');
+      
+      const email1 = await db.get('emails', 'user.name@domain.com');
+      const email2 = await db.get('emails', 'other@email.com');
+      
+      assert.strictEqual(email1, undefined);
+      assert.strictEqual(email2.verified, false);
+    });
+  });
+
   describe('Delete Operations', function() {
     it('should delete a key', async function() {
       await db.set('temp', 'value');