resplite 1.4.6 → 1.4.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "resplite",
-  "version": "1.4.6",
+  "version": "1.4.8",
   "description": "A RESP2 server with practical Redis compatibility, backed by SQLite",
   "type": "module",
   "main": "src/index.js",

package/src/commands/score-bounds.js

@@ -0,0 +1,15 @@
+/**
+ * Parse score bound used by sorted-set score range commands.
+ * Supports Redis-style infinities: -inf, +inf, inf.
+ *
+ * @param {Buffer|string|number} raw
+ * @returns {number|null}
+ */
+export function parseScoreBound(raw) {
+  const s = Buffer.isBuffer(raw) ? raw.toString('utf8') : String(raw);
+  const lower = s.toLowerCase();
+  if (lower === '-inf') return Number.NEGATIVE_INFINITY;
+  if (lower === '+inf' || lower === 'inf') return Number.POSITIVE_INFINITY;
+  const n = parseFloat(s);
+  return Number.isNaN(n) ? null : n;
+}

package/src/commands/zcount.js

@@ -2,14 +2,16 @@
  * ZCOUNT key min max - returns count of members in sorted set with score in [min, max].
  */
 
+import { parseScoreBound } from './score-bounds.js';
+
 export function handleZcount(engine, args) {
   if (!args || args.length < 3) {
     return { error: 'ERR wrong number of arguments for \'ZCOUNT\' command' };
   }
   try {
-    const min = parseFloat(String(args[1]));
-    const max = parseFloat(String(args[2]));
-    if (Number.isNaN(min) || Number.isNaN(max)) {
+    const min = parseScoreBound(args[1]);
+    const max = parseScoreBound(args[2]);
+    if (min == null || max == null) {
       return { error: 'ERR value is not a valid float' };
     }
     const n = engine.zcount(args[0], min, max);

package/src/commands/zrangebyscore.js

@@ -2,6 +2,8 @@
  * ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count]
  */
 
+import { parseScoreBound } from './score-bounds.js';
+
 export function handleZrangebyscore(engine, args) {
   if (!args || args.length < 3) {
     return { error: 'ERR wrong number of arguments for \'ZRANGEBYSCORE\' command' };
@@ -25,9 +27,9 @@ export function handleZrangebyscore(engine, args) {
     }
   }
   try {
-    const min = parseFloat(String(args[1]));
-    const max = parseFloat(String(args[2]));
-    if (Number.isNaN(min) || Number.isNaN(max)) {
+    const min = parseScoreBound(args[1]);
+    const max = parseScoreBound(args[2]);
+    if (min == null || max == null) {
       return { error: 'ERR value is not a valid float' };
     }
     const options = { withScores };

package/src/commands/zremrangebyscore.js

@@ -2,14 +2,16 @@
  * ZREMRANGEBYSCORE key min max - removes members with score in [min, max]. Returns count removed.
  */
 
+import { parseScoreBound } from './score-bounds.js';
+
 export function handleZremrangebyscore(engine, args) {
   if (!args || args.length < 3) {
     return { error: 'ERR wrong number of arguments for \'ZREMRANGEBYSCORE\' command' };
   }
   try {
-    const min = parseFloat(String(args[1]));
-    const max = parseFloat(String(args[2]));
-    if (Number.isNaN(min) || Number.isNaN(max)) {
+    const min = parseScoreBound(args[1]);
+    const max = parseScoreBound(args[2]);
+    if (min == null || max == null) {
       return { error: 'ERR value is not a valid float' };
     }
     const n = engine.zremrangebyscore(args[0], min, max);

package/src/commands/zrevrangebyscore.js

@@ -4,6 +4,8 @@
  * Note: Redis uses max min (first score is upper bound, second is lower bound).
  */
 
+import { parseScoreBound } from './score-bounds.js';
+
 export function handleZrevrangebyscore(engine, args) {
   if (!args || args.length < 3) {
     return { error: 'ERR wrong number of arguments for \'ZREVRANGEBYSCORE\' command' };
@@ -27,9 +29,9 @@ export function handleZrevrangebyscore(engine, args) {
     }
   }
   try {
-    const max = parseFloat(String(args[1]));
-    const min = parseFloat(String(args[2]));
-    if (Number.isNaN(max) || Number.isNaN(min)) {
+    const max = parseScoreBound(args[1]);
+    const min = parseScoreBound(args[2]);
+    if (max == null || min == null) {
       return { error: 'ERR value is not a valid float' };
     }
     const options = { withScores };

package/src/engine/engine.js

@@ -569,6 +569,7 @@ export function createEngine(opts = {}) {
         if (keys.get(nk)) keys.delete(nk);
         keys.set(nk, meta.type, {
           expiresAt: meta.expiresAt,
+          setCount: meta.type === KEY_TYPES.SET ? meta.setCount : undefined,
           hashCount: meta.type === KEY_TYPES.HASH ? meta.hashCount : undefined,
           zsetCount: meta.type === KEY_TYPES.ZSET ? meta.zsetCount : undefined,
         });

package/src/storage/sqlite/keys.js

@@ -9,16 +9,22 @@ import { KEY_TYPES } from './schema.js';
  */
 export function createKeysStorage(db) {
   const getByKey = db.prepare(
-    'SELECT key, type, expires_at AS expiresAt, hash_count AS hashCount, zset_count AS zsetCount, version, updated_at AS updatedAt FROM redis_keys WHERE key = ?'
+    'SELECT key, type, expires_at AS expiresAt, set_count AS setCount, hash_count AS hashCount, zset_count AS zsetCount, version, updated_at AS updatedAt FROM redis_keys WHERE key = ?'
   );
   const insert = db.prepare(
-    `INSERT INTO redis_keys (key, type, expires_at, hash_count, zset_count, version, updated_at) VALUES (?, ?, ?, ?, ?, 1, ?)`
+    `INSERT INTO redis_keys (key, type, expires_at, set_count, hash_count, zset_count, version, updated_at) VALUES (?, ?, ?, ?, ?, ?, 1, ?)`
   );
   const updateMeta = db.prepare(
-    'UPDATE redis_keys SET type = ?, expires_at = ?, hash_count = ?, zset_count = ?, version = version + 1, updated_at = ? WHERE key = ?'
+    'UPDATE redis_keys SET type = ?, expires_at = ?, set_count = ?, hash_count = ?, zset_count = ?, version = version + 1, updated_at = ? WHERE key = ?'
   );
   const updateExpires = db.prepare('UPDATE redis_keys SET expires_at = ?, updated_at = ? WHERE key = ?');
   const updateVersion = db.prepare('UPDATE redis_keys SET version = version + 1, updated_at = ? WHERE key = ?');
+  const updateSetCount = db.prepare('UPDATE redis_keys SET set_count = ?, updated_at = ? WHERE key = ?');
+  const updateSetCountOnly = db.prepare('UPDATE redis_keys SET set_count = ? WHERE key = ?');
+  const incrSetCount = db.prepare(
+    'UPDATE redis_keys SET set_count = COALESCE(set_count, 0) + ?, updated_at = ? WHERE key = ?'
+  );
+  const incrSetCountOnly = db.prepare('UPDATE redis_keys SET set_count = COALESCE(set_count, 0) + ? WHERE key = ?');
   const updateHashCount = db.prepare('UPDATE redis_keys SET hash_count = ?, updated_at = ? WHERE key = ?');
   const updateHashCountOnly = db.prepare('UPDATE redis_keys SET hash_count = ? WHERE key = ?');
   const incrHashCount = db.prepare(
@@ -50,6 +56,9 @@ export function createKeysStorage(db) {
       const now = options.updatedAt ?? Date.now();
       const expiresAt = options.expiresAt ?? null;
       const existing = getByKey.get(key);
+      const setCount = type === KEY_TYPES.SET
+        ? (options.setCount ?? existing?.setCount ?? 0)
+        : null;
       const hashCount = type === KEY_TYPES.HASH
         ? (options.hashCount ?? existing?.hashCount ?? 0)
         : null;
@@ -57,9 +66,9 @@ export function createKeysStorage(db) {
         ? (options.zsetCount ?? existing?.zsetCount ?? 0)
         : null;
       if (existing) {
-        updateMeta.run(type, expiresAt, hashCount, zsetCount, now, key);
+        updateMeta.run(type, expiresAt, setCount, hashCount, zsetCount, now, key);
       } else {
-        insert.run(key, type, expiresAt, hashCount, zsetCount, now);
+        insert.run(key, type, expiresAt, setCount, hashCount, zsetCount, now);
       }
     },
 
@@ -71,6 +80,24 @@ export function createKeysStorage(db) {
       updateVersion.run(Date.now(), key);
     },
 
+    setSetCount(key, setCount, options = {}) {
+      const touchUpdatedAt = options.touchUpdatedAt !== false;
+      if (touchUpdatedAt) {
+        updateSetCount.run(setCount, options.updatedAt ?? Date.now(), key);
+      } else {
+        updateSetCountOnly.run(setCount, key);
+      }
+    },
+
+    incrSetCount(key, delta, options = {}) {
+      const touchUpdatedAt = options.touchUpdatedAt !== false;
+      if (touchUpdatedAt) {
+        incrSetCount.run(delta, options.updatedAt ?? Date.now(), key);
+      } else {
+        incrSetCountOnly.run(delta, key);
+      }
+    },
+
     setHashCount(key, hashCount, options = {}) {
       const touchUpdatedAt = options.touchUpdatedAt !== false;
       if (touchUpdatedAt) {

package/src/storage/sqlite/schema.js

@@ -7,6 +7,7 @@ CREATE TABLE IF NOT EXISTS redis_keys (
   key BLOB PRIMARY KEY,
   type INTEGER NOT NULL,
   expires_at INTEGER,
+  set_count INTEGER,
   hash_count INTEGER,
   zset_count INTEGER,
   version INTEGER NOT NULL DEFAULT 1,
@@ -90,8 +91,12 @@ export function applySchema(db) {
   db.exec(SCHEMA);
   // Backward-compatible migration for databases created before count columns existed.
   const cols = db.prepare('PRAGMA table_info(redis_keys)').all();
+  const hasSetCount = cols.some((c) => c.name === 'set_count');
   const hasHashCount = cols.some((c) => c.name === 'hash_count');
   const hasZsetCount = cols.some((c) => c.name === 'zset_count');
+  if (!hasSetCount) {
+    db.exec('ALTER TABLE redis_keys ADD COLUMN set_count INTEGER;');
+  }
   if (!hasHashCount) {
     db.exec('ALTER TABLE redis_keys ADD COLUMN hash_count INTEGER;');
   }

package/src/storage/sqlite/sets.js

@@ -22,34 +22,52 @@ export function createSetsStorage(db, keys) {
       return runInTransaction(db, () => {
         const now = options.updatedAt ?? Date.now();
         const meta = keys.get(key);
+        let knownCount = 0;
         if (meta) {
           if (meta.type !== KEY_TYPES.SET) {
             throw new Error('WRONGTYPE Operation against a key holding the wrong kind of value');
           }
           keys.bumpVersion(key);
+          if (meta.setCount == null) {
+            const row = countStmt.get(key);
+            knownCount = (row && row.n) || 0;
+            keys.setSetCount(key, knownCount, { touchUpdatedAt: false });
+          } else {
+            knownCount = meta.setCount;
+          }
         } else {
-          keys.set(key, KEY_TYPES.SET, { updatedAt: now });
+          keys.set(key, KEY_TYPES.SET, { updatedAt: now, setCount: 0 });
         }
         let added = 0;
         for (const m of members) {
           const r = insertStmt.run(key, m);
           if (r.changes > 0) added++;
         }
+        if (added > 0) {
+          if (meta) keys.incrSetCount(key, added, { touchUpdatedAt: false });
+          else keys.setSetCount(key, added, { touchUpdatedAt: false });
+        } else if (meta && meta.setCount == null) {
+          // Legacy rows may have null counters; persist hydrated value.
+          keys.setSetCount(key, knownCount, { touchUpdatedAt: false });
+        }
         return added;
       });
     },
 
     remove(key, members) {
       return runInTransaction(db, () => {
+        const meta = keys.get(key);
+        const before = meta && meta.setCount != null ? meta.setCount : null;
         let n = 0;
         for (const m of members) {
           n += deleteStmt.run(key, m).changes;
         }
-        const row = countStmt.get(key);
-        const remaining = (row && row.n) || 0;
+        const remaining = before != null ? Math.max(0, before - n) : ((countStmt.get(key) || {}).n || 0);
         if (remaining === 0) {
           deleteAllStmt.run(key);
           keys.delete(key);
+        } else if (n > 0) {
+          keys.setSetCount(key, remaining, { touchUpdatedAt: false });
         }
         return n;
       });
@@ -65,8 +83,17 @@ export function createSetsStorage(db, keys) {
     },
 
     count(key) {
+      const meta = keys.get(key);
+      if (meta && meta.type === KEY_TYPES.SET && meta.setCount != null) {
+        return meta.setCount;
+      }
       const row = countStmt.get(key);
-      return row ? row.n : 0;
+      const n = row ? row.n : 0;
+      if (meta && meta.type === KEY_TYPES.SET && meta.setCount == null) {
+        // One-time hydration for databases created before set_count existed.
+        keys.setSetCount(key, n, { touchUpdatedAt: false });
+      }
+      return n;
     },
 
     /** Copy all members from oldKey to newKey. Caller ensures newKey exists in redis_keys. */
@@ -75,6 +102,9 @@ export function createSetsStorage(db, keys) {
       for (const r of rows) {
         insertStmt.run(newKey, r.member);
       }
+      const sourceMeta = keys.get(oldKey);
+      const nextCount = sourceMeta && sourceMeta.setCount != null ? sourceMeta.setCount : rows.length;
+      keys.setSetCount(newKey, nextCount, { touchUpdatedAt: false });
     },
 
     /** Get random members without removing. count null/1 = single; count > 0 = up to count distinct; count < 0 = |count| with replacement. */
@@ -117,13 +147,13 @@ export function createSetsStorage(db, keys) {
           for (let i = 0; i < -c; i++) chosen.push(arr[Math.floor(Math.random() * arr.length)]);
         }
         for (const m of chosen) deleteStmt.run(key, m);
-        const row = countStmt.get(key);
-        const remaining = (row && row.n) || 0;
+        const remaining = arr.length - chosen.length;
         if (remaining === 0) {
           deleteAllStmt.run(key);
           keys.delete(key);
         } else {
           keys.bumpVersion(key);
+          keys.setSetCount(key, remaining, { touchUpdatedAt: false });
         }
         return c === 1 ? chosen[0] : chosen;
       });

package/src/storage/sqlite/zsets.js

@@ -315,6 +315,9 @@ export function createZsetsStorage(db, keys) {
     },
 
     countByScore(key, min, max) {
+      if (min === Number.NEGATIVE_INFINITY && max === Number.POSITIVE_INFINITY) {
+        return this.count(key);
+      }
       const row = countByScoreStmt.get(key, min, max);
       return row ? row.n : 0;
     },

package/test/integration/sets.test.js

@@ -1,7 +1,9 @@
 import { describe, it, before, after } from 'node:test';
 import assert from 'node:assert/strict';
+import Database from 'better-sqlite3';
 import { createTestServer } from '../helpers/server.js';
 import { sendCommand, argv } from '../helpers/client.js';
+import { tryParseValue } from '../../src/resp/parser.js';
 
 describe('Sets integration', () => {
   let s;
@@ -24,4 +26,51 @@ describe('Sets integration', () => {
     assert.ok(s.includes('$1\r\nb\r\n'));
     assert.ok(s.includes('$1\r\nc\r\n'));
   });
+
+  it('SCARD returns member count', async () => {
+    await sendCommand(port, argv('SADD', 'scard:1', 'a', 'b', 'c'));
+    const reply = await sendCommand(port, argv('SCARD', 'scard:1'));
+    assert.equal(tryParseValue(reply, 0).value, 3);
+  });
+
+  it('SCARD on non-existent key returns 0', async () => {
+    const reply = await sendCommand(port, argv('SCARD', 'scard:none'));
+    assert.equal(tryParseValue(reply, 0).value, 0);
+  });
+
+  it('SCARD decreases after SREM', async () => {
+    await sendCommand(port, argv('SADD', 'scard:2', 'x', 'y'));
+    await sendCommand(port, argv('SREM', 'scard:2', 'x'));
+    const reply = await sendCommand(port, argv('SCARD', 'scard:2'));
+    assert.equal(tryParseValue(reply, 0).value, 1);
+  });
+
+  it('RENAME keeps set cardinality metadata', async () => {
+    await sendCommand(port, argv('SADD', 'srename:src', 'm1', 'm2', 'm3'));
+    await sendCommand(port, argv('RENAME', 'srename:src', 'srename:dst'));
+    const reply = await sendCommand(port, argv('SCARD', 'srename:dst'));
+    assert.equal(tryParseValue(reply, 0).value, 3);
+  });
+
+  it('legacy set rows with null set_count hydrate on first SCARD', async () => {
+    const s1 = await createTestServer();
+    await sendCommand(s1.port, argv('SADD', 'legacy:s', 'a', 'b'));
+    const dbPath = s1.dbPath;
+    await s1.closeAsync();
+    s1.db.close();
+
+    const legacyDb = new Database(dbPath);
+    legacyDb.prepare('UPDATE redis_keys SET set_count = NULL WHERE key = ?').run(Buffer.from('legacy:s', 'utf8'));
+    legacyDb.close();
+
+    const s2 = await createTestServer({ dbPath });
+    const first = await sendCommand(s2.port, argv('SCARD', 'legacy:s'));
+    assert.equal(tryParseValue(first, 0).value, 2);
+    const second = await sendCommand(s2.port, argv('SCARD', 'legacy:s'));
+    assert.equal(tryParseValue(second, 0).value, 2);
+
+    const row = s2.db.prepare('SELECT set_count AS n FROM redis_keys WHERE key = ?').get(Buffer.from('legacy:s', 'utf8'));
+    assert.equal(row.n, 2);
+    await s2.closeAsync();
+  });
 });

package/test/integration/zsets.test.js

@@ -159,6 +159,37 @@ describe('ZSET integration', () => {
     assert.equal(limited[1].toString('utf8'), 'c');
   });
 
+  it('ZCOUNT supports numeric ranges and full-range infinities', async () => {
+    await sendCommand(port, argv('ZADD', 'zc1', '1', 'a', '2', 'b', '3', 'c', '4', 'd'));
+
+    const mid = await sendCommand(port, argv('ZCOUNT', 'zc1', '2', '3'));
+    assert.equal(tryParseValue(mid, 0).value, 2);
+
+    const all = await sendCommand(port, argv('ZCOUNT', 'zc1', '-inf', '+inf'));
+    assert.equal(tryParseValue(all, 0).value, 4);
+  });
+
+  it('score-range commands accept -inf/+inf bounds', async () => {
+    await sendCommand(port, argv('ZADD', 'zinf', '1', 'a', '2', 'b', '3', 'c', '4', 'd'));
+
+    const rangeAll = await sendCommand(port, argv('ZRANGEBYSCORE', 'zinf', '-inf', '+inf'));
+    const rAll = tryParseValue(rangeAll, 0).value;
+    assert.equal(rAll.length, 4);
+    assert.equal(rAll[0].toString('utf8'), 'a');
+    assert.equal(rAll[3].toString('utf8'), 'd');
+
+    const revAll = await sendCommand(port, argv('ZREVRANGEBYSCORE', 'zinf', '+inf', '-inf'));
+    const rvAll = tryParseValue(revAll, 0).value;
+    assert.equal(rvAll.length, 4);
+    assert.equal(rvAll[0].toString('utf8'), 'd');
+    assert.equal(rvAll[3].toString('utf8'), 'a');
+
+    const removed = await sendCommand(port, argv('ZREMRANGEBYSCORE', 'zinf', '-inf', '+inf'));
+    assert.equal(tryParseValue(removed, 0).value, 4);
+    const card = await sendCommand(port, argv('ZCARD', 'zinf'));
+    assert.equal(tryParseValue(card, 0).value, 0);
+  });
+
   it('ZCARD non-existent returns 0, ZSCORE non-existent returns nil', async () => {
     const cardReply = await sendCommand(port, argv('ZCARD', 'nonexistent_z'));
     assert.equal(tryParseValue(cardReply, 0).value, 0);