resplite 1.2.16 → 1.2.18

package/package.json

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

package/src/commands/client.js

@@ -1,5 +1,5 @@
 /**
- * CLIENT - connection introspection (SETNAME, GETNAME, ID).
+ * CLIENT - connection introspection (SETNAME, GETNAME, ID) and SETINFO (no-op for client lib version).
  * Requires connection context.
  */
 
@@ -31,5 +31,11 @@ export function handleClient(engine, args, context) {
     }
     return context.connectionId;
   }
+  if (sub === 'SETINFO') {
+    if (args.length !== 3) {
+      return { error: 'ERR wrong number of arguments for \'CLIENT SETINFO\' command' };
+    }
+    return { simple: 'OK' };
+  }
   return { error: 'ERR unknown subcommand or wrong number of arguments for \'CLIENT\'. Try CLIENT HELP.' };
 }

package/src/commands/command.js

@@ -0,0 +1,81 @@
+/**
+ * COMMAND - introspection: list commands, count, or info for specific commands.
+ * Reply format compatible with Redis COMMAND (array of [name, arity, flags, firstKey, lastKey, step, acl_categories]).
+ */
+
+/** @type {Set<string>} Commands that modify data (write). */
+const WRITE_COMMANDS = new Set([
+  'SET', 'MSET', 'DEL', 'UNLINK', 'EXPIRE', 'PEXPIRE', 'PERSIST', 'INCR', 'DECR', 'INCRBY', 'DECRBY',
+  'HSET', 'HDEL', 'HINCRBY', 'SADD', 'SREM', 'LPUSH', 'RPUSH', 'LPOP', 'RPOP', 'LREM', 'ZADD', 'ZREM',
+  'FT.CREATE', 'FT.ADD', 'FT.DEL', 'FT.SUGADD', 'FT.SUGDEL', 'CLIENT',
+]);
+
+/**
+ * Build Redis-style command doc: [name, arity, flags, firstKey, lastKey, step, acl_categories].
+ * @param {string} name - Command name (lowercase for reply).
+ * @returns {Array<string|number|string[]>}
+ */
+function docFor(name) {
+  const lower = name.toLowerCase();
+  const flags = WRITE_COMMANDS.has(name) ? ['write', 'fast'] : ['readonly', 'fast'];
+  let arity = 2;
+  let firstKey = 1;
+  let lastKey = 1;
+  let step = 1;
+  if (['MGET', 'MSET', 'DEL', 'UNLINK', 'EXISTS', 'KEYS', 'SCAN', 'PING', 'ECHO', 'QUIT', 'TYPE', 'OBJECT', 'SQLITE.INFO', 'CACHE.INFO', 'MEMORY.INFO', 'COMMAND', 'MONITOR', 'CLIENT'].includes(name)) {
+    if (['PING', 'ECHO', 'QUIT', 'COMMAND', 'MONITOR'].includes(name)) {
+      firstKey = 0;
+      lastKey = 0;
+      step = 0;
+      arity = name === 'COMMAND' ? -1 : (name === 'ECHO' ? 2 : 1);
+    } else if (['MGET', 'EXISTS', 'KEYS', 'SCAN'].includes(name)) {
+      arity = -2;
+      lastKey = -1;
+    } else if (name === 'MSET') {
+      arity = -3;
+      lastKey = -1;
+      step = 2;
+    } else if (['DEL', 'UNLINK'].includes(name)) {
+      arity = -2;
+      lastKey = -1;
+    }
+  } else if (name.startsWith('FT.') || name.startsWith('SQLITE.') || name.startsWith('CACHE.') || name.startsWith('MEMORY.')) {
+    firstKey = 0;
+    lastKey = 0;
+    step = 0;
+    arity = -2;
+  } else if (['BLPOP', 'BRPOP'].includes(name)) {
+    arity = -3;
+    lastKey = -1;
+    step = 1;
+  } else if (['HMGET', 'HGETALL', 'HGET', 'HSET', 'HDEL', 'HEXISTS', 'HINCRBY', 'HLEN'].includes(name)) {
+    arity = (name === 'HGET' || name === 'HLEN' || name === 'HEXISTS') ? 3 : -3;
+  }
+  return [lower, arity, flags, firstKey, lastKey, step, []];
+}
+
+/**
+ * @param {object} engine
+ * @param {Buffer[]} args - subcommand and optional names for INFO
+ * @param {{ getCommandNames?: () => string[] }} context
+ */
+export function handleCommand(engine, args, context) {
+  const allNames = context?.getCommandNames ? context.getCommandNames() : [];
+  const sub = (args && args.length > 0 && Buffer.isBuffer(args[0])) ? args[0].toString('utf8').toUpperCase() : '';
+
+  if (!sub || sub === '') {
+    const reply = allNames.map((n) => docFor(n));
+    return reply;
+  }
+  if (sub === 'COUNT') {
+    return allNames.length;
+  }
+  if (sub === 'INFO') {
+    const names = (args.slice(1) || []).map((b) => (Buffer.isBuffer(b) ? b.toString('utf8') : String(b)).toUpperCase());
+    const set = new Set(allNames);
+    const reply = names.map((n) => set.has(n) ? docFor(n) : null).filter((x) => x != null);
+    return reply;
+  }
+
+  return { error: 'ERR unknown subcommand or wrong number of arguments for \'COMMAND\'. Try COMMAND HELP.' };
+}

