@nestjs-redisx/testing 1.5.0

package/dist/index.mjs

@@ -0,0 +1,1739 @@
+import { registerDriver, BaseRedisDriver, RedisXError, ErrorCode, RedisModule } from '@nestjs-redisx/core';
+import { createHash } from 'crypto';
+
+// src/memory/api/register-memory-driver.ts
+
+// src/shared/constants/index.ts
+var MEMORY_DRIVER_TYPE = "memory";
+var MemoryDriverError = class extends RedisXError {
+  constructor(message, cause) {
+    super(message, ErrorCode.OP_FAILED, cause);
+    this.name = "MemoryDriverError";
+  }
+};
+var LuaExecutionError = class extends MemoryDriverError {
+  constructor(message, cause) {
+    super(`Lua execution error: ${message}`, cause);
+    this.name = "LuaExecutionError";
+  }
+};
+var WrongTypeError = class extends MemoryDriverError {
+  constructor() {
+    super("WRONGTYPE Operation against a key holding the wrong kind of value");
+    this.name = "WrongTypeError";
+  }
+};
+
+// src/memory/domain/store/stream-value.ts
+function parseId(id) {
+  const [msPart, seqPart = "0"] = id.split("-");
+  return { ms: Number(msPart), seq: Number(seqPart) };
+}
+function compareIds(a, b) {
+  const pa = parseId(a);
+  const pb = parseId(b);
+  return pa.ms !== pb.ms ? pa.ms - pb.ms : pa.seq - pb.seq;
+}
+function resolveRangeBound(token, isStart) {
+  let exclusive = false;
+  let t = token;
+  if (t.startsWith("(")) {
+    exclusive = true;
+    t = t.slice(1);
+  }
+  if (t === "-") return { id: "0-0", exclusive };
+  if (t === "+") return { id: `${Number.MAX_SAFE_INTEGER}-${Number.MAX_SAFE_INTEGER}`, exclusive };
+  if (!t.includes("-")) t = isStart ? `${t}-0` : `${t}-${Number.MAX_SAFE_INTEGER}`;
+  return { id: t, exclusive };
+}
+var StreamValue = class {
+  entries = [];
+  lastId = "0-0";
+  groups = /* @__PURE__ */ new Map();
+  /** Computes the next auto id (`*`) given the current time, keeping ids monotonic. */
+  nextAutoId(now) {
+    const last = parseId(this.lastId);
+    if (now > last.ms) return `${now}-0`;
+    return `${last.ms}-${last.seq + 1}`;
+  }
+  /** Resolves an explicit or `*` id for XADD, validating monotonicity. */
+  resolveAddId(id, now) {
+    if (id === "*") return this.nextAutoId(now);
+    let resolved = id;
+    if (id.endsWith("-*")) {
+      const ms = Number(id.slice(0, -2));
+      const last = parseId(this.lastId);
+      resolved = last.ms === ms ? `${ms}-${last.seq + 1}` : `${ms}-0`;
+    }
+    if (compareIds(resolved, this.lastId) <= 0 && this.lastId !== "0-0") {
+      throw new MemoryDriverError("ERR The ID specified in XADD is equal or smaller than the target stream top item");
+    }
+    return resolved;
+  }
+  /** Appends an entry. Returns its id. */
+  add(id, fields, now) {
+    const resolved = this.resolveAddId(id, now);
+    this.entries.push({ id: resolved, fields });
+    this.lastId = resolved;
+    return resolved;
+  }
+  len() {
+    return this.entries.length;
+  }
+  /** Entries within [start, end] (inclusive bounds, `-`/`+`/`(` supported). */
+  range(start, end, count, reverse = false) {
+    const lo = resolveRangeBound(start, true);
+    const hi = resolveRangeBound(end, false);
+    let out = this.entries.filter((e) => {
+      const geLo = lo.exclusive ? compareIds(e.id, lo.id) > 0 : compareIds(e.id, lo.id) >= 0;
+      const leHi = hi.exclusive ? compareIds(e.id, hi.id) < 0 : compareIds(e.id, hi.id) <= 0;
+      return geLo && leHi;
+    });
+    if (reverse) out = out.reverse();
+    if (count !== void 0 && count >= 0) out = out.slice(0, count);
+    return out;
+  }
+  /** Deletes entries by id. Returns the number removed. */
+  del(ids) {
+    let removed = 0;
+    for (const id of ids) {
+      const idx = this.entries.findIndex((e) => e.id === id);
+      if (idx !== -1) {
+        this.entries.splice(idx, 1);
+        removed += 1;
+      }
+    }
+    return removed;
+  }
+  /** Trims to at most `maxLen` newest entries. Returns the number removed. */
+  trimMaxLen(maxLen) {
+    if (maxLen < 0 || this.entries.length <= maxLen) return 0;
+    const removed = this.entries.length - maxLen;
+    this.entries.splice(0, removed);
+    return removed;
+  }
+  // --- consumer groups ------------------------------------------------------
+  createGroup(name, startId) {
+    if (this.groups.has(name)) {
+      throw new MemoryDriverError(`BUSYGROUP Consumer Group name already exists`);
+    }
+    const lastDeliveredId = startId === "$" ? this.lastId : startId === "0" ? "0-0" : startId;
+    this.groups.set(name, { lastDeliveredId, pending: /* @__PURE__ */ new Map(), consumers: /* @__PURE__ */ new Set() });
+  }
+  destroyGroup(name) {
+    return this.groups.delete(name) ? 1 : 0;
+  }
+  setGroupId(name, id) {
+    const group = this.requireGroup(name);
+    group.lastDeliveredId = id === "$" ? this.lastId : id === "0" ? "0-0" : id;
+  }
+  delConsumer(name, consumer) {
+    const group = this.requireGroup(name);
+    let removed = 0;
+    for (const [id, p] of group.pending) {
+      if (p.consumer === consumer) {
+        group.pending.delete(id);
+        removed += 1;
+      }
+    }
+    group.consumers.delete(consumer);
+    return removed;
+  }
+  requireGroup(name) {
+    const group = this.groups.get(name);
+    if (!group) throw new MemoryDriverError(`NOGROUP No such consumer group '${name}'`);
+    return group;
+  }
+  /**
+   * XREADGROUP semantics. `id === '>'` delivers never-delivered entries and adds
+   * them to the consumer's PEL; an explicit id re-reads that consumer's pending
+   * history with id greater than the given one.
+   */
+  readGroup(name, consumer, id, now, count, noAck) {
+    const group = this.requireGroup(name);
+    group.consumers.add(consumer);
+    if (id === ">") {
+      let fresh = this.entries.filter((e) => compareIds(e.id, group.lastDeliveredId) > 0);
+      if (count !== void 0) fresh = fresh.slice(0, count);
+      for (const entry of fresh) {
+        group.lastDeliveredId = entry.id;
+        if (!noAck) group.pending.set(entry.id, { consumer, deliveryTime: now, deliveryCount: 1 });
+      }
+      return fresh;
+    }
+    const from = resolveRangeBound(id, true);
+    const pendingIds = [...group.pending.entries()].filter(([eid, p]) => p.consumer === consumer && compareIds(eid, from.id) >= 0).map(([eid]) => eid).sort(compareIds);
+    const limited = count !== void 0 ? pendingIds.slice(0, count) : pendingIds;
+    return limited.map((eid) => this.entries.find((e) => e.id === eid)).filter((e) => e !== void 0);
+  }
+  ack(name, ids) {
+    const group = this.requireGroup(name);
+    let acked = 0;
+    for (const id of ids) {
+      if (group.pending.delete(id)) acked += 1;
+    }
+    return acked;
+  }
+  /** XPENDING summary: total, min/max pending id, and per-consumer counts. */
+  pendingSummary(name) {
+    const group = this.requireGroup(name);
+    const ids = [...group.pending.keys()].sort(compareIds);
+    const perConsumer = /* @__PURE__ */ new Map();
+    for (const p of group.pending.values()) perConsumer.set(p.consumer, (perConsumer.get(p.consumer) ?? 0) + 1);
+    return {
+      count: ids.length,
+      minId: ids[0] ?? null,
+      maxId: ids[ids.length - 1] ?? null,
+      consumers: [...perConsumer.entries()]
+    };
+  }
+  /** XPENDING range: pending entries in [start,end], optionally filtered by consumer. */
+  pendingRange(name, start, end, count, now, consumer) {
+    const group = this.requireGroup(name);
+    const lo = resolveRangeBound(start, true);
+    const hi = resolveRangeBound(end, false);
+    return [...group.pending.entries()].filter(([id]) => compareIds(id, lo.id) >= 0 && compareIds(id, hi.id) <= 0).filter(([, p]) => consumer ? p.consumer === consumer : true).sort((a, b) => compareIds(a[0], b[0])).slice(0, count).map(([id, p]) => ({ id, consumer: p.consumer, idleTime: Math.max(0, now - p.deliveryTime), deliveryCount: p.deliveryCount }));
+  }
+  /** XCLAIM: reassign pending entries idle >= minIdle to `consumer`. Returns claimed entries. */
+  claim(name, consumer, minIdle, ids, now) {
+    const group = this.requireGroup(name);
+    group.consumers.add(consumer);
+    const claimed = [];
+    for (const id of ids) {
+      const p = group.pending.get(id);
+      if (!p) continue;
+      if (now - p.deliveryTime < minIdle) continue;
+      const entry = this.entries.find((e) => e.id === id);
+      if (!entry) {
+        group.pending.delete(id);
+        continue;
+      }
+      group.pending.set(id, { consumer, deliveryTime: now, deliveryCount: p.deliveryCount + 1 });
+      claimed.push(entry);
+    }
+    return claimed;
+  }
+  /** Entries strictly greater than `id` (XREAD); `$` resolves to the current last id. */
+  readAfter(id, count) {
+    const after = id === "$" ? this.lastId : resolveRangeBound(id, true).id;
+    let out = this.entries.filter((e) => compareIds(e.id, after) > 0);
+    if (count !== void 0) out = out.slice(0, count);
+    return out;
+  }
+};
+
+// src/memory/domain/store/memory-store.ts
+var MemoryStore = class {
+  keyspace = /* @__PURE__ */ new Map();
+  /** Current logical time (epoch ms). Overridable for deterministic TTL tests. */
+  now() {
+    return Date.now();
+  }
+  /** Returns the live entry for a key, lazily evicting it if expired. */
+  live(key) {
+    const entry = this.keyspace.get(key);
+    if (!entry) return void 0;
+    if (entry.expireAt !== null && entry.expireAt <= this.now()) {
+      this.keyspace.delete(key);
+      return void 0;
+    }
+    return entry;
+  }
+  has(key) {
+    return this.live(key) !== void 0;
+  }
+  /** Deletes a key. Returns true if a live key was removed. */
+  delete(key) {
+    const existed = this.live(key) !== void 0;
+    this.keyspace.delete(key);
+    return existed;
+  }
+  /** Returns the Redis type name, or 'none' if missing. */
+  type(key) {
+    return this.live(key)?.data.kind ?? "none";
+  }
+  flush() {
+    this.keyspace.clear();
+  }
+  keys() {
+    const out = [];
+    for (const key of [...this.keyspace.keys()]) {
+      if (this.has(key)) out.push(key);
+    }
+    return out;
+  }
+  // --- expiry ---------------------------------------------------------------
+  /** Sets absolute expiry (epoch ms) or null to persist. Returns true if key exists. */
+  setExpireAt(key, atMs) {
+    const entry = this.live(key);
+    if (!entry) return false;
+    entry.expireAt = atMs;
+    return true;
+  }
+  /** Remaining TTL in ms: -2 missing, -1 no expiry, else >= 0. */
+  pttl(key) {
+    const entry = this.live(key);
+    if (!entry) return -2;
+    if (entry.expireAt === null) return -1;
+    return Math.max(0, entry.expireAt - this.now());
+  }
+  // --- typed access ---------------------------------------------------------
+  /** Reads a container of the expected kind; undefined if missing; throws on type mismatch. */
+  read(key, kind) {
+    const entry = this.live(key);
+    if (!entry) return void 0;
+    if (entry.data.kind !== kind) throw new WrongTypeError();
+    return entry.data.value;
+  }
+  /** Gets the existing container of `kind`, creating an empty one (no expiry) if absent. Throws on type mismatch. */
+  readOrCreate(key, kind) {
+    const existing = this.read(key, kind);
+    if (existing !== void 0) return existing;
+    const value = this.emptyContainer(kind);
+    this.keyspace.set(key, { data: { kind, value }, expireAt: null });
+    return value;
+  }
+  /** Overwrites a key with a string value, clearing any previous type and expiry. */
+  writeString(key, value) {
+    this.keyspace.set(key, { data: { kind: "string", value }, expireAt: null });
+  }
+  emptyContainer(kind) {
+    switch (kind) {
+      case "string":
+        return "";
+      case "hash":
+        return /* @__PURE__ */ new Map();
+      case "set":
+        return /* @__PURE__ */ new Set();
+      case "zset":
+        return /* @__PURE__ */ new Map();
+      case "list":
+        return [];
+      case "stream":
+        return new StreamValue();
+    }
+  }
+};
+
+// src/memory/domain/lua/lua-lexer.ts
+var KEYWORDS = /* @__PURE__ */ new Set(["local", "if", "then", "elseif", "else", "end", "for", "do", "return", "and", "or", "not", "nil", "true", "false"]);
+var MULTI_OPS = ["==", "~=", "<=", ">=", ".."];
+var SINGLE_OPS = /* @__PURE__ */ new Set(["+", "-", "*", "/", "%", "<", ">", "=", "#", "(", ")", "[", "]", "{", "}", ",", "."]);
+function tokenize(src) {
+  const tokens = [];
+  let i = 0;
+  const n = src.length;
+  const isDigit = (c) => c >= "0" && c <= "9";
+  const isNameStart = (c) => c === "_" || c >= "a" && c <= "z" || c >= "A" && c <= "Z";
+  const isNamePart = (c) => isNameStart(c) || isDigit(c);
+  while (i < n) {
+    const c = src[i];
+    if (c === " " || c === "	" || c === "\r" || c === "\n") {
+      i++;
+      continue;
+    }
+    if (c === "-" && src[i + 1] === "-") {
+      i += 2;
+      while (i < n && src[i] !== "\n") i++;
+      continue;
+    }
+    if (c === '"' || c === "'") {
+      const quote = c;
+      i++;
+      let str = "";
+      while (i < n && src[i] !== quote) {
+        if (src[i] === "\\") {
+          const next = src[i + 1];
+          str += next === "n" ? "\n" : next === "t" ? "	" : next ?? "";
+          i += 2;
+        } else {
+          str += src[i];
+          i++;
+        }
+      }
+      if (i >= n) throw new LuaExecutionError("unterminated string literal");
+      i++;
+      tokens.push({ type: "string", value: str });
+      continue;
+    }
+    if (isDigit(c) || c === "." && isDigit(src[i + 1] ?? "")) {
+      let num = "";
+      while (i < n && (isDigit(src[i]) || src[i] === ".")) {
+        num += src[i];
+        i++;
+      }
+      tokens.push({ type: "number", value: num });
+      continue;
+    }
+    if (isNameStart(c)) {
+      let name = "";
+      while (i < n && isNamePart(src[i])) {
+        name += src[i];
+        i++;
+      }
+      tokens.push({ type: KEYWORDS.has(name) ? "keyword" : "name", value: name });
+      continue;
+    }
+    const two = src.slice(i, i + 2);
+    if (MULTI_OPS.includes(two)) {
+      tokens.push({ type: "op", value: two });
+      i += 2;
+      continue;
+    }
+    if (SINGLE_OPS.has(c)) {
+      tokens.push({ type: "op", value: c });
+      i++;
+      continue;
+    }
+    throw new LuaExecutionError(`unexpected character '${c}'`);
+  }
+  tokens.push({ type: "eof", value: "" });
+  return tokens;
+}
+
+// src/memory/domain/lua/lua-parser.ts
+var BINARY_PRECEDENCE = {
+  or: 1,
+  and: 2,
+  "==": 3,
+  "~=": 3,
+  "<": 3,
+  "<=": 3,
+  ">": 3,
+  ">=": 3,
+  "..": 4,
+  "+": 5,
+  "-": 5,
+  "*": 6,
+  "/": 6,
+  "%": 6
+};
+var BLOCK_TERMINATORS = /* @__PURE__ */ new Set(["end", "else", "elseif"]);
+function parse(src) {
+  const tokens = tokenize(src);
+  let pos = 0;
+  const peek = () => tokens[pos];
+  const next = () => tokens[pos++];
+  const isKeyword = (kw) => peek().type === "keyword" && peek().value === kw;
+  const isOp = (op) => peek().type === "op" && peek().value === op;
+  const expectOp = (op) => {
+    if (!isOp(op)) throw new LuaExecutionError(`expected '${op}' but got '${peek().value}'`);
+    pos++;
+  };
+  const expectKeyword = (kw) => {
+    if (!isKeyword(kw)) throw new LuaExecutionError(`expected '${kw}' but got '${peek().value}'`);
+    pos++;
+  };
+  function parseBlock() {
+    const stmts = [];
+    while (peek().type !== "eof" && !(peek().type === "keyword" && BLOCK_TERMINATORS.has(peek().value))) {
+      stmts.push(parseStatement());
+    }
+    return stmts;
+  }
+  function parseStatement() {
+    if (isKeyword("local")) {
+      next();
+      const name = next();
+      if (name.type !== "name") throw new LuaExecutionError(`expected name after 'local'`);
+      let expr;
+      if (isOp("=")) {
+        next();
+        expr = parseExpr();
+      }
+      return { kind: "local", name: name.value, expr };
+    }
+    if (isKeyword("if")) return parseIf();
+    if (isKeyword("for")) return parseFor();
+    if (isKeyword("return")) {
+      next();
+      if (peek().type === "eof" || peek().type === "keyword" && BLOCK_TERMINATORS.has(peek().value)) {
+        return { kind: "return" };
+      }
+      return { kind: "return", expr: parseExpr() };
+    }
+    const prefix = parseExpr();
+    if (isOp("=")) {
+      next();
+      const value = parseExpr();
+      if (prefix.kind !== "name" && prefix.kind !== "index") {
+        throw new LuaExecutionError("invalid assignment target");
+      }
+      return { kind: "assign", target: prefix, expr: value };
+    }
+    return { kind: "exprStmt", expr: prefix };
+  }
+  function parseIf() {
+    expectKeyword("if");
+    const clauses = [];
+    const cond = parseExpr();
+    expectKeyword("then");
+    clauses.push({ cond, body: parseBlock() });
+    while (isKeyword("elseif")) {
+      next();
+      const c = parseExpr();
+      expectKeyword("then");
+      clauses.push({ cond: c, body: parseBlock() });
+    }
+    let elseBody;
+    if (isKeyword("else")) {
+      next();
+      elseBody = parseBlock();
+    }
+    expectKeyword("end");
+    return { kind: "if", clauses, elseBody };
+  }
+  function parseFor() {
+    expectKeyword("for");
+    const varTok = next();
+    if (varTok.type !== "name") throw new LuaExecutionError(`expected loop variable name`);
+    expectOp("=");
+    const from = parseExpr();
+    expectOp(",");
+    const to = parseExpr();
+    let step;
+    if (isOp(",")) {
+      next();
+      step = parseExpr();
+    }
+    expectKeyword("do");
+    const body = parseBlock();
+    expectKeyword("end");
+    return { kind: "for", varName: varTok.value, from, to, step, body };
+  }
+  function parseExpr(minPrec = 0) {
+    let left = parseUnary();
+    for (; ; ) {
+      const t = peek();
+      const opName = t.type === "keyword" && (t.value === "and" || t.value === "or") ? t.value : t.type === "op" ? t.value : void 0;
+      if (opName === void 0) break;
+      const prec = BINARY_PRECEDENCE[opName];
+      if (prec === void 0 || prec < minPrec) break;
+      next();
+      const nextMin = opName === ".." ? prec : prec + 1;
+      const right = parseExpr(nextMin);
+      left = { kind: "binop", op: opName, left, right };
+    }
+    return left;
+  }
+  function parseUnary() {
+    if (isKeyword("not")) {
+      next();
+      return { kind: "unop", op: "not", expr: parseUnary() };
+    }
+    if (isOp("-")) {
+      next();
+      return { kind: "unop", op: "-", expr: parseUnary() };
+    }
+    if (isOp("#")) {
+      next();
+      return { kind: "unop", op: "#", expr: parseUnary() };
+    }
+    return parsePostfix();
+  }
+  function parsePostfix() {
+    let expr = parsePrimary();
+    for (; ; ) {
+      if (isOp(".")) {
+        next();
+        const name = next();
+        if (name.type !== "name" && name.type !== "keyword") throw new LuaExecutionError("expected field name after .");
+        expr = { kind: "index", obj: expr, key: { kind: "str", value: name.value } };
+      } else if (isOp("[")) {
+        next();
+        const key = parseExpr();
+        expectOp("]");
+        expr = { kind: "index", obj: expr, key };
+      } else if (isOp("(")) {
+        next();
+        const args = [];
+        if (!isOp(")")) {
+          args.push(parseExpr());
+          while (isOp(",")) {
+            next();
+            args.push(parseExpr());
+          }
+        }
+        expectOp(")");
+        expr = { kind: "call", callee: expr, args };
+      } else {
+        break;
+      }
+    }
+    return expr;
+  }
+  function parsePrimary() {
+    const t = peek();
+    if (t.type === "number") {
+      next();
+      return { kind: "num", value: Number(t.value) };
+    }
+    if (t.type === "string") {
+      next();
+      return { kind: "str", value: t.value };
+    }
+    if (t.type === "keyword") {
+      if (t.value === "nil") {
+        next();
+        return { kind: "nil" };
+      }
+      if (t.value === "true" || t.value === "false") {
+        next();
+        return { kind: "bool", value: t.value === "true" };
+      }
+    }
+    if (t.type === "name") {
+      next();
+      return { kind: "name", name: t.value };
+    }
+    if (isOp("(")) {
+      next();
+      const e = parseExpr();
+      expectOp(")");
+      return e;
+    }
+    if (isOp("{")) {
+      next();
+      const items = [];
+      if (!isOp("}")) {
+        items.push(parseExpr());
+        while (isOp(",")) {
+          next();
+          if (isOp("}")) break;
+          items.push(parseExpr());
+        }
+      }
+      expectOp("}");
+      return { kind: "table", items };
+    }
+    throw new LuaExecutionError(`unexpected token '${t.value}'`);
+  }
+  const block = parseBlock();
+  if (peek().type !== "eof") throw new LuaExecutionError(`unexpected trailing token '${peek().value}'`);
+  return block;
+}
+
+// src/memory/domain/lua/lua-interpreter.ts
+var LuaTable = class {
+  map = /* @__PURE__ */ new Map();
+  get(key) {
+    return this.map.has(key) ? this.map.get(key) : null;
+  }
+  set(key, value) {
+    if (value === null) this.map.delete(key);
+    else this.map.set(key, value);
+  }
+  /** Lua `#t`: length of the array part (largest n with 1..n present). */
+  length() {
+    let n = 0;
+    while (this.map.has(n + 1)) n++;
+    return n;
+  }
+};
+function truthy(v) {
+  return v !== null && v !== false;
+}
+function luaToString(v) {
+  if (v === null) return "nil";
+  if (typeof v === "boolean") return v ? "true" : "false";
+  if (typeof v === "number") return Number.isInteger(v) ? String(v) : String(v);
+  if (typeof v === "string") return v;
+  throw new LuaExecutionError("cannot convert table to string");
+}
+function toNumber(v) {
+  if (typeof v === "number") return v;
+  if (typeof v === "string") {
+    const n = Number(v);
+    if (Number.isNaN(n)) throw new LuaExecutionError(`cannot convert '${v}' to number`);
+    return n;
+  }
+  throw new LuaExecutionError("arithmetic on non-number");
+}
+var LuaInterpreter = class {
+  /**
+   * Runs a Redis Lua script.
+   *
+   * @param source - Lua source
+   * @param keys - KEYS array (strings)
+   * @param argv - ARGV array (strings)
+   * @param redisCall - bridge to execute redis.call(cmd, ...args)
+   * @returns the script's return value converted to a Redis reply
+   */
+  run(source, keys, argv, redisCall) {
+    const program = parse(source);
+    const env = /* @__PURE__ */ new Map();
+    env.set("KEYS", this.arrayTable(keys));
+    env.set("ARGV", this.arrayTable(argv));
+    const result = this.execBlock(program, env, redisCall);
+    return result ? this.luaToRedis(result.value) : null;
+  }
+  arrayTable(items) {
+    const t = new LuaTable();
+    items.forEach((item, idx) => t.set(idx + 1, item));
+    return t;
+  }
+  execBlock(stmts, env, redisCall) {
+    for (const stmt of stmts) {
+      const sig = this.execStmt(stmt, env, redisCall);
+      if (sig) return sig;
+    }
+    return void 0;
+  }
+  execStmt(stmt, env, redisCall) {
+    switch (stmt.kind) {
+      case "local":
+        env.set(stmt.name, stmt.expr ? this.evalExpr(stmt.expr, env, redisCall) : null);
+        return void 0;
+      case "assign": {
+        const value = this.evalExpr(stmt.expr, env, redisCall);
+        if (stmt.target.kind === "name") {
+          env.set(stmt.target.name, value);
+        } else if (stmt.target.kind === "index") {
+          const obj = this.evalExpr(stmt.target.obj, env, redisCall);
+          if (!(obj instanceof LuaTable)) throw new LuaExecutionError("index assignment on non-table");
+          const key = this.normalizeKey(this.evalExpr(stmt.target.key, env, redisCall));
+          obj.set(key, value);
+        } else {
+          throw new LuaExecutionError("invalid assignment target");
+        }
+        return void 0;
+      }
+      case "if": {
+        for (const clause of stmt.clauses) {
+          if (truthy(this.evalExpr(clause.cond, env, redisCall))) {
+            return this.execBlock(clause.body, env, redisCall);
+          }
+        }
+        if (stmt.elseBody) return this.execBlock(stmt.elseBody, env, redisCall);
+        return void 0;
+      }
+      case "for": {
+        const from = toNumber(this.evalExpr(stmt.from, env, redisCall));
+        const to = toNumber(this.evalExpr(stmt.to, env, redisCall));
+        const step = stmt.step ? toNumber(this.evalExpr(stmt.step, env, redisCall)) : 1;
+        if (step === 0) throw new LuaExecutionError("'for' step is zero");
+        const had = env.has(stmt.varName);
+        const prev = env.get(stmt.varName);
+        for (let i = from; step > 0 ? i <= to : i >= to; i += step) {
+          env.set(stmt.varName, i);
+          const sig = this.execBlock(stmt.body, env, redisCall);
+          if (sig) {
+            this.restore(env, stmt.varName, had, prev);
+            return sig;
+          }
+        }
+        this.restore(env, stmt.varName, had, prev);
+        return void 0;
+      }
+      case "return":
+        return { returned: true, value: stmt.expr ? this.evalExpr(stmt.expr, env, redisCall) : null };
+      case "exprStmt":
+        this.evalExpr(stmt.expr, env, redisCall);
+        return void 0;
+    }
+  }
+  restore(env, name, had, prev) {
+    if (had) env.set(name, prev);
+    else env.delete(name);
+  }
+  evalExpr(expr, env, redisCall) {
+    switch (expr.kind) {
+      case "num":
+        return expr.value;
+      case "str":
+        return expr.value;
+      case "bool":
+        return expr.value;
+      case "nil":
+        return null;
+      case "name":
+        return env.has(expr.name) ? env.get(expr.name) : null;
+      case "index": {
+        const obj = this.evalExpr(expr.obj, env, redisCall);
+        if (!(obj instanceof LuaTable)) {
+          throw new LuaExecutionError("attempt to index a non-table value");
+        }
+        return obj.get(this.normalizeKey(this.evalExpr(expr.key, env, redisCall)));
+      }
+      case "table": {
+        const t = new LuaTable();
+        expr.items.forEach((item, idx) => t.set(idx + 1, this.evalExpr(item, env, redisCall)));
+        return t;
+      }
+      case "unop":
+        return this.evalUnop(expr.op, this.evalExpr(expr.expr, env, redisCall));
+      case "binop":
+        return this.evalBinop(expr, env, redisCall);
+      case "call":
+        return this.evalCall(expr, env, redisCall);
+    }
+  }
+  normalizeKey(key) {
+    if (typeof key === "number") return key;
+    if (typeof key === "string") return key;
+    throw new LuaExecutionError("invalid table key");
+  }
+  evalUnop(op, v) {
+    switch (op) {
+      case "not":
+        return !truthy(v);
+      case "-":
+        return -toNumber(v);
+      case "#":
+        if (typeof v === "string") return v.length;
+        if (v instanceof LuaTable) return v.length();
+        throw new LuaExecutionError("attempt to get length of a non-string/table");
+      default:
+        throw new LuaExecutionError(`unsupported unary operator '${op}'`);
+    }
+  }
+  evalBinop(expr, env, redisCall) {
+    const { op } = expr;
+    if (op === "and") {
+      const left = this.evalExpr(expr.left, env, redisCall);
+      return truthy(left) ? this.evalExpr(expr.right, env, redisCall) : left;
+    }
+    if (op === "or") {
+      const left = this.evalExpr(expr.left, env, redisCall);
+      return truthy(left) ? left : this.evalExpr(expr.right, env, redisCall);
+    }
+    const l = this.evalExpr(expr.left, env, redisCall);
+    const r = this.evalExpr(expr.right, env, redisCall);
+    switch (op) {
+      case "..":
+        return luaToString(l) + luaToString(r);
+      case "==":
+        return this.luaEquals(l, r);
+      case "~=":
+        return !this.luaEquals(l, r);
+      case "<":
+        return this.compare(l, r) < 0;
+      case "<=":
+        return this.compare(l, r) <= 0;
+      case ">":
+        return this.compare(l, r) > 0;
+      case ">=":
+        return this.compare(l, r) >= 0;
+      case "+":
+        return toNumber(l) + toNumber(r);
+      case "-":
+        return toNumber(l) - toNumber(r);
+      case "*":
+        return toNumber(l) * toNumber(r);
+      case "/":
+        return toNumber(l) / toNumber(r);
+      case "%": {
+        const a = toNumber(l);
+        const b = toNumber(r);
+        return a - Math.floor(a / b) * b;
+      }
+      default:
+        throw new LuaExecutionError(`unsupported operator '${op}'`);
+    }
+  }
+  luaEquals(a, b) {
+    if (typeof a !== typeof b) return false;
+    return a === b;
+  }
+  compare(a, b) {
+    if (typeof a === "number" && typeof b === "number") return a - b;
+    if (typeof a === "string" && typeof b === "string") return a < b ? -1 : a > b ? 1 : 0;
+    throw new LuaExecutionError("attempt to compare incompatible values");
+  }
+  evalCall(expr, env, redisCall) {
+    const callee = expr.callee;
+    const args = expr.args.map((a) => this.evalExpr(a, env, redisCall));
+    if (callee.kind === "index" && callee.obj.kind === "name" && callee.obj.name === "redis" && callee.key.kind === "str") {
+      if (callee.key.value === "call" || callee.key.value === "pcall") {
+        return this.doRedisCall(args, redisCall);
+      }
+      throw new LuaExecutionError(`unsupported redis.${callee.key.value}()`);
+    }
+    if (callee.kind === "index" && callee.obj.kind === "name" && callee.obj.name === "math" && callee.key.kind === "str") {
+      return this.doMath(callee.key.value, args);
+    }
+    if (callee.kind === "name" && callee.name === "tonumber") {
+      const v = args[0] ?? null;
+      if (typeof v === "number") return v;
+      if (typeof v === "string") {
+        const n = Number(v);
+        return Number.isNaN(n) ? null : n;
+      }
+      return null;
+    }
+    if (callee.kind === "name" && callee.name === "tostring") {
+      return luaToString(args[0] ?? null);
+    }
+    throw new LuaExecutionError("unsupported function call");
+  }
+  doMath(fn, args) {
+    const nums = args.map(toNumber);
+    switch (fn) {
+      case "floor":
+        return Math.floor(nums[0]);
+      case "ceil":
+        return Math.ceil(nums[0]);
+      case "abs":
+        return Math.abs(nums[0]);
+      case "min":
+        return Math.min(...nums);
+      case "max":
+        return Math.max(...nums);
+      default:
+        throw new LuaExecutionError(`unsupported math.${fn}()`);
+    }
+  }
+  doRedisCall(args, redisCall) {
+    if (args.length === 0) throw new LuaExecutionError("redis.call requires a command");
+    const command = luaToString(args[0]);
+    const callArgs = args.slice(1).map((a) => {
+      if (typeof a === "number") return a;
+      if (typeof a === "string") return a;
+      throw new LuaExecutionError("redis.call argument must be string or number");
+    });
+    return this.redisToLua(redisCall(command, callArgs));
+  }
+  /** Converts a Redis reply (from the executor) into a Lua value. */
+  redisToLua(reply) {
+    if (reply === null || reply === void 0) return null;
+    if (typeof reply === "number") return reply;
+    if (typeof reply === "string") return reply;
+    if (typeof reply === "boolean") return reply ? 1 : null;
+    if (Array.isArray(reply)) {
+      const t = new LuaTable();
+      reply.forEach((el, idx) => t.set(idx + 1, this.redisToLua(el)));
+      return t;
+    }
+    if (typeof reply === "object") {
+      const t = new LuaTable();
+      let idx = 1;
+      for (const [field, value] of Object.entries(reply)) {
+        t.set(idx++, field);
+        t.set(idx++, this.redisToLua(value));
+      }
+      return t;
+    }
+    throw new LuaExecutionError("unsupported redis reply type from in-memory executor");
+  }
+  /** Converts a Lua return value into a Redis reply. */
+  luaToRedis(v) {
+    if (v === null) return null;
+    if (typeof v === "boolean") return v ? 1 : null;
+    if (typeof v === "number") return Math.floor(v);
+    if (typeof v === "string") return v;
+    const out = [];
+    const len = v.length();
+    for (let i = 1; i <= len; i++) {
+      out.push(this.luaToRedis(v.get(i)));
+    }
+    return out;
+  }
+};
+
+// src/memory/application/services/command-executor.service.ts
+var OK = "OK";
+function globToRegExp(glob) {
+  let re = "^";
+  for (const ch of glob) {
+    if (ch === "*") re += ".*";
+    else if (ch === "?") re += ".";
+    else if (".+^${}()|\\/[".includes(ch)) re += `\\${ch}`;
+    else re += ch;
+  }
+  return new RegExp(`${re}$`);
+}
+function parseScoreBound(raw) {
+  let str = String(raw);
+  let exclusive = false;
+  if (str.startsWith("(")) {
+    exclusive = true;
+    str = str.slice(1);
+  }
+  if (str === "-inf") return { value: -Infinity, exclusive };
+  if (str === "+inf" || str === "inf") return { value: Infinity, exclusive };
+  return { value: Number(str), exclusive };
+}
+var CommandExecutor = class {
+  constructor(store, interpreter = new LuaInterpreter()) {
+    this.store = store;
+    this.interpreter = interpreter;
+  }
+  scripts = /* @__PURE__ */ new Map();
+  redisCall = (command, args) => this.execute(command, args);
+  execute(command, args) {
+    const cmd = command.toUpperCase();
+    switch (cmd) {
+      // --- connection / server ---
+      case "PING":
+        return args.length ? this.str(args[0]) : "PONG";
+      case "DBSIZE":
+        return this.store.keys().length;
+      case "FLUSHDB":
+      case "FLUSHALL":
+        this.store.flush();
+        return OK;
+      // --- strings ---
+      case "GET":
+        return this.store.read(this.str(args[0]), "string") ?? null;
+      case "SET":
+        return this.cmdSet(args);
+      case "SETEX":
+        return this.cmdSet([args[0], args[2], "EX", args[1]]);
+      case "SETNX":
+        return this.cmdSet([args[0], args[1], "NX"]) === OK ? 1 : 0;
+      case "DEL":
+      case "UNLINK":
+        return args.reduce((acc, k) => acc + (this.store.delete(this.str(k)) ? 1 : 0), 0);
+      case "EXISTS":
+        return args.reduce((acc, k) => acc + (this.store.has(this.str(k)) ? 1 : 0), 0);
+      case "INCR":
+        return this.incrBy(this.str(args[0]), 1);
+      case "INCRBY":
+        return this.incrBy(this.str(args[0]), this.num(args[1]));
+      case "DECR":
+        return this.incrBy(this.str(args[0]), -1);
+      case "DECRBY":
+        return this.incrBy(this.str(args[0]), -this.num(args[1]));
+      case "APPEND": {
+        const key = this.str(args[0]);
+        const cur = this.store.read(key, "string") ?? "";
+        const next = cur + this.str(args[1]);
+        this.preserveTtl(key, () => this.store.writeString(key, next));
+        return next.length;
+      }
+      case "STRLEN":
+        return (this.store.read(this.str(args[0]), "string") ?? "").length;
+      case "MGET":
+        return args.map((k) => this.store.read(this.str(k), "string") ?? null);
+      case "MSET": {
+        for (let i = 0; i < args.length; i += 2) this.store.writeString(this.str(args[i]), this.str(args[i + 1]));
+        return OK;
+      }
+      // --- keys / TTL ---
+      case "EXPIRE":
+        return this.store.setExpireAt(this.str(args[0]), this.store.now() + this.num(args[1]) * 1e3) ? 1 : 0;
+      case "PEXPIRE":
+        return this.store.setExpireAt(this.str(args[0]), this.store.now() + this.num(args[1])) ? 1 : 0;
+      case "EXPIREAT":
+        return this.store.setExpireAt(this.str(args[0]), this.num(args[1]) * 1e3) ? 1 : 0;
+      case "PEXPIREAT":
+        return this.store.setExpireAt(this.str(args[0]), this.num(args[1])) ? 1 : 0;
+      case "PERSIST":
+        return this.store.setExpireAt(this.str(args[0]), null) ? 1 : 0;
+      case "TTL": {
+        const ms = this.store.pttl(this.str(args[0]));
+        return ms < 0 ? ms : Math.ceil(ms / 1e3);
+      }
+      case "PTTL":
+        return this.store.pttl(this.str(args[0]));
+      case "TYPE":
+        return this.store.type(this.str(args[0]));
+      case "KEYS": {
+        const re = globToRegExp(this.str(args[0]));
+        return this.store.keys().filter((k) => re.test(k));
+      }
+      case "SCAN":
+        return this.cmdScan(args);
+      // --- hashes ---
+      case "HSET":
+      case "HMSET":
+        return this.cmdHset(cmd, args);
+      case "HGET": {
+        const hash = this.store.read(this.str(args[0]), "hash");
+        return hash?.get(this.str(args[1])) ?? null;
+      }
+      case "HMGET": {
+        const hash = this.store.read(this.str(args[0]), "hash");
+        return args.slice(1).map((f) => hash?.get(this.str(f)) ?? null);
+      }
+      case "HGETALL": {
+        const hash = this.store.read(this.str(args[0]), "hash");
+        const obj = {};
+        if (hash) for (const [f, v] of hash) obj[f] = v;
+        return obj;
+      }
+      case "HDEL": {
+        const key = this.str(args[0]);
+        const hash = this.store.read(key, "hash");
+        if (!hash) return 0;
+        let removed = 0;
+        for (const f of args.slice(1)) if (hash.delete(this.str(f))) removed++;
+        if (hash.size === 0) this.store.delete(key);
+        return removed;
+      }
+      case "HEXISTS":
+        return this.store.read(this.str(args[0]), "hash")?.has(this.str(args[1])) ? 1 : 0;
+      case "HLEN":
+        return this.store.read(this.str(args[0]), "hash")?.size ?? 0;
+      case "HKEYS":
+        return [...this.store.read(this.str(args[0]), "hash")?.keys() ?? []];
+      case "HVALS":
+        return [...this.store.read(this.str(args[0]), "hash")?.values() ?? []];
+      case "HINCRBY": {
+        const key = this.str(args[0]);
+        const field = this.str(args[1]);
+        const hash = this.store.readOrCreate(key, "hash");
+        const next = Number(hash.get(field) ?? "0") + this.num(args[2]);
+        hash.set(field, String(next));
+        return next;
+      }
+      // --- lists ---
+      case "LPUSH": {
+        const list = this.store.readOrCreate(this.str(args[0]), "list");
+        for (const v of args.slice(1)) list.unshift(this.str(v));
+        return list.length;
+      }
+      case "RPUSH": {
+        const list = this.store.readOrCreate(this.str(args[0]), "list");
+        for (const v of args.slice(1)) list.push(this.str(v));
+        return list.length;
+      }
+      case "LPOP":
+      case "RPOP":
+        return this.cmdPop(cmd, args);
+      case "LLEN":
+        return this.store.read(this.str(args[0]), "list")?.length ?? 0;
+      case "LRANGE":
+        return this.cmdLrange(args);
+      case "LINDEX": {
+        const list = this.store.read(this.str(args[0]), "list");
+        if (!list) return null;
+        let idx = this.num(args[1]);
+        if (idx < 0) idx = list.length + idx;
+        return list[idx] ?? null;
+      }
+      case "LREM": {
+        const key = this.str(args[0]);
+        const list = this.store.read(key, "list");
+        if (!list) return 0;
+        const target = this.str(args[2]);
+        const before = list.length;
+        const kept = list.filter((v) => v !== target);
+        list.length = 0;
+        list.push(...kept);
+        if (list.length === 0) this.store.delete(key);
+        return before - list.length;
+      }
+      // --- sets ---
+      case "SADD": {
+        const set = this.store.readOrCreate(this.str(args[0]), "set");
+        let added = 0;
+        for (const m of args.slice(1)) {
+          const member = this.str(m);
+          if (!set.has(member)) {
+            set.add(member);
+            added++;
+          }
+        }
+        return added;
+      }
+      case "SREM": {
+        const key = this.str(args[0]);
+        const set = this.store.read(key, "set");
+        if (!set) return 0;
+        let removed = 0;
+        for (const m of args.slice(1)) if (set.delete(this.str(m))) removed++;
+        if (set.size === 0) this.store.delete(key);
+        return removed;
+      }
+      case "SMEMBERS":
+        return [...this.store.read(this.str(args[0]), "set") ?? []];
+      case "SISMEMBER":
+        return this.store.read(this.str(args[0]), "set")?.has(this.str(args[1])) ? 1 : 0;
+      case "SCARD":
+        return this.store.read(this.str(args[0]), "set")?.size ?? 0;
+      // --- sorted sets ---
+      case "ZADD":
+        return this.cmdZadd(args);
+      case "ZCARD":
+        return this.store.read(this.str(args[0]), "zset")?.size ?? 0;
+      case "ZSCORE": {
+        const score = this.store.read(this.str(args[0]), "zset")?.get(this.str(args[1]));
+        return score === void 0 ? null : String(score);
+      }
+      case "ZREM": {
+        const key = this.str(args[0]);
+        const zset = this.store.read(key, "zset");
+        if (!zset) return 0;
+        let removed = 0;
+        for (const m of args.slice(1)) if (zset.delete(this.str(m))) removed++;
+        if (zset.size === 0) this.store.delete(key);
+        return removed;
+      }
+      case "ZRANGE":
+        return this.cmdZrange(args);
+      case "ZRANGEBYSCORE":
+        return this.cmdZrangeByScore(args);
+      case "ZREMRANGEBYSCORE":
+        return this.cmdZremRangeByScore(args);
+      case "ZCOUNT": {
+        const zset = this.store.read(this.str(args[0]), "zset");
+        if (!zset) return 0;
+        const min = parseScoreBound(args[1]);
+        const max = parseScoreBound(args[2]);
+        return [...zset.values()].filter((s) => this.inRange(s, min, max)).length;
+      }
+      // --- streams ---
+      case "XADD":
+        return this.cmdXadd(args);
+      case "XLEN":
+        return this.store.read(this.str(args[0]), "stream")?.len() ?? 0;
+      case "XRANGE":
+        return this.cmdXrange(args, false);
+      case "XREVRANGE":
+        return this.cmdXrange(args, true);
+      case "XDEL":
+        return this.store.read(this.str(args[0]), "stream")?.del(args.slice(1).map((i) => this.str(i))) ?? 0;
+      case "XTRIM":
+        return this.cmdXtrim(args);
+      case "XINFO":
+        return this.cmdXinfo(args);
+      case "XGROUP":
+        return this.cmdXgroup(args);
+      case "XREADGROUP":
+        return this.cmdXreadgroup(args);
+      case "XREAD":
+        return this.cmdXread(args);
+      case "XACK":
+        return this.cmdXack(args);
+      case "XPENDING":
+        return this.cmdXpending(args);
+      case "XCLAIM":
+        return this.cmdXclaim(args);
+      // --- scripting ---
+      case "SCRIPT":
+        if (this.str(args[0]).toUpperCase() === "LOAD") {
+          const source = this.str(args[1]);
+          const sha = createHash("sha1").update(source).digest("hex");
+          this.scripts.set(sha, source);
+          return sha;
+        }
+        return OK;
+      case "EVAL":
+        return this.runScript(this.str(args[0]), args);
+      case "EVALSHA": {
+        const sha = this.str(args[0]);
+        const source = this.scripts.get(sha);
+        if (!source) throw new MemoryDriverError("NOSCRIPT No matching script. Please use EVAL.");
+        return this.runScript(source, args);
+      }
+      default:
+        throw new MemoryDriverError(`In-memory driver does not implement command: ${cmd}`);
+    }
+  }
+  // --- helpers --------------------------------------------------------------
+  str(v) {
+    return String(v);
+  }
+  num(v) {
+    const n = Number(v);
+    if (Number.isNaN(n)) throw new MemoryDriverError(`value is not an integer or out of range: ${String(v)}`);
+    return n;
+  }
+  preserveTtl(key, mutate) {
+    const ttl = this.store.pttl(key);
+    mutate();
+    if (ttl >= 0) this.store.setExpireAt(key, this.store.now() + ttl);
+  }
+  incrBy(key, by) {
+    const cur = this.store.read(key, "string");
+    const next = (cur === void 0 ? 0 : this.num(cur)) + by;
+    this.preserveTtl(key, () => this.store.writeString(key, String(next)));
+    return next;
+  }
+  cmdSet(args) {
+    const key = this.str(args[0]);
+    const value = this.str(args[1]);
+    let nx = false;
+    let xx = false;
+    let ex;
+    let px;
+    let getOld = false;
+    for (let i = 2; i < args.length; i++) {
+      const opt = this.str(args[i]).toUpperCase();
+      if (opt === "NX") nx = true;
+      else if (opt === "XX") xx = true;
+      else if (opt === "GET") getOld = true;
+      else if (opt === "EX") ex = this.num(args[++i]);
+      else if (opt === "PX") px = this.num(args[++i]);
+    }
+    const exists = this.store.has(key);
+    const old = exists ? this.store.read(key, "string") ?? null : null;
+    if (nx && exists || xx && !exists) return getOld ? old : null;
+    this.store.writeString(key, value);
+    if (ex !== void 0) this.store.setExpireAt(key, this.store.now() + ex * 1e3);
+    else if (px !== void 0) this.store.setExpireAt(key, this.store.now() + px);
+    return getOld ? old : OK;
+  }
+  cmdPop(cmd, args) {
+    const key = this.str(args[0]);
+    const list = this.store.read(key, "list");
+    if (!list || list.length === 0) return args.length > 1 ? [] : null;
+    const take = (fn) => fn();
+    const pop = () => cmd === "LPOP" ? list.shift() : list.pop();
+    if (args.length > 1) {
+      const count = this.num(args[1]);
+      const out = [];
+      for (let i = 0; i < count && list.length > 0; i++) out.push(take(pop));
+      if (list.length === 0) this.store.delete(key);
+      return out;
+    }
+    const value = pop() ?? null;
+    if (list.length === 0) this.store.delete(key);
+    return value;
+  }
+  cmdLrange(args) {
+    const list = this.store.read(this.str(args[0]), "list");
+    if (!list) return [];
+    const len = list.length;
+    let start = this.num(args[1]);
+    let stop = this.num(args[2]);
+    if (start < 0) start = Math.max(0, len + start);
+    if (stop < 0) stop = len + stop;
+    return list.slice(start, stop + 1);
+  }
+  cmdScan(args) {
+    let match;
+    for (let i = 1; i < args.length; i++) {
+      const opt = this.str(args[i]).toUpperCase();
+      if (opt === "MATCH") match = this.str(args[++i]);
+      else if (opt === "COUNT") i++;
+    }
+    const re = match ? globToRegExp(match) : void 0;
+    const keys = re ? this.store.keys().filter((k) => re.test(k)) : this.store.keys();
+    return ["0", keys];
+  }
+  cmdHset(cmd, args) {
+    const hash = this.store.readOrCreate(this.str(args[0]), "hash");
+    let added = 0;
+    for (let i = 1; i < args.length; i += 2) {
+      const field = this.str(args[i]);
+      if (!hash.has(field)) added++;
+      hash.set(field, this.str(args[i + 1]));
+    }
+    return cmd === "HMSET" ? OK : added;
+  }
+  cmdZadd(args) {
+    const zset = this.store.readOrCreate(this.str(args[0]), "zset");
+    let added = 0;
+    for (let i = 1; i < args.length; i += 2) {
+      const score = this.num(args[i]);
+      const member = this.str(args[i + 1]);
+      if (!zset.has(member)) added++;
+      zset.set(member, score);
+    }
+    return added;
+  }
+  sortedMembers(key) {
+    const zset = this.store.read(key, "zset");
+    if (!zset) return [];
+    return [...zset.entries()].sort((a, b) => a[1] !== b[1] ? a[1] - b[1] : a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0);
+  }
+  cmdZrange(args) {
+    const sorted = this.sortedMembers(this.str(args[0]));
+    let start = this.num(args[1]);
+    let stop = this.num(args[2]);
+    const withScores = args.slice(3).some((a) => this.str(a).toUpperCase() === "WITHSCORES");
+    const len = sorted.length;
+    if (start < 0) start = Math.max(0, len + start);
+    if (stop < 0) stop = len + stop;
+    const slice = sorted.slice(start, stop + 1);
+    return this.flatten(slice, withScores);
+  }
+  cmdZrangeByScore(args) {
+    const sorted = this.sortedMembers(this.str(args[0]));
+    const min = parseScoreBound(args[1]);
+    const max = parseScoreBound(args[2]);
+    const withScores = args.slice(3).some((a) => this.str(a).toUpperCase() === "WITHSCORES");
+    return this.flatten(
+      sorted.filter(([, s]) => this.inRange(s, min, max)),
+      withScores
+    );
+  }
+  cmdZremRangeByScore(args) {
+    const key = this.str(args[0]);
+    const zset = this.store.read(key, "zset");
+    if (!zset) return 0;
+    const min = parseScoreBound(args[1]);
+    const max = parseScoreBound(args[2]);
+    let removed = 0;
+    for (const [member, score] of [...zset.entries()]) {
+      if (this.inRange(score, min, max)) {
+        zset.delete(member);
+        removed++;
+      }
+    }
+    if (zset.size === 0) this.store.delete(key);
+    return removed;
+  }
+  inRange(score, min, max) {
+    const okMin = min.exclusive ? score > min.value : score >= min.value;
+    const okMax = max.exclusive ? score < max.value : score <= max.value;
+    return okMin && okMax;
+  }
+  flatten(entries, withScores) {
+    const out = [];
+    for (const [member, score] of entries) {
+      out.push(member);
+      if (withScores) out.push(String(score));
+    }
+    return out;
+  }
+  // --- stream helpers -------------------------------------------------------
+  /** Formats a stream entry as the Redis reply shape `[id, [field, value, ...]]`. */
+  entryReply(entry) {
+    return [entry.id, entry.fields];
+  }
+  cmdXadd(args) {
+    const key = this.str(args[0]);
+    let i = 1;
+    let noMkStream = false;
+    let maxLen;
+    let minId;
+    for (; i < args.length; ) {
+      const opt = this.str(args[i]).toUpperCase();
+      if (opt === "NOMKSTREAM") {
+        noMkStream = true;
+        i += 1;
+      } else if (opt === "MAXLEN") {
+        i += 1;
+        if (this.str(args[i]) === "~" || this.str(args[i]) === "=") i += 1;
+        maxLen = this.num(args[i]);
+        i += 1;
+      } else if (opt === "MINID") {
+        i += 1;
+        if (this.str(args[i]) === "~" || this.str(args[i]) === "=") i += 1;
+        minId = this.str(args[i]);
+        i += 1;
+      } else {
+        break;
+      }
+    }
+    const id = this.str(args[i]);
+    const fields = args.slice(i + 1).map((f) => this.str(f));
+    if (noMkStream && !this.store.has(key)) return null;
+    const stream = this.store.readOrCreate(key, "stream");
+    const newId = stream.add(id, fields, this.store.now());
+    if (maxLen !== void 0) stream.trimMaxLen(maxLen);
+    if (minId !== void 0) {
+      const toDelete = stream.range("-", "+").filter((e) => compareIds(e.id, minId) < 0).map((e) => e.id);
+      stream.del(toDelete);
+    }
+    return newId;
+  }
+  cmdXrange(args, reverse) {
+    const stream = this.store.read(this.str(args[0]), "stream");
+    if (!stream) return [];
+    const start = reverse ? this.str(args[2]) : this.str(args[1]);
+    const end = reverse ? this.str(args[1]) : this.str(args[2]);
+    let count;
+    for (let i = 3; i < args.length; i++) {
+      if (this.str(args[i]).toUpperCase() === "COUNT") count = this.num(args[++i]);
+    }
+    return stream.range(start, end, count, reverse).map((e) => this.entryReply(e));
+  }
+  cmdXtrim(args) {
+    const stream = this.store.read(this.str(args[0]), "stream");
+    if (!stream) return 0;
+    let i = 1;
+    const strategy = this.str(args[i]).toUpperCase();
+    i += 1;
+    if (this.str(args[i]) === "~" || this.str(args[i]) === "=") i += 1;
+    if (strategy !== "MAXLEN") throw new MemoryDriverError(`XTRIM strategy not supported: ${strategy}`);
+    return stream.trimMaxLen(this.num(args[i]));
+  }
+  cmdXinfo(args) {
+    const sub = this.str(args[0]).toUpperCase();
+    if (sub !== "STREAM") throw new MemoryDriverError(`XINFO subcommand not supported: ${sub}`);
+    const stream = this.store.read(this.str(args[1]), "stream");
+    if (!stream) throw new MemoryDriverError("ERR no such key");
+    const all = stream.range("-", "+");
+    const first = all[0];
+    const last = all[all.length - 1];
+    return ["length", stream.len(), "radix-tree-keys", 1, "radix-tree-nodes", 2, "last-generated-id", stream.lastId, "groups", stream.groups.size, "first-entry", first ? this.entryReply(first) : null, "last-entry", last ? this.entryReply(last) : null];
+  }
+  cmdXgroup(args) {
+    const sub = this.str(args[0]).toUpperCase();
+    const key = this.str(args[1]);
+    const group = this.str(args[2]);
+    if (sub === "CREATE") {
+      const id = this.str(args[3]);
+      const mkstream = args[4] !== void 0 && this.str(args[4]).toUpperCase() === "MKSTREAM";
+      if (!this.store.has(key)) {
+        if (!mkstream) throw new MemoryDriverError("ERR The XGROUP subcommand requires the key to exist. Note that for CREATE you may want to use the MKSTREAM option to create an empty stream automatically.");
+        this.store.readOrCreate(key, "stream");
+      }
+      this.store.read(key, "stream").createGroup(group, id);
+      return OK;
+    }
+    if (sub === "DESTROY") return this.store.read(key, "stream")?.destroyGroup(group) ?? 0;
+    if (sub === "DELCONSUMER") return this.store.read(key, "stream")?.delConsumer(group, this.str(args[3])) ?? 0;
+    if (sub === "SETID") {
+      this.store.read(key, "stream")?.setGroupId(group, this.str(args[3]));
+      return OK;
+    }
+    throw new MemoryDriverError(`XGROUP subcommand not supported: ${sub}`);
+  }
+  /** Parses the trailing `STREAMS key... id...` section into key/id pairs. */
+  parseStreamsSection(args, fromIndex) {
+    let count;
+    let i = fromIndex;
+    for (; i < args.length; i++) {
+      const tok = this.str(args[i]).toUpperCase();
+      if (tok === "STREAMS") {
+        i += 1;
+        break;
+      }
+      if (tok === "COUNT") count = this.num(args[++i]);
+      else if (tok === "BLOCK")
+        i += 1;
+      else if (tok === "NOACK") continue;
+    }
+    const rest = args.slice(i).map((a) => this.str(a));
+    const half = rest.length / 2;
+    const keys = rest.slice(0, half);
+    const ids = rest.slice(half);
+    return { count, pairs: keys.map((k, idx) => [k, ids[idx]]) };
+  }
+  cmdXreadgroup(args) {
+    const group = this.str(args[1]);
+    const consumer = this.str(args[2]);
+    const noAck = args.slice(3).some((a) => this.str(a).toUpperCase() === "NOACK");
+    const { count, pairs } = this.parseStreamsSection(args, 3);
+    const now = this.store.now();
+    const out = [];
+    for (const [key, id] of pairs) {
+      const stream = this.store.read(key, "stream");
+      if (!stream) continue;
+      const entries = stream.readGroup(group, consumer, id, now, count, noAck);
+      if (entries.length > 0) out.push([key, entries.map((e) => this.entryReply(e))]);
+    }
+    return out.length > 0 ? out : null;
+  }
+  cmdXread(args) {
+    const { count, pairs } = this.parseStreamsSection(args, 0);
+    const out = [];
+    for (const [key, id] of pairs) {
+      const stream = this.store.read(key, "stream");
+      if (!stream) continue;
+      const entries = stream.readAfter(id, count);
+      if (entries.length > 0) out.push([key, entries.map((e) => this.entryReply(e))]);
+    }
+    return out.length > 0 ? out : null;
+  }
+  cmdXack(args) {
+    const stream = this.store.read(this.str(args[0]), "stream");
+    const group = this.str(args[1]);
+    if (!stream?.groups.has(group)) return 0;
+    return stream.ack(
+      group,
+      args.slice(2).map((i) => this.str(i))
+    );
+  }
+  cmdXpending(args) {
+    const stream = this.store.read(this.str(args[0]), "stream");
+    const group = this.str(args[1]);
+    const now = this.store.now();
+    if (args.length <= 2) {
+      if (!stream?.groups.has(group)) return [0, null, null, null];
+      const s = stream.pendingSummary(group);
+      return [s.count, s.minId, s.maxId, s.consumers.length > 0 ? s.consumers.map(([name, c]) => [name, String(c)]) : null];
+    }
+    if (!stream?.groups.has(group)) return [];
+    const start = this.str(args[2]);
+    const end = this.str(args[3]);
+    const count = this.num(args[4]);
+    const consumer = args[5] !== void 0 ? this.str(args[5]) : void 0;
+    return stream.pendingRange(group, start, end, count, now, consumer).map((p) => [p.id, p.consumer, p.idleTime, p.deliveryCount]);
+  }
+  cmdXclaim(args) {
+    const stream = this.store.read(this.str(args[0]), "stream");
+    const group = this.str(args[1]);
+    if (!stream?.groups.has(group)) return [];
+    const consumer = this.str(args[2]);
+    const minIdle = this.num(args[3]);
+    const ids = [];
+    for (let i = 4; i < args.length; i++) {
+      const tok = this.str(args[i]);
+      if (["IDLE", "TIME", "RETRYCOUNT", "FORCE", "JUSTID", "LASTID"].includes(tok.toUpperCase())) break;
+      ids.push(tok);
+    }
+    return stream.claim(group, consumer, minIdle, ids, this.store.now()).map((e) => this.entryReply(e));
+  }
+  runScript(source, args) {
+    const numKeys = this.num(args[1]);
+    const keys = args.slice(2, 2 + numKeys).map((k) => this.str(k));
+    const argv = args.slice(2 + numKeys).map((a) => this.str(a));
+    return this.interpreter.run(source, keys, argv, this.redisCall);
+  }
+};
+
+// src/memory/infrastructure/adapters/memory-redis.adapter.ts
+var MemoryPipeline = class {
+  constructor(executor) {
+    this.executor = executor;
+  }
+  queue = [];
+  enqueue(cmd, args) {
+    this.queue.push({ cmd, args });
+    return this;
+  }
+  get(key) {
+    return this.enqueue("GET", [key]);
+  }
+  set(key, value, options) {
+    const args = [key, value];
+    if (options?.ex !== void 0) args.push("EX", options.ex);
+    if (options?.px !== void 0) args.push("PX", options.px);
+    if (options?.nx) args.push("NX");
+    if (options?.xx) args.push("XX");
+    return this.enqueue("SET", args);
+  }
+  del(...keys) {
+    return this.enqueue("DEL", keys);
+  }
+  mget(...keys) {
+    return this.enqueue("MGET", keys);
+  }
+  mset(data) {
+    return this.enqueue("MSET", Object.entries(data).flat());
+  }
+  expire(key, seconds) {
+    return this.enqueue("EXPIRE", [key, seconds]);
+  }
+  ttl(key) {
+    return this.enqueue("TTL", [key]);
+  }
+  incr(key) {
+    return this.enqueue("INCR", [key]);
+  }
+  incrby(key, increment) {
+    return this.enqueue("INCRBY", [key, increment]);
+  }
+  hget(key, field) {
+    return this.enqueue("HGET", [key, field]);
+  }
+  hset(key, field, value) {
+    return this.enqueue("HSET", [key, field, value]);
+  }
+  hmset(key, data) {
+    return this.enqueue("HMSET", [key, ...Object.entries(data).flat()]);
+  }
+  hgetall(key) {
+    return this.enqueue("HGETALL", [key]);
+  }
+  lpush(key, ...values) {
+    return this.enqueue("LPUSH", [key, ...values]);
+  }
+  rpush(key, ...values) {
+    return this.enqueue("RPUSH", [key, ...values]);
+  }
+  sadd(key, ...members) {
+    return this.enqueue("SADD", [key, ...members]);
+  }
+  srem(key, ...members) {
+    return this.enqueue("SREM", [key, ...members]);
+  }
+  zadd(key, ...args) {
+    return this.enqueue("ZADD", [key, ...args]);
+  }
+  zrem(key, ...members) {
+    return this.enqueue("ZREM", [key, ...members]);
+  }
+  exec() {
+    const results = [];
+    for (const { cmd, args } of this.queue) {
+      try {
+        results.push([null, this.executor.execute(cmd, args)]);
+      } catch (error) {
+        results.push([error, null]);
+      }
+    }
+    this.queue = [];
+    return Promise.resolve(results);
+  }
+};
+var MemoryMulti = class extends MemoryPipeline {
+  discard() {
+    this.queue = [];
+  }
+};
+var MemoryRedisAdapter = class extends BaseRedisDriver {
+  store;
+  executor;
+  constructor(config, options) {
+    super(config, options);
+    this.store = new MemoryStore();
+    this.executor = new CommandExecutor(this.store);
+  }
+  /** Exposes the backing store for assertions / manual reset in tests. */
+  getStore() {
+    return this.store;
+  }
+  doConnect() {
+    return Promise.resolve();
+  }
+  doDisconnect() {
+    return Promise.resolve();
+  }
+  async executeCommand(command, ...args) {
+    const result = this.executor.execute(command, args);
+    const cmd = command.toUpperCase();
+    if (result === null && (cmd === "XREADGROUP" || cmd === "XREAD")) {
+      const blockIdx = args.findIndex((a) => String(a).toUpperCase() === "BLOCK");
+      if (blockIdx !== -1) {
+        const blockMs = Number(args[blockIdx + 1]);
+        const delay = Number.isFinite(blockMs) && blockMs > 0 ? Math.min(blockMs, 20) : 20;
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+    return result;
+  }
+  createPipeline() {
+    return new MemoryPipeline(this.executor);
+  }
+  createMulti() {
+    return new MemoryMulti(this.executor);
+  }
+};
+
+// src/memory/api/register-memory-driver.ts
+var registered = false;
+function registerMemoryDriver() {
+  if (registered) return;
+  registerDriver(MEMORY_DRIVER_TYPE, (config, options) => new MemoryRedisAdapter(config, options));
+  registered = true;
+}
+var DEFAULT_CLIENTS = { type: "single", host: "localhost", port: 6379 };
+var RedisTestingModule = class {
+  static forRoot(options = {}) {
+    registerMemoryDriver();
+    return RedisModule.forRoot({
+      ...options,
+      clients: options.clients ?? DEFAULT_CLIENTS,
+      global: { ...options.global, driver: MEMORY_DRIVER_TYPE }
+    });
+  }
+  static forRootAsync(options) {
+    registerMemoryDriver();
+    const userFactory = options.useFactory;
+    return RedisModule.forRootAsync({
+      ...options,
+      useFactory: async (...args) => {
+        const resolved = userFactory ? await userFactory(...args) : {};
+        return {
+          ...resolved,
+          clients: resolved.clients ?? DEFAULT_CLIENTS,
+          global: { ...resolved.global, driver: MEMORY_DRIVER_TYPE }
+        };
+      }
+    });
+  }
+};
+
+// src/index.ts
+registerMemoryDriver();
+
+export { CommandExecutor, LuaExecutionError, LuaInterpreter, MEMORY_DRIVER_TYPE, MemoryDriverError, MemoryRedisAdapter, MemoryStore, RedisTestingModule, WrongTypeError, registerMemoryDriver };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map