resplite 1.1.4 → 1.1.8

package/README.md

@@ -29,17 +29,19 @@ A typical comparison is **Redis (e.g. in Docker)** on one side and **RESPLite lo
 
 | Suite           | Redis (Docker) | RESPLite (default) |
 |-----------------|----------------|--------------------|
-| PING            | 9.17K/s        | 27.59K/s           |
-| SET+GET         | 4.65K/s        | 9.53K/s            |
-| MSET+MGET(10)   | 4.47K/s        | 5.35K/s            |
-| INCR            | 9.84K/s        | 15.56K/s           |
-| HSET+HGET       | 4.63K/s        | 10.95K/s           |
-| HGETALL(50)     | 9.19K/s        | 8.19K/s            |
-| SADD+SMEMBERS   | 9.16K/s        | 15.54K/s           |
-| LPUSH+LRANGE    | 7.97K/s        | 10.24K/s           |
-| ZADD+ZRANGE     | 8.08K/s        | 2.89K/s            |
-| SET+DEL         | 4.60K/s        | 6.62K/s            |
-| FT.SEARCH       | 8.20K/s        | 7.20K/s            |
+| 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            |
 
 *Run `npm run benchmark -- --template default` to reproduce. Numbers depend on host and whether Redis is native or in Docker.*
 
