resplite 1.2.8 → 1.2.10

package/package.json

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

package/src/commands/registry.js

@@ -53,6 +53,7 @@ import * as zrem from './zrem.js';
 import * as zcard from './zcard.js';
 import * as zscore from './zscore.js';
 import * as zrange from './zrange.js';
+import * as zrevrange from './zrevrange.js';
 import * as zrangebyscore from './zrangebyscore.js';
 import * as sqliteInfo from './sqlite-info.js';
 import * as cacheInfo from './cache-info.js';
@@ -118,6 +119,7 @@ const HANDLERS = new Map([
   ['ZCARD', (e, a) => zcard.handleZcard(e, a)],
   ['ZSCORE', (e, a) => zscore.handleZscore(e, a)],
   ['ZRANGE', (e, a) => zrange.handleZrange(e, a)],
+  ['ZREVRANGE', (e, a) => zrevrange.handleZrevrange(e, a)],
   ['ZRANGEBYSCORE', (e, a) => zrangebyscore.handleZrangebyscore(e, a)],
   ['SQLITE.INFO', (e, a) => sqliteInfo.handleSqliteInfo(e, a)],
   ['CACHE.INFO', (e, a) => cacheInfo.handleCacheInfo(e, a)],

package/src/commands/zrevrange.js

@@ -0,0 +1,27 @@
+/**
+ * ZREVRANGE key start stop [WITHSCORES]
+ * Same as ZRANGE but ordered from highest to lowest score (rank 0 = highest).
+ */
+
+export function handleZrevrange(engine, args) {
+  if (!args || args.length < 3) {
+    return { error: 'ERR wrong number of arguments for \'ZREVRANGE\' command' };
+  }
+  let withScores = false;
+  for (let i = 3; i < args.length; i++) {
+    const a = (Buffer.isBuffer(args[i]) ? args[i].toString('utf8') : String(args[i])).toUpperCase();
+    if (a === 'WITHSCORES') withScores = true;
+  }
+  try {
+    const start = parseInt(String(args[1]), 10);
+    const stop = parseInt(String(args[2]), 10);
+    if (Number.isNaN(start) || Number.isNaN(stop)) {
+      return { error: 'ERR value is not an integer or out of range' };
+    }
+    const arr = engine.zrevrange(args[0], start, stop, { withScores });
+    return arr;
+  } catch (e) {
+    const msg = e && e.message ? e.message : String(e);
+    return { error: msg.startsWith('ERR ') ? msg : msg.startsWith('WRONGTYPE') ? msg : 'ERR ' + msg };
+  }
+}

package/src/engine/engine.js

@@ -387,6 +387,14 @@ export function createEngine(opts = {}) {
       return zsets.rangeByRank(k, start, stop, { withScores: options.withScores });
     },
 
+    zrevrange(key, start, stop, options = {}) {
+      const k = asKey(key);
+      const meta = getKeyMeta(key);
+      if (!meta) return [];
+      expectZset(meta);
+      return zsets.rangeByRankReverse(k, start, stop, { withScores: options.withScores });
+    },
+
     zrangebyscore(key, min, max, options = {}) {
       const k = asKey(key);
       const meta = getKeyMeta(key);

package/src/storage/sqlite/zsets.js

@@ -36,6 +36,12 @@ export function createZsetsStorage(db, keys) {
      ORDER BY score ASC, member ASC
      LIMIT ? OFFSET ?`
   );
+  const rangeByRankReverseStmt = db.prepare(
+    `SELECT member, score FROM redis_zsets
+     WHERE key = ?
+     ORDER BY score DESC, member DESC
+     LIMIT ? OFFSET ?`
+  );
   const rangeByScoreStmt = db.prepare(
     `SELECT member, score FROM redis_zsets
      WHERE key = ? AND score >= ? AND score <= ?
@@ -143,6 +149,34 @@ export function createZsetsStorage(db, keys) {
       return out;
     },
 
+    /**
+     * Range by rank in reverse order (ZREVRANGE). Rank 0 = highest score.
+     * Same start/stop semantics as rangeByRank; order is score DESC, member DESC.
+     * @param {Buffer} key
+     * @param {number} start 0-based inclusive (0 = highest score)
+     * @param {number} stop 0-based inclusive
+     * @param {{ withScores?: boolean }} options
+     * @returns {Buffer[] | Array<Buffer|string>} members or [member, score, ...]
+     */
+    rangeByRankReverse(key, start, stop, options = {}) {
+      const len = this.count(key);
+      if (len === 0) return [];
+      let s = start >= 0 ? start : Math.max(0, len + start);
+      let e = stop >= 0 ? stop : Math.max(0, len + stop);
+      if (s > e) return [];
+      s = Math.min(s, len - 1);
+      e = Math.min(e, len - 1);
+      const limit = e - s + 1;
+      const offset = s;
+      const rows = rangeByRankReverseStmt.all(key, limit, offset);
+      if (!options.withScores) return rows.map((r) => r.member);
+      const out = [];
+      for (const r of rows) {
+        out.push(r.member, formatScore(r.score));
+      }
+      return out;
+    },
+
     /**
      * Range by score (min/max inclusive). Order: score ASC, member ASC.
      * @param {Buffer} key

package/test/integration/zsets.test.js

@@ -51,6 +51,24 @@ describe('ZSET integration', () => {
     assert.equal(arr[3].toString('utf8'), '2');
   });
 
+  it('ZREVRANGE returns order highest to lowest and supports WITHSCORES', async () => {
+    await sendCommand(port, argv('ZADD', 'zrev', '1', 'a', '2', 'b', '3', 'c'));
+    const rev = await sendCommand(port, argv('ZREVRANGE', 'zrev', '0', '-1'));
+    const arr = tryParseValue(rev, 0).value;
+    assert.equal(arr.length, 3);
+    assert.equal(arr[0].toString('utf8'), 'c');
+    assert.equal(arr[1].toString('utf8'), 'b');
+    assert.equal(arr[2].toString('utf8'), 'a');
+
+    const withScores = await sendCommand(port, argv('ZREVRANGE', 'zrev', '0', '30', 'WITHSCORES'));
+    const withArr = tryParseValue(withScores, 0).value;
+    assert.equal(withArr.length, 6);
+    assert.equal(withArr[0].toString('utf8'), 'c');
+    assert.equal(withArr[1].toString('utf8'), '3');
+    assert.equal(withArr[2].toString('utf8'), 'b');
+    assert.equal(withArr[3].toString('utf8'), '2');
+  });
+
   it('ZRANGE negative indices and start > stop', async () => {
     await sendCommand(port, argv('ZADD', 'z4', '1', 'a', '2', 'b', '3', 'c'));
     const last = await sendCommand(port, argv('ZRANGE', 'z4', '-1', '-1'));