package/src/commands/registry.js

@@ -72,6 +72,7 @@ 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';
+import * as command from './command.js';
 
 const HANDLERS = new Map([
   ['PING', (e, a) => ping.handlePing()],
@@ -143,6 +144,7 @@ const HANDLERS = new Map([
   ['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)],
+  ['COMMAND', (e, a, ctx) => command.handleCommand(e, a, ctx)],
 ]);
 
 /**
@@ -159,6 +161,7 @@ export function dispatch(engine, argv, context) {
   const cmd = (Buffer.isBuffer(argv[0]) ? argv[0].toString('utf8') : String(argv[0])).toUpperCase();
   const args = argv.slice(1);
   const argvStrings = argv.map((b) => (Buffer.isBuffer(b) ? b.toString('utf8') : String(b)));
+  if (context) context.getCommandNames = () => Array.from(HANDLERS.keys());
   const handler = HANDLERS.get(cmd);
   if (!handler) {
     context?.onUnknownCommand?.({

package/test/integration/client.test.js

@@ -87,6 +87,13 @@ describe('CLIENT integration', () => {
     assert.equal(getResult.length, 0);
   });
 
+  it('CLIENT SETINFO LIB-VER / LIB-NAME returns OK (no-op)', async () => {
+    const reply = await sendCommand(port, argv('CLIENT', 'SETINFO', 'LIB-VER', '1.5.17'));
+    assert.equal(tryParseValue(reply, 0).value, 'OK');
+    const reply2 = await sendCommand(port, argv('CLIENT', 'SETINFO', 'LIB-NAME', 'myclient'));
+    assert.equal(tryParseValue(reply2, 0).value, 'OK');
+  });
+
   it('CLIENT wrong subcommand returns error', async () => {
     const reply = await sendCommand(port, argv('CLIENT', 'LIST'));
     const v = tryParseValue(reply, 0).value;

package/test/integration/command.test.js

@@ -0,0 +1,75 @@
+/**
+ * Integration tests for COMMAND (introspection).
+ */
+
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { createTestServer } from '../helpers/server.js';
+import { sendCommand, argv } from '../helpers/client.js';
+import { tryParseValue } from '../../src/resp/parser.js';
+
+describe('COMMAND integration', () => {
+  let s;
+  let port;
+
+  before(async () => {
+    s = await createTestServer();
+    port = s.port;
+  });
+
+  after(async () => {
+    await s.closeAsync();
+  });
+
+  it('COMMAND (no args) returns array of command docs', async () => {
+    const reply = await sendCommand(port, argv('COMMAND'));
+    const v = tryParseValue(reply, 0).value;
+    assert.ok(Array.isArray(v), 'expected array');
+    assert.ok(v.length > 0, 'expected at least one command');
+    const pingDoc = v.find((doc) => {
+      const n = Buffer.isBuffer(doc[0]) ? doc[0].toString('utf8') : doc[0];
+      return n === 'ping';
+    });
+    assert.ok(pingDoc, 'expected ping in command list');
+    const first = pingDoc;
+    assert.ok(Array.isArray(first), 'each doc is array');
+    const name = Buffer.isBuffer(first[0]) ? first[0].toString('utf8') : first[0];
+    assert.strictEqual(name, 'ping', 'first element is name (lowercase)');
+    assert.strictEqual(typeof first[1], 'number', 'arity');
+    assert.ok(Array.isArray(first[2]), 'flags');
+    const flags = first[2].map((f) => (Buffer.isBuffer(f) ? f.toString('utf8') : f));
+    assert.ok(flags.includes('readonly') || flags.includes('write'));
+  });
+
+  it('COMMAND COUNT returns integer', async () => {
+    const reply = await sendCommand(port, argv('COMMAND', 'COUNT'));
+    const v = tryParseValue(reply, 0).value;
+    assert.strictEqual(typeof v, 'number');
+    assert.ok(Number.isInteger(v) && v > 0);
+  });
+
+  it('COMMAND INFO name returns doc for that command', async () => {
+    const reply = await sendCommand(port, argv('COMMAND', 'INFO', 'GET'));
+    const v = tryParseValue(reply, 0).value;
+    assert.ok(Array.isArray(v));
+    assert.ok(v.length >= 1);
+    const getDoc = v[0];
+    const name = Buffer.isBuffer(getDoc[0]) ? getDoc[0].toString('utf8') : getDoc[0];
+    assert.strictEqual(name, 'get');
+    assert.strictEqual(getDoc[1], 2, 'GET arity 2');
+  });
+
+  it('COMMAND INFO unknown returns empty array', async () => {
+    const reply = await sendCommand(port, argv('COMMAND', 'INFO', 'NOSUCHCOMMAND'));
+    const v = tryParseValue(reply, 0).value;
+    assert.ok(Array.isArray(v));
+    assert.strictEqual(v.length, 0);
+  });
+
+  it('COMMAND unknown subcommand returns error', async () => {
+    const reply = await sendCommand(port, argv('COMMAND', 'NOSUCH'));
+    const v = tryParseValue(reply, 0).value;
+    assert.ok(v && v.error);
+    assert.match(v.error, /unknown subcommand|COMMAND/);
+  });
+});