resplite 1.2.12 → 1.2.14

package/package.json

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

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';
@@ -70,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()],
@@ -78,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)],
@@ -139,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/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/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'));