resplite 1.4.20 → 1.5.2

package/README.md

@@ -62,6 +62,10 @@ const log = new LemonLog('RESPlite');
 const srv = await createRESPlite({
   port: 6380,
   db: './data.db',
+  commandPolicy: {
+    rename: { KEYS: 'SAFE_KEYS' }, // original KEYS is blocked
+    disabled: ['MONITOR'],         // blocked as unsupported
+  },
   hooks: {
     onUnknownCommand({ command, argv, clientAddress }) {
       log.warn({ command, argv, clientAddress }, 'unsupported command');
@@ -84,6 +88,28 @@ Available hooks:
 
 If you want a tiny in-process smoke test that starts RESPLite and connects with the `redis` client in the same script, see [Minimal embedded example](#minimal-embedded-example) below.
 
+### Command hardening (rename/disable)
+
+You can harden the command surface by renaming sensitive commands and/or disabling them:
+
+```javascript
+const srv = await createRESPlite({
+  db: './secure.db',
+  commandPolicy: {
+    rename: {
+      KEYS: 'SAFE_KEYS',
+      DEL: 'RMDEL',
+    },
+    disabled: ['MONITOR', 'CLIENT'],
+  },
+});
+```
+
+Behavior:
+- `rename`: only the new alias is accepted; the original command name is blocked.
+- `disabled`: command is blocked and replies with `ERR command not supported yet`.
+- `COMMAND`, `COMMAND COUNT`, and `COMMAND INFO` expose only visible commands (including aliases, excluding blocked names).
+
 ## Migration from Redis
 
 RESPLite is a good fit for migrating **non-replicated Redis** instances that have **grown large** (e.g. tens of GB) and where RESPLite's latency is acceptable. The recommended path is to drive the migration from a Node.js script via `resplite/migration`, keeping preflight, dirty tracking, bulk import, cutover, and verification in one place.
@@ -574,7 +600,7 @@ To reproduce the benchmark, run `npm run benchmark -- --template default`. Numbe
 | **Connection** | PING, ECHO, QUIT |
 | **Strings** | GET, SET, MGET, MSET, DEL, EXISTS, INCR, DECR, INCRBY, DECRBY, STRLEN |
 | **TTL** | EXPIRE, PEXPIRE, TTL, PTTL, PERSIST |
-| **Hashes** | HSET, HGET, HMGET, HGETALL, HKEYS, HVALS, HDEL, HEXISTS, HINCRBY |
+| **Hashes** | HSET, HGET, HMGET, HGETALL, HKEYS, HVALS, HDEL, HEXISTS, HINCRBY, HEXPIRE, HTTL, HPERSIST |
 | **Sets** | SADD, SREM, SMEMBERS, SISMEMBER, SCARD, SPOP, SRANDMEMBER |
 | **Lists** | LPUSH, RPUSH, LLEN, LRANGE, LINDEX, LPOP, RPOP, LSET, LTRIM, BLPOP, BRPOP |
 | **Sorted sets** | ZADD, ZREM, ZCARD, ZSCORE, ZRANGE, ZREVRANGE, ZRANGEBYSCORE, ZREVRANGEBYSCORE, ZRANK, ZREVRANK, ZCOUNT, ZINCRBY, ZREMRANGEBYRANK, ZREMRANGEBYSCORE |

package/package.json

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

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

@@ -98,9 +98,13 @@ function spawnResplite(templateName, port, dbPath) {
 }
 
 function formatNum(n) {
+  if (!Number.isFinite(n)) return '—';
   if (n >= 1e6) return (n / 1e6).toFixed(2) + 'M';
   if (n >= 1e3) return (n / 1e3).toFixed(2) + 'K';
-  return String(n);
+  if (n >= 100) return n.toFixed(2);
+  if (n >= 10) return n.toFixed(2);
+  if (n >= 1) return n.toFixed(2);
+  return n.toFixed(3);
 }
 
 function formatMs(ms) {
@@ -603,23 +607,41 @@ async function main() {
   for (const { client } of respliteClients) await client.quit();
   for (const { child } of children) child.kill();
 
-  const colWidth = 10;
   const headerCols = ['Suite', 'Redis', ...templateNames];
-  const sep = headerCols.map((_, i) => (i === 0 ? '-'.repeat(18) : '-'.repeat(colWidth))).join('|');
-  console.log('');
-  console.log('--- Summary (ops/sec) ---');
-  console.log(headerCols.map((h, i) => (i === 0 ? h.padEnd(18) : h.padStart(colWidth))).join(' | '));
-  console.log(sep);
-  for (const r of results) {
-    if (r.error) {
-      console.log(`${r.suite.padEnd(18)} | ERROR: ${r.error}`);
-      continue;
-    }
+  const summaryRows = results.map((r) => {
+    if (r.error) return { suite: r.suite, values: [`ERROR: ${r.error}`] };
     const redisVal = r.redis.error ? '—' : formatNum(r.redis.opsPerSec);
     const templateVals = templateNames.map((t) => (r.templates[t]?.error ? '—' : formatNum(r.templates[t]?.opsPerSec)));
-    console.log(
-      [r.suite.padEnd(18), redisVal.padStart(colWidth), ...templateVals.map((v) => v.padStart(colWidth))].join(' | ')
-    );
+    return { suite: r.suite, values: [redisVal, ...templateVals] };
+  });
+
+  const suiteWidth = Math.max(
+    headerCols[0].length,
+    ...summaryRows.map((r) => r.suite.length)
+  );
+  const valueWidths = headerCols.slice(1).map((h, idx) =>
+    Math.max(
+      h.length,
+      ...summaryRows.map((r) => (r.values[idx] || '').length)
+    )
+  );
+
+  console.log('');
+  console.log('--- Summary (ops/sec) ---');
+  console.log([
+    headerCols[0].padEnd(suiteWidth),
+    ...headerCols.slice(1).map((h, idx) => h.padStart(valueWidths[idx])),
+  ].join(' | '));
+  console.log([
+    '-'.repeat(suiteWidth),
+    ...valueWidths.map((w) => '-'.repeat(w)),
+  ].join('-|-'));
+
+  for (const row of summaryRows) {
+    console.log([
+      row.suite.padEnd(suiteWidth),
+      ...row.values.map((v, idx) => v.padStart(valueWidths[idx])),
+    ].join(' | '));
   }
 
   console.log('');

package/src/commands/command.js

@@ -15,42 +15,42 @@ const WRITE_COMMANDS = new Set([
  * @param {string} name - Command name (lowercase for reply).
  * @returns {Array<string|number|string[]>}
  */
-function docFor(name) {
+function docFor(name, canonicalName = name) {
   const lower = name.toLowerCase();
-  const flags = WRITE_COMMANDS.has(name) ? ['write', 'fast'] : ['readonly', 'fast'];
+  const flags = WRITE_COMMANDS.has(canonicalName) ? ['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)) {
+  if (['MGET', 'MSET', 'DEL', 'UNLINK', 'EXISTS', 'KEYS', 'SCAN', 'PING', 'ECHO', 'QUIT', 'TYPE', 'OBJECT', 'SQLITE.INFO', 'CACHE.INFO', 'MEMORY.INFO', 'COMMAND', 'MONITOR', 'CLIENT'].includes(canonicalName)) {
+    if (['PING', 'ECHO', 'QUIT', 'COMMAND', 'MONITOR'].includes(canonicalName)) {
       firstKey = 0;
       lastKey = 0;
       step = 0;
-      arity = name === 'COMMAND' ? -1 : (name === 'ECHO' ? 2 : 1);
-    } else if (['MGET', 'EXISTS', 'KEYS', 'SCAN'].includes(name)) {
+      arity = canonicalName === 'COMMAND' ? -1 : (canonicalName === 'ECHO' ? 2 : 1);
+    } else if (['MGET', 'EXISTS', 'KEYS', 'SCAN'].includes(canonicalName)) {
       arity = -2;
       lastKey = -1;
-    } else if (name === 'MSET') {
+    } else if (canonicalName === 'MSET') {
       arity = -3;
       lastKey = -1;
       step = 2;
-    } else if (['DEL', 'UNLINK'].includes(name)) {
+    } else if (['DEL', 'UNLINK'].includes(canonicalName)) {
       arity = -2;
       lastKey = -1;
     }
-  } else if (name.startsWith('FT.') || name.startsWith('SQLITE.') || name.startsWith('CACHE.') || name.startsWith('MEMORY.')) {
+  } else if (canonicalName.startsWith('FT.') || canonicalName.startsWith('SQLITE.') || canonicalName.startsWith('CACHE.') || canonicalName.startsWith('MEMORY.')) {
     firstKey = 0;
     lastKey = 0;
     step = 0;
     arity = -2;
-  } else if (['BLPOP', 'BRPOP'].includes(name)) {
+  } else if (['BLPOP', 'BRPOP'].includes(canonicalName)) {
     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;
-  } else if (name === 'SETEX') {
+  } else if (['HMGET', 'HGETALL', 'HGET', 'HSET', 'HDEL', 'HEXISTS', 'HINCRBY', 'HLEN'].includes(canonicalName)) {
+    arity = (canonicalName === 'HGET' || canonicalName === 'HLEN' || canonicalName === 'HEXISTS') ? 3 : -3;
+  } else if (canonicalName === 'SETEX') {
     arity = 4;
   }
   return [lower, arity, flags, firstKey, lastKey, step, []];
@@ -63,10 +63,13 @@ function docFor(name) {
  */
 export function handleCommand(engine, args, context) {
   const allNames = context?.getCommandNames ? context.getCommandNames() : [];
+  const resolveCanonical = context?.resolveCommandForIntrospection
+    ? (name) => context.resolveCommandForIntrospection(name)
+    : (name) => name;
   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));
+    const reply = allNames.map((n) => docFor(n, resolveCanonical(n)));
     return reply;
   }
   if (sub === 'COUNT') {
@@ -75,7 +78,7 @@ export function handleCommand(engine, args, context) {
   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);
+    const reply = names.map((n) => set.has(n) ? docFor(n, resolveCanonical(n)) : null).filter((x) => x != null);
     return reply;
   }
 

package/src/commands/hexpire.js

@@ -0,0 +1,54 @@
+/**
+ * HEXPIRE key seconds [NX | XX | GT | LT] FIELDS numfields field [field ...]
+ * Redis 7.4 per-field TTL. Returns array of integers (-2/0/1/2) per field.
+ */
+
+const CONDITIONS = new Set(['NX', 'XX', 'GT', 'LT']);
+
+function parseFieldsTail(args, startIdx) {
+  if (args.length <= startIdx) return { error: 'ERR syntax error' };
+  const token = (Buffer.isBuffer(args[startIdx]) ? args[startIdx].toString('utf8') : String(args[startIdx])).toUpperCase();
+  if (token !== 'FIELDS') return { error: 'ERR syntax error' };
+  const numStr = args[startIdx + 1];
+  if (numStr == null) return { error: 'ERR syntax error' };
+  const n = parseInt(Buffer.isBuffer(numStr) ? numStr.toString('utf8') : String(numStr), 10);
+  if (!Number.isInteger(n) || n < 1) {
+    return { error: 'ERR numfields should be greater than 0' };
+  }
+  const fields = args.slice(startIdx + 2);
+  if (fields.length !== n) {
+    return { error: "ERR Parameter `numFields` should be equal to the number of arguments" };
+  }
+  return { fields };
+}
+
+export function handleHexpire(engine, args) {
+  if (!args || args.length < 5) {
+    return { error: "ERR wrong number of arguments for 'HEXPIRE' command" };
+  }
+  const key = args[0];
+  const secondsStr = Buffer.isBuffer(args[1]) ? args[1].toString('utf8') : String(args[1]);
+  const seconds = parseInt(secondsStr, 10);
+  if (!Number.isInteger(seconds)) {
+    return { error: 'ERR value is not an integer or out of range' };
+  }
+
+  let idx = 2;
+  let condition = null;
+  const maybeCond = (Buffer.isBuffer(args[idx]) ? args[idx].toString('utf8') : String(args[idx])).toUpperCase();
+  if (CONDITIONS.has(maybeCond)) {
+    condition = maybeCond;
+    idx += 1;
+  }
+
+  const parsed = parseFieldsTail(args, idx);
+  if (parsed.error) return parsed;
+
+  const expiresAtMs = engine._clock() + seconds * 1000;
+  try {
+    return engine.hexpire(key, expiresAtMs, parsed.fields, { condition });
+  } catch (e) {
+    const msg = e && e.message ? e.message : String(e);
+    return { error: msg.startsWith('ERR ') || msg.startsWith('WRONGTYPE') ? msg : 'ERR ' + msg };
+  }
+}

package/src/commands/hpersist.js

@@ -0,0 +1,36 @@
+/**
+ * HPERSIST key FIELDS numfields field [field ...]
+ * Removes per-field TTL. Returns array: -2 (missing), -1 (no TTL), 1 (cleared).
+ */
+
+function parseFieldsTail(args, startIdx) {
+  if (args.length <= startIdx) return { error: 'ERR syntax error' };
+  const token = (Buffer.isBuffer(args[startIdx]) ? args[startIdx].toString('utf8') : String(args[startIdx])).toUpperCase();
+  if (token !== 'FIELDS') return { error: 'ERR syntax error' };
+  const numStr = args[startIdx + 1];
+  if (numStr == null) return { error: 'ERR syntax error' };
+  const n = parseInt(Buffer.isBuffer(numStr) ? numStr.toString('utf8') : String(numStr), 10);
+  if (!Number.isInteger(n) || n < 1) {
+    return { error: 'ERR numfields should be greater than 0' };
+  }
+  const fields = args.slice(startIdx + 2);
+  if (fields.length !== n) {
+    return { error: "ERR Parameter `numFields` should be equal to the number of arguments" };
+  }
+  return { fields };
+}
+
+export function handleHpersist(engine, args) {
+  if (!args || args.length < 4) {
+    return { error: "ERR wrong number of arguments for 'HPERSIST' command" };
+  }
+  const key = args[0];
+  const parsed = parseFieldsTail(args, 1);
+  if (parsed.error) return parsed;
+  try {
+    return engine.hpersist(key, parsed.fields);
+  } catch (e) {
+    const msg = e && e.message ? e.message : String(e);
+    return { error: msg.startsWith('ERR ') || msg.startsWith('WRONGTYPE') ? msg : 'ERR ' + msg };
+  }
+}

package/src/commands/httl.js

@@ -0,0 +1,36 @@
+/**
+ * HTTL key FIELDS numfields field [field ...]
+ * Returns array of seconds per field: -2 (missing), -1 (no TTL), else remaining seconds.
+ */
+
+function parseFieldsTail(args, startIdx) {
+  if (args.length <= startIdx) return { error: 'ERR syntax error' };
+  const token = (Buffer.isBuffer(args[startIdx]) ? args[startIdx].toString('utf8') : String(args[startIdx])).toUpperCase();
+  if (token !== 'FIELDS') return { error: 'ERR syntax error' };
+  const numStr = args[startIdx + 1];
+  if (numStr == null) return { error: 'ERR syntax error' };
+  const n = parseInt(Buffer.isBuffer(numStr) ? numStr.toString('utf8') : String(numStr), 10);
+  if (!Number.isInteger(n) || n < 1) {
+    return { error: 'ERR numfields should be greater than 0' };
+  }
+  const fields = args.slice(startIdx + 2);
+  if (fields.length !== n) {
+    return { error: "ERR Parameter `numFields` should be equal to the number of arguments" };
+  }
+  return { fields };
+}
+
+export function handleHttl(engine, args) {
+  if (!args || args.length < 4) {
+    return { error: "ERR wrong number of arguments for 'HTTL' command" };
+  }
+  const key = args[0];
+  const parsed = parseFieldsTail(args, 1);
+  if (parsed.error) return parsed;
+  try {
+    return engine.httl(key, parsed.fields);
+  } catch (e) {
+    const msg = e && e.message ? e.message : String(e);
+    return { error: msg.startsWith('ERR ') || msg.startsWith('WRONGTYPE') ? msg : 'ERR ' + msg };
+  }
+}

package/src/commands/registry.js

@@ -36,6 +36,9 @@ import * as hdel from './hdel.js';
 import * as hlen from './hlen.js';
 import * as hexists from './hexists.js';
 import * as hincrby from './hincrby.js';
+import * as hexpireCmd from './hexpire.js';
+import * as httlCmd from './httl.js';
+import * as hpersistCmd from './hpersist.js';
 import * as sadd from './sadd.js';
 import * as srem from './srem.js';
 import * as smembers from './smembers.js';
@@ -88,6 +91,8 @@ import * as monitor from './monitor.js';
 import * as client from './client.js';
 import * as command from './command.js';
 
+const COMPILED_POLICY_TAG = Symbol('compiled-command-policy');
+
 const HANDLERS = new Map([
   ['PING', (e, a) => ping.handlePing()],
   ['ECHO', (e, a) => echo.handleEcho(a)],
@@ -122,6 +127,9 @@ const HANDLERS = new Map([
   ['HLEN', (e, a) => hlen.handleHlen(e, a)],
   ['HEXISTS', (e, a) => hexists.handleHexists(e, a)],
   ['HINCRBY', (e, a) => hincrby.handleHincrby(e, a)],
+  ['HEXPIRE', (e, a) => hexpireCmd.handleHexpire(e, a)],
+  ['HTTL', (e, a) => httlCmd.handleHttl(e, a)],
+  ['HPERSIST', (e, a) => hpersistCmd.handleHpersist(e, a)],
   ['SADD', (e, a) => sadd.handleSadd(e, a)],
   ['SREM', (e, a) => srem.handleSrem(e, a)],
   ['SMEMBERS', (e, a) => smembers.handleSmembers(e, a)],
@@ -175,6 +183,100 @@ const HANDLERS = new Map([
   ['COMMAND', (e, a, ctx) => command.handleCommand(e, a, ctx)],
 ]);
 
+function assertCommandName(value, field) {
+  if (typeof value !== 'string' || value.trim() === '') {
+    throw new Error(`invalid command policy: ${field} must be a non-empty string`);
+  }
+  return value.trim().toUpperCase();
+}
+
+function isCompiledPolicy(value) {
+  return !!(value && typeof value === 'object' && value[COMPILED_POLICY_TAG] === true);
+}
+
+export function compileCommandPolicy(policy = {}) {
+  if (policy == null) return null;
+  if (isCompiledPolicy(policy)) return policy;
+  if (typeof policy !== 'object') {
+    throw new Error('invalid command policy: expected an object');
+  }
+
+  const rename = policy.rename ?? {};
+  const disabled = policy.disabled ?? [];
+
+  if (rename == null || typeof rename !== 'object' || Array.isArray(rename)) {
+    throw new Error('invalid command policy: rename must be an object');
+  }
+  if (!Array.isArray(disabled)) {
+    throw new Error('invalid command policy: disabled must be an array');
+  }
+
+  const knownCommands = new Set(HANDLERS.keys());
+  const renamedOriginals = new Set();
+  const aliasToOriginal = new Map();
+
+  for (const [rawOriginal, rawAlias] of Object.entries(rename)) {
+    const original = assertCommandName(rawOriginal, 'rename key');
+    const alias = assertCommandName(rawAlias, `rename.${rawOriginal}`);
+    if (!knownCommands.has(original)) {
+      throw new Error(`invalid command policy: cannot rename unknown command "${original}"`);
+    }
+    if (alias === original) {
+      throw new Error(`invalid command policy: alias for "${original}" must be different`);
+    }
+    if (knownCommands.has(alias)) {
+      throw new Error(`invalid command policy: alias "${alias}" conflicts with existing command`);
+    }
+    if (aliasToOriginal.has(alias)) {
+      throw new Error(`invalid command policy: alias "${alias}" is duplicated`);
+    }
+    renamedOriginals.add(original);
+    aliasToOriginal.set(alias, original);
+  }
+
+  const disabledSet = new Set();
+  for (const rawName of disabled) {
+    const name = assertCommandName(rawName, 'disabled[] item');
+    disabledSet.add(name);
+  }
+
+  return {
+    [COMPILED_POLICY_TAG]: true,
+    disabledSet,
+    aliasToOriginal,
+    renamedOriginals,
+  };
+}
+
+function listVisibleCommandNames(policy) {
+  const names = [];
+  for (const name of HANDLERS.keys()) {
+    if (policy?.renamedOriginals?.has(name)) continue;
+    if (policy?.disabledSet?.has(name)) continue;
+    names.push(name);
+  }
+  if (policy?.aliasToOriginal) {
+    for (const [alias] of policy.aliasToOriginal.entries()) {
+      if (policy.disabledSet.has(alias)) continue;
+      names.push(alias);
+    }
+  }
+  return names;
+}
+
+function resolveIncomingCommand(inputCommand, policy) {
+  if (!policy) return { blocked: false, resolvedCommand: inputCommand };
+  if (policy.disabledSet.has(inputCommand)) {
+    return { blocked: true, resolvedCommand: inputCommand };
+  }
+  const target = policy.aliasToOriginal.get(inputCommand);
+  if (target) return { blocked: false, resolvedCommand: target };
+  if (policy.renamedOriginals.has(inputCommand)) {
+    return { blocked: true, resolvedCommand: inputCommand };
+  }
+  return { blocked: false, resolvedCommand: inputCommand };
+}
+
 /**
  * Dispatch command. Full argv: [commandNameBuf, ...argBuffers].
  * @param {object} engine
@@ -187,10 +289,22 @@ export function dispatch(engine, argv, context) {
     return { error: 'ERR wrong number of arguments' };
   }
   const cmd = (Buffer.isBuffer(argv[0]) ? argv[0].toString('utf8') : String(argv[0])).toUpperCase();
+  const policy = compileCommandPolicy(context?.commandPolicy);
+  const commandResolution = resolveIncomingCommand(cmd, policy);
+  if (commandResolution.blocked) {
+    return { error: unsupported() };
+  }
+  const resolvedCommand = commandResolution.resolvedCommand;
   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 (context) {
+    context.getCommandNames = () => listVisibleCommandNames(policy);
+    context.resolveCommandForIntrospection = (name) => {
+      if (!policy) return name;
+      return policy.aliasToOriginal.get(String(name).toUpperCase()) ?? String(name).toUpperCase();
+    };
+  }
+  const handler = HANDLERS.get(resolvedCommand);
   if (!handler) {
     context?.onUnknownCommand?.({
       command: cmd,

package/src/embed.js

@@ -13,6 +13,7 @@ import net from 'node:net';
 import { handleConnection } from './server/connection.js';
 import { createEngine } from './engine/engine.js';
 import { openDb } from './storage/sqlite/db.js';
+import { compileCommandPolicy } from './commands/registry.js';
 
 export { handleConnection, createEngine, openDb };
 
@@ -37,6 +38,7 @@ export { handleConnection, createEngine, openDb };
  * @param {Record<string, string|number>} [options.pragma] Override specific pragmas only when needed (e.g. { synchronous: 'FULL' }). Applied after the template.
  * @param {RESPliteHooks} [options.hooks]         Optional event hooks for observability (onUnknownCommand, onCommandError, onSocketError).
  * @param {boolean} [options.gracefulShutdown=true] If true, register SIGTERM/SIGINT to call close(). Set false if you handle shutdown yourself to avoid double handlers.
+ * @param {{ rename?: Record<string, string>, disabled?: string[] } | null} [options.commandPolicy] Optional: rename/disable commands for hardening.
  * @returns {Promise<{ port: number, host: string, close: () => Promise<void> }>}
  */
 export async function createRESPlite({
@@ -47,7 +49,9 @@ export async function createRESPlite({
   pragma,
   hooks = {},
   gracefulShutdown = true,
+  commandPolicy = null,
 } = {}) {
+  const compiledCommandPolicy = compileCommandPolicy(commandPolicy);
   const db = openDb(dbPath, { pragmaTemplate, pragma });
   const engine = createEngine({ db });
   const connections = new Set();
@@ -55,7 +59,7 @@ export async function createRESPlite({
   const server = net.createServer((socket) => {
     connections.add(socket);
     socket.once('close', () => connections.delete(socket));
-    handleConnection(socket, engine, hooks);
+    handleConnection(socket, engine, hooks, compiledCommandPolicy);
   });
   await new Promise((resolve) => server.listen(port, host, resolve));
 

package/src/engine/engine.js

@@ -16,15 +16,14 @@ import { asKey, asValue } from '../util/buffers.js';
 
 export function createEngine(opts = {}) {
   const { db, cache } = opts;
+  const clock = opts.clock ?? (() => Date.now());
   const keys = createKeysStorage(db);
   const strings = createStringsStorage(db, keys);
-  const hashes = createHashesStorage(db, keys);
+  const hashes = createHashesStorage(db, keys, { clock });
   const sets = createSetsStorage(db, keys);
   const lists = createListsStorage(db, keys);
   const zsets = createZsetsStorage(db, keys);
 
-  const clock = opts.clock ?? (() => Date.now());
-
   function _incrBy(key, delta) {
     const k = asKey(key);
     const meta = getKeyMeta(key);
@@ -254,6 +253,44 @@ export function createEngine(opts = {}) {
       return hashes.incr(k, asKey(field), amt);
     },
 
+    /**
+     * HEXPIRE: apply absolute expiresAtMs to each hash field with optional NX/XX/GT/LT.
+     * Returns an array of integers per spec: -2 (missing), 0 (cond), 1 (set), 2 (deleted).
+     */
+    hexpire(key, expiresAtMs, fields, { condition = null } = {}) {
+      const k = asKey(key);
+      const meta = getKeyMeta(key);
+      if (!meta) return fields.map(() => -2);
+      expectHash(meta);
+      return fields.map((f) => hashes.setFieldExpire(k, asKey(f), expiresAtMs, { condition }));
+    },
+
+    /**
+     * HTTL: seconds remaining per field. -2 missing, -1 no TTL, else seconds.
+     */
+    httl(key, fields) {
+      const k = asKey(key);
+      const meta = getKeyMeta(key);
+      if (!meta) return fields.map(() => -2);
+      expectHash(meta);
+      return fields.map((f) => {
+        const ms = hashes.getFieldTtl(k, asKey(f));
+        if (ms < 0) return ms;
+        return Math.floor(ms / 1000);
+      });
+    },
+
+    /**
+     * HPERSIST: clear field TTL. -2 missing, -1 no TTL, 1 cleared.
+     */
+    hpersist(key, fields) {
+      const k = asKey(key);
+      const meta = getKeyMeta(key);
+      if (!meta) return fields.map(() => -2);
+      expectHash(meta);
+      return fields.map((f) => hashes.persistField(k, asKey(f)));
+    },
+
     sadd(key, ...members) {
       const k = asKey(key);
       getKeyMeta(key);

package/src/engine/expiration.js

@@ -1,5 +1,6 @@
 /**
  * Active expiration: background sweeper that deletes expired keys in batches.
+ * Also prunes expired hash fields (redis_hash_field_ttl) and drops now-empty hashes.
  */
 
 /**
@@ -18,11 +19,38 @@ export function createExpirationSweeper(opts) {
   const deleteExpiredStmt = db.prepare(
     'DELETE FROM redis_keys WHERE key IN (SELECT key FROM redis_keys WHERE expires_at IS NOT NULL AND expires_at <= ? LIMIT ?)'
   );
+  const selectExpiredFieldsStmt = db.prepare(
+    'SELECT key, field FROM redis_hash_field_ttl WHERE expires_at <= ? LIMIT ?'
+  );
+  const deleteHashFieldStmt = db.prepare('DELETE FROM redis_hashes WHERE key = ? AND field = ?');
+  const deleteFieldTtlStmt = db.prepare('DELETE FROM redis_hash_field_ttl WHERE key = ? AND field = ?');
+  const countHashStmt = db.prepare('SELECT COUNT(*) AS n FROM redis_hashes WHERE key = ?');
+  const updateHashCountStmt = db.prepare('UPDATE redis_keys SET hash_count = ? WHERE key = ?');
+  const deleteKeyStmt = db.prepare('DELETE FROM redis_keys WHERE key = ?');
+
+  const sweepFieldsTxn = db.transaction((pairs) => {
+    const affected = new Map();
+    for (const pair of pairs) {
+      deleteHashFieldStmt.run(pair.key, pair.field);
+      deleteFieldTtlStmt.run(pair.key, pair.field);
+      const seenKey = pair.key.toString('base64');
+      if (!affected.has(seenKey)) affected.set(seenKey, pair.key);
+    }
+    for (const key of affected.values()) {
+      const row = countHashStmt.get(key);
+      const n = row ? row.n : 0;
+      if (n === 0) deleteKeyStmt.run(key);
+      else updateHashCountStmt.run(n, key);
+    }
+  });
+
   let intervalId = null;
 
   function sweep() {
     const now = clock();
     deleteExpiredStmt.run(now, maxKeysPerSweep);
+    const pairs = selectExpiredFieldsStmt.all(now, maxKeysPerSweep);
+    if (pairs.length > 0) sweepFieldsTxn(pairs);
   }
 
   return {

package/src/index.js

@@ -26,6 +26,7 @@ const DEFAULT_PORT = 6379;
  * @param {string} [options.pragmaTemplate]
  * @param {Record<string, string|number>} [options.pragma] Override specific pragmas when needed (e.g. { synchronous: 'FULL' }). Convention: template is applied by default.
  * @param {boolean} [options.gracefulShutdown=true] If true, register SIGTERM/SIGINT to close server and DB. Set false if you handle shutdown yourself.
+ * @param {{ rename?: Record<string, string>, disabled?: string[] } | null} [options.commandPolicy] Optional: rename/disable commands for hardening.
  */
 export function startServer(options = {}) {
   const dbPath = options.dbPath ?? process.env.RESPLITE_DB ?? DEFAULT_DB_PATH;
@@ -45,7 +46,7 @@ export function startServer(options = {}) {
   sweeper.start();
 
   const connections = new Set();
-  const server = createServer({ engine, port, connections });
+  const server = createServer({ engine, port, connections, commandPolicy: options.commandPolicy ?? null });
 
   if (gracefulShutdown) {
     let shuttingDown = false;