resplite 1.2.10 → 1.2.14

package/README.md

@@ -515,21 +515,24 @@ A typical comparison is **Redis (for example, in Docker)** on one side and **RES
 
 **Example results (Redis vs RESPLite, default pragma, 10k iterations):**
 
-| Suite           | Redis (Docker) | RESPLite (default) |
-|-----------------|----------------|--------------------|
-| PING            | 8.79K/s        | 37.36K/s           |
-| SET+GET         | 4.68K/s        | 11.96K/s           |
-| MSET+MGET(10)   | 4.41K/s        | 5.81K/s            |
-| INCR            | 9.54K/s        | 18.97K/s           |
-| HSET+HGET       | 4.40K/s        | 11.91K/s           |
-| HGETALL(50)     | 8.39K/s        | 11.01K/s           |
-| HLEN(50)        | 9.36K/s        | 31.21K/s           |
-| SADD+SMEMBERS   | 9.27K/s        | 17.37K/s           |
-| LPUSH+LRANGE    | 8.34K/s        | 14.27K/s           |
-| LREM            | 4.37K/s        | 6.08K/s            |
-| ZADD+ZRANGE     | 7.80K/s        | 17.12K/s           |
-| SET+DEL         | 4.39K/s        | 9.57K/s            |
-| FT.SEARCH       | 8.36K/s        | 8.22K/s            |
+| Suite             | Redis (Docker) | RESPLite (default) |
+|-------------------|----------------|--------------------|
+| PING              | 9.72K/s        | 37.66K/s           |
+| SET+GET           | 4.60K/s        | 11.96K/s           |
+| MSET+MGET(10)     | 4.38K/s        | 5.71K/s            |
+| INCR              | 9.76K/s        | 19.15K/s           |
+| HSET+HGET         | 4.42K/s        | 11.71K/s           |
+| HGETALL(50)       | 8.42K/s        | 11.12K/s           |
+| HLEN(50)          | 8.88K/s        | 30.72K/s           |
+| SADD+SMEMBERS     | 8.33K/s        | 18.19K/s           |
+| LPUSH+LRANGE      | 8.29K/s        | 14.78K/s           |
+| LREM              | 4.85K/s        | 6.35K/s            |
+| ZADD+ZRANGE       | 9.37K/s        | 16.43K/s           |
+| ZADD+ZREVRANGE    | 8.22K/s        | 16.82K/s           |
+| ZRANK+ZREVRANK    | 4.56K/s        | 13.03K/s           |
+| ZREVRANGEBYSCORE  | 8.88K/s        | 16.88K/s           |
+| SET+DEL           | 4.75K/s        | 9.99K/s            |
+| FT.SEARCH         | 8.39K/s        | 8.81K/s            |
 
 To reproduce the benchmark, run `npm run benchmark -- --template default`. Numbers depend on host and whether Redis is native or in Docker.
 
@@ -545,7 +548,7 @@ To reproduce the benchmark, run `npm run benchmark -- --template default`. Numbe
 | **Hashes** | HSET, HGET, HMGET, HGETALL, HDEL, HEXISTS, HINCRBY |
 | **Sets** | SADD, SREM, SMEMBERS, SISMEMBER, SCARD |
 | **Lists** | LPUSH, RPUSH, LLEN, LRANGE, LINDEX, LPOP, RPOP, BLPOP, BRPOP |
-| **Sorted sets** | ZADD, ZREM, ZCARD, ZSCORE, ZRANGE, ZRANGEBYSCORE |
+| **Sorted sets** | ZADD, ZREM, ZCARD, ZSCORE, ZRANGE, ZREVRANGE, ZRANGEBYSCORE, ZREVRANGEBYSCORE, ZRANK, ZREVRANK |
 | **Search (FT.\*)** | FT.CREATE, FT.INFO, FT.ADD, FT.DEL, FT.SEARCH, FT.SUGADD, FT.SUGGET, FT.SUGDEL |
 | **Introspection** | TYPE, OBJECT IDLETIME, SCAN, KEYS, MONITOR |
 | **Admin** | SQLITE.INFO, CACHE.INFO, MEMORY.INFO |