@@ -327,7 +329,7 @@ RESPLite implements **47 core Redis commands** (~19% of the ~246 commands in Red
 | **Lists** | LPUSH, RPUSH, LLEN, LRANGE, LINDEX, LPOP, RPOP, BLPOP, BRPOP |
 | **Sorted sets** | ZADD, ZREM, ZCARD, ZSCORE, ZRANGE, ZRANGEBYSCORE |
 | **Search (FT.\*)** | FT.CREATE, FT.INFO, FT.ADD, FT.DEL, FT.SEARCH, FT.SUGADD, FT.SUGGET, FT.SUGDEL |
-| **Introspection** | TYPE, SCAN |
+| **Introspection** | TYPE, SCAN, KEYS, MONITOR |
 | **Admin** | SQLITE.INFO, CACHE.INFO, MEMORY.INFO |
 | **Tooling** | Redis import CLI (see Migration from Redis) |
 

package/package.json

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

package/src/commands/keys.js

@@ -0,0 +1,67 @@
+/**
+ * KEYS pattern - return all keys matching the glob pattern.
+ */
+
+function escapeRegexChar(ch) {
+  return /[\\^$+?.()|{}]/.test(ch) ? '\\' + ch : ch;
+}
+
+function globToRegExp(glob) {
+  let out = '^';
+  let i = 0;
+  while (i < glob.length) {
+    const ch = glob[i];
+    if (ch === '\\') {
+      if (i + 1 < glob.length) {
+        out += escapeRegexChar(glob[i + 1]);
+        i += 2;
+      } else {
+        out += '\\\\';
+        i += 1;
+      }
+      continue;
+    }
+    if (ch === '*') {
+      out += '.*';
+      i += 1;
+      continue;
+    }
+    if (ch === '?') {
+      out += '.';
+      i += 1;
+      continue;
+    }
+    out += escapeRegexChar(ch);
+    i += 1;
+  }
+  out += '$';
+  return new RegExp(out);
+}
+
+export function handleKeys(engine, args) {
+  if (!args || args.length !== 1) {
+    return { error: 'ERR wrong number of arguments for \'KEYS\' command' };
+  }
+  const pattern = args[0].toString('utf8');
+  const matcher = globToRegExp(pattern);
+  const seen = new Set();
+  const matches = [];
+
+  let cursor = '0';
+  do {
+    const scanned = engine.scan(cursor, { count: 256 });
+    const keys = scanned.keys ?? [];
+    for (const key of keys) {
+      if (!Buffer.isBuffer(key)) continue;
+      const hex = key.toString('hex');
+      if (seen.has(hex)) continue;
+      seen.add(hex);
+      if (engine.type(key) === 'none') continue;
+      const keyText = key.toString('utf8');
+      if (matcher.test(keyText)) matches.push(key);
+    }
+    cursor = String(scanned.cursor);
+  } while (cursor !== '0');
+
+  return matches;
+}

package/src/commands/monitor.js

@@ -0,0 +1,10 @@
+/**
+ * MONITOR - switch the current connection to monitor mode.
+ */
+
+export function handleMonitor(args) {
+  if (args && args.length !== 0) {
+    return { error: 'ERR wrong number of arguments for \'MONITOR\' command' };
+  }
+  return { simple: 'OK' };
+}

package/src/commands/registry.js

@@ -46,6 +46,7 @@ import * as lrem from './lrem.js';
 import * as blpop from './blpop.js';
 import * as brpop from './brpop.js';
 import * as scan from './scan.js';
+import * as keys from './keys.js';
 import * as zadd from './zadd.js';
 import * as zrem from './zrem.js';
 import * as zcard from './zcard.js';
@@ -63,6 +64,7 @@ import * as ftSearch from './ft-search.js';
 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';
 
 const HANDLERS = new Map([
   ['PING', (e, a) => ping.handlePing()],
@@ -108,6 +110,7 @@ const HANDLERS = new Map([
   ['BLPOP', (e, a, ctx) => blpop.handleBlpop(e, a, ctx)],
   ['BRPOP', (e, a, ctx) => brpop.handleBrpop(e, a, ctx)],
   ['SCAN', (e, a) => scan.handleScan(e, a)],
+  ['KEYS', (e, a) => keys.handleKeys(e, a)],
   ['ZADD', (e, a) => zadd.handleZadd(e, a)],
   ['ZREM', (e, a) => zrem.handleZrem(e, a)],
   ['ZCARD', (e, a) => zcard.handleZcard(e, a)],
@@ -125,6 +128,7 @@ const HANDLERS = new Map([
   ['FT.SUGADD', (e, a) => ftSugadd.handleFtSugadd(e, a)],
   ['FT.SUGGET', (e, a) => ftSugget.handleFtSugget(e, a)],
   ['FT.SUGDEL', (e, a) => ftSugdel.handleFtSugdel(e, a)],
+  ['MONITOR', (e, a, ctx) => monitor.handleMonitor(a, ctx)],
 ]);
 
 /**

package/src/server/connection.js

@@ -5,6 +5,7 @@
 import { RESPReader } from '../resp/parser.js';
 import { dispatch } from '../commands/registry.js';
 import { encode, encodeSimpleString, encodeError } from '../resp/encoder.js';
+import { registerMonitorClient, unregisterMonitorClient, broadcastMonitorCommand } from './monitor.js';
 
 let nextConnectionId = 0;
 
@@ -17,6 +18,8 @@ export function handleConnection(socket, engine) {
   const connectionId = ++nextConnectionId;
   const context = {
     connectionId,
+    monitorMode: false,
+    clientAddress: `${socket.remoteAddress ?? 'unknown'}:${socket.remotePort ?? 0}`,
     writeResponse(buf) {
       if (socket.writable) socket.write(buf);
     },
@@ -46,7 +49,18 @@ export function handleConnection(socket, engine) {
     reader.feed(chunk);
     const commands = reader.parseCommands();
     for (const argv of commands) {
+      const cmd = argv[0] ? argv[0].toString('utf8').toUpperCase() : '';
+      if (context.monitorMode && cmd !== 'QUIT') {
+        socket.write(encodeError('ERR MONITOR mode only supports QUIT'));
+        continue;
+      }
       const out = dispatch(engine, argv, context);
+      if (cmd === 'MONITOR' && !out.error) {
+        context.monitorMode = true;
+        registerMonitorClient(context);
+      } else if (!context.monitorMode) {
+        broadcastMonitorCommand(argv, context);
+      }
       if (out.quit) {
         writeResult(out);
         return;
@@ -77,6 +91,7 @@ export function handleConnection(socket, engine) {
 
   socket.on('close', () => {
     if (engine._blockingManager) engine._blockingManager.cancel(connectionId);
+    unregisterMonitorClient(connectionId);
   });
 
   socket.on('error', () => {});

package/src/server/monitor.js

@@ -0,0 +1,59 @@
+/**
+ * MONITOR support: track monitor clients and broadcast command traces.
+ */
+
+import { encodeSimpleString } from '../resp/encoder.js';
+
+const monitorClients = new Map();
+
+function escapeArg(value) {
+  return value
+    .replace(/\\/g, '\\\\')
+    .replace(/"/g, '\\"')
+    .replace(/\r/g, '\\r')
+    .replace(/\n/g, '\\n')
+    .replace(/\t/g, '\\t');
+}
+
+function formatCommand(argv) {
+  const parts = [];
+  for (const arg of argv) {
+    const text = Buffer.isBuffer(arg) ? arg.toString('utf8') : String(arg);
+    parts.push('"' + escapeArg(text) + '"');
+  }
+  return parts.join(' ');
+}
+
+function timestamp() {
+  const now = Date.now();
+  const sec = Math.floor(now / 1000);
+  const micros = String((now % 1000) * 1000).padStart(6, '0');
+  return sec + '.' + micros;
+}
+
+function sourceLabel(sourceContext) {
+  const label = sourceContext && sourceContext.clientAddress ? sourceContext.clientAddress : 'unknown';
+  return '[0 ' + label + ']';
+}
+
+export function registerMonitorClient(context) {
+  if (!context || !context.connectionId) return;
+  monitorClients.set(context.connectionId, context);
+}
+
+export function unregisterMonitorClient(connectionId) {
+  if (!connectionId) return;
+  monitorClients.delete(connectionId);
+}
+
+export function broadcastMonitorCommand(argv, sourceContext) {
+  if (!Array.isArray(argv) || argv.length === 0) return;
+  if (monitorClients.size === 0) return;
+  const line = timestamp() + ' ' + sourceLabel(sourceContext) + ' ' + formatCommand(argv);
+  const payload = encodeSimpleString(line);
+  for (const monitor of monitorClients.values()) {
+    if (monitor && typeof monitor.writeResponse === 'function') {
+      monitor.writeResponse(payload);
+    }
+  }
+}

package/tasks/todo.md

@@ -42,3 +42,22 @@
 - [x] package.json `bin`: resplite-import, resplite-dirty-tracker
 - [x] Unit tests: `test/unit/migration-registry.test.js`
 - [x] README: minimal-downtime migration flow and commands
+
+---
+
+# KEYS + MONITOR Commands
+
+## Plan
+
+- [x] Add `KEYS pattern` command with glob matching support
+- [x] Add `MONITOR` command and streaming monitor bus in TCP server
+- [x] Register commands in command registry
+- [x] Add integration tests for both commands
+- [x] Verify with targeted and full integration suites
+
+## Review
+
+- Added `KEYS` command with wildcard matching (`*`, `?`) and proper arity validation
+- Added server-side monitor broadcasting for `MONITOR` clients and restricted monitor-mode commands to `QUIT`
+- Added integration coverage in `test/integration/keys.test.js` and `test/integration/monitor.test.js`
+- Verified with `npm test -- test/integration/keys.test.js`, `npm test -- test/integration/monitor.test.js`, and `npm run test:integration`

package/test/integration/keys.test.js

@@ -0,0 +1,49 @@
+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('KEYS integration', () => {
+  let s;
+  let port;
+
+  before(async () => {
+    s = await createTestServer();
+    port = s.port;
+  });
+
+  after(async () => {
+    await s.closeAsync();
+  });
+
+  it('KEYS * returns matching keys', async () => {
+    await sendCommand(port, argv('SET', 'keys:k1', 'v1'));
+    await sendCommand(port, argv('SET', 'keys:k2', 'v2'));
+    await sendCommand(port, argv('SET', 'other:k3', 'v3'));
+
+    const reply = await sendCommand(port, argv('KEYS', 'keys:*'));
+    const parsed = tryParseValue(reply, 0);
+    assert.ok(Array.isArray(parsed.value));
+    const values = parsed.value.map((v) => v.toString('utf8')).sort();
+    assert.deepEqual(values, ['keys:k1', 'keys:k2']);
+  });
+
+  it('KEYS with ? wildcard works', async () => {
+    await sendCommand(port, argv('SET', 'q:a1', 'x'));
+    await sendCommand(port, argv('SET', 'q:b2', 'x'));
+    await sendCommand(port, argv('SET', 'q:bb2', 'x'));
+
+    const reply = await sendCommand(port, argv('KEYS', 'q:?2'));
+    const parsed = tryParseValue(reply, 0);
+    const values = parsed.value.map((v) => v.toString('utf8')).sort();
+    assert.deepEqual(values, ['q:b2']);
+  });
+
+  it('KEYS wrong number of arguments returns error', async () => {
+    const reply = await sendCommand(port, argv('KEYS'));
+    const parsed = tryParseValue(reply, 0);
+    assert.ok(parsed.value && parsed.value.error);
+    assert.ok(parsed.value.error.includes('wrong number of arguments'));
+  });
+});

package/test/integration/monitor.test.js

@@ -0,0 +1,102 @@
+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 createStreamingClient(port) {
+  return new Promise((resolve, reject) => {
+    let recv = Buffer.alloc(0);
+    const queue = [];
+    const waiters = [];
+    const socket = net.createConnection({ port, host: '127.0.0.1' }, () => {
+      resolve({
+        send(commandArgv) {
+          socket.write(encode(commandArgv));
+        },
+        async nextValue(timeoutMs = 2000) {
+          if (queue.length > 0) return queue.shift();
+          return new Promise((res, rej) => {
+            const timer = setTimeout(() => {
+              const idx = waiters.findIndex((w) => w.resolve === res);
+              if (idx >= 0) waiters.splice(idx, 1);
+              rej(new Error('timeout waiting for RESP value'));
+            }, timeoutMs);
+            waiters.push({
+              resolve(value) {
+                clearTimeout(timer);
+                res(value);
+              },
+            });
+          });
+        },
+        close() {
+          socket.destroy();
+        },
+      });
+    });
+
+    socket.on('data', (chunk) => {
+      recv = Buffer.concat([recv, chunk]);
+      for (;;) {
+        const parsed = tryParseValue(recv, 0);
+        if (parsed === null) break;
+        recv = recv.subarray(parsed.end);
+        if (waiters.length > 0) {
+          waiters.shift().resolve(parsed.value);
+        } else {
+          queue.push(parsed.value);
+        }
+      }
+    });
+    socket.on('error', reject);
+  });
+}
+
+describe('MONITOR integration', () => {
+  let s;
+  let port;
+
+  before(async () => {
+    s = await createTestServer();
+    port = s.port;
+  });
+
+  after(async () => {
+    await s.closeAsync();
+  });
+
+  it('MONITOR streams commands from other clients', async () => {
+    const monitorClient = await createStreamingClient(port);
+    try {
+      monitorClient.send(argv('MONITOR'));
+      const first = await monitorClient.nextValue();
+      assert.equal(first, 'OK');
+
+      await sendCommand(port, argv('SET', 'mk1', 'v1'));
+      const event = await monitorClient.nextValue();
+      assert.equal(typeof event, 'string');
+      assert.match(event, /"SET"\s+"mk1"\s+"v1"/);
+    } finally {
+      monitorClient.close();
+    }
+  });
+
+  it('MONITOR connection only accepts QUIT', async () => {
+    const monitorClient = await createStreamingClient(port);
+    try {
+      monitorClient.send(argv('MONITOR'));
+      assert.equal(await monitorClient.nextValue(), 'OK');
+      monitorClient.send(argv('PING'));
+      const err = await monitorClient.nextValue();
+      assert.ok(err && err.error);
+      assert.match(err.error, /MONITOR mode only supports QUIT/);
+      monitorClient.send(argv('QUIT'));
+      assert.equal(await monitorClient.nextValue(), 'OK');
+    } finally {
+      monitorClient.close();
+    }
+  });
+});