package/package.json

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

package/scripts/benchmark-redis-vs-resplite.js

@@ -258,6 +258,34 @@ async function benchZaddZrange(client, n) {
   }
 }
 
+async function benchZaddZrevrange(client, n) {
+  const key = 'bm:zset:rev';
+  for (let i = 0; i < n; i++) {
+    await client.zAdd(key, { score: i, value: `m${i}` });
+    if (i % 10 === 0) await client.zRange(key, 0, 49, { REV: true });
+  }
+}
+
+async function benchZrankZrevrank(client, n) {
+  const key = 'bm:zset:rank';
+  await client.del(key);
+  await client.zAdd(key, Array.from({ length: 100 }, (_, i) => ({ score: i, value: `m${i}` })));
+  for (let i = 0; i < n; i++) {
+    const member = `m${i % 100}`;
+    await client.zRank(key, member);
+    await client.zRevRank(key, member);
+  }
+}
+
+async function benchZrevrangebyscore(client, n) {
+  const key = 'bm:zset:byscore';
+  await client.del(key);
+  await client.zAdd(key, Array.from({ length: 100 }, (_, i) => ({ score: i, value: `m${i}` })));
+  for (let i = 0; i < n; i++) {
+    await client.sendCommand(['ZREVRANGEBYSCORE', key, '99', '0', 'LIMIT', '0', '20']);
+  }
+}
+
 async function benchDel(client, n) {
   for (let i = 0; i < n; i++) {
     await client.set(`bm:del:${i}`, 'x');
@@ -311,6 +339,9 @@ const SUITES = [
   { name: 'LPUSH+LRANGE', fn: benchLpushLrange, iterScale: 1 },
   { name: 'LREM', fn: benchLrem, iterScale: 1 },
   { name: 'ZADD+ZRANGE', fn: benchZaddZrange, iterScale: 1 },
+  { name: 'ZADD+ZREVRANGE', fn: benchZaddZrevrange, iterScale: 1 },
+  { name: 'ZRANK+ZREVRANK', fn: benchZrankZrevrank, iterScale: 1 },
+  { name: 'ZREVRANGEBYSCORE', fn: benchZrevrangebyscore, iterScale: 1 },
   { name: 'SET+DEL', fn: benchDel, iterScale: 1 },
   { name: 'FT.SEARCH', fn: benchFtSearch, iterScale: 1 },
 ];

package/src/commands/client.js

@@ -0,0 +1,35 @@
+/**
+ * CLIENT - connection introspection (SETNAME, GETNAME, ID).
+ * Requires connection context.
+ */
+
+function argStr(buf) {
+  return Buffer.isBuffer(buf) ? buf.toString('utf8') : String(buf);
+}
+
+export function handleClient(engine, args, context) {
+  if (!args || args.length < 1) {
+    return { error: 'ERR wrong number of arguments for \'CLIENT\' command' };
+  }
+  const sub = argStr(args[0]).toUpperCase();
+  if (sub === 'SETNAME') {
+    if (args.length !== 2) {
+      return { error: 'ERR wrong number of arguments for \'CLIENT SETNAME\' command' };
+    }
+    context.connectionName = argStr(args[1]);
+    return { simple: 'OK' };
+  }
+  if (sub === 'GETNAME') {
+    if (args.length !== 1) {
+      return { error: 'ERR wrong number of arguments for \'CLIENT GETNAME\' command' };
+    }
+    return context.connectionName ?? null;
+  }
+  if (sub === 'ID') {
+    if (args.length !== 1) {
+      return { error: 'ERR wrong number of arguments for \'CLIENT ID\' command' };
+    }
+    return context.connectionId;
+  }
+  return { error: 'ERR unknown subcommand or wrong number of arguments for \'CLIENT\'. Try CLIENT HELP.' };
+}

package/src/commands/registry.js

@@ -9,6 +9,7 @@ import * as quit from './quit.js';
 import * as get from './get.js';
 import * as set from './set.js';
 import * as del from './del.js';
+import * as unlink from './unlink.js';
 import * as exists from './exists.js';
 import * as type from './type.js';
 import * as object from './object.js';
@@ -53,8 +54,11 @@ 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 zrevrange from './zrevrange.js';
+import * as zrevrangebyscore from './zrevrangebyscore.js';
+import * as zrevrank from './zrevrank.js';
+import * as zrank from './zrank.js';
 import * as sqliteInfo from './sqlite-info.js';
 import * as cacheInfo from './cache-info.js';
 import * as memoryInfo from './memory-info.js';
@@ -67,6 +71,7 @@ import * as ftSugadd from './ft-sugadd.js';
 import * as ftSugget from './ft-sugget.js';
 import * as ftSugdel from './ft-sugdel.js';
 import * as monitor from './monitor.js';
+import * as client from './client.js';
 
 const HANDLERS = new Map([
   ['PING', (e, a) => ping.handlePing()],
@@ -75,6 +80,7 @@ const HANDLERS = new Map([
   ['GET', (e, a) => get.handleGet(e, a)],
   ['SET', (e, a) => set.handleSet(e, a)],
   ['DEL', (e, a) => del.handleDel(e, a)],
+  ['UNLINK', (e, a) => unlink.handleUnlink(e, a)],
   ['EXISTS', (e, a) => exists.handleExists(e, a)],
   ['TYPE', (e, a) => type.handleType(e, a)],
   ['OBJECT', (e, a) => object.handleObject(e, a)],
@@ -119,8 +125,11 @@ 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)],
+  ['ZREVRANGE', (e, a) => zrevrange.handleZrevrange(e, a)],
+  ['ZREVRANGEBYSCORE', (e, a) => zrevrangebyscore.handleZrevrangebyscore(e, a)],
+  ['ZREVRANK', (e, a) => zrevrank.handleZrevrank(e, a)],
+  ['ZRANK', (e, a) => zrank.handleZrank(e, a)],
   ['SQLITE.INFO', (e, a) => sqliteInfo.handleSqliteInfo(e, a)],
   ['CACHE.INFO', (e, a) => cacheInfo.handleCacheInfo(e, a)],
   ['MEMORY.INFO', (e, a) => memoryInfo.handleMemoryInfo(e, a)],
@@ -133,6 +142,7 @@ const HANDLERS = new Map([
   ['FT.SUGGET', (e, a) => ftSugget.handleFtSugget(e, a)],
   ['FT.SUGDEL', (e, a) => ftSugdel.handleFtSugdel(e, a)],
   ['MONITOR', (e, a, ctx) => monitor.handleMonitor(a, ctx)],
+  ['CLIENT', (e, a, ctx) => client.handleClient(e, a, ctx)],
 ]);
 
 /**

package/src/commands/unlink.js

@@ -0,0 +1,12 @@
+/**
+ * UNLINK key [key ...] - same as DEL; returns count of removed keys.
+ * In Redis, UNLINK is non-blocking; in RESPlite we delegate to DEL.
+ */
+
+export function handleUnlink(engine, args) {
+  if (!args || args.length < 1) {
+    return { error: 'ERR wrong number of arguments for \'UNLINK\' command' };
+  }
+  const n = engine.del(args);
+  return n;
+}

package/src/commands/zrank.js

@@ -0,0 +1,18 @@
+/**
+ * ZRANK key member
+ * Returns the 0-based rank of member in the sorted set (low to high score).
+ * Returns null if key does not exist or member is not in the set.
+ */
+
+export function handleZrank(engine, args) {
+  if (!args || args.length < 2) {
+    return { error: 'ERR wrong number of arguments for \'ZRANK\' command' };
+  }
+  try {
+    const rank = engine.zrank(args[0], args[1]);
+    return rank;
+  } 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/commands/zrevrangebyscore.js

@@ -0,0 +1,46 @@
+/**
+ * ZREVRANGEBYSCORE key max min [WITHSCORES] [LIMIT offset count]
+ * Same as ZRANGEBYSCORE but ordered from highest to lowest score.
+ * Note: Redis uses max min (first score is upper bound, second is lower bound).
+ */
+
+export function handleZrevrangebyscore(engine, args) {
+  if (!args || args.length < 3) {
+    return { error: 'ERR wrong number of arguments for \'ZREVRANGEBYSCORE\' command' };
+  }
+  let withScores = false;
+  let limitOffset = null;
+  let limitCount = null;
+  const raw = args.slice(3);
+  for (let i = 0; i < raw.length; i++) {
+    const a = (Buffer.isBuffer(raw[i]) ? raw[i].toString('utf8') : String(raw[i])).toUpperCase();
+    if (a === 'WITHSCORES') {
+      withScores = true;
+    } else if (a === 'LIMIT' && i + 2 < raw.length) {
+      const off = parseInt(String(raw[i + 1]), 10);
+      const cnt = parseInt(String(raw[i + 2]), 10);
+      if (!Number.isNaN(off) && !Number.isNaN(cnt)) {
+        limitOffset = off;
+        limitCount = cnt;
+      }
+      i += 2;
+    }
+  }
+  try {
+    const max = parseFloat(String(args[1]));
+    const min = parseFloat(String(args[2]));
+    if (Number.isNaN(max) || Number.isNaN(min)) {
+      return { error: 'ERR value is not a valid float' };
+    }
+    const options = { withScores };
+    if (limitOffset != null && limitCount != null) {
+      options.offset = limitOffset;
+      options.limit = limitCount;
+    }
+    const arr = engine.zrevrangebyscore(args[0], max, min, options);
+    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/commands/zrevrank.js

@@ -0,0 +1,18 @@
+/**
+ * ZREVRANK key member
+ * Returns the 0-based rank of member in the sorted set (high to low score).
+ * Returns null if key does not exist or member is not in the set.
+ */
+
+export function handleZrevrank(engine, args) {
+  if (!args || args.length < 2) {
+    return { error: 'ERR wrong number of arguments for \'ZREVRANK\' command' };
+  }
+  try {
+    const rank = engine.zrevrank(args[0], args[1]);
+    return rank;
+  } 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

@@ -395,6 +395,22 @@ export function createEngine(opts = {}) {
       return zsets.rangeByRankReverse(k, start, stop, { withScores: options.withScores });
     },
 
+    zrevrank(key, member) {
+      const k = asKey(key);
+      const meta = getKeyMeta(key);
+      if (!meta) return null;
+      expectZset(meta);
+      return zsets.rankReverse(k, asKey(member));
+    },
+
+    zrank(key, member) {
+      const k = asKey(key);
+      const meta = getKeyMeta(key);
+      if (!meta) return null;
+      expectZset(meta);
+      return zsets.rank(k, asKey(member));
+    },
+
     zrangebyscore(key, min, max, options = {}) {
       const k = asKey(key);
       const meta = getKeyMeta(key);
@@ -407,6 +423,18 @@ export function createEngine(opts = {}) {
       });
     },
 
+    zrevrangebyscore(key, max, min, options = {}) {
+      const k = asKey(key);
+      const meta = getKeyMeta(key);
+      if (!meta) return [];
+      expectZset(meta);
+      return zsets.rangeByScoreReverse(k, max, min, {
+        withScores: options.withScores,
+        offset: options.offset ?? 0,
+        limit: options.limit,
+      });
+    },
+
     type(key) {
       const meta = getKeyMeta(key);
       return typeName(meta);

package/src/server/connection.js

@@ -21,6 +21,7 @@ export function handleConnection(socket, engine, hooks = {}) {
   const context = {
     connectionId,
     clientAddress,
+    connectionName: null,
     monitorMode: false,
     writeResponse(buf) {
       if (socket.writable) socket.write(buf);

package/src/storage/sqlite/zsets.js

@@ -48,6 +48,20 @@ export function createZsetsStorage(db, keys) {
      ORDER BY score ASC, member ASC
      LIMIT ? OFFSET ?`
   );
+  const rankReverseStmt = db.prepare(
+    `SELECT COUNT(*) AS n FROM redis_zsets
+     WHERE key = ? AND (score > ? OR (score = ? AND member > ?))`
+  );
+  const rankStmt = db.prepare(
+    `SELECT COUNT(*) AS n FROM redis_zsets
+     WHERE key = ? AND (score < ? OR (score = ? AND member < ?))`
+  );
+  const rangeByScoreReverseStmt = db.prepare(
+    `SELECT member, score FROM redis_zsets
+     WHERE key = ? AND score <= ? AND score >= ?
+     ORDER BY score DESC, member DESC
+     LIMIT ? OFFSET ?`
+  );
 
   return {
     /**
@@ -195,5 +209,52 @@ export function createZsetsStorage(db, keys) {
       }
       return out;
     },
+
+    /**
+     * Rank of member in reverse order (ZREVRANK). Rank 0 = highest score.
+     * Returns null if key does not exist or member not in set.
+     * @param {Buffer} key
+     * @param {Buffer} member
+     * @returns {number | null} 0-based rank or null
+     */
+    rankReverse(key, member) {
+      const scoreRow = scoreStmt.get(key, member);
+      if (scoreRow == null) return null;
+      const row = rankReverseStmt.get(key, scoreRow.score, scoreRow.score, member);
+      return row ? row.n : 0;
+    },
+
+    /**
+     * Rank of member in ascending order (ZRANK). Rank 0 = lowest score.
+     * Returns null if key does not exist or member not in set.
+     * @param {Buffer} key
+     * @param {Buffer} member
+     * @returns {number | null} 0-based rank or null
+     */
+    rank(key, member) {
+      const scoreRow = scoreStmt.get(key, member);
+      if (scoreRow == null) return null;
+      const row = rankStmt.get(key, scoreRow.score, scoreRow.score, member);
+      return row ? row.n : 0;
+    },
+
+    /**
+     * Range by score in reverse order (ZREVRANGEBYSCORE). max/min inclusive, order score DESC, member DESC.
+     * @param {Buffer} key
+     * @param {number} max
+     * @param {number} min
+     * @param {{ withScores?: boolean, limit?: number, offset?: number }} options
+     */
+    rangeByScoreReverse(key, max, min, options = {}) {
+      const limit = options.limit ?? -1;
+      const offset = options.offset ?? 0;
+      const rows = rangeByScoreReverseStmt.all(key, max, min, limit < 0 ? 1e9 : 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;
+    },
   };
 }

package/test/integration/client.test.js

@@ -0,0 +1,103 @@
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import net from 'node:net';
+import { createTestServer } from '../helpers/server.js';
+import { sendCommand, argv } from '../helpers/client.js';
+import { encode } from '../../src/resp/encoder.js';
+import { tryParseValue } from '../../src/resp/parser.js';
+
+function sendTwoCommands(port, argv1, argv2) {
+  return new Promise((resolve, reject) => {
+    let recv = Buffer.alloc(0);
+    const results = [];
+    const socket = net.createConnection({ port, host: '127.0.0.1' }, () => {
+      socket.write(encode(argv1));
+      socket.write(encode(argv2));
+    });
+    const t = setTimeout(() => {
+      socket.destroy();
+      reject(new Error('sendTwoCommands timeout'));
+    }, 3000);
+    socket.on('data', (chunk) => {
+      recv = Buffer.concat([recv, chunk]);
+      while (results.length < 2) {
+        const parsed = tryParseValue(recv, 0);
+        if (parsed === null) break;
+        results.push(parsed.value);
+        recv = recv.subarray(parsed.end);
+      }
+      if (results.length === 2) {
+        clearTimeout(t);
+        socket.destroy();
+        resolve(results);
+      }
+    });
+    socket.on('error', (err) => {
+      clearTimeout(t);
+      reject(err);
+    });
+  });
+}
+
+describe('CLIENT integration', () => {
+  let s;
+  let port;
+
+  before(async () => {
+    s = await createTestServer();
+    port = s.port;
+  });
+
+  after(async () => {
+    await s.closeAsync();
+  });
+
+  it('CLIENT ID returns connection id', async () => {
+    const reply = await sendCommand(port, argv('CLIENT', 'ID'));
+    const v = tryParseValue(reply, 0).value;
+    assert.strictEqual(typeof v, 'number');
+    assert.ok(Number.isInteger(v) && v >= 1);
+  });
+
+  it('CLIENT GETNAME returns null when no name set', async () => {
+    const reply = await sendCommand(port, argv('CLIENT', 'GETNAME'));
+    const v = tryParseValue(reply, 0).value;
+    assert.strictEqual(v, null);
+  });
+
+  it('CLIENT SETNAME then GETNAME roundtrip', async () => {
+    const [setResult, getResult] = await sendTwoCommands(
+      port,
+      argv('CLIENT', 'SETNAME', 'my-conn'),
+      argv('CLIENT', 'GETNAME')
+    );
+    assert.equal(setResult, 'OK');
+    assert.ok(Buffer.isBuffer(getResult));
+    assert.equal(getResult.toString('utf8'), 'my-conn');
+  });
+
+  it('CLIENT SETNAME with empty name is allowed', async () => {
+    const [setResult, getResult] = await sendTwoCommands(
+      port,
+      argv('CLIENT', 'SETNAME', ''),
+      argv('CLIENT', 'GETNAME')
+    );
+    assert.equal(setResult, 'OK');
+    assert.ok(Buffer.isBuffer(getResult));
+    assert.equal(getResult.length, 0);
+  });
+
+  it('CLIENT wrong subcommand returns error', async () => {
+    const reply = await sendCommand(port, argv('CLIENT', 'LIST'));
+    const v = tryParseValue(reply, 0).value;
+    assert.ok(v && v.error);
+    assert.match(v.error, /unknown subcommand|CLIENT HELP/);
+  });
+
+  it('CLIENT without subcommand returns error', async () => {
+    const reply = await sendCommand(port, argv('CLIENT'));
+    const v = tryParseValue(reply, 0).value;
+    assert.ok(v && v.error);
+    assert.match(v.error, /wrong number of arguments/);
+  });
+});

package/test/integration/embed.test.js

@@ -147,10 +147,10 @@ describe('createRESPlite', () => {
     } catch (_) {}
     await client.quit();
     await srv.close();
-    assert.equal(errorCalls.length, 1);
-    assert.equal(errorCalls[0].command, 'HGET');
-    assert.ok(errorCalls[0].error.includes('WRONGTYPE'));
-    assert.equal(typeof errorCalls[0].connectionId, 'number');
-    assert.ok(errorCalls[0].clientAddress.length > 0);
+    const hgetError = errorCalls.find((c) => c.command === 'HGET');
+    assert.ok(hgetError, 'expected at least one HGET error (got: ' + errorCalls.map((c) => c.command).join(', ') + ')');
+    assert.ok(hgetError.error.includes('WRONGTYPE'));
+    assert.equal(typeof hgetError.connectionId, 'number');
+    assert.ok(hgetError.clientAddress.length > 0);
   });
 });

package/test/integration/strings.test.js

@@ -33,6 +33,17 @@ describe('Strings integration', () => {
     assert.equal(reply.toString('ascii'), ':1\r\n');
   });
 
+  it('UNLINK returns count like DEL', async () => {
+    await sendCommand(port, argv('SET', 'u1', 'a'));
+    await sendCommand(port, argv('SET', 'u2', 'b'));
+    const one = await sendCommand(port, argv('UNLINK', 'u1'));
+    assert.equal(one.toString('ascii'), ':1\r\n');
+    const two = await sendCommand(port, argv('UNLINK', 'u2', 'u3'));
+    assert.equal(two.toString('ascii'), ':1\r\n');
+    const zero = await sendCommand(port, argv('UNLINK', 'u1'));
+    assert.equal(zero.toString('ascii'), ':0\r\n');
+  });
+
   it('EXISTS returns count', async () => {
     await sendCommand(port, argv('SET', 'ex1', 'a'));
     const r = await sendCommand(port, argv('EXISTS', 'ex1', 'ex2'));

package/test/integration/zsets.test.js

@@ -69,6 +69,56 @@ describe('ZSET integration', () => {
     assert.equal(withArr[3].toString('utf8'), '2');
   });
 
+  it('ZREVRANK returns 0-based rank high-to-low and nil when missing', async () => {
+    await sendCommand(port, argv('ZADD', 'zrevrank', '1', 'a', '2', 'b', '3', 'c'));
+    const rankC = await sendCommand(port, argv('ZREVRANK', 'zrevrank', 'c'));
+    assert.equal(tryParseValue(rankC, 0).value, 0);
+    const rankB = await sendCommand(port, argv('ZREVRANK', 'zrevrank', 'b'));
+    assert.equal(tryParseValue(rankB, 0).value, 1);
+    const rankA = await sendCommand(port, argv('ZREVRANK', 'zrevrank', 'a'));
+    assert.equal(tryParseValue(rankA, 0).value, 2);
+
+    const noMember = await sendCommand(port, argv('ZREVRANK', 'zrevrank', 'x'));
+    assert.ok(noMember.toString('ascii').startsWith('$-1'));
+    const noKey = await sendCommand(port, argv('ZREVRANK', 'nokey', 'a'));
+    assert.ok(noKey.toString('ascii').startsWith('$-1'));
+  });
+
+  it('ZRANK returns 0-based rank low-to-high and nil when missing', async () => {
+    await sendCommand(port, argv('ZADD', 'zrank', '1', 'a', '2', 'b', '3', 'c'));
+    const rankA = await sendCommand(port, argv('ZRANK', 'zrank', 'a'));
+    assert.equal(tryParseValue(rankA, 0).value, 0);
+    const rankB = await sendCommand(port, argv('ZRANK', 'zrank', 'b'));
+    assert.equal(tryParseValue(rankB, 0).value, 1);
+    const rankC = await sendCommand(port, argv('ZRANK', 'zrank', 'c'));
+    assert.equal(tryParseValue(rankC, 0).value, 2);
+
+    const noMember = await sendCommand(port, argv('ZRANK', 'zrank', 'x'));
+    assert.ok(noMember.toString('ascii').startsWith('$-1'));
+  });
+
+  it('ZREVRANGEBYSCORE returns score range high-to-low and supports WITHSCORES and LIMIT', async () => {
+    await sendCommand(port, argv('ZADD', 'zrevscore', '1', 'a', '2', 'b', '3', 'c', '4', 'd'));
+    const rev = await sendCommand(port, argv('ZREVRANGEBYSCORE', 'zrevscore', '4', '2'));
+    const arr = tryParseValue(rev, 0).value;
+    assert.equal(arr.length, 3);
+    assert.equal(arr[0].toString('utf8'), 'd');
+    assert.equal(arr[1].toString('utf8'), 'c');
+    assert.equal(arr[2].toString('utf8'), 'b');
+
+    const withScores = await sendCommand(port, argv('ZREVRANGEBYSCORE', 'zrevscore', '10', '0', 'WITHSCORES'));
+    const withArr = tryParseValue(withScores, 0).value;
+    assert.equal(withArr.length, 8);
+    assert.equal(withArr[0].toString('utf8'), 'd');
+    assert.equal(withArr[1].toString('utf8'), '4');
+
+    const limitReply = await sendCommand(port, argv('ZREVRANGEBYSCORE', 'zrevscore', '10', '0', 'LIMIT', '1', '2'));
+    const limited = tryParseValue(limitReply, 0).value;
+    assert.equal(limited.length, 2);
+    assert.equal(limited[0].toString('utf8'), 'c');
+    assert.equal(limited[1].toString('utf8'), 'b');
+  });
+
   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'));